jekyll-maplibre 1.0.pre.alpha.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8ab808189fd4b1d54aab12429599ebf2cef5ef6579e315fb5eeb8e409324d0e7
+  data.tar.gz: 64ee05a010230a5712494c45016fc400f871ad3211d64e576e0df66da780ca55
+SHA512:
+  metadata.gz: b6c0ca7186c6e4fa6c8765faddf510bd38f44677e254431e8e1fe4a7214e8d8e0d9aa2cc5a445edbe8af934109fcd1167448d9aca8c547b994a16288bf3601e2
+  data.tar.gz: 746f400184fd527e050f6bc35c299ff992079b4c1ce10ba6c2a7a49f1ba17931acdbd782724c75ced778fe5113afd2ebc2e2c5620d5852d597ae5177e11e5183

data/.gitignore

@@ -0,0 +1,10 @@
+.idea
+*.gem
+Gemfile.lock
+tmp
+spec/dest
+coverage
+_site
+node_modules
+.DS_store
+.#*

data/.rubocop.yml

@@ -0,0 +1,112 @@
+---
+AllCops:
+  TargetRubyVersion: 3.1
+  Include:
+  - lib/**/*.rb
+  # - spec/**/*.rb
+  NewCops: enable
+  SuggestExtensions: false
+Layout/EndAlignment:
+  Severity: error
+Lint/UnreachableCode:
+  Severity: error
+Lint/UselessAccessModifier:
+  Enabled: false
+Metrics/AbcSize:
+  Max: 20
+Metrics/BlockLength:
+  Exclude:
+    - spec/**/*.rb
+Metrics/ClassLength:
+  Max: 300
+  Exclude:
+  - !ruby/regexp /spec\/.*.rb$/
+Metrics/CyclomaticComplexity:
+  Max: 8
+Layout/LineLength:
+  Exclude:
+    - Rakefile
+    - Gemfile
+    - jekyll-maps.gemspec
+  Max: 90
+  Severity: warning
+Metrics/MethodLength:
+  Max: 20
+  CountComments: false
+  Severity: error
+Metrics/ModuleLength:
+  Max: 240
+Metrics/ParameterLists:
+  Max: 4
+Metrics/PerceivedComplexity:
+  Max: 8
+Style/Alias:
+  Enabled: false
+Style/AndOr:
+  Severity: error
+Style/Attr:
+  Enabled: false
+Style/ClassAndModuleChildren:
+  Enabled: false
+Style/Documentation:
+  Enabled: false
+Style/DoubleNegation:
+  Enabled: false
+Layout/EmptyLinesAroundAccessModifier:
+  Enabled: false
+Layout/EmptyLinesAroundModuleBody:
+  Enabled: false
+Layout/ExtraSpacing:
+  AllowForAlignment: true
+Naming/FileName:
+  Enabled: false
+Layout/FirstParameterIndentation:
+  EnforcedStyle: consistent
+Style/GuardClause:
+  Enabled: false
+Style/HashSyntax:
+  EnforcedStyle: hash_rockets
+  Severity: error
+Style/IfUnlessModifier:
+  Enabled: false
+Layout/IndentationWidth:
+  Severity: error
+Style/ModuleFunction:
+  Enabled: false
+Layout/MultilineMethodCallIndentation:
+  EnforcedStyle: indented
+Layout/MultilineOperationIndentation:
+  EnforcedStyle: indented
+Style/MultilineTernaryOperator:
+  Severity: error
+Style/PercentLiteralDelimiters:
+  PreferredDelimiters:
+    "%q": "{}"
+    "%Q": "{}"
+    "%r": "!!"
+    "%s": "()"
+    "%w": "()"
+    "%W": "()"
+    "%x": "()"
+Style/RedundantReturn:
+  Enabled: false
+Style/RedundantSelf:
+  Enabled: false
+Style/RegexpLiteral:
+  EnforcedStyle: percent_r
+Style/RescueModifier:
+  Enabled: false
+Style/SignalException:
+  EnforcedStyle: only_raise
+Style/SingleLineMethods:
+  Enabled: false
+Layout/SpaceAroundOperators:
+  Enabled: false
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: double_quotes
+Style/RedundantCapitalW:
+  Enabled: false
+Style/SymbolArray:
+  Enabled: false

data/CHANGELOG.md

