bridgetown-core 0.19.2 → 0.21.0.beta3

data/lib/bridgetown-core/resource/destination.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  module Resource
+    class Destination
+      # @return [Bridgetown::Resource::Base]
+      attr_accessor :resource
+
+      # @return [String]
+      attr_accessor :output_ext
+
+      # @param resource [Bridgetown::Resource::Base]
+      def initialize(resource)
+        @resource = resource
+        @output_ext = resource.transformer.final_ext
+      end
+
+      def absolute_url
+        Addressable::URI.parse(
+          resource.site.config.url.to_s + relative_url
+        ).normalize.to_s
+      end
+
+      def relative_url
+        @processor ||= PermalinkProcessor.new(resource)
+        @processor.transform
+      end
+
+      def final_ext
+        output_ext || resource.extname
+      end
+
+      def output_path
+        path = URL.unescape_path(relative_url)
+        path = path.delete_prefix(resource.site.baseurl) if resource.site.baseurl.present?
+        path = resource.site.in_dest_dir(path)
+        path = File.join(path, "index.html") if relative_url.end_with? "/"
+        path
+      end
+
+      def write(output)
+        path = output_path
+        FileUtils.mkdir_p(File.dirname(path))
+        Bridgetown.logger.debug "Writing:", path
+        File.write(path, output, mode: "wb")
+      end
+    end
+  end
+end

data/lib/bridgetown-core/resource/permalink_processor.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  module Resource
+    class PermalinkProcessor
+      # @return [Bridgetown::Resource::Base]
+      attr_accessor :resource
+
+      attr_accessor :slugify_mode
+
+      def self.placeholder_processors
+        @placeholder_processors || {}
+      end
+
+      def self.register_placeholder(key, block)
+        @placeholder_processors ||= {}
+        @placeholder_processors[key] = block
+      end
+
+      def initialize(resource)
+        @resource = resource
+        @slugify_mode = @resource.site.config.slugify_mode
+      end
+
+      def final_ext
+        resource.method(:destination).arity == 1 ? resource.extname : resource.destination.final_ext
+      end
+
+      def transform
+        permalink = resource.data.permalink ||
+          permalink_for_permalink_style(resource.collection.default_permalink)
+
+        # Strip out file extension and process each segment of a URL to swap out
+        # placeholders such as :categories or :title
+        url_segments = Bridgetown::Filters::URLFilters.strip_extname(permalink).split("/")
+        new_url = url_segments.map do |segment|
+          segment.starts_with?(":") ? process_segment(segment.sub(%r{^:}, "")) : segment
+        end.select(&:present?).join("/")
+
+        # No relative URLs should ever end in /index.html
+        new_url.sub!(%r{/index$}, "") if final_ext == ".html"
+
+        add_baseurl finalize_permalink(new_url, permalink)
+      end
+
+      def process_segment(segment)
+        segment = segment.to_sym
+        if self.class.placeholder_processors[segment]
+          segment_value = self.class.placeholder_processors[segment].(resource)
+          if segment_value.is_a?(Hash)
+            segment_value[:raw_value]
+          elsif segment_value.is_a?(Array)
+            segment_value.map do |subsegment|
+              Utils.slugify(subsegment, mode: slugify_mode)
+            end.join("/")
+          else
+            Utils.slugify(segment_value, mode: slugify_mode)
+          end
+        else
+          segment
+        end
+      end
+
+      def permalink_for_permalink_style(permalink_style)
+        collection_prefix = ("/:collection" unless resource.collection.builtin?)
+
+        case permalink_style.to_sym
+        when :pretty
+          "#{collection_prefix}/:categories/:year/:month/:day/:slug/"
+        when :pretty_ext, :date
+          "#{collection_prefix}/:categories/:year/:month/:day/:slug.*"
+        when :simple
+          "#{collection_prefix}/:categories/:slug/"
+        when :simple_ext
+          "#{collection_prefix}/:categories/:slug.*"
+        else
+          permalink_style.to_s
+        end
+      end
+
+      # @param new_url [String]
+      # @param permalink [String]
+      def finalize_permalink(new_url, permalink)
+        # Handle .* style permalinks or files not ending in .html
+        if permalink.ends_with?(".*") || !%r{\.html?$}.match?(final_ext)
+          "/#{new_url}#{final_ext}"
+        # If permalink includes the file extension, add it back in to the URL
+        elsif permalink =~ %r{\.[^/]*$}
+          "/#{new_url}#{Regexp.last_match[0]}"
+        # Ensure index-style URLs get output correctly
+        elsif permalink.ends_with?("/")
+          "/#{new_url}/".sub(%r{^/index/$}, "/")
+        # We good :)
+        else
+          "/#{new_url}"
+        end
+      end
+
+      def add_baseurl(permalink)
+        resource.site.baseurl.present? ? "#{resource.site.baseurl}#{permalink}" : permalink
+      end
+
+      ### Default Placeholders Processors
+
+      # @param resource [Bridgetown::Resource::Base]
+      register_placeholder :path, ->(resource) do
+        { raw_value: resource.relative_path_basename_without_prefix }
+      end
+
+      # @param resource [Bridgetown::Resource::Base]
+      register_placeholder :name, ->(resource) do
+        resource.basename_without_ext
+      end
+
+      # @param resource [Bridgetown::Resource::Base]
+      register_placeholder :slug, ->(resource) do
+        resource.data.slug || placeholder_processors[:name].(resource)
+      end
+
+      # @param resource [Bridgetown::Resource::Base]
+      register_placeholder :title, ->(resource) do
+        resource.data.title || placeholder_processors[:slug].(resource)
+      end
+
+      # @param resource [Bridgetown::Resource::Base]
+      register_placeholder :locale, ->(resource) do
+        locale_data = resource.data.locale
+        resource.site.config.available_locales.include?(locale_data) ? locale_data : nil
+      end
+      register_placeholder :lang, placeholder_processors[:locale]
+
+      # @param resource [Bridgetown::Resource::Base]
+      register_placeholder :collection, ->(resource) do
+        resource.collection.label
+      end
+
+      # @param resource [Bridgetown::Resource::Base]
+      register_placeholder :categories, ->(resource) do
+        resource.taxonomies.category&.terms&.map(&:label)&.uniq
+      end
+
+      # YYYY
+      # @param resource [Bridgetown::Resource::Base]
+      register_placeholder :year, ->(resource) do
+        resource.date.strftime("%Y")
+      end
+
+      # MM: 01..12
+      # @param resource [Bridgetown::Resource::Base]
+      register_placeholder :month, ->(resource) do
+        resource.date.strftime("%m")
+      end
+
+      # DD: 01..31
+      # @param resource [Bridgetown::Resource::Base]
+      register_placeholder :day, ->(resource) do
+        resource.date.strftime("%d")
+      end
+
+      # D: 1..31
+      # @param resource [Bridgetown::Resource::Base]
+      register_placeholder :i_day, ->(resource) do
+        resource.date.strftime("%-d")
+      end
+
+      # M: 1..12
+      # @param resource [Bridgetown::Resource::Base]
+      register_placeholder :i_month, ->(resource) do
+        resource.date.strftime("%-m")
+      end
+
+      # YY: 00..99
+      # @param resource [Bridgetown::Resource::Base]
+      register_placeholder :short_year, ->(resource) do
+        resource.date.strftime("%y")
+      end
+    end
+  end
+end

