kontent-jekyll 0.11.0

data/lib/kontent-jekyll/gem_name.rb

@@ -0,0 +1,5 @@
+module Kentico
+  module Kontent
+    GEM_NAME = 'kontent-jekyll'
+  end
+end

data/lib/kontent-jekyll/generator.rb

@@ -0,0 +1,106 @@
+require 'kontent-jekyll/site_processing/custom_site_processor'
+require 'kontent-jekyll/site_processing/kentico_kontent_importer'
+require 'kontent-jekyll/site_processing/site_processor'
+
+module Kentico
+  module Kontent
+    ##
+    # This class generates content stored in Kentico Cloud CMS and populute
+    # particular Jekyll structures so the website is correctly outputted
+    # during the build process.
+
+    class ContentGenerator < Jekyll::Generator
+      include SiteProcessing
+      DEFAULT_LANGUAGE = nil
+
+      safe true
+      priority :highest
+
+      def generate(site)
+        Jekyll::logger.info 'Importing from Kentico Kontent...'
+
+        config = parse_config(site)
+
+        load_custom_processors!(config)
+        process_site(site, config)
+
+        Jekyll::logger.info 'Import finished'
+      end
+
+      private
+
+      ##
+      # Parses Jekyll configuration into OpenStruct structure.
+
+      def parse_config(site)
+        JSON.parse(
+          JSON.generate(site.config),
+          object_class: OpenStruct
+        )
+      end
+
+      ##
+      # Load custom resolvers from the _plugins/kentico directory.
+
+      def load_custom_processors!(config)
+        mapper_search_path = File.join(config.source, config.plugins_dir, 'kentico')
+        mapper_files = Jekyll::Utils.safe_glob(mapper_search_path, File.join('**', '*.rb'))
+
+        Jekyll::External.require_with_graceful_fail(mapper_files)
+      end
+
+      ##
+      # Processed the site.
+      # It imports KC content for every language from the config file.
+      # Then it pass the content to the site processor to populate Jekyll structures.
+
+      def process_site(site, config)
+        kentico_config = config.kentico
+        importer = create_importer(kentico_config)
+
+        processor = SiteProcessor.new(site, kentico_config)
+
+        all_items_by_type = {}
+
+        languages = kentico_config.languages || [DEFAULT_LANGUAGE]
+        languages.each do |language|
+          items_by_type = importer.items_by_type(language)
+
+          all_items_by_type.merge!(items_by_type) do |key, currentItems, newItems|
+            currentItems || newItems
+          end
+        end
+
+        taxonomies = importer.taxonomies
+
+        processor.process_pages(all_items_by_type)
+        processor.process_posts(all_items_by_type)
+        processor.process_data(all_items_by_type)
+        processor.process_taxonomies(taxonomies)
+
+        unique_items = all_items_by_type
+          .values
+          .flatten(1)
+          .uniq{ |i| "#{i.system.language};#{i.system.id}" }
+
+        kentico_data = OpenStruct.new(
+          items: unique_items,
+          taxonomy_groups: taxonomies,
+        )
+
+        custom_site_processor = CustomSiteProcessor.for(kentico_config)
+        custom_site_processor&.generate(site, kentico_data)
+      end
+
+
+      ##
+      # Creates a desired content importer. RACK_TEST_IMPORTER class name and implementation
+      # is specified in RSpec tests.
+
+      def create_importer(kentico_config)
+        importer_name = ENV['RACK_TEST_IMPORTER'] || KenticoKontentImporter.to_s
+        Module.const_get(importer_name).new(kentico_config)
+      end
+    end
+  end
+end

data/lib/kontent-jekyll/resolvers/content_link_resolver.rb

@@ -0,0 +1,15 @@
+module Kentico
+  module Kontent
+    module Resolvers
+      ##
+      # This class instantiate the resolver based on the name from configuration.
+
+      class ContentLinkResolver
+        def self.for(config)
+          class_name = config.content_link_resolver
+          class_name && Module.const_get(class_name).new
+        end
+      end
+    end
+  end
+end

data/lib/kontent-jekyll/resolvers/content_resolver.rb

