kontent-jekyll 0.11.0

data/lib/kontent-jekyll/site_processing/custom_site_processor.rb

@@ -0,0 +1,12 @@
+module Kentico
+  module Kontent
+    module SiteProcessing
+      class CustomSiteProcessor
+        def self.for(config)
+          class_name = config.custom_site_processor
+          class_name && Module.const_get(class_name).new
+        end
+      end
+    end
+  end
+end

data/lib/kontent-jekyll/site_processing/kentico_kontent_importer.rb

@@ -0,0 +1,88 @@
+require 'kontent-delivery-sdk-ruby'
+
+require 'kontent-jekyll/resolvers/content_link_resolver'
+require 'kontent-jekyll/resolvers/inline_content_item_resolver'
+
+require 'kontent-jekyll/constants/kentico_config_keys'
+
+require 'kontent-jekyll/version'
+require 'kontent-jekyll/gem_name'
+
+module Kentico
+  module Kontent
+    module SiteProcessing
+      include Constants
+      include Resolvers
+
+      class KenticoKontentImporter
+        def initialize(config)
+          @config = config
+          @items = []
+          @taxonomy_groups = []
+        end
+
+        def items_by_type(language)
+          retrieve_items(language)
+            .group_by { |item| item.system.type }
+        end
+
+        def taxonomies
+          @taxonomy_groups = retrieve_taxonomies
+        end
+
+        private
+
+        def inline_content_item_resolver
+          @inline_content_item_resolver ||= Resolvers::InlineContentItemResolver.for(@config)
+        end
+
+        def content_link_url_resolver
+          @content_link_url_resolver ||= Resolvers::ContentLinkResolver.for(@config)
+        end
+
+        def delivery_client
+          project_id = value_for(@config, Constants::KenticoConfigKeys::PROJECT_ID)
+          secure_key = value_for(@config, Constants::KenticoConfigKeys::SECURE_KEY)
+
+          Kentico::Kontent::Delivery::DeliveryClient.new(
+            project_id: project_id,
+            secure_key: secure_key,
+            content_link_url_resolver: content_link_url_resolver,
+            inline_content_item_resolver: inline_content_item_resolver
+          )
+        end
+
+        def retrieve_taxonomies
+          delivery_client
+            .taxonomies
+            .custom_headers(custom_headers)
+            .request_latest_content
+            .execute { |response| return response.taxonomies }
+        end
+
+        def retrieve_items(language)
+          client = delivery_client.items
+          client = client.language(language) if language
+          client
+            .custom_headers(custom_headers)
+            .request_latest_content
+            .depth(@config.max_linked_items_depth || 1)
+            .execute { |response| return response.items }
+        end
+
+        def value_for(config, key)
+          potential_value = config[key]
+          return ENV[potential_value.gsub('ENV_', '')] if !potential_value.nil? && potential_value.start_with?('ENV_')
+          potential_value
+        end
+
+        # Add extra headers like tracking
+        def custom_headers
+          {
+            'X-KC-SOURCE' => "#{GEM_NAME} #{VERSION}",
+          }
+        end
+      end
+    end
+  end
+end

data/lib/kontent-jekyll/site_processing/site_processor.rb