data/lib/bridgetown-core/resource/relations.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  module Resource
+    class Relations
+      # @return [Bridgetown::Resource::Base]
+      attr_reader :resource
+
+      # @return [Bridgetown::Site]
+      attr_reader :site
+
+      # @param resource [Bridgetown::Resource::Base]
+      def initialize(resource)
+        @resource = resource
+        @site = resource.site
+      end
+
+      # @return [HashWithDotAccess::Hash]
+      def relation_schema
+        resource.collection.metadata.relations
+      end
+
+      # @return [Array<String>]
+      def relation_types
+        @relation_types ||= begin
+          types = []
+          relation_schema&.each do |_relation_type, collections|
+            types << collections
+            types << Array(collections).map { |item| ActiveSupport::Inflector.pluralize(item) }
+          end
+          types.flatten.uniq
+        end
+      end
+
+      # @param type [Symbol]
+      # @return [Bridgetown::Resource::Base, Array<Bridgetown::Resource::Base>]
+      def resources_for_type(type)
+        relation_kind = kind_of_relation_for_type(type)
+        return [] unless relation_kind
+
+        case relation_kind.to_sym
+        when :belongs_to
+          belongs_to_relation_for_type(type)
+        when :has_many
+          has_many_relation_for_type(type)
+        when :has_one
+          has_one_relation_for_type(type)
+        end
+      end
+
+      def method_missing(type, *args)
+        return super unless type.to_s.in?(relation_types)
+
+        resources_for_type(type)
+      end
+
+      def respond_to_missing?(type, *_args)
+        type.to_s.in?(relation_types)
+      end
+
+      def to_liquid
+        @to_liquid ||= Drops::RelationsDrop.new(self)
+      end
+
+      private
+
+      # @param type [Symbol]
+      # @return [String]
+      def kind_of_relation_for_type(type)
+        relation_schema&.each do |relation_type, collections|
+          collections = Array(collections).yield_self do |collections_arr|
+            collections_arr +
+              collections_arr.map { |item| ActiveSupport::Inflector.pluralize(item) }
+          end.flatten.uniq
+          return relation_type if collections.include?(type.to_s)
+        end
+      end
+
+      # @param type [Symbol]
+      # @return [Bridgetown::Collection]
+      def other_collection_for_type(type)
+        site.collections[type] || site.collections[ActiveSupport::Inflector.pluralize(type)]
+      end
+
+      # @return [Array<String>]
+      def collection_labels
+        [
+          resource.collection.label,
+          ActiveSupport::Inflector.singularize(resource.collection.label),
+        ]
+      end
+
+      # @param type [Symbol]
+      # @return [Bridgetown::Resource::Base, Array<Bridgetown::Resource::Base>]
+      def belongs_to_relation_for_type(type)
+        if resource.data[type].is_a?(Array)
+          other_collection_for_type(type).resources.select do |other_resource|
+            other_resource.data.slug.in?(resource.data[type])
+          end
+        else
+          other_collection_for_type(type).resources.find do |other_resource|
+            other_resource.data.slug == resource.data[type]
+          end
+        end
+      end
+
+      # @param type [Symbol]
+      # @return [Array<Bridgetown::Resource::Base>]
+      def has_many_relation_for_type(type) # rubocop:disable Naming/PredicateName
+        label, singular_label = collection_labels
+
+        other_collection_for_type(type).resources.select do |other_resource|
+          resource.data.slug.in?(
+            Array(other_resource.data[label] || other_resource.data[singular_label])
+          )
+        end
+      end
+
+      # @param type [Symbol]
+      # @return [Bridgetown::Resource::Base]
+      def has_one_relation_for_type(type) # rubocop:disable Naming/PredicateName
+        label, singular_label = collection_labels
+
+        other_collection_for_type(type).resources.find do |other_resource|
+          resource.data.slug.in?(
+            Array(other_resource.data[label] || other_resource.data[singular_label])
+          )
+        end
+      end
+    end
+  end
+end