@@ -0,0 +1,47 @@
+module Kentico
+  module Kontent
+    module Resolvers
+      ##
+      # This class resolve the content of the content item to be injected
+      # under the front matter part of the page.
+      # If no user-defined resolver was provided or it returned nil
+      # then content will be resolved in a default way.
+
+      class ContentResolver
+        def initialize(global_config)
+          @global_config = global_config
+        end
+
+        def execute(content_item, config)
+          content = custom_resolver && custom_resolver.resolve(content_item)
+          content || resolve_internal(content_item, config)
+        end
+
+        private
+
+        ##
+        # User-provided provided resolver is instantiated based on the name from configuration.
+
+        def custom_resolver
+          return @custom_resolver if @custom_resolver
+
+          resolver_name = @global_config.content_resolver
+          return unless resolver_name
+
+          @custom_resolver = Module.const_get(resolver_name).new
+        end
+
+        ##
+        # Resolves content in a default way, it looks up element with a codename 'content'
+        # or codename specified in the config and takes its string value. This also resolves
+        # content components and linked items.
+
+        def resolve_internal(content_item, config)
+          element_name = config.content || 'content'
+          element = content_item.elements[element_name]
+          element && content_item.get_string(element_name)
+        end
+      end
+    end
+  end
+end

data/lib/kontent-jekyll/resolvers/data_resolver.rb

@@ -0,0 +1,46 @@
+module Kentico
+  module Kontent
+    module Resolvers
+      ##
+      # This class resolve the data that will be injected into 'site.data' object.
+      # If no user-defined resolver was provided or it returned nil
+      # then content will be resolved in a default way.
+
+      class DataResolver
+        def initialize(global_config)
+          @global_config = global_config
+        end
+
+        def execute(content_item)
+          data = custom_resolver && custom_resolver.resolve(content_item)
+          data || resolve_internal(content_item)
+        end
+
+        private
+
+        ##
+        # User-provided provided resolver is instantiated based on the name from configuration.
+
+        def custom_resolver
+          return @custom_resolver if @custom_resolver
+
+          resolver_name = @global_config.data_resolver
+          return unless resolver_name
+
+          @custom_resolver = Module.const_get(resolver_name).new
+        end
+
+        ##
+        # It resolves the content item and outputs only system and element fields as the original
+        # item also contains methods, etc.
+
+        def resolve_internal(item)
+          OpenStruct.new(
+            system: item.system,
+            elements: item.elements,
+          )
+        end
+      end
+    end
+  end
+end

data/lib/kontent-jekyll/resolvers/filename_resolver.rb

@@ -0,0 +1,52 @@
+module Kentico
+  module Kontent
+    module Resolvers
+      ##
+      # This class resolve the filename of the page.
+      # If no user-defined resolver was provided or it returned nil
+      # then content will be resolved in a default way.
+
+      class FilenameResolver
+        def initialize(global_config)
+          @global_config = global_config
+        end
+
+        def execute(content_item)
+          filename = custom_resolver && custom_resolver.resolve(content_item)
+          filename || resolve_internal(content_item)
+        end
+
+        private
+
+        ##
+        # User-provided provided resolver is instantiated based on the name from configuration.
+
+        def custom_resolver
+          return @custom_resolver if @custom_resolver
+
+          resolver_name = @global_config.filename_resolver
+          return unless resolver_name
+
+          @custom_resolver = Module.const_get(resolver_name).new
+        end
+
+        ##
+        # Internal resolver will try to locate the url slug element and return its value.
+        # If no slug was present then the item's codename will be used as the filename.
+
+        def resolve_internal(content_item)
+          url_slug = get_url_slug(content_item)
+          url_slug&.value || content_item.system.codename
+        end
+
+        def get_url_slug(item)
+          item.elements.each_pair { |_codename, element| return element if slug?(element) }
+        end
+
+        def slug?(element)
+          element.type == Constants::ItemElementType::URL_SLUG
+        end
+      end
+    end
+  end
+end

data/lib/kontent-jekyll/resolvers/front_matter_resolver.rb