@@ -0,0 +1,249 @@
+require 'date'
+
+require 'kontent-jekyll/constants/page_type'
+
+require 'kontent-jekyll/resolvers/front_matter_resolver'
+require 'kontent-jekyll/resolvers/content_resolver'
+require 'kontent-jekyll/resolvers/data_resolver'
+require 'kontent-jekyll/resolvers/filename_resolver'
+
+require 'kontent-jekyll/utils/normalize_object'
+
+module Kentico
+  module Kontent
+    module SiteProcessing
+      ##
+      # This class processes the the imported content and populate Jekyll structures.
+
+      class SiteProcessor
+        include Constants
+        include Resolvers
+        include Utils
+
+        ##
+        # These collections have specific purposes in the original Jekyll generation will be omitted.
+
+        RESERVED_COLLECTIONS = %w(posts data)
+
+        def initialize(site, config)
+          @site = site
+          @config = config
+        end
+
+        ##
+        # Populates standard Jekyll pages and collections
+
+        def process_pages(items_by_type)
+          pages_config = @config.pages
+          return unless pages_config
+
+          pages_config.each_pair do |type, page_config|
+            pages = items_by_type[type.to_s]
+            next unless pages
+
+            collection_name = page_config&.collection
+
+            pages_data = []
+            pages.each do |page_item|
+              content = content_resolver.execute(page_item, page_config)
+              front_matter = front_matter_resolver.execute(page_item, PageType::PAGE)
+              front_matter = normalize_object(front_matter)
+
+              mapped_name = filename_resolver.execute(page_item)
+              filename = "#{mapped_name}.html"
+
+              page_data = OpenStruct.new(content: content, collection: collection_name, front_matter: front_matter, filename: filename)
+              pages_data << page_data
+            end
+
+            are_pages_from_collection = collection_name && !collection_name.empty? && !RESERVED_COLLECTIONS.include?(collection_name)
+
+            unless are_pages_from_collection
+              @site.pages += pages_data.map { |page_data| create_kentico_page(@site, page_data) }
+              next
+            end
+
+            collection_config = @site.config['collections'][collection_name]
+            if collection_config
+              collection_config['output'] = true unless defined?(collection_config['output'])
+            else
+              @site.config['collections'][collection_name] = { 'output' => true }
+            end
+
+            collection = @site.collections[collection_name] ||= Jekyll::Collection.new(@site, collection_name)
+
+            pages_data.each do |page_data|
+              path = File.join(@site.source, "_#{collection_name}", page_data.filename)
+
+              page = create_document(path, @site, collection, page_data)
+
+              page.instance_eval 'merge_defaults'
+              page.instance_eval 'read_post_data'
+
+              collection.docs << page
+            end
+
+            collection.docs = collection.docs.reverse.uniq(&:path).reverse
+            collection.docs.sort!
+          end
+
+          @site.pages = @site.pages.reverse.uniq(&:path).reverse
+          @site.pages.sort_by!(&:name)
+        end
+
+        ##
+        # Populates posts part of the Jekyll site
+
+        def process_posts(items_by_type)
+          posts_config = @config.posts
+          return unless posts_config
+
+          type = posts_config&.type
+
+          posts = items_by_type[type.to_s]
+          return unless posts
+
+          posts.each do |post_item|
+            content = content_resolver.execute(post_item, posts_config)
+            front_matter = front_matter_resolver.execute(post_item, PageType::POST)
+            front_matter = normalize_object(front_matter)
+
+            date = post_item.elements[posts_config.date || 'date'].value
+            date_string = DateTime.parse(date).strftime('%Y-%m-%d')
+
+            mapped_name = filename_resolver.execute(post_item)
+            filename = "#{date_string}-#{mapped_name}.html"
+
+            post_data = OpenStruct.new(content: content, front_matter: front_matter, filename: filename)
+
+            path = File.join(@site.source, '_posts', filename)
+            post = create_document(path, @site, @site.posts, post_data)
+
+            ##
+            # We need to invoke these private methods as they correctly populate certain data automatically.
+
+            post.instance_eval 'merge_defaults'
+            post.instance_eval 'read_post_data'
+
+            @site.posts.docs << post
+          end
+
+          @site.posts.docs = @site.posts.docs.reverse.uniq(&:path).reverse
+          @site.posts.docs.sort!
+        end
+
+        ##
+        # Populates data part of the Jekyll site.
+
+        def process_data(items_by_type)
+          config = @config.data
+
+          data_items = {}
+          config && config.each_pair do |item_type, name|
+            items = items_by_type[item_type.to_s]
+            next unless items
+
+            name ||= item_type.to_s
+            processed_items = items.map do |item|
+              data = data_resolver.execute(item)
+              normalize_object(data)
+            end
+
+            data_items[name] = (data_items[name] || []) + processed_items
+          end
+
+          @site.data.merge!({ 'items' => data_items })
+        end
+
+        ##
+        # Populates data part of the Jekyll site with taxonomies.
+
+        def process_taxonomies(taxonomies)
+          codenames = @config.taxonomies
+          return unless codenames && taxonomies
+
+          filtered_taxonomies = taxonomies.select { |taxonomy| codenames.include? taxonomy.system.codename }
+
+          processed_taxonomies = {}
+          filtered_taxonomies.each do |taxonomy|
+            taxonomy_data = normalize_object({
+               system: taxonomy.system,
+               terms: taxonomy.terms,
+            })
+
+            processed_taxonomies[taxonomy.system.codename] = taxonomy_data
+          end
+
+          @site.data['taxonomies'] = processed_taxonomies
+        end
+
+        private
+
+        ##
+        # Creates a Jekyll::Page.
+
+        def create_kentico_page(site, page_info)
+          page = Jekyll::Page.allocate
+
+          ## A hack to create a Jekyll::Page with custom constructor without overriding the class
+          # because jekyll-redirect-from can work only with Jekyll::Page instances.
+          # Once this PR https://github.com/jekyll/jekyll-redirect-from/pull/204 is merged and released
+          # we can create a subclass of the Page and simplify the code.
+
+          page.define_singleton_method(:initialize) do
+            @site = site
+            @base = site.source
+            @dir = ''
+            @name = page_info.filename
+            @path = if site.in_theme_dir(@base) == @base
+                      site.in_theme_dir(@base, @dir, @name)
+                    else
+                      site.in_source_dir(@base, @dir, @name)
+                    end
+
+            self.process(@name)
+
+            self.data = page_info.front_matter
+            self.content = page_info.content
+
+            data.default_proc = proc do |_, key|
+              site.frontmatter_defaults.find(File.join(@dir, @name), type, key)
+            end
+
+            Jekyll::Hooks.trigger :pages, :post_init, self
+
+            self
+          end
+
+          page.initialize
+        end
+
+        ##
+        # Creates a Jekyll::Document. Used for collections.
+
+        def create_document(path, site, collection, source)
+          doc = Jekyll::Document.new(path, site: site, collection: collection)
+          doc.content = source.content
+          doc.data.merge!(source.front_matter)
+          doc
+        end
+
+        def content_resolver
+          @content_resolver ||= Resolvers::ContentResolver.new(@config)
+        end
+
+        def filename_resolver
+          @filename_resolver ||= Resolvers::FilenameResolver.new(@config)
+        end
+
+        def front_matter_resolver
+          @front_matter_resolver ||= Resolvers::FrontMatterResolver.new(@config)
+        end
+
+        def data_resolver
+          @data_resolver ||= Resolvers::DataResolver.new(@config)
+        end
+      end
+    end
+  end
+end

