jekyll-polyglotter 1.4.0.pre.alpha.pre.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a3d60f4151f75331cc6d48bd65def65107d2118e17977bddf6b4688c803222f8
+  data.tar.gz: 5719649978b4af4e75a3a5ee62d55da957f40307bab757901068971893925628
+SHA512:
+  metadata.gz: 9f759bf20ace058c9bc234bfdc846e16571dd4ae54157c321a6245003ea394b20eb4151f6f0f8916fea4dc074a5276761531605cef51efa34e407eefcc967c8f
+  data.tar.gz: 65bab4ffef4f2d0d5876cd8f5688f2f5f96fd225e5ad07ee887dd419835906d0dcdf0e6ed7f82299d28e712aa07d766ee6cffad68334dd19abb84dfcd2b3ceb8

data/LICENSE.txt

@@ -0,0 +1,8 @@
+Copyright (c) 2018 Tnarik Innael
+Copyright (c) 2015 - 2017 Samuel Volin
+
+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,164 @@
+Polyglotter
+---
+[![Gem Version](https://badge.fury.io/rb/jekyll-polyglotter.svg)](https://badge.fury.io/rb/jekyll-polyglotter)
+[![Build Status](https://travis-ci.org/tnarik/polyglotter.svg?branch=master)](https://travis-ci.org/tnarik/polyglotter)
+
+__Polyglotter__ is a fast, painless, open-source internationalization plugin for [Jekyll](http://jekyllrb.com) blogs, based on [Polyglot](http://polyglot.untra.io/). Polyglotter is as easy (easier) to setup and use with any Jekyll project, and it scales to the languages you want to support. With fallback support for missing content (or language isolation), automatic url relativization, and powerful SEO tools, Polyglot allows any multi-language jekyll blog to focus on content without the cruft.
+
+## Why?
+Jekyll doesn't provide native support for multi-language blogs. This plugin was forked from [jekyll-polyglot](https://github.com/untra/polyglot), as it was lacking some features and didn't seem to be maintained.
+
+## Installation
+Add jekyll-polyglotter to your `Gemfile` if you are using Bundler:
+
+```Ruby
+group :jekyll_plugins do
+   gem "jekyll-polyglotter"
+end
+```
+
+Or install the gem manually by doing `gem install jekyll-polyglotter` and specify the plugin using `_config.yml`:
+```YAML
+plugins:
+  - jekyll-polyglotter
+```
+
+## Configuration
+In your `_config.yml` file, add the following preferences
+```YAML
+languages: ["en", "sv", "de", "fr"]
+default_lang: "en"
+exclude_from_localization: ["javascript", "images", "css"]
+parallel_localization: true
+```
+These configuration preferences indicate
+- what i18n languages you wish to support
+- what is your default "fallback" language for your content
+- what root level folders are you excluding from localization
+- whether to run language processing in parallel or serial
+
+## How To Use It
+When adding new posts and pages, add to the YAML front matter:
+```
+lang: es
+```
+or whatever appropriate [I18n language code](https://developer.chrome.com/webstore/i18n)
+the page should build for. And you're done. Ideally, when designing your site, you should
+organize files by their relative urls.
+
+Polyglotter works by associating documents with similar permalinks to the `lang` specified in their frontmatter. Files that correspond to similar routes should have identical permalinks. If you don't provide a permalink for a post, ___make sure you are consistent___ with how you place and name corresponding files:
+
+```
+_posts/2010-03-01-salad-recipes-en.md
+_posts/2010-03-01-salad-recipes-sv.md
+_posts/2010-03-01-salad-recipes-fr.md
+```
+
+Organized names will generate consistent permalinks when the post is rendered, and polyglot will know to build seperate language versions of
+the website using only the files with the correct `lang` variable in the front matter.
+
+In short:
+* Be consistent with how you name and place your *posts* files
+* Always give your *pages* permalinks in the frontmatter
+* Don't overthink it, :wink:
+
+
+#### Fallback Language Support
+Lets say you are building your website. You have an `/about/` page written in *english*, *german* and
+*swedish*. You are also supporting a *french* website, but you never designed a *french* version of your `/about/` page!
+
+No worries. Polyglotter ensures the sitemap of your *english* site matches your *french* site, matches your *swedish* and *german* sites too. In this case, because you specified a `default_lang` variable in your `_config.yml`, all sites missing their languages' counterparts will fallback to your `default_lang`, so content is preserved across different languages of your site.
+
+#### Relativized Local Urls
+No need to meticulously manage anchor tags to link to your correct language. Polyglot modifies how pages get written to the site so your *french* links keep vistors on your *french* blog.
+```md
+---
+title: au sujet de notre entreprise
+permalink: /about/
+lang: fr
+---
+Nous sommes un restaurant situé à Paris . [Ceci est notre menu.](/menu/)
+```
+becomes
+```html
+<header class="post-header">
+  <h1 class="post-title">au sujet de notre entreprise</h1>
+</header>
+
+<article class="post-content">
+  <p>Nous sommes un restaurant situé à Paris . <a href="/fr/menu/">Ceci est notre menu.</a></p>
+</article>
+```
+Notice the link `<a href="/fr/menu/">...` directs to the french website.
+
+Even if you are falling back to `default_lang` page, relative links built on the *french* site will
+still link to *french* pages.
+
+#### Relativized Absolute Urls
+If you defined a site `url` in your `_config.yaml`, polyglot will automatically relativize absolute links pointing to your website directory:
+
+```md
+---
+lang: fr
+---
+Cliquez [ici]({{site.url}}) pour aller à l'entrée du site.
+```
+becomes
+```html
+<p>Cliquez <a href="https://mywebsite.com/fr/">ici</a> pour aller à l'entrée du site.
+```
+
+#### Disabling Url Relativizing
+If you don't want a url to be relativized, you can add a space explicitly into the href to prevents a url from being relativized by polyglot.
+
+For example, the following urls will be relativized:
+
+```html
+href="http://mywebsite.com/about"
+href="/about"
+```
+
+and the following urls will be left alone:
+
+```html
+href=" http://mywebsite.com/about"
+href=" /about"
+```
+
+combine with a [html minifier](https://github.com/digitalsparky/jekyll-minifier) for a polished and production ready website.
+
+#### Localized site.data
+
+There are cases when `site.data` localization is required.
+For instance: you might need to localize `_data/navigation.yml` that holds "navigation menu".
+In order to localize it, just place language-specific files in `_data/:lang/...` folder, and Polyglot will bring those keys to the top level.
+
+## How It Works
+This plugin makes modifications to existing Jekyll classes and modules, namely `Jekyll::StaticFile` and `Jekyll::Site`. These changes are as lightweight and slim as possible. The biggest change is in `Jekyll::Site.process`. Polyglot overwrites this method to instead spawn a separate thread for each language you intend to process the site for. Each of those threads calls the original `Jekyll::Site.process` method with its language in mind, ensuring your website scales to support any number of languages, while building all of your site languages simultaneously.
+
+`Jekyll::Site.process` is the entry point for the Jekyll build process. Take care whatever other plugins you use do not also attempt to overwrite this method. You may have problems.
+
+## Features
+This plugin stands out from other I18n Jekyll plugins:
+
+- automatically corrects your relative links, keeping your *french* visitors on your *french* website, even when content has to fallback to the `default_lang`.
+- builds all versions of your website *simultaneously*, allowing big websites to scale efficiently.
+- provides the liquid tag `{{ site.languages }}` to get an array of your I18n strings.
+- provides the liquid tag `{{ site.default_lang }}` to get the default_lang I18n string.
+- provides the liquid tag `{{ site.active_lang }}` to get the I18n language string the website was built for. Alternative names for `active_lang` can be configured via `config.lang_vars`.
+- provides the liquid tag `{{ I18n_Headers https://yourwebsite.com/ }}` to append SEO bonuses to your website.
+- provides `site.data` localization for efficient rich text replacement.
+- a creator that will answer all of your questions and issues.
+
+## SEO Recipes
+Jekyll-polyglotter uses the same few spectacular [Search Engine Optimization techniques](https://untra.github.io/polyglot/seo) as [Polyglot](http://polyglot.untra.io/) to ensure your Jekyll blog gets the most out of it's multilingual audience. Check them out!
+
+## Compatibility
+Currently supports Jekyll 3.0 .
+Windows users will need to disable parallel_localization on their machines by setting `parallel_localization: false` in the `_config.yml`
+
+## Copyright
+
+Copyright (c) Tnarik Innael 2018. License: MIT
+
+Copyright (c) Samuel Volin 2017. License: MIT

data/lib/jekyll-polyglotter.rb

@@ -0,0 +1 @@
+require "jekyll/polyglotter"

data/lib/jekyll/polyglotter.rb

@@ -0,0 +1,6 @@
+require 'jekyll'
+
+require_relative 'polyglotter/liquid'
+require_relative 'polyglotter/patches'
+require_relative 'polyglotter/hooks'
+require_relative 'polyglotter/version'

data/lib/jekyll/polyglotter/hooks.rb

@@ -0,0 +1,3 @@
+require_relative 'hooks/assets-toggle'
+require_relative 'hooks/coordinate'
+require_relative 'hooks/process'

data/lib/jekyll/polyglotter/hooks/assets-toggle.rb

@@ -0,0 +1,7 @@
+# Jekyll::Hooks.register :site, :after_init do |site|
+#   if site.config['assets']
+#     if site.active_lang != site.default_lang
+#       then jekyll.sprockets.asset_config['autowrite'] = false
+#     end
+#   end
+# end

data/lib/jekyll/polyglotter/hooks/coordinate.rb

@@ -0,0 +1,23 @@
+# hook to coordinate blog posts and pages into distinct urls,
+# and remove duplicate multilanguage posts and pages
+Jekyll::Hooks.register :site, :post_read do |site|
+  hook_coordinate(site)
+end
+
+def hook_coordinate(site)
+  # Copy the language specific data, by recursively merging it with the default data.
+  # Favour active_lang first, then default_lang, then any non-language-specific data.
+  # See: https://www.ruby-forum.com/topic/142809
+  merger = proc { |key, v1, v2| Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : v2 }
+  if site.data.include?(site.default_lang)
+    site.data = site.data.merge(site.data[site.default_lang], &merger)
+  end
+  if site.data.include?(site.active_lang)
+    site.data = site.data.merge(site.data[site.active_lang], &merger)
+  end
+
+  site.collections.each do |_, collection|
+    collection.docs = site.coordinate_documents(collection.docs)
+  end
+  site.pages = site.coordinate_documents(site.pages)
+end

data/lib/jekyll/polyglotter/hooks/process.rb

@@ -0,0 +1,11 @@
+# hook to make a call to process rendered documents,
+Jekyll::Hooks.register :site, :post_render do |site|
+  hook_process(site)
+end
+
+def hook_process(site)
+  site.collections.each do |_, collection|
+    site.process_documents(collection.docs)
+  end
+  site.process_documents(site.pages)
+end

data/lib/jekyll/polyglotter/liquid.rb

@@ -0,0 +1,7 @@
+module Jekyll
+  module Polyglotter
+    module Liquid
+      require_relative 'liquid/tags/i18n-headers'
+    end
+  end
+end

data/lib/jekyll/polyglotter/liquid/tags/i18n-headers.rb

@@ -0,0 +1,31 @@
+module Jekyll
+  module Polyglotter
+    module Liquid
+      class I18nHeadersTag < ::Liquid::Tag
+        def initialize(tag_name, text, tokens)
+          super
+          @url = text
+          @url.strip!
+          @url.chomp! '/'
+        end
+
+        def render(context)
+          site = context.registers[:site]
+          permalink = context.registers[:page]['permalink']
+          site_url = @url.empty? ? site.config['url'] : @url
+          i18n = "<meta http-equiv=\"Content-Language\" content=\"#{site.active_lang}\">\n"
+          i18n += "<link rel=\"alternate\" hreflang=\"#{site.default_lang}\" "\
+          "href=\" #{site_url}#{permalink}\"/>\n"
+          site.languages.each do |lang|
+            next if lang == site.default_lang
+            i18n += "<link rel=\"alternate\" hreflang=\"#{lang}\" "\
+            "href=\"#{site_url}/#{lang}#{permalink}\"/>\n"
+          end
+          i18n
+        end
+      end
+    end
+  end
+end
+
+Liquid::Template.register_tag('I18n_Headers', Jekyll::Polyglotter::Liquid::I18nHeadersTag)

data/lib/jekyll/polyglotter/patches.rb

@@ -0,0 +1,4 @@
+require_relative 'patches/jekyll/site'
+require_relative 'patches/jekyll/page'
+require_relative 'patches/jekyll/document'
+require_relative 'patches/jekyll/static_file'

data/lib/jekyll/polyglotter/patches/jekyll/document.rb

@@ -0,0 +1,41 @@
+module Jekyll
+
+  # Monkey patched to unify the title (remove the language token suffix if there is any)
+  # The language token comes from the Front Matter or the default language
+  class Document
+    def lang
+      data[site.lang_field] || site.default_lang
+    end
+
+    alias_method :read_post_data_orig, :read_post_data
+    def read_post_data
+      read_post_data_orig
+      site.page_lang_vars.each do |v|
+        data[v] ||= lang
+      end
+    end
+
+    def title_url_regex
+      # File basename matching .{language} -{language} {language}. {language}-
+      regex = "([\.\-]#{lang}[\.\-]?)|([\.\-]?#{lang}[\.\-])"
+      %r{#{regex}}
+    end
+
+    def path_url_regex
+      # Path like bar/{language}/foo , bar.{language}/foo, bar/{language}/fu/foo, bar.{language}/fu/foo
+      regex = "([\/\.]#{lang}[\/]?)"
+      %r{#{regex}}
+    end
+
+    def url
+      unified_title = url_placeholders['title'].gsub(title_url_regex, '')
+      unified_path = url_placeholders['path'].gsub(path_url_regex, '')
+
+      @url ||= URL.new({
+        :template     => url_template,
+        :placeholders => url_placeholders.to_h.merge({ 'path' => unified_path, 'title' => unified_title }),
+        :permalink    => permalink,
+      }).to_s
+    end
+  end
+end

data/lib/jekyll/polyglotter/patches/jekyll/page.rb

@@ -0,0 +1,33 @@
+module Jekyll
+
+  # Monkey patched to unify the title (remove the language token suffix if there is any)
+  # The language token comes from the Front Matter or the default language
+  class Page
+    def lang
+      data[site.lang_field] || site.default_lang
+    end
+
+    def title_url_regex
+      # File basename matching .{language} -{language} {language}. {language}-
+      regex = "([\.\-]#{lang}[\.\-]?)|([\.\-]?#{lang}[\.\-])"
+      %r{#{regex}}
+    end
+
+    def path_url_regex
+      # Path like /{language}/foo , .{language}/foo
+      regex = "([\/\.]#{lang}[\/]?)"
+      %r{#{regex}}
+    end
+
+    def url
+      unified_title = url_placeholders[:basename].gsub(title_url_regex, '')
+      unified_path = url_placeholders[:path].gsub(path_url_regex, '')
+
+      @url ||= URL.new({
+        :template     => template,
+        :placeholders => url_placeholders.merge({ path: unified_path, basename: unified_title }),
+        :permalink    => permalink,
+      }).to_s
+    end
+  end
+end

data/lib/jekyll/polyglotter/patches/jekyll/site.rb

@@ -0,0 +1,218 @@
+include Process
+module Jekyll
+  class Site
+    attr_reader :default_lang, :languages, :exclude_from_localization, :lang_vars, :lang_field, :page_lang_vars
+    attr_accessor :file_langs, :active_lang
+
+    def prepare
+      @file_langs = {}
+      fetch_languages
+      @parallel_localization = config.fetch('parallel_localization', true)
+      @exclude_from_localization = config.fetch('exclude_from_localization', [])
+      @isolate_languages = config.fetch('isolate_languages', false)
+      @all_docs = {}
+      @lang_field = config.fetch('lang_field', 'lang')
+
+    end
+
+    def fetch_languages
+      @default_lang = config.fetch('default_lang', 'en')
+      @languages = config.fetch('languages', ['en'])
+      @keep_files += (@languages - [@default_lang])
+      @active_lang = @default_lang
+      @lang_vars = config.fetch('lang_vars', [])
+      @page_lang_vars = config.fetch('page_lang_vars', [])
+    end
+
+    alias_method :process_orig, :process
+    def process
+      prepare
+      all_langs = (@languages + [@default_lang]).uniq
+      if @parallel_localization
+        pids = {}
+        all_langs.each do |lang|
+          pids[lang] = fork do
+            process_language lang
+          end
+        end
+        Signal.trap('INT') do
+          all_langs.each do |lang|
+            puts "Killing #{pids[lang]} : #{lang}"
+            kill('INT', pids[lang])
+          end
+        end
+        all_langs.each do |lang|
+          waitpid pids[lang]
+          detach pids[lang]
+        end
+      else
+        all_langs.each do |lang|
+          process_language lang
+        end
+      end
+    end
+
+
+    # Unified configuration
+    def description
+      if config.fetch('description', '').is_a?(Hash)
+        @description ||= config['description'].has_key?(active_lang)? config['description'][active_lang] : config['description'][@default_lang]
+      else
+        @description ||= config.fetch('description', '')
+      end
+    end
+
+    def title
+      if config.fetch('title', '').is_a?(Hash)
+        @title ||= config['title'].has_key?(active_lang)? config['title'][active_lang] : config['title'][@default_lang]
+      else
+        @title ||= config.fetch('title', '')
+      end
+    end
+
+    # This allows injecting runtime 'config values' (or site.* liquid tags)
+    alias_method :site_payload_orig, :site_payload
+    def site_payload
+      payload = site_payload_orig
+      payload['site']['default_lang'] = default_lang
+      payload['site']['languages'] = languages
+      payload['site']['active_lang'] = active_lang
+      payload['site']['all_docs'] = @all_docs
+
+      payload['site']['description'] = description
+      payload['site']['title'] = title
+
+      lang_vars.each do |v|
+        payload['site'][v] = active_lang
+      end
+      payload
+    end
+
+    def process_language(lang)
+      @active_lang = lang
+      config['active_lang'] = @active_lang
+      lang_vars.each do |v|
+        config[v] = @active_lang
+      end
+      if @active_lang == @default_lang
+      then process_default_language
+      else process_active_language
+      end
+    end
+
+    def process_default_language
+      old_include = @include
+      process_orig
+      @include = old_include
+    end
+
+    def process_active_language
+      old_dest = @dest
+      old_exclude = @exclude
+      @file_langs = {}
+      @dest = @dest + '/' + @active_lang
+      @exclude += @exclude_from_localization
+      process_orig
+      @dest = old_dest
+      @exclude = old_exclude
+    end
+
+    # assigns natural permalinks to documents and cascades prioritizing documents with
+    # active_lang languages (except for, optionally, posts and HTML pages)
+    def coordinate_documents(docs)
+      approved = {}
+      docs.each do |doc|
+        lang = doc.data[@lang_field] || @default_lang
+        @all_docs[doc.url] ||= []
+        @all_docs[doc.url] << lang
+        @all_docs[doc.url].uniq!
+        @all_docs[doc.url].sort!
+
+        if @isolate_languages
+          # posts/HTML pages are only approved for the active language (no mixing of languages)
+          next if (doc.is_a?(Jekyll::Document) || doc.is_a?(Jekyll::Page) && doc.html? ) && lang != @active_lang
+        end
+        # otherwise use whatever we have, giving priority to the default and active languages
+        next if @file_langs[doc.url] == @active_lang
+        next if @file_langs[doc.url] == @default_lang && lang != @active_lang
+        approved[doc.url] = doc
+        @file_langs[doc.url] = lang
+      end
+      approved.values
+    end
+
+    # performs any necessary operations on the documents before rendering them
+    def process_documents(docs)
+      # Inject the language token in the URLs (except for the default language)
+      unless @active_lang == @default_lang
+        url = config.fetch('url', false)
+        rel_regex = relative_url_regex
+        abs_regex = absolute_url_regex(url)
+        docs.each do |doc|
+          relativize_urls(doc, rel_regex)
+          if url
+          then relativize_absolute_urls(doc, abs_regex, url)
+          end
+        end
+      end
+
+      # Remove the language token for the default languages
+      rel_regex = relative_url_regex([@default_lang])
+      abs_regex = absolute_url_regex(url, [@default_lang])
+      docs.each do |doc|
+        unrelativize_urls(doc, rel_regex)
+        if url
+        then unrelativize_absolute_urls(doc, abs_regex, url)
+        end
+      end
+    end
+
+    # a regex that matches relative urls in a html document
+    # matches href="baseurl/foo/bar-baz" and others like it
+    # avoids matching excluded files
+    def relative_url_regex(langs = [])
+      exclude_regex = ''
+      (@exclude + @languages.reject { |l| langs.include?(l) }).each do |x|
+        exclude_regex += "(?!#{x}\/)"
+      end
+
+      strip_regex = ''
+      langs.each do |x|
+        strip_regex += "(?:#{x}\/)?"
+      end
+
+      %r{href=\"?#{@baseurl}\/#{strip_regex}((?:#{exclude_regex}[^,'\"\s\/?\.#]+\.?)*(?:\/[^\]\[\)\(\"\'\s]*)?)\"}
+    end
+
+    def absolute_url_regex(url, langs = [])
+      exclude_regex = ''
+      (@exclude + @languages.reject { |l| langs.include?(l) }).each do |x|
+        exclude_regex += "(?!#{x}\/)"
+      end
+
+      strip_regex = ''
+      langs.each do |x|
+        strip_regex += "(?:#{x}\/)?"
+      end
+
+      %r{href=\"?#{url}#{@baseurl}\/#{strip_regex}((?:#{exclude_regex}[^,'\"\s\/?\.#]+\.?)*(?:\/[^\]\[\)\(\"\'\s]*)?)\"}
+    end
+
+    def relativize_urls(doc, regex)
+      doc.output.gsub!(regex, "href=\"#{@baseurl}/#{@active_lang}/" + '\1"')
+    end
+
+    def relativize_absolute_urls(doc, regex, url)
+      doc.output.gsub!(regex, "href=\"#{url}#{@baseurl}/#{@active_lang}/" + '\1"')
+    end
+
+    def unrelativize_urls(doc, regex)
+      doc.output.gsub!(regex, "href=\"#{@baseurl}/" + '\1"')
+    end
+
+    def unrelativize_absolute_urls(doc, regex, url)
+      doc.output.gsub!(regex, "href=\"#{url}#{@baseurl}/" + '\1"')
+    end
+
+  end
+end

data/lib/jekyll/polyglotter/patches/jekyll/static_file.rb

@@ -0,0 +1,21 @@
+
+module Jekyll
+  # Alteration to Jekyll StaticFile
+  # provides aliased methods to direct write to skip files
+  # excluded from localization
+  class StaticFile
+    alias_method :write_orig, :write
+    def write(dest)
+      return false if exclude_from_localization?
+      write_orig(dest)
+    end
+
+    def exclude_from_localization?
+      return false if @site.active_lang == @site.default_lang
+      @site.exclude_from_localization.each do |e|
+        return true if relative_path[1..-1].start_with?(e)
+      end
+      false
+    end
+  end
+end

data/lib/jekyll/polyglotter/version.rb

@@ -0,0 +1,5 @@
+module Jekyll
+  module Polyglotter
+    VERSION = '1.4.0-alpha'.freeze
+  end
+end

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification
+name: jekyll-polyglotter
+version: !ruby/object:Gem::Version
+  version: 1.4.0.pre.alpha.pre.2
+platform: ruby
+authors:
+- Samuel Volin
+- Tnarik Innael
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-07-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: jekyll
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+description: Fast open source i18n plugin for Jekyll blogs.
+email: tnarik@lecafeautomatique.co.uk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/jekyll-polyglotter.rb
+- lib/jekyll/polyglotter.rb
+- lib/jekyll/polyglotter/hooks.rb
+- lib/jekyll/polyglotter/hooks/assets-toggle.rb
+- lib/jekyll/polyglotter/hooks/coordinate.rb
+- lib/jekyll/polyglotter/hooks/process.rb
+- lib/jekyll/polyglotter/liquid.rb
+- lib/jekyll/polyglotter/liquid/tags/i18n-headers.rb
+- lib/jekyll/polyglotter/patches.rb
+- lib/jekyll/polyglotter/patches/jekyll/document.rb
+- lib/jekyll/polyglotter/patches/jekyll/page.rb
+- lib/jekyll/polyglotter/patches/jekyll/site.rb
+- lib/jekyll/polyglotter/patches/jekyll/static_file.rb
+- lib/jekyll/polyglotter/version.rb
+homepage: https://github.com/tnarik/polyglotter
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.7
+signing_key: 
+specification_version: 4
+summary: I18n plugin for Jekyll Blogs
+test_files: []