bridgetown-core 0.7.0 → 0.7.1

data/lib/bridgetown-core/cleaner.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  # Handles the cleanup of a site's destination before it is built.
+  class Cleaner
+    HIDDEN_FILE_REGEX = %r!\/\.{1,2}$!.freeze
+    attr_reader :site
+
+    def initialize(site)
+      @site = site
+    end
+
+    # Cleans up the site's destination directory
+    def cleanup!
+      FileUtils.rm_rf(obsolete_files)
+      FileUtils.rm_rf(metadata_file) unless @site.incremental?
+    end
+
+    private
+
+    # Private: The list of files and directories to be deleted during cleanup process
+    #
+    # Returns an Array of the file and directory paths
+    def obsolete_files
+      out = (existing_files - new_files - new_dirs + replaced_files).to_a
+      Bridgetown::Hooks.trigger :clean, :on_obsolete, out
+      out
+    end
+
+    # Private: The metadata file storing dependency tree and build history
+    #
+    # Returns an Array with the metdata file as the only item
+    def metadata_file
+      [site.regenerator.metadata_file]
+    end
+
+    # Private: The list of existing files, apart from those included in
+    # keep_files and hidden files.
+    #
+    # Returns a Set with the file paths
+    def existing_files
+      files = Set.new
+      regex = keep_file_regex
+      dirs = keep_dirs
+
+      Utils.safe_glob(site.in_dest_dir, ["**", "*"], File::FNM_DOTMATCH).each do |file|
+        next if file =~ HIDDEN_FILE_REGEX || file =~ regex || dirs.include?(file)
+
+        files << file
+      end
+
+      files
+    end
+
+    # Private: The list of files to be created when site is built.
+    #
+    # Returns a Set with the file paths
+    def new_files
+      @new_files ||= Set.new.tap do |files|
+        site.each_site_file { |item| files << item.destination(site.dest) }
+      end
+    end
+
+    # Private: The list of directories to be created when site is built.
+    # These are the parent directories of the files in #new_files.
+    #
+    # Returns a Set with the directory paths
+    def new_dirs
+      @new_dirs ||= new_files.flat_map { |file| parent_dirs(file) }.to_set
+    end
+
+    # Private: The list of parent directories of a given file
+    #
+    # Returns an Array with the directory paths
+    def parent_dirs(file)
+      parent_dir = File.dirname(file)
+      if parent_dir == site.dest
+        []
+      else
+        parent_dirs(parent_dir).unshift(parent_dir)
+      end
+    end
+
+    # Private: The list of existing files that will be replaced by a directory
+    # during build
+    #
+    # Returns a Set with the file paths
+    def replaced_files
+      new_dirs.select { |dir| File.file?(dir) }.to_set
+    end
+
+    # Private: The list of directories that need to be kept because they are
+    # parent directories of files specified in keep_files
+    #
+    # Returns a Set with the directory paths
+    def keep_dirs
+      site.keep_files.flat_map { |file| parent_dirs(site.in_dest_dir(file)) }.to_set
+    end
+
+    # Private: Creates a regular expression from the config's keep_files array
+    #
+    # Examples
+    #   ['.git','.svn'] with site.dest "/myblog/_site" creates
+    #   the following regex: /\A\/myblog\/_site\/(\.git|\/.svn)/
+    #
+    # Returns the regular expression
+    def keep_file_regex
+      %r!\A#{Regexp.quote(site.dest)}\/(#{Regexp.union(site.keep_files).source})!
+    end
+  end
+end

data/lib/bridgetown-core/collection.rb

