I'm building an app with mapbox-gl#0.44.2 and the latest version of Mapbox GL JS is 0.46.0. The API documentation on their website always reflects the latest release, but I still need to read the docs for this older version. Is it available somewhere on their website, or on their GitHub?
I've looked around the mapbox GitHub repos but I don't think I'm looking at the right branches.
It's on the Mapbox GL JS GitHub repository:
You can do the following:
Go to the v0.44.2 tree: https://github.com/mapbox/mapbox-gl-js/tree/v0.44.2
Download ZIP file of the repository (green button named "Clone or download")
Prepare your development enviroment for your OS.
You don't need to clone the repostory since you've downloaded it before. Just extract the ZIP file and execute yarn install within the mapbox-gl-js-0.44.2 directory.
Run npm run start-docs to start a documentation server locally.
Use the printed URL to view the documentation, in my case it is http://localhost:8080/mapbox-gl-js/api/:
Related
Error log
Liquid Exception: Liquid syntax error (line 6): Unknown tag 'include_cached' in /_layouts/post.html
I am currently making a blog by forking this project at https://github.com/hydecorp/hydejack.
I've tried several methods for 2 days, but it doesn't work. Locally it's fine, but when I build I get an error.
this is my project
https://github.com/JangHwanPark/JangHwanPark.github.io
I tried changing config.yml and layout to md file. I also tried deleting the repository, but it didn't work.
When you build the way you do, the "classic" way (as opposed to using an action), GitHub uses a fixed configuration and a list of whitelisted plugins (visible here). It really only includes the github-pages gem, which includes all other dependencies. Your Gemfile is ignored for the build; among other things, this means the build uses Jekyll v3.9.2, and not v4.1 as in your Gemfile.
There are two approaches:
Stick with the "classic" experience. I recommend you make your local environment match that; the Gemfile simplifies to
source "https://rubygems.org"
gem "github-pages", "~> 227", group: :jekyll_plugins
Don't forget to run bundle install after you've updated the Gemfile so the lockfile gets updated, too.
You'll have to update _config.yml to include your theme via the remote-theme plugin, and add the include-cache plugin to the plugins list.
This closely matches what the docs for your theme also recommend.
Switch to a custom GitHub Actions flow to deploy your page. There is a starter workflow for Jekyll; using that should get you most of the way there. You might still have to specify remote_theme in the config instead of theme, unless you copy the entire theme into your repo.
Doing this lets you use any gems you want, and any Jekyll version you want.
Is it possible to release on GitHub through the command line with an attached file that is not pushed to a repository?
I have a file over 1GB that I easily attached through a web GitHub release page, but I want to automate that using bash.
You can from command-line, using gh: cli/cli/
create a relase
gh release create <tag> [<files>...] [flags]
upload a file to that release
gh release upload <tag> <files>... [flags]
And since Github CLI 2.4.0 (Dec. 2021), you have:
the non-interactive flag --generate-notes, which allows you to skip the editor phase.
an interactive mode to choose a tag name
There's a REST API that can be used for this purpose. It's used to upload a release asset if you know the ID for the release (which you can get by querying the release itself). You can also get the upload URL by querying the release using a GET request; that returns the upload_url attribute.
If you want an example of how to do this from the command line with curl, Git LFS has a script that it uses to do releases and upload assets which you could look at. It's a little complex, but it is reasonably comprehensive.
In addition to the gh tool and directly using the REST API (as mentioned in other answers), there are several command-line tools which let you create and manipulate GitHub releases. These are likely to be much simpler to use than directly using the REST API.
There is only one* I could identify that I could unreservedly recommend, however: github-release, which is written in Go. Binaries can be downloaded from the project's Releases page, it "dogfoods (transparently uses its own tool), and is actively maintained (as at January 2022).
Some others are:
Another Go app called github-release, released by BuildKite. However, this seems to be less actively maintained, and it doesn't transparently "dogfood" (viewing its CI results require an account with BuildKite).
For Haskell developers, there's yet another tool called github-release, created by Taylor Fausak. It seems to be actively maintained; however, no downloadable executables are provided, so you must build it yourself using a Haskell compiler and build tools.
For node.js developers, there's release-it; but as a node project, it doesn't provide executable binaries that could be invoked from Bash at all.
*If there are others that I've missed, feel free to add them in comments.
I have a repository/program that requires Electron. GitHub doesn't allow adding files larger than 100MB, however, the electron.exe file in the Electron node module is 105MB so I can't figure out how to add it into my repo. Any ideas?
I think that is not required. Because Git is needed for management source code. Electron.exe and node modules can be processed by package.json.
So if you add package.json includes electron and other information, you can use easily later.
From this question I would like to know if there's a way to check current version of a repo directly from the website (without Git command line). I need this for a web scraping bot.
By using the REST API, you can get the latest release at:
https://api.github.com/repos/$org/$repo/releases/latest
I've used static site generators like jekyll and had it hosted through github pages just fine using prose.io as a content management system.
I decided I wanted to go with a site using Hexo static site generator, but I cannot seem to figure out a good workflow for publishing content.
To my understanding this is the following in how I'd have to do it:
write *.md text file
hexo generate
(optional) hexo serve (to see local content)
hexo deploy (to publish the public content to whatever site using config.yml). Can publish on amazon S3, github pages, etc
Is there another workflow other than this?
the way I've been doing it before with jekyll+github pages is simply
go to prose.io
Write content
save (which publishes ocntent)
Ideally I'd like to use hexo+github pages the same way I do with jekyll+github pages.
Basically, can github generate static files automatically like it does with jekyll / ruby packages?
I figured out my own answer and posted it on my blog
http://www.tangycode.com/Quick-Start-Guide-To-Hexo-Install/
It covers everything you need to know on how to set up a hexo blog site and manage content workflows
One approach I am trying myself:
prose.io or similar to write and save on github repository
travis-ci.org to build hexo site and deploy
This is how it works:
Edit document on your editor of love
Commit it to your repository
travis-ci.org detects the commit and start working
My .travis.yml do (among few other things) the follow:
npm install hexo-cli
npm install grunt-cli
npm install inside site´s repository (hexo plugins and dependecies)
hexo generate
grunt deploy-production
hexo deploy (I use this to have a historic of the site stored in the repo itself)
If your editor of choice can direct commit to github repository your have exact same experience you had with Jekyll on GH pages. The advantage here is that you can use third-part plugin what GH pages avoid.
Alternatively, you can use INSTANT, which is a content management tool that you can use on any static website. You just install their javascript and can directly edit content in your website (without any admin dashboard). It saves and serves the content from the client. Pretty neat.
The easiest way is to use a hosting provider like Netlify in combination with a headless CMS, for example Headless (full disclore: I created it).
Netlify can do the build process for you and during that build process, it can fetch content from a headless CMS. Whenever you update content in the CMS, then Netlify does a rebuild.
Then you have your website on the Netlify CDN, a real CMS for your content management and you never need to dive in your code or github files. And that's all for free.