@@ -0,0 +1,163 @@
+class FrontMatterResolverBase
+  def initialize(global_config, type_config, content_item)
+    @global_config = global_config
+    @type_config = type_config
+    @content_item = content_item
+  end
+
+  def item
+    {
+      system: @content_item.system,
+      elements: @content_item.elements,
+    }
+  end
+
+  ##
+  # Title is resolved from the element with 'title' codename or codename
+  # specified in the config.
+
+  def title
+    element = get_element(@type_config&.title || 'title')
+    element&.value
+  end
+
+  ##
+  # Layout is either specified in the config for this type or global config.
+
+  def layout
+    @type_config&.layout || @global_config.default_layout
+  end
+
+  def get_element(codename)
+    @content_item.elements[codename]
+  end
+end
+
+class PageFrontMatterResolver < FrontMatterResolverBase
+  def resolve
+    {
+      item: item,
+      title: title,
+      layout: layout
+    }
+  end
+end
+
+class PostFrontMatterResolver < FrontMatterResolverBase
+  def resolve
+    {
+      item: item,
+      title: title,
+      layout: layout,
+      date: date,
+      categories: categories,
+      tags: tags
+    }
+  end
+
+  ##
+  # Date is resolved from the element with 'date' codename or codename
+  # specified in the config.
+
+  def date
+    element = get_element(@type_config.date || 'date')
+    element && Time.parse(element.value)
+  end
+
+  ##
+  # Categories are resolved from the element with 'categories' codename or codename
+  # specified in the config.
+
+  def categories
+    element = get_element(@type_config.categories || 'categories')
+    return unless element
+
+    element.value.map(&:codename)
+  end
+
+  ##
+  # Tags are resolved from the element with 'tags' codename or codename
+  # specified in the config.
+
+  def tags
+    element = get_element(@type_config.tags || 'tags')
+    return unless element
+
+    element.value.map(&:codename)
+  end
+end
+
+module Kentico
+  module Kontent
+    module Resolvers
+      ##
+      # This class resolve the front matter of the page.
+      # It will be merged with internally generated front matter.
+
+      class FrontMatterResolver
+        def initialize(global_config)
+          @global_config = global_config
+        end
+
+        def execute(content_item, page_type)
+          front_matter = resolve_internal(content_item, page_type)
+
+          if custom_resolver
+            extra_data = custom_resolver.resolve(content_item, page_type)
+            front_matter.merge!(extra_data) if extra_data
+          end
+
+          front_matter
+        end
+
+        private
+
+        ##
+        # User-provided provided resolver is instantiated based on the name from configuration.
+
+        def custom_resolver
+          return @custom_resolver if @custom_resolver
+
+          resolver_name = @global_config.front_matter_resolver
+          return unless resolver_name
+
+          @custom_resolver = Module.const_get(resolver_name).new
+        end
+
+        ##
+        # Posts and pages have different default front matter (tags, categories etc)
+        # so we need to determine the correct internal resolver based on the page type.
+
+        def resolve_internal(content_item, page_type)
+          @content_item = content_item
+          @page_type = page_type
+
+          resolver_factory
+            .new(@global_config, type_config, content_item)
+            .resolve
+        end
+
+        ##
+        # Determines default front matter resolver based on the page type.
+
+        def resolver_factory
+          return PostFrontMatterResolver if post?
+          PageFrontMatterResolver if page?
+        end
+
+        def type_config
+          return @global_config.posts if post?
+          @global_config.pages[@content_item.system.type] if page?
+        end
+
+        def page?
+          @page_type == Constants::PageType::PAGE
+        end
+
+        def post?
+          @page_type == Constants::PageType::POST
+        end
+      end
+    end
+  end
+end

data/lib/kontent-jekyll/resolvers/inline_content_item_resolver.rb

@@ -0,0 +1,15 @@
+module Kentico
+  module Kontent
+    module Resolvers
+      ##
+      # This class instantiate the resolver based on the name from configuration.
+
+      class InlineContentItemResolver
+        def self.for(config)
+          class_name = config.inline_content_item_resolver
+          class_name && Module.const_get(class_name).new
+        end
+      end
+    end
+  end
+end