@@ -0,0 +1,279 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  class Collection
+    attr_reader :site, :label, :metadata
+    attr_writer :docs
+
+    # Create a new Collection.
+    #
+    # site - the site to which this collection belongs.
+    # label - the name of the collection
+    #
+    # Returns nothing.
+    def initialize(site, label)
+      @site     = site
+      @label    = sanitize_label(label)
+      @metadata = extract_metadata
+    end
+
+    # Fetch the Documents in this collection.
+    # Defaults to an empty array if no documents have been read in.
+    #
+    # Returns an array of Bridgetown::Document objects.
+    def docs
+      @docs ||= []
+    end
+
+    # Override of normal respond_to? to match method_missing's logic for
+    # looking in @data.
+    def respond_to_missing?(method, include_private = false)
+      docs.respond_to?(method.to_sym, include_private) || super
+    end
+
+    # Override of method_missing to check in @data for the key.
+    def method_missing(method, *args, &blck)
+      if docs.respond_to?(method.to_sym)
+        Bridgetown.logger.warn "Deprecation:",
+                               "#{label}.#{method} should be changed to #{label}.docs.#{method}."
+        Bridgetown.logger.warn "", "Called by #{caller(0..0)}."
+        docs.public_send(method.to_sym, *args, &blck)
+      else
+        super
+      end
+    end
+
+    # Fetch the static files in this collection.
+    # Defaults to an empty array if no static files have been read in.
+    #
+    # Returns an array of Bridgetown::StaticFile objects.
+    def files
+      @files ||= []
+    end
+
+    # Read the allowed documents into the collection's array of docs.
+    #
+    # Returns the sorted array of docs.
+    def read
+      filtered_entries.each do |file_path|
+        full_path = collection_dir(file_path)
+        next if File.directory?(full_path)
+
+        if Utils.has_yaml_header? full_path
+          read_document(full_path)
+        else
+          read_static_file(file_path, full_path)
+        end
+      end
+      sort_docs!
+    end
+
+    # All the entries in this collection.
+    #
+    # Returns an Array of file paths to the documents in this collection
+    #   relative to the collection's directory
+    def entries
+      return [] unless exists?
+
+      @entries ||= begin
+        collection_dir_slash = "#{collection_dir}/"
+        Utils.safe_glob(collection_dir, ["**", "*"], File::FNM_DOTMATCH).map do |entry|
+          entry[collection_dir_slash] = ""
+          entry
+        end
+      end
+    end
+
+    # Filtered version of the entries in this collection.
+    # See `Bridgetown::EntryFilter#filter` for more information.
+    #
+    # Returns a list of filtered entry paths.
+    def filtered_entries
+      return [] unless exists?
+
+      @filtered_entries ||=
+        Dir.chdir(directory) do
+          entry_filter.filter(entries).reject do |f|
+            path = collection_dir(f)
+            File.directory?(path) || entry_filter.symlink?(f)
+          end
+        end
+    end
+
+    # The directory for this Collection, relative to the site source or the directory
+    # containing the collection.
+    #
+    # Returns a String containing the directory name where the collection
+    #   is stored on the filesystem.
+    def relative_directory
+      @relative_directory ||= "_#{label}"
+    end
+
+    # The full path to the directory containing the collection.
+    #
+    # Returns a String containing th directory name where the collection
+    #   is stored on the filesystem.
+    def directory
+      @directory ||= site.in_source_dir(
+        File.join(container, relative_directory)
+      )
+    end
+
+    # The full path to the directory containing the collection, with
+    #   optional subpaths.
+    #
+    # *files - (optional) any other path pieces relative to the
+    #           directory to append to the path
+    #
+    # Returns a String containing th directory name where the collection
+    #   is stored on the filesystem.
+    def collection_dir(*files)
+      return directory if files.empty?
+
+      site.in_source_dir(container, relative_directory, *files)
+    end
+
+    # Checks whether the directory "exists" for this collection.
+    def exists?
+      File.directory?(directory)
+    end
+
+    # The entry filter for this collection.
+    # Creates an instance of Bridgetown::EntryFilter.
+    #
+    # Returns the instance of Bridgetown::EntryFilter for this collection.
+    def entry_filter
+      @entry_filter ||= Bridgetown::EntryFilter.new(site, relative_directory)
+    end
+
+    # An inspect string.
+    #
+    # Returns the inspect string
+    def inspect
+      "#<#{self.class} @label=#{label} docs=#{docs}>"
+    end
+
+    # Produce a sanitized label name
+    # Label names may not contain anything but alphanumeric characters,
+    #   underscores, and hyphens.
+    #
+    # label - the possibly-unsafe label
+    #
+    # Returns a sanitized version of the label.
+    def sanitize_label(label)
+      label.gsub(%r![^a-z0-9_\-\.]!i, "")
+    end
+
+    # Produce a representation of this Collection for use in Liquid.
+    # Exposes two attributes:
+    #   - label
+    #   - docs
+    #
+    # Returns a representation of this collection for use in Liquid.
+    def to_liquid
+      Drops::CollectionDrop.new self
+    end
+
+    # Whether the collection's documents ought to be written as individual
+    #   files in the output.
+    #
+    # Returns true if the 'write' metadata is true, false otherwise.
+    def write?
+      !!metadata.fetch("output", false)
+    end
+
+    # The URL template to render collection's documents at.
+    #
+    # Returns the URL template to render collection's documents at.
+    def url_template
+      @url_template ||= metadata.fetch("permalink") do
+        Utils.add_permalink_suffix("/:collection/:path", site.permalink_style)
+      end
+    end
+
+    # Extract options for this collection from the site configuration.
+    #
+    # Returns the metadata for this collection
+    def extract_metadata
+      if site.config["collections"].is_a?(Hash)
+        site.config["collections"][label] || {}
+      else
+        {}
+      end
+    end
+
+    private
+
+    def container
+      @container ||= site.config["collections_dir"]
+    end
+
+    def read_document(full_path)
+      doc = Document.new(full_path, :site => site, :collection => self)
+      doc.read
+      docs << doc if site.unpublished || doc.published?
+    end
+
+    def sort_docs!
+      if metadata["sort_by"].is_a?(String)
+        sort_docs_by_key!
+      else
+        docs.sort!
+      end
+    end
+
+    # A custom sort function based on Schwartzian transform
+    # Refer https://byparker.com/blog/2017/schwartzian-transform-faster-sorting/ for details
+    def sort_docs_by_key!
+      meta_key = metadata["sort_by"]
+      # Modify `docs` array to cache document's property along with the Document instance
+      docs.map! { |doc| [doc.data[meta_key], doc] }.sort! do |apples, olives|
+        order = determine_sort_order(meta_key, apples, olives)
+
+        # Fall back to `Document#<=>` if the properties were equal or were non-sortable
+        # Otherwise continue with current sort-order
+        if order.nil? || order.zero?
+          apples[-1] <=> olives[-1]
+        else
+          order
+        end
+
+        # Finally restore the `docs` array with just the Document objects themselves
+      end.map!(&:last)
+    end
+
+    def determine_sort_order(sort_key, apples, olives)
+      apple_property, apple_document = apples
+      olive_property, olive_document = olives
+
+      if apple_property.nil? && !olive_property.nil?
+        order_with_warning(sort_key, apple_document, 1)
+      elsif !apple_property.nil? && olive_property.nil?
+        order_with_warning(sort_key, olive_document, -1)
+      else
+        apple_property <=> olive_property
+      end
+    end
+
+    def order_with_warning(sort_key, document, order)
+      Bridgetown.logger.warn "Sort warning:", "'#{sort_key}' not defined in" \
+                              " #{document.relative_path}"
+      order
+    end
+
+    def read_static_file(file_path, full_path)
+      relative_dir = Bridgetown.sanitized_path(
+        relative_directory,
+        File.dirname(file_path)
+      ).chomp("/.")
+
+      files << StaticFile.new(
+        site,
+        site.source,
+        relative_dir,
+        File.basename(full_path),
+        self
+      )
+    end
+  end
+end