@@ -0,0 +1,8 @@
+## 1.0.0-alpha.1
+
+* fork jekyll-maps to create jekyll-maplibre
+* remove all code related to Google Maps and use MapLibre GL JS (<https://maplibre.org/maplibre-gl-js/docs/>) instead
+* flexible configuration of sources, layers, styles through page metadata and site config
+* update README.md
+* prepare minimal example
+* prepare a folder with useful assets

data/Gemfile

@@ -0,0 +1,5 @@
+source "https://rubygems.org"
+
+gemspec
+
+gem "jekyll", ENV["JEKYLL_VERSION"] if ENV["JEKYLL_VERSION"]

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+Copyright (c) 2016 Anatoliy Yastreb
+Copyright (c) 2023 Robert Riemann (<robert@riemann.cc>)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,280 @@
+# Jekyll MapLibre 
+
+[![Gem Version](https://badge.fury.io/rb/jekyll-maplibre.svg)](https://badge.fury.io/rb/jekyll-maplibre)
+
+Jekyll MapLibre is a Jekyll plugin that allows to easily display maps with [MapLibre GL JS](https://maplibre.org/). It is a fork of [Jekyll Maps](https://github.com/ayastreb/jekyll-maps) that uses Google Maps.
+
+MapLibre GL JS is open source software and allows for self-hosted maps. Self-hosting become much easier with [PMTiles](https://docs.protomaps.com/pmtiles/), which is a single-file archive format for pyramids of tiled data that can be hosted on Github, Gitlab, Netlify, etc. and enables low-cost, zero-maintenance map applications.
+
+Check out a Jekyll MapLibre [demo at blog.riemann.cc](https://blog.riemann.cc/projects/jekyll-maplibre)!
+
+## Installation
+
+1. Add the following to your site's `Gemfile`:
+
+
+```ruby
+gem 'jekyll-maplibre'
+```
+
+2. Add the following to your site's `_config.yml`:
+
+
+```yml
+plugins:
+  - jekyll-maplibre
+```
+
+3. Also prepare configuration specific for `jekyll-maplibre` in your site's `_config.yml`:
+
+```
+maplibre:
+  width:  600
+  height: 400
+  zoom:   10
+  pmtiles: true
+  style: false
+  # if style is not set to an URL (Mapbox, MapTiler, OpenMapTiles), the following values are used
+  sprite: /assets/maps/osm-liberty-sprites/osm-liberty
+  glyphs: /assets/maps/fonts/{fontstack}/{range}.pbf
+  layers: /assets/maps/OSM-Liberty-layers.json
+  sources:
+    openmaptiles: 
+      type: vector
+      url: pmtiles:///assets/maps/maptiler-osm-2020-02-10-v3.11-belgium_brussels.pmtiles
+      attribution: © <a href='https://openstreetmap.org'>OpenStreetMap contributors</a>
+    natural_earth_shaded_relief:
+      attribution: Made with <a href='https://www.naturalearthdata.com/'>Natural Earth</a> data
+      maxzoom: 6
+      type: raster
+      url: pmtiles:///assets/maps/natural_earth_2_shaded_relief.raster.pmtiles
+      # uncomment tileSize and tiles for cloud CDN tiles
+      # tileSize: 256
+      # tiles:
+      #   - "https://klokantech.github.io/naturalearthtiles/tiles/natural_earth_2_shaded_relief.raster/{z}/{x}/{y}.png"
+```
+
+4. Prepare assets to display maps with MapLibre GL JS:
+
+The required assets depend on your specific map configuration. With cloud hosting (untested), it may be sufficient to only configure the `style` property above.
+
+For self-hosted maps, you need to host and configure the following resources:
+
+- **The source.** PMTiles covering the map area you need. Use `pmtiles convert input.mbtiles output.pmtiles` to convert your mbtiles from e.g. <https://data.maptiler.com/downloads/planet/>. More on `pmtiles` and extraction of custom areas at <https://docs.protomaps.com/guide/getting-started>.
+- **The glyphs.** Font files in pbf format when using vector sources. Check out <https://github.com/openmaptiles/fonts/releases>.
+- **The sprite.** Icons used when using vector sources.
+- **The layers.** A map requires at least one layer. Layers describe how to render source data and rely on glyphs and sprite. The layer definition for vector data depends on the schema used to encode the data in the vector source.
+- **The Mapbox Style file.** It links all assets together.
+
+For an easy start `jekyll-maplibre` suggests to use PMTiles raster files and vector files following the *OpenMapTiles Vector Tile Schema*, so that the layers from [OSM-Liberty](https://maputnik.github.io/osm-liberty/) can be used. Find a demo of OSM Liberty [here](https://maputnik.github.io/editor/?style=https://maputnik.github.io/osm-liberty/style.json).
+
+Example assets folder:
+
+```
+assets
+└── maps
+    ├── fonts
+    │   ├── Roboto Condensed Italic
+    │   │   ├── 0-255.pbf
+    │   │   ├── […]
+    │   │   └── 9984-10239.pbf
+    │   ├── Roboto Medium
+    │   │   ├── 0-255.pbf
+    │   │   ├── […]
+    │   │   └── 9984-10239.pbf
+    │   └── Roboto Regular
+    │       ├── 0-255.pbf
+    │       ├── […]
+    │       └── 9984-10239.pbf
+    ├── maplibre-gl.css
+    ├── maplibre-gl.js
+    ├── maptiler-osm-2020-02-10-v3.11-belgium_brussels.pmtiles
+    ├── natural_earth_2_shaded_relief.raster.pmtiles
+    ├── natural_earth.vector.pmtiles
+    ├── OSM-Liberty-layers.json
+    ├── osm-liberty-sprites
+    │   ├── osm-liberty@2x.json
+    │   ├── osm-liberty@2x.png
+    │   ├── osm-liberty.json
+    │   └── osm-liberty.png
+    └── pmtiles.js
+
+```
+
+Example assets sources:
+
+- [pmtiles.js](https://unpkg.com/pmtiles@2.11.0/dist/index.js)
+- [osm-liberty-sprites](https://github.com/maputnik/osm-liberty/tree/gh-pages/sprites)
+- [fonts](https://github.com/maputnik/osm-liberty/tree/gh-pages/sprites) (the v2.0 zip)
+- [maplibre-gl.js](https://unpkg.com/maplibre-gl@3.6.2/dist/maplibre-gl.js)
+- [maplibre-gl.css](https://unpkg.com/maplibre-gl@3.6.2/dist/maplibre-gl.css)
+- [OSM-Liberty-layers.json extracted from OSM Liberty style.json](https://github.com/maputnik/osm-liberty/blob/f2c798e80dc11d47613e3b093881b4d37a5fde8e/style.json)
+
+5. Load MapLibre GL JS CSS in `<head>`
+
+The file `maplibre-gl.css` should be linked in your `<head>` or included in another css file.
+
+Many Jeyll templates provide for a file `_includes/my-head.html` or `_includes/custom-head.html` (check the docs). If so, add a line such as `<link href="/assets/maps/maplibre-gl.css" rel="stylesheet">`.
+
+## Usage
+
+### MapLibre Tag
+
+```
+{% maplibre %}
+```
+
+The following optional attributes are supported:
+
+- id
+- width
+- height
+- class
+- style
+- zoom
+- center
+- description
+- latitude
+- longitude
+
+The flag `no_cluster` can be used to disable clustering of points.
+
+Example with all attributes and flags:
+
+```
+{% maplibre id="custom-id" width="100%" height="200" class="custom-class" style="clear: both;" zoom="10" center="4.300,50.800" description="<a href='#'>Popup Link</a>" longitude="4.300" latitude="50.800" no_cluster %}
+```
+
+### Data Source
+
+Jekyll MapLibre offers several ways to add markers to the map. While in principle MapLibre GL JS allows to add all kinds of data other than markers to the map, more configuration must be added to the style definition.
+
+#### Location data in the tag attributes
+
+Example:
+
+```
+{% maplibre longitude="4.300" latitude="50.800" %}
+```
+
+#### Location data in the YAML frontmatter
+
+```yml
+location:
+  latitude: 50.800
+  longitude: 4.300
+```
+
+#### GeoJSON data in the YAML frontmatter
+
+The `geojson` attribute in the YAML frontmatter supports (a) individual GeoJSON features or (b) collections of features.
+
+Individual feature:
+
+```
+geojson:
+  type: Feature
+  properties:
+    description: |
+      <strong>A Little Night Music</strong><p>The Arlington Players' production of Stephen Sondheim's <em>A Little Night Music</em> comes to the Kogod Cradle at The Mead Center for American Theater (1101 6th Street SW) this weekend and next. 8:00 p.m.</p>
+  geometry:
+    type: Point
+    coordinates: [4.300, 50.800]
+```
+
+Collection of features:
+
+```
+geojson:
+  type: FeatureCollection
+  features:
+    -
+      type: Feature
+      properties:
+        description: "<strong>A Little Night Music</strong><p>The Arlington Players' production of Stephen Sondheim's <em>A Little Night Music</em> comes to the Kogod Cradle at The Mead Center for American Theater (1101 6th Street SW) this weekend and next. 8:00 p.m.</p>\n"
+      geometry:
+        type: Point
+        coordinates: [4.376, - 50.83012]
+    -
+      type: Feature
+      ...
+```
+
+#### GeoJSON data in a JSON file
+
+The `geojson` attribute in the YAML frontmatter can also contain a URL with `.json` extension.
+
+Example:
+
+```
+geojson: /post-locations.json`
+```
+
+The linked file can be a static file on the same host or another server. If the data source points to a generated file capturing the `location` attribute of posts, Jekyll MapLibre can display maps with post markers.
+
+Example for `/post-locations.json`:
+
+```
+{% assign posts = site.posts | where_exp:"location", "location != nil" %}
+{
+  "type": "FeatureCollection",
+  "features": [
+  {% for post in posts limit:20 %}
+    {
+      "type": "Feature",
+      "properties": {
+        "description": "<b><a href='{{post.url}}'>{{post.title}}</a></b><br/>{{post.description}}<br/>"
+      },
+      "geometry": {
+        "type": "Point",
+        "coordinates": {{post.location | jsonify }}
+      }
+    }{% unless forloop.last %},{% endif %}
+  {% endfor %}
+  ]
+}
+```
+
+With `where` and `where_exp` (see [documentation](https://jekyllrb.com/docs/liquid/filters/)), Jekyll permits to implement various filters.
+
+### Marker Cluster
+
+Clusters are enabled by default. Use the flag `no_cluster` in the tag to disable clusters.
+
+## Examples
+
+Want to see Jekyll MapLibre in action? Check out [Demo Page](https://ayastreb.me/jekyll-maps/#examples)!
+
+## Contributing
+
+1. Fork it (https://github.com/rriemann/jekyll-maplibre/fork)
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request
+
+## TODOs
+
+The following issues and limitation require contribution:
+
+- implement random SVG markers, see: <https://github.com/maplibre/maplibre-gl-js/discussions/3243>, <https://github.com/rbrundritt/maplibre-gl-svg/>
+- implement more than one map tag per page
+- add more examples on how to generate geojson data from Jekyll collections/data.
+- Jekyll-Maps has spec tests (still in this repo) – make them work again with Jekyll MapLibre
+- add flag to switch popups to open by default (without click to open)
+
+## Similar Software
+
+- <https://github.com/ayastreb/jekyll-maps/>
+- <https://github.com/matthewowen/jekyll-mapping>
+- <https://wiki.openstreetmap.org/wiki/UMap>
+
+## Contributors
+
+- Anatoliy Yastreb (as the author of the forked Jekyll Maps gem)
+- Robert Riemann
+
+## License
+
+[MIT](https://github.com/rriemann/jekyll-maplibre/blob/master/LICENSE). Feel free to use, copy or
+distribute it.

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/jekyll-maplibre.gemspec

@@ -0,0 +1,27 @@
+lib = File.expand_path("lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require "jekyll-maplibre/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "jekyll-maplibre"
+  spec.summary       = "Maplibre GL JS for Jekyll"
+  spec.description   = "MapLibre GL JS support for Jekyll websites to easily display vector maps with geojson data"
+  spec.version       = Jekyll::MapLibre::VERSION
+  spec.authors       = ["Anatoliy Yastreb, Robert Riemann"]
+  spec.email         = ["robert@riemann.cc"]
+
+  spec.homepage      = "https://blog.riemann.cc/projects/jekyll-maplibre"
+  spec.licenses      = ["MIT"]
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r!^(test|spec|features)/!) }
+  spec.require_paths = ["lib"]
+  
+  spec.required_ruby_version = '>= 3.1.0'
+
+  spec.add_dependency "jekyll", ">= 3.0", "< 5.0"
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake", "~> 13.1"
+  spec.add_development_dependency "rspec", "~> 3.5"
+  spec.add_development_dependency "rubocop", "1.50.2"
+end

data/lib/jekyll-maplibre/maplibre.html.erb

@@ -0,0 +1,151 @@
+<script src="/assets/maps/maplibre-gl.js"></script>
+<% if context.registers[:site].config.dig("maplibre","pmtiles") %>
+<script src="/assets/maps/pmtiles.js"></script>
+<script type="text/javascript">
+  // add the PMTiles plugin to the maplibregl global.
+  let protocol = new pmtiles.Protocol();
+  maplibregl.addProtocol("pmtiles",protocol.tile);
+</script>
+<% end %>
+<div <%= attributes(context) %>></div>
+
+<script type="text/javascript">
+  (async () => {
+    const map = new maplibregl.Map({
+      container: '<%= @options[:attributes][:id] %>',
+      zoom: <%= zoom %>,
+      center: <%= center(context).to_json %>,
+      style: <%= style(context) %>,
+    });
+    // map.showTileBoundaries = true;
+    
+    // Add zoom and rotation controls to the map.
+    map.addControl(new maplibregl.NavigationControl());
+    
+    <% if geojson(context) %>
+    map.on('load', () => {
+        // Add a new source from our GeoJSON data and
+        // set the 'cluster' option to true. GL-JS will
+        // add the point_count property to your source data.
+        map.addSource('jekyll-data', {
+            type: 'geojson',
+            data: <%= geojson(context).to_json %>,
+            cluster: <%= (!@options[:flags][:no_cluster]).to_s %>,
+            clusterMaxZoom: 14, // Max zoom to cluster points on
+            clusterRadius: 50 // Radius of each cluster when clustering points (defaults to 50)
+        });
+
+        map.addLayer({
+            id: 'clusters',
+            type: 'circle',
+            source: 'jekyll-data',
+            filter: ['has', 'point_count'],
+            paint: {
+                // Use step expressions (https://maplibre.org/maplibre-style-spec/#expressions-step)
+                // with three steps to implement three types of circles:
+                //   * Blue, 20px circles when point count is less than 100
+                //   * Yellow, 30px circles when point count is between 100 and 750
+                //   * Pink, 40px circles when point count is greater than or equal to 750
+                'circle-color': [
+                    'step',
+                    ['get', 'point_count'],
+                    '#51bbd6',
+                    100,
+                    '#f1f075',
+                    750,
+                    '#f28cb1'
+                ],
+                'circle-radius': [
+                    'step',
+                    ['get', 'point_count'],
+                    20,
+                    100,
+                    30,
+                    750,
+                    40
+                ]
+            }
+        });
+
+        map.addLayer({
+            id: 'cluster-count',
+            type: 'symbol',
+            source: 'jekyll-data',
+            filter: ['has', 'point_count'],
+            layout: {
+                'text-field': '{point_count_abbreviated}',
+                'text-font': ['Roboto Regular'],
+                'text-size': 12
+            }
+        });
+
+        map.addLayer({
+            id: 'unclustered-point',
+            type: 'symbol',
+            source: 'jekyll-data',
+            filter: ['!', ['has', 'point_count']],
+            layout: {
+              "icon-image": "marker",
+              "icon-size": 2,
+              "icon-anchor": "bottom",
+            }
+        });
+
+        // inspect a cluster on click
+        map.on('click', 'clusters', (e) => {
+            const features = map.queryRenderedFeatures(e.point, {
+                layers: ['clusters']
+            });
+            const clusterId = features[0].properties.cluster_id;
+            map.getSource('jekyll-data').getClusterExpansionZoom(
+                clusterId,
+                (err, zoom) => {
+                    if (err) return;
+
+                    map.easeTo({
+                        center: features[0].geometry.coordinates,
+                        zoom
+                    });
+                }
+            );
+        });
+
+        // When a click event occurs on a feature in
+        // the unclustered-point layer, open a popup at
+        // the location of the feature, with
+        // description HTML from its properties.
+        map.on('click', 'unclustered-point', (e) => {
+          if(!e.features[0].properties.description) return;
+          const coordinates = e.features[0].geometry.coordinates.slice();
+
+          // Ensure that if the map is zoomed out such that
+          // multiple copies of the feature are visible, the
+          // popup appears over the copy being pointed to.
+          while (Math.abs(e.lngLat.lng - coordinates[0]) > 180) {
+            coordinates[0] += e.lngLat.lng > coordinates[0] ? 360 : -360;
+          }
+
+          new maplibregl.Popup({offset: [0, -35]})
+            .setLngLat(coordinates)
+            .setHTML(e.features[0].properties.description)
+            .addTo(map);
+        });
+
+        map.on('mouseenter', 'unclustered-point', () => {
+          if(!e.features[0].properties.description) return;
+          map.getCanvas().style.cursor = 'pointer';
+        });
+        map.on('mouseleave', 'unclustered-point', () => {
+          map.getCanvas().style.cursor = '';
+        });
+
+        map.on('mouseenter', 'clusters', () => {
+            map.getCanvas().style.cursor = 'pointer';
+        });
+        map.on('mouseleave', 'clusters', () => {
+            map.getCanvas().style.cursor = '';
+        });
+    });
+    <% end %>
+  })();
+</script>

data/lib/jekyll-maplibre/maplibre_tag.rb

@@ -0,0 +1,221 @@
+##
+# copyright: 2020 Anatoliy Yastreb <anatoliy.yastreb@gmail.com>,
+#            2023 Robert Riemann <robert@riemann.cc>
+# license:   MIT
+#
+# original code from jekyll-maps, https://github.com/ayastreb/jekyll-maps/
+
+require 'json'
+require 'erb'
+
+# taken from Active Support Gem (MIT license)
+class Hash
+  # File activesupport/lib/active_support/core_ext/hash/keys.rb, line 82
+  def deep_transform_keys(&block)
+    result = {}
+    each do |key, value|
+      result[yield(key)] = value.is_a?(Hash) ? value.deep_transform_keys(&block) : value
+    end
+    result
+  end
+
+  # File activesupport/lib/active_support/core_ext/hash/keys.rb, line 128
+  def deep_symbolize_keys
+    deep_transform_keys{ |key| key.to_sym rescue key }
+  end
+end
+
+module Jekyll
+  module MapLibre
+    
+    # @author Robert Riemann <robert@riemann.cc>
+    class MapLibreTag < Liquid::Tag
+      DEFAULT_MAP_WIDTH  = 600
+      DEFAULT_MAP_HEIGHT = 400
+      DEFAULT_ZOOM       = 10
+
+      def initialize(tag_name, args, tokens)
+        @options = OptionsParser.parse(args)
+        super
+      end
+
+      # @return [String] HTML code with JS to render map with MapLibre GL
+      def render(context)
+        zoom = @options[:attributes][:zoom] || context.registers[:site].config.dig('maplibre', 'zoom') || DEFAULT_ZOOM
+        
+        @options[:attributes][:id] ||= "maplibre-#{SecureRandom.uuid}"
+
+        template = ERB.new File.read(File.expand_path("maplibre.html.erb", __dir__))
+        template.result(binding)
+      end
+      
+      private
+      # @return [String] absolute URL for sprite property pursuant to Mapbox Style Spec
+      def sprite_url(context)
+        # note: unlike glyphs, sprites must be an absolute path with protocol
+        # see: https://github.com/mapbox/mapbox-gl-js/pull/9225
+        sprite_config = context.registers[:site].config["maplibre"]["sprite"]
+        if sprite_config.start_with?('/') then
+          "#{context.registers[:site].config["url"]}#{sprite_config}"
+        else
+          sprite_config
+        end
+      end
+      
+      private
+      # Generates from page metadata and site config
+      # the style object pursuant to the Mapbox Style Spec
+      #
+      # @note The output can include some JS code to load layers asynchronously
+      #       and is as such not always valid JSON.
+      # @return [String] style persuant to Mapbox Style Spec
+      def style(context)
+        page_config = context.registers[:page].to_hash
+        site_config = context.registers[:site].config
+        
+        if page_config.dig('maplibre', 'style') then
+          page_config.dig('maplibre', 'style').to_json
+        elsif site_config.dig('maplibre', 'style') then
+          site_config.dig('maplibre', 'style').to_json
+        else
+          {
+            version: 8,
+            name: "OSM Liberty",
+            metadata: {
+              "maputnik:license": "https://github.com/maputnik/osm-liberty/blob/gh-pages/LICENSE.md",
+              "maputnik:renderer": "mbgljs",
+              "openmaptiles:version": "3.x"
+            },
+            sources: sources(context),
+            sprite: sprite_url(context),
+            glyphs: context.registers[:site].config["maplibre"]["glyphs"],
+            layers: "__LAYERS__",
+            id: "osm-liberty"
+          }.to_json.sub(%r{"__LAYERS__"}, layers(context)) # assumes that #to_json uses double quotes
+        end
+      end
+      
+      private
+      # Generates from page metadata and site config the sources
+      # for the style object pursuant to the Mapbox Style Spec
+      #
+      # @return [Hash] Mapbox Style sources
+      def sources(context)
+        page_config = context.registers[:page].to_hash
+        site_config = context.registers[:site].config
+        
+        if page_config.dig('maplibre', 'sources') then
+          page_config.dig('maplibre', 'sources')
+        elsif site_config.dig('maplibre', 'sources') then
+          site_config.dig('maplibre', 'sources')
+        else
+          raise "No MapLibre source found in site config and page meta data."
+        end
+      end
+      
+      private
+      # Generates from page metadata and site config the layers
+      # for the style object pursuant to the Mapbox Style Spec
+      # 
+      # @note The string is either some JS code to load a JSON file asynchronously or directly a JSON Hash.
+      # @return [String] Mapbox Style layers
+      def layers(context)
+        page_config = context.registers[:page].to_hash
+        site_config = context.registers[:site].config
+        
+        unless page_config.dig('maplibre', 'layers') or site_config.dig('maplibre', 'layers') then
+          raise "No MapLibre layers found in site config and page meta data."
+        end
+        
+        obj = page_config.dig('maplibre', 'layers') || site_config.dig('maplibre', 'layers')
+        if obj&.end_with? '.json' then
+          "await (await fetch('#{obj}')).json()"
+        else
+          obj.to_json
+        end
+      end
+      
+      private
+      # LngLat array from tag options or geojson to center the map
+      #
+      # @return [Array,nil] LngLat array or nil
+      def center(context)
+        @options[:attributes][:center]&.map{|v| v.to_f} || geojson(context).dig(:features, 0, :geometry, :coordinates)
+      end
+
+      private
+      # Generates map div attributes
+      #
+      # @return [String]
+      def attributes(context)
+        attr = []
+        attr << "id='#{@options[:attributes][:id]}'"
+        attr << %(class='#{Array(@options[:attributes][:class]).join(" ")}') if @options[:attributes][:class]
+        attr << %(style='#{(Array(@options[:attributes][:style]) + dimensions(context)).join(";")}')
+        attr.join(" ")
+      end
+
+      private
+      # Generates map div css with dimensions
+      #
+      # @return [String]
+      def dimensions(context)
+        width       = @options[:attributes][:width] || context.registers[:site].config.dig('maplibre', 'width') || DEFAULT_MAP_WIDTH
+        height      = @options[:attributes][:height] || context.registers[:site].config.dig('maplibre', 'height') || DEFAULT_MAP_HEIGHT
+        width_unit  = width.to_s.include?("%") ? "" : "px"
+        height_unit = height.to_s.include?("%") ? "" : "px"
+        ["width:#{width}#{width_unit}", "height:#{height}#{height_unit}"]
+      end
+
+      private
+      # Generates GeoJSON Hash from tag attributes or page metadata
+      #
+      # @return [Hash] GeoJSON Hash
+      def geojson(context)
+        @geojson ||= if @options[:attributes][:latitude] and @options[:attributes][:longitude] then
+          {
+            type: "FeatureCollection",
+            features: [{
+              type: "Feature",
+              # properties: {}.select {|key, value| !value.nil? },
+              geometry: {
+                type: "Point",
+                coordinates: [ # first long, that lat
+                  @options[:attributes]["longitude"].to_f,
+                  @options[:attributes]["latitude"].to_f,
+                ]
+              }
+            }],
+          }
+        elsif (context.registers[:page]["geojson"]&.is_a?(String) and context.registers[:page]["geojson"]&.end_with?(".json")) or
+              context.registers[:page]["geojson"]["type"] == "FeatureCollection" then
+          context.registers[:page]["geojson"].deep_symbolize_keys
+        elsif context.registers[:page]["geojson"]["type"] == "Feature" then
+          {
+            type: "FeatureCollection",
+            features: [context.registers[:page]["geojson"].deep_symbolize_keys]
+          }
+        elsif context.registers[:page]["location"]["latitude"] and context.registers[:page]["location"]["longitude"] then
+          {
+            type: "FeatureCollection",
+            features: [{
+              type: "Feature",
+              # properties: {}.select {|key, value| !value.nil? },
+              geometry: {
+                type: "Point",
+                coordinates: [ # first long, that lat
+                  context.registers[:page]["location"]["longitude"].to_f,
+                  context.registers[:page]["location"]["latitude"].to_f,
+                ]
+              }
+            }]
+          }
+        else
+          nil
+        end
+      end
+    end
+  end
+end
+
+Liquid::Template.register_tag("maplibre", Jekyll::MapLibre::MapLibreTag)

data/lib/jekyll-maplibre/options_parser.rb

@@ -0,0 +1,49 @@
+##
+# copyright: 2020 Anatoliy Yastreb <anatoliy.yastreb@gmail.com>
+# license: MIT
+#
+# original code from jekyll-maps, https://github.com/ayastreb/jekyll-maps/
+
+module Jekyll
+  module MapLibre
+    class OptionsParser
+      OPTIONS_SYNTAX     = %r!([^\s]+)\s*=\s*['"]+([^'"]+)['"]+!
+      ALLOWED_FLAGS      = %w(
+        no_cluster
+      ).freeze
+      ALLOWED_ATTRIBUTES = %w(
+        id
+        width
+        height
+        class
+        style
+        zoom
+        center
+        description
+        latitude
+        longitude
+      ).freeze
+
+      class << self
+        def parse(raw_options)
+          options = {
+            :attributes => {},
+            :flags      => {}
+          }
+          raw_options.scan(OPTIONS_SYNTAX).each do |key, value|
+            value = value.split(",") if value.include?(",")
+            if ALLOWED_ATTRIBUTES.include?(key)
+              options[:attributes][key.to_sym] = value
+            else
+              raise "found not allowed MapLibre tag attribute #{key}"
+            end
+          end
+          ALLOWED_FLAGS.each do |key|
+            options[:flags][key.to_sym] = true if raw_options.include?(key)
+          end
+          options
+        end
+      end
+    end
+  end
+end

data/lib/jekyll-maplibre/version.rb

@@ -0,0 +1,5 @@
+module Jekyll
+  module MapLibre
+    VERSION = "1.0-alpha.1".freeze
+  end
+end

data/lib/jekyll-maplibre.rb

@@ -0,0 +1,11 @@
+require "securerandom"
+
+require_relative "jekyll-maplibre/options_parser"
+require_relative "jekyll-maplibre/version"
+
+require_relative "jekyll-maplibre/maplibre_tag"
+
+module Jekyll
+  module MapLibre
+  end
+end

data/script/bootstrap

@@ -0,0 +1,3 @@
+#!/bin/sh
+
+bundle install

data/script/cibuild

@@ -0,0 +1,4 @@
+#! /bin/sh
+
+bundle exec rspec --color $@
+bundle exec rubocop -S -D

metadata

@@ -0,0 +1,135 @@
+--- !ruby/object:Gem::Specification
+name: jekyll-maplibre
+version: !ruby/object:Gem::Version
+  version: 1.0.pre.alpha.1
+platform: ruby
+authors:
+- Anatoliy Yastreb, Robert Riemann
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-12-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: jekyll
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.1'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.50.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.50.2
+description: MapLibre GL JS support for Jekyll websites to easily display vector maps
+  with geojson data
+email:
+- robert@riemann.cc
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rubocop.yml"
+- CHANGELOG.md
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- jekyll-maplibre.gemspec
+- lib/jekyll-maplibre.rb
+- lib/jekyll-maplibre/maplibre.html.erb
+- lib/jekyll-maplibre/maplibre_tag.rb
+- lib/jekyll-maplibre/options_parser.rb
+- lib/jekyll-maplibre/version.rb
+- script/bootstrap
+- script/cibuild
+homepage: https://blog.riemann.cc/projects/jekyll-maplibre
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubygems_version: 3.3.7
+signing_key:
+specification_version: 4
+summary: Maplibre GL JS for Jekyll
+test_files: []