data/lib/bridgetown-core/resource/taxonomy_term.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  module Resource
+    class TaxonomyTerm
+      attr_reader :resource
+
+      attr_reader :label
+
+      attr_reader :type
+
+      def initialize(resource:, label:, type:)
+        @resource = resource
+        @label = label
+        @type = type
+      end
+
+      def to_liquid
+        {
+          "label" => label,
+        }
+      end
+      alias_method :to_h, :to_liquid
+
+      def as_json(*)
+        to_h
+      end
+
+      ruby2_keywords def to_json(*options)
+        as_json(*options).to_json(*options)
+      end
+    end
+  end
+end

data/lib/bridgetown-core/resource/taxonomy_type.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  module Resource
+    class TaxonomyType
+      # @return [Bridgetown::Site]
+      attr_reader :site
+
+      # @return [String] aka `category`, `tag`, `region`, etc.
+      attr_reader :label
+
+      # @return [String] the key used in front matter
+      attr_reader :key
+
+      # @return [HashWithDotAccess::Hash] any associated metadata
+      attr_reader :metadata
+
+      # @param site [Bridgetown::Site]
+      # @param label [String]
+      # @param key [String]
+      def initialize(site:, label:, key:, metadata:)
+        @site = site
+        @label = label
+        @key = key
+        @metadata = metadata
+      end
+
+      def terms
+        site.resources.map do |resource|
+          resource.taxonomies[label].terms
+        end.flatten.group_by(&:label).with_dot_access
+      end
+
+      def inspect
+        "#<#{self.class} label=#{label}>"
+      end
+
+      def to_liquid
+        {
+          "label"    => label,
+          "key"      => key,
+          "metadata" => metadata,
+        }
+      end
+      alias_method :to_h, :to_liquid
+
+      def as_json(*)
+        to_h
+      end
+
+      ruby2_keywords def to_json(*options)
+        as_json(*options).to_json(*options)
+      end
+    end
+  end
+end