bridgetown-core 0.7.0 → 0.7.1

data/lib/bridgetown-core/page.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  class Page
+    include Convertible
+
+    attr_writer :dir
+    attr_accessor :site, :pager
+    attr_accessor :name, :ext, :basename
+    attr_accessor :data, :content, :output
+
+    alias_method :extname, :ext
+
+    # Attributes for Liquid templates
+    ATTRIBUTES_FOR_LIQUID = %w(
+      content
+      dir
+      name
+      path
+      url
+    ).freeze
+
+    # A set of extensions that are considered HTML or HTML-like so we
+    # should not alter them,  this includes .xhtml through XHTM5.
+
+    HTML_EXTENSIONS = %w(
+      .html
+      .xhtml
+      .htm
+    ).freeze
+
+    # Initialize a new Page.
+    #
+    # site - The Site object.
+    # base - The String path to the source.
+    # dir  - The String path between the source and the file.
+    # name - The String filename of the file.
+    def initialize(site, base, dir, name)
+      @site = site
+      @base = base
+      @dir  = dir
+      @name = name
+      @path = site.in_source_dir(base, dir, name)
+
+      process(name)
+      read_yaml(PathManager.join(base, dir), name)
+
+      data.default_proc = proc do |_, key|
+        site.frontmatter_defaults.find(relative_path, type, key)
+      end
+
+      Bridgetown::Hooks.trigger :pages, :post_init, self
+    end
+
+    # The generated directory into which the page will be placed
+    # upon generation. This is derived from the permalink or, if
+    # permalink is absent, will be '/'
+    #
+    # Returns the String destination directory.
+    def dir
+      if url.end_with?("/")
+        url
+      else
+        url_dir = File.dirname(url)
+        url_dir.end_with?("/") ? url_dir : "#{url_dir}/"
+      end
+    end
+
+    # For backwards-compatibility in subclasses that do not redefine
+    # the `:to_liquid` method, stash existing definition under a new name
+    #
+    # TODO: Remove in Bridgetown 5.0
+    alias_method :legacy_to_liquid, :to_liquid
+    private :legacy_to_liquid
+
+    # Private
+    # Subclasses can choose to optimize their `:to_liquid` method by wrapping
+    # it around this definition.
+    #
+    # TODO: Remove in Bridgetown 5.0
+    def liquid_drop
+      @liquid_drop ||= begin
+        defaults = site.frontmatter_defaults.all(relative_path, type)
+        unless defaults.empty?
+          Utils.deep_merge_hashes!(data, Utils.deep_merge_hashes!(defaults, data))
+        end
+        Drops::PageDrop.new(self)
+      end
+    end
+    private :liquid_drop
+
+    # Public
+    #
+    # Liquid representation of current page
+    #
+    # TODO: Remove optional parameter in Bridgetown 5.0
+    def to_liquid(attrs = nil)
+      self.class == Bridgetown::Page ? liquid_drop : legacy_to_liquid(attrs)
+    end
+
+    # The full path and filename of the post. Defined in the YAML of the post
+    # body.
+    #
+    # Returns the String permalink or nil if none has been set.
+    def permalink
+      data.nil? ? nil : data["permalink"]
+    end
+
+    # The template of the permalink.
+    #
+    # Returns the template String.
+    def template
+      if !html?
+        "/:path/:basename:output_ext"
+      elsif index?
+        "/:path/"
+      else
+        Utils.add_permalink_suffix("/:path/:basename", site.permalink_style)
+      end
+    end
+
+    # The generated relative url of this page. e.g. /about.html.
+    #
+    # Returns the String url.
+    def url
+      @url ||= URL.new(
+        :template     => template,
+        :placeholders => url_placeholders,
+        :permalink    => permalink
+      ).to_s
+    end
+
+    # Returns a hash of URL placeholder names (as symbols) mapping to the
+    # desired placeholder replacements. For details see "url.rb"
+    def url_placeholders
+      {
+        :path       => @dir,
+        :basename   => basename,
+        :output_ext => output_ext,
+      }
+    end
+
+    # Extract information from the page filename.
+    #
+    # name - The String filename of the page file.
+    #
+    # NOTE: `String#gsub` removes all trailing periods (in comparison to `String#chomp`)
+    # Returns nothing.
+    def process(name)
+      self.ext = File.extname(name)
+      self.basename = name[0..-ext.length - 1].gsub(%r!\.*\z!, "")
+    end
+
+    # Add any necessary layouts to this post
+    #
+    # layouts      - The Hash of {"name" => "layout"}.
+    # site_payload - The site payload Hash.
+    #
+    # Returns String rendered page.
+    def render(layouts, site_payload)
+      site_payload["page"] = to_liquid
+      site_payload["paginator"] = pager.to_liquid
+
+      do_layout(site_payload, layouts)
+    end
+
+    # The path to the source file
+    #
+    # Returns the path to the source file
+    def path
+      data.fetch("path") { relative_path }
+    end
+
+    # The path to the page source file, relative to the site source
+    def relative_path
+      @relative_path ||= File.join(*[@dir, @name].map(&:to_s).reject(&:empty?)).sub(%r!\A\/!, "")
+    end
+
+    # Obtain destination path.
+    #
+    # dest - The String path to the destination dir.
+    #
+    # Returns the destination file path String.
+    def destination(dest)
+      path = site.in_dest_dir(dest, URL.unescape_path(url))
+      path = File.join(path, "index") if url.end_with?("/")
+      path << output_ext unless path.end_with? output_ext
+      path
+    end
+
+    # Returns the object as a debug String.
+    def inspect
+      "#<#{self.class} @relative_path=#{relative_path.inspect}>"
+    end
+
+    # Returns the Boolean of whether this Page is HTML or not.
+    def html?
+      HTML_EXTENSIONS.include?(output_ext)
+    end
+
+    # Returns the Boolean of whether this Page is an index file or not.
+    def index?
+      basename == "index"
+    end
+
+    def trigger_hooks(hook_name, *args)
+      Bridgetown::Hooks.trigger :pages, hook_name, self, *args
+    end
+
+    def write?
+      true
+    end
+  end
+end

