bridgetown-core 1.3.4 → 2.0.0.beta1

data/lib/bridgetown-core/commands/webpack.rb

@@ -1,82 +0,0 @@
-# frozen_string_literal: true
-
-module Bridgetown
-  module Commands
-    class Webpack < Thor::Group
-      include Thor::Actions
-      extend Summarizable
-
-      Registrations.register do
-        register(Webpack, "webpack", "webpack ACTION", Webpack.summary)
-      end
-
-      def self.banner
-        "bridgetown webpack ACTION"
-      end
-      summary "Perform actions on the Bridgetown Webpack configuration"
-
-      def self.exit_on_failure?
-        true
-      end
-
-      def webpack
-        @logger = Bridgetown.logger
-        return show_actions if args.empty?
-
-        action = args.first
-        if supported_actions.include?(action)
-          perform action
-        else
-          @logger.error "Error:".red, "🚨 Please enter a valid action."
-          say "\n"
-          show_actions
-        end
-      end
-
-      def self.source_root
-        File.expand_path("./webpack", __dir__)
-      end
-
-      def self.destination_root
-        config.root_dir
-      end
-
-      protected
-
-      def config
-        @config ||= Bridgetown.configuration({ root_dir: Dir.pwd })
-      end
-
-      def package_json
-        @package_json ||= begin
-          package_json_file = File.read(Bridgetown.sanitized_path(config.root_dir, "package.json"))
-          JSON.parse(package_json_file)
-        end
-      end
-
-      def perform(action)
-        automation = find_in_source_paths("#{action}.rb")
-        inside(New.created_site_dir || Dir.pwd) do
-          apply automation, verbose: false
-        end
-      end
-
-      def show_actions
-        say "Available actions:\n".bold
-
-        longest_action = supported_actions.keys.max_by(&:size).size
-        supported_actions.each do |action, description|
-          say "#{action.ljust(longest_action).to_s.bold.blue}\t# #{description}"
-        end
-      end
-
-      def supported_actions
-        {
-          setup: "Sets up a Webpack integration with Bridgetown in your project",
-          update: "Updates the Bridgetown Webpack defaults to the latest available version",
-          "enable-postcss": "Configures PostCSS in your project",
-        }.with_indifferent_access
-      end
-    end
-  end
-end