data/lib/bridgetown-core/command.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  class Command
+    class << self
+      # A list of subclasses of Bridgetown::Command
+      def subclasses
+        @subclasses ||= []
+      end
+
+      # Keep a list of subclasses of Bridgetown::Command every time it's inherited
+      # Called automatically.
+      #
+      # base - the subclass
+      #
+      # Returns nothing
+      def inherited(base)
+        subclasses << base
+        super(base)
+      end
+
+      # Run Site#process and catch errors
+      #
+      # site - the Bridgetown::Site object
+      #
+      # Returns nothing
+      def process_site(site)
+        site.process
+      rescue Bridgetown::Errors::FatalException => e
+        Bridgetown.logger.error "ERROR:", "YOUR SITE COULD NOT BE BUILT:"
+        Bridgetown.logger.error "", "------------------------------------"
+        Bridgetown.logger.error "", e.message
+        exit(1)
+      end
+
+      # Create a full Bridgetown configuration with the options passed in as overrides
+      #
+      # options - the configuration overrides
+      #
+      # Returns a full Bridgetown configuration
+      def configuration_from_options(options)
+        return options if options.is_a?(Bridgetown::Configuration)
+
+        Bridgetown.configuration(options)
+      end
+
+      # Add common options to a command for building configuration
+      #
+      # cmd - the Bridgetown::Command to add these options to
+      #
+      # Returns nothing
+      # rubocop:disable Metrics/MethodLength
+      def add_build_options(cmd)
+        cmd.option "config", "--config CONFIG_FILE[,CONFIG_FILE2,...]",
+                   Array, "Custom configuration file"
+        cmd.option "destination", "-d", "--destination DESTINATION",
+                   "The current folder will be generated into DESTINATION"
+        cmd.option "root_dir", "-r", "--root_dir ROOT_DIR", "The top-level root folder" \
+                    " where config files are located"
+        cmd.option "source", "-s", "--source SOURCE", "Custom source directory"
+        cmd.option "future", "--future", "Publishes posts with a future date"
+        cmd.option "limit_posts", "--limit_posts MAX_POSTS", Integer,
+                   "Limits the number of posts to parse and publish"
+        cmd.option "watch", "-w", "--[no-]watch", "Watch for changes and rebuild"
+        cmd.option "baseurl", "-b", "--baseurl URL",
+                   "Serve the website from the given base URL"
+        cmd.option "force_polling", "--force_polling", "Force watch to use polling"
+        cmd.option "lsi", "--lsi", "Use LSI for improved related posts"
+        cmd.option "unpublished", "--unpublished",
+                   "Render posts that were marked as unpublished"
+        cmd.option "disable_disk_cache", "--disable-disk-cache",
+                   "Disable caching to disk"
+        cmd.option "quiet", "-q", "--quiet", "Silence output."
+        cmd.option "verbose", "-V", "--verbose", "Print verbose output."
+        cmd.option "incremental", "-I", "--incremental", "Enable incremental rebuild."
+        cmd.option "strict_front_matter", "--strict_front_matter",
+                   "Fail if errors are present in front matter"
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      # Run ::process method in a given set of Bridgetown::Command subclasses and suggest
+      # re-running the associated command with --trace switch to obtain any additional
+      # information or backtrace regarding the encountered Exception.
+      #
+      # cmd     - the Bridgetown::Command to be handled
+      # options - configuration overrides
+      # klass   - an array of Bridgetown::Command subclasses associated with the command
+      #
+      # Note that all exceptions are rescued..
+      # rubocop: disable Lint/RescueException
+      def process_with_graceful_fail(cmd, options, *klass)
+        klass.each { |k| k.process(options) if k.respond_to?(:process) }
+      rescue Exception => e
+        raise e if cmd.trace
+
+        msg = " Please append `--trace` to the `#{cmd.name}` command "
+        dashes = "-" * msg.length
+        Bridgetown.logger.error "", dashes
+        Bridgetown.logger.error "Bridgetown #{Bridgetown::VERSION} ", msg
+        Bridgetown.logger.error "", " for any additional information or backtrace. "
+        Bridgetown.logger.abort_with "", dashes
+      end
+      # rubocop: enable Lint/RescueException
+    end
+  end
+end