data/lib/bridgetown-core/page_without_a_file.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  # A Bridgetown::Page subclass to handle processing files without reading it to
+  # determine the page-data and page-content based on Front Matter delimiters.
+  #
+  # The class instance is basically just a bare-bones entity with just
+  # attributes "dir", "name", "path", "url" defined on it.
+  class PageWithoutAFile < Page
+    def read_yaml(*)
+      @data ||= {}
+    end
+  end
+end

data/lib/bridgetown-core/path_manager.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  # A singleton class that caches frozen instances of path strings returned from its methods.
+  #
+  # NOTE:
+  #   This class exists because `File.join` allocates an Array and returns a new String on every
+  #   call using **the same arguments**. Caching the result means reduced memory usage.
+  #   However, the caches are never flushed so that they can be used even when a site is
+  #   regenerating. The results are frozen to deter mutation of the cached string.
+  #
+  #   Therefore, employ this class only for situations where caching the result is necessary
+  #   for performance reasons.
+  #
+  class PathManager
+    # This class cannot be initialized from outside
+    private_class_method :new
+
+    # Wraps `File.join` to cache the frozen result.
+    # Reassigns `nil`, empty strings and empty arrays to a frozen empty string beforehand.
+    #
+    # Returns a frozen string.
+    def self.join(base, item)
+      base = "" if base.nil? || base.empty?
+      item = "" if item.nil? || item.empty?
+      @join ||= {}
+      @join[base] ||= {}
+      @join[base][item] ||= File.join(base, item).freeze
+    end
+  end
+end

data/lib/bridgetown-core/plugin.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  class Plugin
+    PRIORITIES = {
+      :low     => -10,
+      :highest => 100,
+      :lowest  => -100,
+      :normal  => 0,
+      :high    => 10,
+    }.freeze
+
+    #
+
+    def self.inherited(const)
+      catch_inheritance(const) do |const_|
+        catch_inheritance(const_)
+      end
+    end
+
+    #
+
+    def self.catch_inheritance(const)
+      const.define_singleton_method :inherited do |const_|
+        (@children ||= Set.new).add const_
+        yield const_ if block_given?
+      end
+    end
+
+    #
+
+    def self.descendants
+      @children ||= Set.new
+      out = @children.map(&:descendants)
+      out << self unless superclass == Plugin
+      Set.new(out).flatten
+    end
+
+    # Get or set the priority of this plugin. When called without an
+    # argument it returns the priority. When an argument is given, it will
+    # set the priority.
+    #
+    # priority - The Symbol priority (default: nil). Valid options are:
+    #            :lowest, :low, :normal, :high, :highest
+    #
+    # Returns the Symbol priority.
+    def self.priority(priority = nil)
+      @priority ||= nil
+      @priority = priority if priority && PRIORITIES.key?(priority)
+      @priority || :normal
+    end
+
+    # Spaceship is priority [higher -> lower]
+    #
+    # other - The class to be compared.
+    #
+    # Returns -1, 0, 1.
+    def self.<=>(other)
+      PRIORITIES[other.priority] <=> PRIORITIES[priority]
+    end
+
+    # Spaceship is priority [higher -> lower]
+    #
+    # other - The class to be compared.
+    #
+    # Returns -1, 0, 1.
+    def <=>(other)
+      self.class <=> other.class
+    end
+
+    # Initialize a new plugin. This should be overridden by the subclass.
+    #
+    # config - The Hash of configuration options.
+    #
+    # Returns a new instance.
+    def initialize(config = {})
+      # no-op for default
+    end
+  end
+end

