jekyll-locale_sgh 0.5.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: cd84ec51b9857cf1c667cd8ae469f775b05faa65939e52d4dfd9ee91393208db
+  data.tar.gz: 19967b20e45e6b449f9c9042a4dbfcc3f1a8e17ddbf263432917c03c517e0c06
+SHA512:
+  metadata.gz: a3198bfd0fd8e3a6500be066531a81a8133f36c36511856f223277cdb87aa71e89821ab29ad5f4106b621174866e534dea13e38b37c08dd00d23dc0d2378f561
+  data.tar.gz: d0b23bb078040c3b59a164d027ddd8d80b114c133280748cf100c6ace50a59a748148dcb63009c0ad62729df2f090ce8e8f0bbfbbb76e73e6e20e4c20d4de659

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Ashwin Maroli
+
+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,23 @@
+# Jekyll Locale
+
+[![Linux Build Status](https://img.shields.io/travis/ashmaroli/jekyll-locale/master.svg?label=Linux%20build)][travis]
+[![Windows Build status](https://img.shields.io/appveyor/ci/ashmaroli/jekyll-locale/master.svg?label=Windows%20build)][appveyor]
+[![Maintainability](https://api.codeclimate.com/v1/badges/3a28682ac6c6693c4e77/maintainability)][maintainability]
+[![Test Coverage](https://api.codeclimate.com/v1/badges/3a28682ac6c6693c4e77/test_coverage)][test_coverage]
+
+[travis]: https://travis-ci.org/ashmaroli/jekyll-locale
+[appveyor]: https://ci.appveyor.com/project/ashmaroli/jekyll-locale/branch/master
+[maintainability]: https://codeclimate.com/github/ashmaroli/jekyll-locale/maintainability
+[test_coverage]: https://codeclimate.com/github/ashmaroli/jekyll-locale/test_coverage
+
+A localization plugin for Jekyll.
+
+
+## Features
+
+* Exposes a `{{ locale }}` object for your Liquid templates that can be used to "translate" strings in your site easily.
+* Depending on configured `mode`, the plugin either generates a *copy* of every page that renders into a HTML file, and
+  every document set to be written, and renders them into dedicated urls prepended by a supported locale, or, the plugin
+  "processes" only those files placed inside the plugin's configured **`content_dir`** .
+
+Read through the [documentation](https://jekyll-locale.netlify.com/) for details.

data/lib/jekyll-locale.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Jekyll
+  module Locale
+    autoload :Drop,     "jekyll/locale/drop"
+    autoload :Document, "jekyll/locale/document"
+    autoload :AutoPage, "jekyll/locale/auto_page"
+    autoload :Page,     "jekyll/locale/page"
+    autoload :Handler,  "jekyll/locale/handler"
+    autoload :Identity, "jekyll/locale/identity"
+  end
+end
+
+require_relative "jekyll/patches/site"
+require_relative "jekyll/patches/utils"
+
+require_relative "jekyll/locale/date_time_handler"
+require_relative "jekyll/locale/filters"
+
+require_relative "jekyll/locale/mixins/support"
+require_relative "jekyll/locale/mixins/helper"
+
+# Enhance Jekyll::Page and Jekyll::Document classes
+[Jekyll::Page, Jekyll::Document].each do |klass|
+  klass.include Jekyll::Locale::Support
+end
+
+Jekyll::Hooks.register :site, :after_reset do |site|
+  handler = site.locale_handler
+  handler.reset
+  I18n.config.enforce_available_locales = false
+end
+
+Jekyll::Hooks.register :site, :post_read do |site|
+  handler = site.locale_handler
+  handler.setup
+  handler.read
+end
+
+Jekyll::Hooks.register [:pages, :documents], :pre_render do |document, payload|
+  handler = document.site.locale_handler
+  handler.current_locale = document.locale
+  document.setup_hreflangs if document.setup_hreflangs?
+  payload["page"]["locale"]    = document.locale || handler.default_locale
+  payload["page"]["hreflangs"] = document.hreflangs
+  payload["page"]["locale_siblings"] = document.locale_siblings
+end

data/lib/jekyll/locale/auto_page.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Jekyll
+  class Locale::AutoPage < Page
+    include Locale::Helper
+
+    attr_reader    :path
+    attr_accessor  :data, :content, :output
+
+    def initialize(canon, locale)
+      setup(canon, locale)
+      @path    = canon.path
+      @content = canon.content
+      @data    = canon.data
+      @name    = File.basename(@path)
+      @relative_path = canon.relative_path
+      process(@name)
+    end
+
+    def url
+      @url ||= File.join("", locale.id, canon.url)
+    end
+
+    def to_liquid
+      @to_liquid ||= configure_payload(canon.to_liquid)
+    end
+  end
+end

data/lib/jekyll/locale/date_time_handler.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Jekyll
+  module Locale::DateTimeHandler
+    DATETIME_DEFAULTS = {
+      :date => {
+        :day_names        => Date::DAYNAMES,
+        :month_names      => Date::MONTHNAMES,
+        :abbr_day_names   => Date::ABBR_DAYNAMES,
+        :abbr_month_names => Date::ABBR_MONTHNAMES,
+      },
+      :time => {
+        :am      => "am",
+        :pm      => "pm",
+        :formats => {
+          :default => "%B %d, %Y %l:%M:%S %p %z",
+        },
+      },
+    }.freeze
+
+    class << self
+      extend Forwardable
+      [:config, :backend].each do |method|
+        private def_delegator I18n, method
+      end
+
+      def bootstrap(handler)
+        @handler = handler
+        config.available_locales = @handler.available_locales
+      end
+
+      def localize(input, format)
+        object = date_cache(input)
+        locale = @handler.current_locale.id.to_sym
+        data   = @handler.locale_dates[locale.to_s] || {}
+        store_translations(locale, data) unless translations.key?(locale)
+        backend.localize(locale, object, format)
+      end
+
+      def store_translations(locale, data)
+        backend.store_translations(
+          locale,
+          Utils.deep_merge_hashes(
+            DATETIME_DEFAULTS, Utils.recursive_symbolize_hash_keys(data)
+          )
+        )
+      end
+
+      private
+
+      def translations
+        backend.send(:translations)
+      end
+
+      def date_cache(input)
+        @date_cache ||= {}
+        @date_cache[input] ||= Liquid::Utils.to_date(input)
+      end
+    end
+  end
+end

data/lib/jekyll/locale/document.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Jekyll
+  class Locale::Document < Document
+    attr_reader :type
+    include Locale::Helper
+
+    def initialize(canon, locale)
+      setup(canon, locale)
+      @collection = canon.collection
+      @extname = File.extname(relative_path)
+      @has_yaml_header = nil
+      @type = @collection.label.to_sym
+      read
+
+      special_dir = draft? ? "_drafts" : @collection.relative_directory
+      categories_from_path(special_dir)
+
+      configure_data
+    end
+
+    def cleaned_relative_path
+      @cleaned_relative_path ||= begin
+        rel_path = relative_path[0..-extname.length - 1]
+        rel_path.sub!(@locale_page_dir, "")
+        rel_path.sub!(collection.relative_directory, "")
+        rel_path.gsub!(%r!\.*\z!, "")
+        rel_path
+      end
+    end
+
+    def url_template
+      @url_template ||= File.join("", locale.id, super)
+    end
+  end
+end

data/lib/jekyll/locale/drop.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Jekyll
+  class Locale::Drop < Drops::Drop
+    extend Forwardable
+
+    mutable false
+    private def_delegator :@obj, :data, :fallback_data
+  end
+end

data/lib/jekyll/locale/filters.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Jekyll
+  module Locale
+    module Filters
+      def localize_date(input, format = :default)
+        format = symbol_or_strftime(format)
+        DateTimeHandler.localize(time(input), format)
+      end
+
+      def prefix_locale(input)
+        return input unless input.is_a?(String)
+        return input if Addressable::URI.parse(input).absolute?
+
+        handler     = @context.registers[:site].locale_handler
+        page_locale = @context.registers[:page]["locale"]
+        page_locale = "" if page_locale.id == handler.default_locale.id
+        File.join("/", page_locale.to_s, input).squeeze("/")
+      end
+
+      private
+
+      def symbol_or_strftime(format)
+        return format if format.is_a?(Symbol)
+
+        format = format.to_s
+        if format.start_with?(":")
+          format.sub(":", "").to_sym
+        elsif format.start_with?("%")
+          format
+        else
+          :default
+        end
+      end
+    end
+  end
+end
+
+Liquid::Template.register_filter(Jekyll::Locale::Filters)

data/lib/jekyll/locale/handler.rb

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+
+module Jekyll
+  class Locale::Handler
+    attr_reader :default_locale, :available_locales, :locale_dates, :content_dirname,
+                :user_locales
+    attr_writer :current_locale
+
+    DEFAULT_CONFIG = {
+      "mode"        => "manual",
+      "locale"      => "en-US",
+      "data_dir"    => "locales",
+      "content_dir" => "_locales",
+      "locales_set" => [],
+      "exclude_set" => [],
+    }.freeze
+
+    def initialize(site)
+      @site   = site
+      config  = site.config["localization"]
+      @config = if config.is_a?(Hash)
+                  Jekyll::Utils.deep_merge_hashes(DEFAULT_CONFIG, config)
+                else
+                  DEFAULT_CONFIG
+                end
+      initialize_locales
+      @content_dirname = mode == "auto" ? "" : fetch("content_dir")
+      @snakeified_keys = {}
+    end
+
+    def reset
+      @locale_data  = {}
+      @locale_dates = {}
+      @portfolio = nil
+    end
+
+    def setup
+      Locale::DateTimeHandler.bootstrap(self)
+      setup_data if @locale_data.empty?
+    end
+
+    def data
+      locale_data[snakeified_keys(current_locale)] ||
+        locale_data[snakeified_keys(default_locale)] || {}
+    end
+
+    def read
+      mode == "auto" ? auto_localization : manual_localization
+    end
+
+    def current_locale
+      @current_locale ||= default_locale
+    end
+
+    def inspect
+      "#<#{self.class} @site=#{site}>"
+    end
+
+    private
+
+    attr_reader :site, :config, :locale_data
+
+    def setup_data
+      locales_dir = fetch("data_dir")
+      base_data   = site.site_data[locales_dir]
+      return @locale_data unless base_data.is_a?(Hash)
+
+      base_data.each do |locale_id, data|
+        next unless data.is_a?(Hash)
+        process_locale_data(locale_id, data)
+      end
+
+      nil
+    end
+
+    def initialize_locales
+      default_locale_id  = fetch("locale")
+      default_metadata   = {}
+      @available_locales = [default_locale_id]
+      @user_locales      = []
+
+      locales_set_config = @config["locales_set"]
+      locales_set_config = case locales_set_config
+                           when Array
+                             Hash[locales_set_config.map { |locale| [locale, {}] }]
+                           when Hash
+                             locales_set_config
+                           else
+                             {}
+                           end
+
+      locales_set_config.each do |locale_id, metadata|
+        if locale_id == default_locale_id
+          default_metadata = metadata
+          next
+        end
+
+        @available_locales << locale_id
+        @user_locales << Locale::Identity.new(locale_id, metadata)
+      end
+
+      @default_locale = Locale::Identity.new(default_locale_id, default_metadata)
+    end
+
+    def process_locale_data(loc, data_hash)
+      locale = snakeified_keys(loc)
+      @locale_data[locale] = {}
+
+      date_data = Locale::DateTimeHandler::DATETIME_DEFAULTS
+      data_hash.each do |key, value|
+        if key == "locale_date"
+          date_data = configure_locale_date(date_data, value)
+        else
+          @locale_data[locale][snakeified_keys(key)] = value
+        end
+      end
+      @locale_dates[loc] = date_data
+    end
+
+    def configure_locale_date(date_defaults, data)
+      return date_defaults unless data.is_a?(Hash)
+
+      Jekyll::Utils.deep_merge_hashes(
+        date_defaults, Utils.recursive_symbolize_hash_keys(data)
+      )
+    end
+
+    # Instances of Jekyll class that include `Jekyll::Locale::Support` mixin
+    # (which are simply Jekyll::Page and Jekyll::Document)
+    def portfolio
+      @portfolio ||= begin
+        html_pages = site.site_payload["site"]["html_pages"] || []
+        html_pages.reject! { |page| page.name == "404.html" }
+
+        (site.docs_to_write + html_pages).select do |doc|
+          doc.is_a?(Jekyll::Locale::Support)
+        end
+      end
+    end
+
+    def auto_localization
+      user_locales.each do |locale|
+        portfolio.each do |canon_doc|
+          next if canon_doc.relative_path =~ exclusion_regex
+          append_page(Locale::AutoPage, canon_doc, locale)
+        end
+      end
+    end
+
+    def manual_localization
+      user_locales.each do |locale|
+        portfolio.each do |canon_doc|
+          loc_page_path = site.in_source_dir(content_dirname, locale.id, canon_doc.relative_path)
+          next unless File.exist?(loc_page_path)
+          next unless Jekyll::Utils.has_yaml_header?(loc_page_path)
+
+          case canon_doc
+          when Jekyll::Page
+            append_page(Locale::Page, canon_doc, locale)
+          when Jekyll::Document
+            append_document(Locale::Document, canon_doc, locale)
+          end
+        end
+      end
+    end
+
+    def append_page(klass, canon_page, locale)
+      locale_page = klass.new(canon_page, locale)
+      return unless locale_page.publish?
+
+      canon_page.locale_pages << locale_page
+      site.pages              << locale_page
+      site.pages.uniq!
+    end
+
+    def append_document(klass, canon_doc, locale)
+      locale_doc = klass.new(canon_doc, locale)
+      return unless locale_doc.publish?
+
+      canon_doc.locale_pages    << locale_doc
+      canon_doc.collection.docs << locale_doc
+      site.docs_to_write        << locale_doc
+      site.docs_to_write.uniq!
+    end
+
+    def snakeified_keys(key)
+      @snakeified_keys[key] ||= Utils.snakeify(key)
+    end
+
+    def mode
+      @mode ||= begin
+        value = config["mode"]
+        value == "auto" ? value : DEFAULT_CONFIG["mode"]
+      end
+    end
+
+    def fetch(key)
+      value   = config[key]
+      default = DEFAULT_CONFIG[key]
+      return default unless value.class == default.class
+      return default if value.to_s.empty?
+
+      value
+    end
+
+    def exclusion_regex
+      @exclusion_regex ||= Regexp.new("\\A(?:#{Regexp.union(Array(config["exclude_set"]))})")
+    end
+  end
+end

data/lib/jekyll/locale/identity.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Jekyll
+  class Locale::Identity
+    attr_reader  :id, :data
+    alias_method :to_s, :id
+
+    def initialize(locale_id, metadata)
+      @id   = locale_id.to_s
+      @data = metadata
+    end
+
+    def to_liquid
+      @to_liquid ||= data.merge("id" => id)
+    end
+  end
+end

data/lib/jekyll/locale/mixins/helper.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Jekyll
+  module Locale::Helper
+    attr_reader :canon, :relative_path
+
+    def setup_hreflangs?
+      true
+    end
+
+    def setup_hreflangs
+      page_set = [canon] + canon.locale_pages
+      @hreflangs = sibling_data(page_set)
+      @locale_siblings = sibling_data(page_set - [self])
+    end
+
+    def permalink
+      canon_link = super
+      File.join(locale.id, canon_link) if canon_link
+    end
+
+    def inspect
+      "#<#{self.class} @canon=#{canon.inspect} @locale=#{locale.inspect}>"
+    end
+    alias_method :to_s, :inspect
+
+    private
+
+    def setup(canon, locale)
+      @locale  = locale
+      @canon   = canon
+      @site    = canon.site
+      @extname = canon.extname
+      @locale_page_dir = File.join(@site.locale_handler.content_dirname, locale.id, "")
+      @relative_path   = File.join(@locale_page_dir, canon.relative_path)
+      @path = @site.in_source_dir(@relative_path)
+    end
+
+    def configure_data
+      Array(@data["categories"]).delete_if do |category|
+        category == @site.locale_handler.content_dirname || category == @locale.id
+      end
+
+      @data = Jekyll::Utils.deep_merge_hashes(canon.data, @data)
+      @data.default_proc = proc do |_, key|
+        site.frontmatter_defaults.find(relative_path, type, key)
+      end
+    end
+
+    def configure_payload(payload)
+      payload.to_h.tap do |data|
+        data["path"] = self.relative_path
+        data["url"]  = self.url
+      end
+    end
+  end
+end

data/lib/jekyll/locale/mixins/support.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Jekyll
+  module Locale::Support
+    attr_reader :site, :locale
+
+    def setup_hreflangs?
+      false
+    end
+
+    def locale_siblings
+      @locale_siblings ||= sibling_data(locale_pages)
+    end
+
+    def hreflangs
+      @hreflangs ||= sibling_data([self] + locale_pages)
+    end
+
+    def locale_pages
+      @locale_pages ||= []
+    end
+
+    def publish?
+      site.publisher.publish?(self)
+    end
+
+    private
+
+    def sibling_data(locale_page_set)
+      locale_page_set.map do |locale_page|
+        next unless locale_page.publish?
+
+        locale = locale_page.locale || site.locale_handler.default_locale
+        {
+          "locale" => locale.to_liquid,
+          "url"    => locale_page.url,
+        }
+      end
+    end
+  end
+end

data/lib/jekyll/locale/page.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Jekyll
+  class Locale::Page < Page
+    include Locale::Helper
+    attr_reader :path
+
+    def initialize(canon, locale)
+      setup(canon, locale)
+      @dir, @name = File.split(relative_path)
+      @base = site.source
+      process(@name)
+      read_yaml(@dir, @name)
+      configure_data
+
+      # Empty the value as it is not longer required.
+      @dir = ""
+    end
+
+    def to_liquid
+      @to_liquid ||= configure_payload(super)
+    end
+
+    def template
+      @template ||= File.join("", locale.id, super)
+    end
+  end
+end

data/lib/jekyll/locale/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Jekyll
+  module Locale
+    VERSION = "0.5.2"
+  end
+end

data/lib/jekyll/patches/site.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Jekyll
+  class Drops::UnifiedPayloadDrop
+    def locale
+      @locale ||= Locale::Drop.new(@obj.locale_handler)
+    end
+  end
+
+  class Site
+    def locale_handler
+      @locale_handler ||= Locale::Handler.new(self)
+    end
+  end
+end

data/lib/jekyll/patches/utils.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Jekyll
+  module Utils
+    extend self
+
+    def snakeify(input)
+      slug = slugify(input.to_s, :mode => "latin", :cased => true)
+      slug.tr!("-", "_")
+      slug
+    end
+
+    def recursive_symbolize_hash_keys(hash)
+      result = {}
+      hash.each do |key, value|
+        new_key = key.to_s.to_sym
+        result[new_key] = value.is_a?(Hash) ? recursive_symbolize_hash_keys(value) : value
+      end
+      result
+    end
+  end
+end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification
+name: jekyll-locale_sgh
+version: !ruby/object:Gem::Version
+  version: 0.5.2
+platform: ruby
+authors:
+- Saeed G
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-05-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: jekyll
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.8'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.8'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description:
+email:
+- dev_projects@ghanavats.co.uk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/jekyll-locale.rb
+- lib/jekyll/locale/auto_page.rb
+- lib/jekyll/locale/date_time_handler.rb
+- lib/jekyll/locale/document.rb
+- lib/jekyll/locale/drop.rb
+- lib/jekyll/locale/filters.rb
+- lib/jekyll/locale/handler.rb
+- lib/jekyll/locale/identity.rb
+- lib/jekyll/locale/mixins/helper.rb
+- lib/jekyll/locale/mixins/support.rb
+- lib/jekyll/locale/page.rb
+- lib/jekyll/locale/version.rb
+- lib/jekyll/patches/site.rb
+- lib/jekyll/patches/utils.rb
+homepage: https://github.com/ghanavat/jekyll-locale
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.4
+signing_key:
+specification_version: 4
+summary: A localization plugin for Jekyll
+test_files: []