data/lib/bridgetown-core/concerns/front_matter_importer.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-module Bridgetown
-  module FrontMatterImporter
-    # Requires klass#content and klass#front_matter_line_count accessors
-    def self.included(klass)
-      klass.include Bridgetown::Utils::RubyFrontMatterDSL
-    end
-
-    YAML_HEADER = %r!\A---\s*\n!.freeze
-    YAML_BLOCK = %r!\A(---\s*\n.*?\n?)^((---|\.\.\.)\s*$\n?)!m.freeze
-    RUBY_HEADER = %r!\A[~`#-]{3,}(?:ruby|<%|{%)\s*\n!.freeze
-    RUBY_BLOCK =
-      %r!#{RUBY_HEADER.source}(.*?\n?)^((?:%>|%})?[~`#-]{3,}\s*$\n?)!m.freeze
-
-    def read_front_matter(file_path) # rubocop:todo Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/MethodLength
-      file_contents = File.read(
-        file_path, **Bridgetown::Utils.merged_file_read_opts(Bridgetown::Current.site, {})
-      )
-      yaml_content = file_contents.match(YAML_BLOCK)
-      if !yaml_content && Bridgetown::Current.site.config.should_execute_inline_ruby?
-        ruby_content = file_contents.match(RUBY_BLOCK)
-      end
-
-      if yaml_content
-        self.content = yaml_content.post_match
-        self.front_matter_line_count = yaml_content[1].lines.size - 1
-        YAMLParser.load(yaml_content[1])
-      elsif ruby_content
-        # rbfm header + content underneath
-        self.content = ruby_content.post_match
-        self.front_matter_line_count = ruby_content[1].lines.size
-        process_ruby_data(ruby_content[1], file_path, 2)
-      elsif Bridgetown::Utils.has_rbfm_header?(file_path)
-        process_ruby_data(File.read(file_path).lines[1..].join("\n"), file_path, 2)
-      elsif is_a?(Layout)
-        self.content = file_contents
-        {}
-      else
-        yaml_data = YAMLParser.load_file(file_path)
-        yaml_data.is_a?(Array) ? { rows: yaml_data } : yaml_data
-      end
-    end
-
-    def process_ruby_data(rubycode, file_path, starting_line)
-      ruby_data = instance_eval(rubycode, file_path.to_s, starting_line)
-      ruby_data.is_a?(Array) ? { rows: ruby_data } : ruby_data.to_h
-    rescue StandardError => e
-      raise "Ruby code isn't returning an array, or object which responds to `to_h' (#{e.message})"
-    end
-  end
-end

data/lib/bridgetown-core/concerns/liquid_renderable.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-module Bridgetown
-  module LiquidRenderable
-    # Determine whether the file should be rendered with Liquid.
-    #
-    # Returns false if the document is a yaml file or if the document doesn't
-    # contain any Liquid Tags or Variables, true otherwise.
-    def render_with_liquid?
-      return false if data["render_with_liquid"] == false
-      return false unless liquid_engine_configured?
-
-      !(yaml_file? || !Utils.has_liquid_construct?(content))
-    end
-
-    def liquid_engine_configured?
-      data["template_engine"].to_s == "liquid" ||
-        (
-          data["template_engine"].nil? && (
-            site.config[:template_engine].nil? || site.config[:template_engine].to_s == "liquid"
-          )
-        )
-    end
-
-    # Override in individual classes
-    def yaml_file?
-      false
-    end
-  end
-end

data/lib/bridgetown-core/core_ext/psych.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module Bridgetown
-  module CoreExt
-    module Psych
-      module SafeLoadFile
-        def safe_load_file(filename, **kwargs)
-          File.open(filename, "r:bom|utf-8") do |f|
-            safe_load f, filename: filename, **kwargs
-          end
-        end
-      end
-    end
-  end
-end

data/lib/bridgetown-core/drops/url_drop.rb

@@ -1,152 +0,0 @@
-# frozen_string_literal: true
-
-module Bridgetown
-  module Drops
-    class UrlDrop < Drop
-      extend Forwardable
-
-      mutable false
-
-      def_delegator :@obj, :cleaned_relative_path, :path
-      def_delegator :@obj, :output_ext, :output_ext
-
-      def collection
-        @obj.collection.label
-      end
-
-      def name
-        Utils.slugify(@obj.basename_without_ext)
-      end
-
-      def title
-        Utils.slugify(qualified_slug_data, mode: "pretty", cased: true)
-      end
-
-      def slug
-        Utils.slugify(qualified_slug_data)
-      end
-
-      def locale
-        locale_data = @obj.data["locale"]
-        @obj.site.config["available_locales"].include?(locale_data) ? locale_data : nil
-      end
-      alias_method :lang, :locale
-
-      def categories
-        category_set = Set.new
-        Array(@obj.data["categories"]).each do |category|
-          category_set << if @obj.site.config["slugify_categories"]
-                            Utils.slugify(category.to_s)
-                          else
-                            category.to_s.downcase
-                          end
-        end
-        category_set.to_a.join("/")
-      end
-
-      # CCYY
-      def year
-        @obj.date.strftime("%Y")
-      end
-
-      # MM: 01..12
-      def month
-        @obj.date.strftime("%m")
-      end
-
-      # DD: 01..31
-      def day
-        @obj.date.strftime("%d")
-      end
-
-      # hh: 00..23
-      def hour
-        @obj.date.strftime("%H")
-      end
-
-      # mm: 00..59
-      def minute
-        @obj.date.strftime("%M")
-      end
-
-      # ss: 00..59
-      def second
-        @obj.date.strftime("%S")
-      end
-
-      # D: 1..31
-      def i_day
-        @obj.date.strftime("%-d")
-      end
-
-      # M: 1..12
-      def i_month
-        @obj.date.strftime("%-m")
-      end
-
-      # MMM: Jan..Dec
-      def short_month
-        @obj.date.strftime("%b")
-      end
-
-      # MMMM: January..December
-      def long_month
-        @obj.date.strftime("%B")
-      end
-
-      # YY: 00..99
-      def short_year
-        @obj.date.strftime("%y")
-      end
-
-      # CCYYw, ISO week year
-      # may differ from CCYY for the first days of January and last days of December
-      def w_year
-        @obj.date.strftime("%G")
-      end
-
-      # WW: 01..53
-      # %W and %U do not comply with ISO 8601-1
-      def week
-        @obj.date.strftime("%V")
-      end
-
-      # d: 1..7 (Monday..Sunday)
-      def w_day
-        @obj.date.strftime("%u")
-      end
-
-      # dd: Mon..Sun
-      def short_day
-        @obj.date.strftime("%a")
-      end
-
-      # ddd: Monday..Sunday
-      def long_day
-        @obj.date.strftime("%A")
-      end
-
-      # DDD: 001..366
-      def y_day
-        @obj.date.strftime("%j")
-      end
-
-      private
-
-      def qualified_slug_data
-        slug_data = @obj.data["slug"] || @obj.basename_without_ext
-        if @obj.data["locale"]
-          slug_data.split(".").tap do |segments|
-            segments.pop if segments.length > 1 && segments.last == @obj.data["locale"]
-          end.join(".")
-        else
-          slug_data
-        end
-      end
-
-      def fallback_data
-        @fallback_data ||= {}
-      end
-    end
-  end
-end

data/lib/bridgetown-core/frontmatter_defaults.rb

@@ -1,223 +0,0 @@
-# frozen_string_literal: true
-
-module Bridgetown
-  # This class handles custom defaults for front matter settings.
-  # It is exposed via the frontmatter_defaults method on the site class.
-  class FrontmatterDefaults
-    # @return [Bridgetown::Site]
-    attr_reader :site
-
-    def initialize(site)
-      @site = site
-      @defaults_cache = {}
-    end
-
-    def reset
-      @glob_cache = {}
-      @defaults_cache = {}
-    end
-
-    def ensure_time!(set)
-      return set unless set.key?("values") && set["values"].key?("date")
-      return set if set["values"]["date"].is_a?(Time)
-
-      set["values"]["date"] = Utils.parse_date(
-        set["values"]["date"],
-        "An invalid date format was found in a front-matter default set: #{set}"
-      )
-      set
-    end
-
-    # Collects a hash with all default values for a resource
-    #
-    # @param path [String] the relative path of the resource
-    # @param collection_name [Symbol] :posts, :pages, etc.
-    #
-    # @return [Hash] all default values (an empty hash if there are none)
-    def all(path, collection_name)
-      if @defaults_cache.key?([path, collection_name])
-        return @defaults_cache[[path, collection_name]]
-      end
-
-      defaults = {}
-      merge_data_cascade_for_path(path, defaults)
-
-      old_scope = nil
-      matching_sets(path, collection_name).each do |set|
-        if has_precedence?(old_scope, set["scope"])
-          defaults = Utils.deep_merge_hashes(defaults, set["values"])
-          old_scope = set["scope"]
-        else
-          defaults = Utils.deep_merge_hashes(set["values"], defaults)
-        end
-      end
-
-      @defaults_cache[[path, collection_name]] = defaults
-    end
-
-    private
-
-    def merge_data_cascade_for_path(path, merged_data)
-      absolute_path = site.in_source_dir(path)
-      site.defaults_reader.path_defaults
-        .select { |k, _v| absolute_path.include? k }
-        .sort_by { |k, _v| k.length }
-        .each do |defaults|
-          merged_data.merge!(defaults[1])
-        end
-    end
-
-    # Checks if a given default setting scope matches the given path and collection
-    #
-    # scope - the hash indicating the scope, as defined in bridgetown.config.yml
-    # path - the path to check for
-    # collection - the collection (:posts or :pages) to check for
-    #
-    # Returns true if the scope applies to the given collection and path
-    def applies?(scope, path, collection)
-      applies_collection?(scope, collection) && applies_path?(scope, path)
-    end
-
-    def applies_path?(scope, path)
-      rel_scope_path = scope["path"]
-      return true if !rel_scope_path.is_a?(String) || rel_scope_path.empty?
-
-      sanitized_path = strip_collections_dir(sanitize_path(path))
-
-      if rel_scope_path.include?("*")
-        glob_scope(sanitized_path, rel_scope_path)
-      else
-        path_is_subpath?(sanitized_path, strip_collections_dir(rel_scope_path))
-      end
-    end
-
-    def glob_scope(sanitized_path, rel_scope_path)
-      site_source    = Pathname.new(site.source)
-      abs_scope_path = site_source.join(rel_scope_path).to_s
-
-      glob_cache(abs_scope_path).each do |scope_path|
-        scope_path = Pathname.new(scope_path).relative_path_from(site_source).to_s
-        scope_path = strip_collections_dir(scope_path)
-        Bridgetown.logger.debug "Globbed Scope Path:", scope_path
-        return true if path_is_subpath?(sanitized_path, scope_path)
-      end
-      false
-    end
-
-    def glob_cache(path)
-      @glob_cache ||= {}
-      @glob_cache[path] ||= Dir.glob(path)
-    end
-
-    def path_is_subpath?(path, parent_path)
-      path.start_with?(parent_path)
-    end
-
-    def strip_collections_dir(path)
-      collections_dir  = site.config["collections_dir"]
-      slashed_coll_dir = collections_dir.empty? ? "/" : "#{collections_dir}/"
-      return path if collections_dir.empty? || !path.to_s.start_with?(slashed_coll_dir)
-
-      path.sub(slashed_coll_dir, "")
-    end
-
-    # Determines whether the scope applies to collection.
-    # The scope applies to the collection if:
-    #   1. no 'collection' is specified
-    #   2. the 'collection' in the scope is the same as the collection asked about
-    #
-    # @param scope [Hash] the defaults set being asked about
-    # @param collection [Symbol] the collection of the resource being processed
-    #
-    # @return [Boolean] whether either of the above conditions are satisfied
-    def applies_collection?(scope, collection)
-      !scope.key?("collection") || scope["collection"].eql?(collection.to_s)
-    end
-
-    # Checks if a given set of default values is valid
-    #
-    # @param set [Hash] the default value hash as defined in bridgetown.config.yml
-    #
-    # @return [Boolean] if the set is valid and can be used
-    def valid?(set)
-      set.is_a?(Hash) && set["values"].is_a?(Hash)
-    end
-
-    # Determines if a new scope has precedence over an old one
-    #
-    # old_scope - the old scope hash, or nil if there's none
-    # new_scope - the new scope hash
-    #
-    # Returns true if the new scope has precedence over the older
-    # rubocop: disable Naming/PredicateName
-    def has_precedence?(old_scope, new_scope)
-      return true if old_scope.nil?
-
-      new_path = sanitize_path(new_scope["path"])
-      old_path = sanitize_path(old_scope["path"])
-
-      if new_path.length != old_path.length
-        new_path.length >= old_path.length
-      elsif new_scope.key?("collection")
-        true
-      else
-        !old_scope.key? "collection"
-      end
-    end
-    # rubocop: enable Naming/PredicateName
-
-    # Collects a list of sets that match the given path and collection
-    #
-    # @return [Array<Hash>]
-    def matching_sets(path, collection)
-      @matched_set_cache ||= {}
-      @matched_set_cache[path] ||= {}
-      @matched_set_cache[path][collection] ||= valid_sets.select do |set|
-        !set.key?("scope") || applies?(set["scope"], path, collection)
-      end
-    end
-
-    # Returns a list of valid sets
-    #
-    # This is not cached to allow plugins to modify the configuration
-    # and have their changes take effect
-    #
-    # @return [Array<Hash>]
-    def valid_sets
-      sets = site.config["defaults"]
-      return [] unless sets.is_a?(Array)
-
-      sets.filter_map do |set|
-        if valid?(set)
-          massage_scope!(set)
-          # TODO: is this trip really necessary?
-          ensure_time!(set)
-        else
-          Bridgetown.logger.warn "Defaults:", "An invalid front-matter default set was found:"
-          Bridgetown.logger.warn set.to_s
-          nil
-        end
-      end
-    end
-
-    # Set path to blank if not specified and alias older type to collection
-    def massage_scope!(set)
-      set["scope"] ||= {}
-      set["scope"]["path"] ||= ""
-      return unless set["scope"]["type"] && !set["scope"]["collection"]
-
-      set["scope"]["collection"] = set["scope"]["type"]
-    end
-
-    SANITIZATION_REGEX = %r!\A/|(?<=[^/])\z!.freeze
-
-    # Sanitizes the given path by removing a leading and adding a trailing slash
-    def sanitize_path(path)
-      if path.nil? || path.empty?
-        ""
-      else
-        path.gsub(SANITIZATION_REGEX, "")
-      end
-    end
-  end
-end

data/lib/bridgetown-core/rack/static_indexes.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-require "roda/plugins/public"
-
-# TODO: extract out to a standalone Roda plugin
-Roda::RodaPlugins::Public::RequestMethods.module_eval do
-  SPLIT = Regexp.union(*[File::SEPARATOR, File::ALT_SEPARATOR].compact) # rubocop:disable Lint/ConstantDefinitionInBlock
-  def public_path_segments(path) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-    segments = []
-
-    path.split(SPLIT).each do |seg|
-      next if seg.empty? || seg == "."
-
-      seg == ".." ? segments.pop : segments << seg
-    end
-
-    path = File.join(roda_class.opts[:public_root], *segments)
-    unless File.file?(path)
-      path = File.join(path, "index.html")
-      if File.file?(path)
-        segments << "index.html"
-      else
-        segments[segments.size - 1] = "#{segments.last}.html"
-      end
-    end
-
-    segments
-  rescue IndexError
-    nil
-  end
-end