data/lib/bridgetown-core/plugin_manager.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  class PluginManager
+    attr_reader :site
+
+    # Create an instance of this class.
+    #
+    # site - the instance of Bridgetown::Site we're concerned with
+    #
+    # Returns nothing
+    def initialize(site)
+      @site = site
+    end
+
+    # Require all the plugins which are allowed.
+    #
+    # Returns nothing
+    def conscientious_require
+      require_plugin_files
+    end
+
+    def self.require_from_bundler
+      if !ENV["BRIDGETOWN_NO_BUNDLER_REQUIRE"] && File.file?("Gemfile")
+        require "bundler"
+
+        Bundler.setup
+        required_gems = Bundler.require(:bridgetown_plugins)
+        message = "Required #{required_gems.map(&:name).join(", ")}"
+        Bridgetown.logger.debug("PluginManager:", message)
+        ENV["BRIDGETOWN_NO_BUNDLER_REQUIRE"] = "true"
+
+        true
+      else
+        false
+      end
+    end
+
+    # Require all .rb files
+    #
+    # Returns nothing.
+    def require_plugin_files
+      plugins_path.each do |plugin_search_path|
+        plugin_files = Utils.safe_glob(plugin_search_path, File.join("**", "*.rb"))
+        Bridgetown::External.require_with_graceful_fail(plugin_files)
+      end
+    end
+
+    # Public: Setup the plugin search path
+    #
+    # Returns an Array of plugin search paths
+    def plugins_path
+      if site.config["plugins_dir"].eql? Bridgetown::Configuration::DEFAULTS["plugins_dir"]
+        [site.in_root_dir(site.config["plugins_dir"])]
+      else
+        Array(site.config["plugins_dir"]).map { |d| File.expand_path(d) }
+      end
+    end
+  end
+end

data/lib/bridgetown-core/publisher.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  class Publisher
+    def initialize(site)
+      @site = site
+    end
+
+    def publish?(thing)
+      can_be_published?(thing) && !hidden_in_the_future?(thing)
+    end
+
+    def hidden_in_the_future?(thing)
+      thing.respond_to?(:date) && !@site.future && thing.date.to_i > @site.time.to_i
+    end
+
+    private
+
+    def can_be_published?(thing)
+      thing.data.fetch("published", true) || @site.unpublished
+    end
+  end
+end

