kontent-jekyll 0.11.1 → 0.11.2

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

@@ -1,15 +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
+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

@@ -1,47 +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
+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

@@ -1,46 +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
+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

@@ -1,52 +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
+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

@@ -1,163 +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
+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