data/lib/kontent-jekyll/utils/normalize_object.rb

@@ -0,0 +1,88 @@
+module Kentico
+  module Kontent
+    module Utils
+      ##
+      # Transforms any object into easily seriazible format.
+      # OpenStruct is converted to hash and Symbol keys are transformed to string keys.
+
+      def normalize_object(object)
+        stringify_all_keys(to_hash(object))
+      end
+
+      private
+
+      def open_struct_values_to_hash(struct)
+        hash = {}
+        struct.each_pair do |key, value|
+          hash[key] = to_hash(value)
+        end
+        hash
+      end
+
+      def hash_values_to_hash(hash)
+        hash.reduce({}) do |reduced, pair|
+          key = pair[0]
+          value = pair[1]
+          new_pair = { key => to_hash(value) }
+          reduced.merge(new_pair)
+        end
+      end
+
+      def to_hash(object)
+        case object
+        when OpenStruct
+          open_struct_values_to_hash object
+        when Array
+          array_values_to_hash object
+        when Hash
+          hash_values_to_hash object
+        else
+          object
+        end
+      end
+
+      def stringify_all_keys_in_array(array)
+        array.map do |item|
+          case item
+          when Hash then stringify_all_keys_in_hash item
+          when Array then stringify_all_keys_in_array item
+          else item end
+        end
+      end
+
+      def stringify_all_keys_in_hash(hash)
+        stringified_hash = {}
+
+        hash.each do |k, v|
+          stringified_hash[k.to_s] =
+            case v
+            when Array then stringify_all_keys_in_array v
+            when Hash then stringify_all_keys_in_hash v
+            else v
+            end
+        end
+
+        stringified_hash
+      end
+
+      def stringify_all_keys(object)
+        case object
+        when Hash then stringify_all_keys_in_hash object
+        when Array then stringify_all_keys_in_array object
+        else object
+        end
+      end
+
+      def array_values_to_hash(array)
+        array.map do |item|
+          case item
+          when Array then array_values_to_hash item
+          when Hash then hash_values_to_hash item
+          when OpenStruct then open_struct_values_to_hash item
+          else item
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kontent-jekyll/version.rb

@@ -0,0 +1,5 @@
+module Kentico
+  module Kontent
+    VERSION = '0.11.0'
+  end
+end

metadata

@@ -0,0 +1,170 @@
+--- !ruby/object:Gem::Specification
+name: kontent-jekyll
+version: !ruby/object:Gem::Version
+  version: 0.11.0
+platform: ruby
+authors:
+- RadoslavK
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-12-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rack-jekyll
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: '0.5'
+- !ruby/object:Gem::Dependency
+  name: capybara
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.29.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.29.0
+- !ruby/object:Gem::Dependency
+  name: jekyll
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.8.6
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.8.6
+- !ruby/object:Gem::Dependency
+  name: kontent-delivery-sdk-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: Kontent Jekyll is utilizing Kentico Kontent, headless CMS, as a content
+  repository and integrates it with Jekyll static site generator. You can generate
+  posts, pages, collections and data items.
+email:
+- RadoslavK@kentico.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- kontent-jekyll.gemspec
+- lib/kontent-jekyll.rb
+- lib/kontent-jekyll/constants/item_element_type.rb
+- lib/kontent-jekyll/constants/kentico_config_keys.rb
+- lib/kontent-jekyll/constants/page_type.rb
+- lib/kontent-jekyll/gem_name.rb
+- lib/kontent-jekyll/generator.rb
+- lib/kontent-jekyll/resolvers/content_link_resolver.rb
+- lib/kontent-jekyll/resolvers/content_resolver.rb
+- lib/kontent-jekyll/resolvers/data_resolver.rb
+- lib/kontent-jekyll/resolvers/filename_resolver.rb
+- lib/kontent-jekyll/resolvers/front_matter_resolver.rb
+- lib/kontent-jekyll/resolvers/inline_content_item_resolver.rb
+- lib/kontent-jekyll/site_processing/custom_site_processor.rb
+- lib/kontent-jekyll/site_processing/kentico_kontent_importer.rb
+- lib/kontent-jekyll/site_processing/site_processor.rb
+- lib/kontent-jekyll/utils/normalize_object.rb
+- lib/kontent-jekyll/version.rb
+homepage: https://github.com/RadoslavK/kontent-jekyll
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Kentico Kontent plugin for Jekyll
+test_files: []