data/lib/bridgetown-core/reader.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  class Reader
+    attr_reader :site
+
+    def initialize(site)
+      @site = site
+    end
+
+    # Read Site data from disk and load it into internal data structures.
+    #
+    # Returns nothing.
+    def read
+      @site.layouts = LayoutReader.new(site).read
+      read_directories
+      read_included_excludes
+      sort_files!
+      @site.data = DataReader.new(site).read(site.config["data_dir"])
+      CollectionReader.new(site).read
+    end
+
+    # Sorts posts, pages, and static files.
+    def sort_files!
+      site.collections.each_value { |c| c.docs.sort! }
+      site.pages.sort_by!(&:name)
+      site.static_files.sort_by!(&:relative_path)
+    end
+
+    # Recursively traverse directories to find pages and static files
+    # that will become part of the site according to the rules in
+    # filter_entries.
+    #
+    # dir - The String relative path of the directory to read. Default: ''.
+    #
+    # Returns nothing.
+    def read_directories(dir = "")
+      base = site.in_source_dir(dir)
+
+      return unless File.directory?(base)
+
+      dot_dirs = []
+      dot_pages = []
+      dot_static_files = []
+
+      dot = Dir.chdir(base) { filter_entries(Dir.entries("."), base) }
+      dot.each do |entry|
+        file_path = @site.in_source_dir(base, entry)
+        if File.directory?(file_path)
+          dot_dirs << entry
+        elsif Utils.has_yaml_header?(file_path)
+          dot_pages << entry
+        else
+          dot_static_files << entry
+        end
+      end
+
+      retrieve_posts(dir)
+      retrieve_dirs(base, dir, dot_dirs)
+      retrieve_pages(dir, dot_pages)
+      retrieve_static_files(dir, dot_static_files)
+    end
+
+    # Retrieves all the posts(posts) from the given directory
+    # and add them to the site and sort them.
+    #
+    # dir - The String representing the directory to retrieve the posts from.
+    #
+    # Returns nothing.
+    def retrieve_posts(dir)
+      return if outside_configured_directory?(dir)
+
+      site.posts.docs.concat(post_reader.read_posts(dir))
+    end
+
+    # Recursively traverse directories with the read_directories function.
+    #
+    # base - The String representing the site's base directory.
+    # dir - The String representing the directory to traverse down.
+    # dot_dirs - The Array of subdirectories in the dir.
+    #
+    # Returns nothing.
+    def retrieve_dirs(_base, dir, dot_dirs)
+      dot_dirs.each do |file|
+        dir_path = site.in_source_dir(dir, file)
+        rel_path = PathManager.join(dir, file)
+        @site.reader.read_directories(rel_path) unless @site.dest.chomp("/") == dir_path
+      end
+    end
+
+    # Retrieve all the pages from the current directory,
+    # add them to the site and sort them.
+    #
+    # dir - The String representing the directory retrieve the pages from.
+    # dot_pages - The Array of pages in the dir.
+    #
+    # Returns nothing.
+    def retrieve_pages(dir, dot_pages)
+      site.pages.concat(PageReader.new(site, dir).read(dot_pages))
+    end
+
+    # Retrieve all the static files from the current directory,
+    # add them to the site and sort them.
+    #
+    # dir - The directory retrieve the static files from.
+    # dot_static_files - The static files in the dir.
+    #
+    # Returns nothing.
+    def retrieve_static_files(dir, dot_static_files)
+      site.static_files.concat(StaticFileReader.new(site, dir).read(dot_static_files))
+    end
+
+    # Filter out any files/directories that are hidden or backup files (start
+    # with "." or "#" or end with "~"), or contain site content (start with "_"),
+    # or are excluded in the site configuration, unless they are web server
+    # files such as '.htaccess'.
+    #
+    # entries - The Array of String file/directory entries to filter.
+    # base_directory - The string representing the optional base directory.
+    #
+    # Returns the Array of filtered entries.
+    def filter_entries(entries, base_directory = nil)
+      EntryFilter.new(site, base_directory).filter(entries)
+    end
+
+    # Read the entries from a particular directory for processing
+    #
+    # dir - The String representing the relative path of the directory to read.
+    # subfolder - The String representing the directory to read.
+    #
+    # Returns the list of entries to process
+    def get_entries(dir, subfolder)
+      base = site.in_source_dir(dir, subfolder)
+      return [] unless File.exist?(base)
+
+      entries = Dir.chdir(base) { filter_entries(Dir["**/*"], base) }
+      entries.delete_if { |e| File.directory?(site.in_source_dir(base, e)) }
+    end
+
+    private
+
+    # Internal
+    #
+    # Determine if the directory is supposed to contain posts.
+    # If the user has defined a custom collections_dir, then attempt to read
+    # posts only from within that directory.
+    #
+    # Returns true if a custom collections_dir has been set but current directory lies
+    # outside that directory.
+    def outside_configured_directory?(dir)
+      collections_dir = site.config["collections_dir"]
+      !collections_dir.empty? && !dir.start_with?("/#{collections_dir}")
+    end
+
+    # Create a single PostReader instance to retrieve posts from all valid
+    # directories in current site.
+    def post_reader
+      @post_reader ||= PostReader.new(site)
+    end
+
+    def read_included_excludes
+      entry_filter = EntryFilter.new(site)
+
+      site.include.each do |entry|
+        next if entry == ".htaccess"
+
+        entry_path = site.in_source_dir(entry)
+        next if File.directory?(entry_path)
+        next if entry_filter.symlink?(entry_path)
+
+        read_included_file(entry_path) if File.file?(entry_path)
+      end
+    end
+
+    def read_included_file(entry_path)
+      dir  = File.dirname(entry_path).sub(site.source, "")
+      file = Array(File.basename(entry_path))
+      if Utils.has_yaml_header?(entry_path)
+        site.pages.concat(PageReader.new(site, dir).read(file))
+      else
+        site.static_files.concat(StaticFileReader.new(site, dir).read(file))
+      end
+    end
+  end
+end