bridgetown-core 0.21.5 → 1.0.0.alpha1

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

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-
-module Bridgetown
-  module Drops
-    class DocumentDrop < Drop
-      extend Forwardable
-
-      NESTED_OBJECT_FIELD_BLACKLIST = %w(
-        content output excerpt next previous
-      ).freeze
-
-      mutable false
-
-      def_delegator :@obj, :relative_path, :path
-      def_delegators :@obj,
-                     :id,
-                     :output,
-                     :content,
-                     :to_s,
-                     :relative_path,
-                     :url,
-                     :date,
-                     :related_posts
-
-      private def_delegator :@obj, :data, :fallback_data
-
-      def collection
-        @collection ||= @obj.collection.to_liquid
-      end
-
-      def excerpt
-        fallback_data["excerpt"].to_s
-      end
-
-      def <=>(other)
-        return nil unless other.is_a? DocumentDrop
-
-        cmp = self["date"] <=> other["date"]
-        cmp = self["path"] <=> other["path"] if cmp.nil? || cmp.zero?
-        cmp
-      end
-
-      def previous
-        @previous ||= @obj.previous_doc.to_liquid
-      end
-
-      def next
-        @next ||= @obj.next_doc.to_liquid
-      end
-
-      # Generate a Hash for use in generating JSON.
-      # This is useful if fields need to be cleared before the JSON can generate.
-      #
-      # state - the JSON::State object which determines the state of current processing.
-      #
-      # Returns a Hash ready for JSON generation.
-      def hash_for_json(state = nil)
-        to_h.tap do |hash|
-          # use collection label in the hash
-          hash["collection"] = hash["collection"]["label"] if hash["collection"]
-
-          if state && state.depth >= 2
-            hash["previous"] = collapse_document(hash["previous"]) if hash["previous"]
-            hash["next"]     = collapse_document(hash["next"]) if hash["next"]
-          end
-        end
-      end
-
-      # Generate a Hash which breaks the recursive chain.
-      # Certain fields which are normally available are omitted.
-      #
-      # Returns a Hash with only non-recursive fields present.
-      def collapse_document(doc)
-        doc.keys.each_with_object({}) do |(key, _), result|
-          result[key] = doc[key] unless NESTED_OBJECT_FIELD_BLACKLIST.include?(key)
-        end
-      end
-    end
-  end
-end

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

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module Bridgetown
-  module Drops
-    class ExcerptDrop < DocumentDrop
-      def layout
-        @obj.doc.data["layout"]
-      end
-
-      def date
-        @obj.doc.date
-      end
-
-      def excerpt
-        nil
-      end
-    end
-  end
-end

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

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module Bridgetown
-  module Drops
-    class PageDrop < Drop
-      extend Forwardable
-
-      mutable false
-
-      def_delegators :@obj, :content, :dir, :name, :path, :url, :pager
-      private def_delegator :@obj, :data, :fallback_data
-
-      def relative_url
-        @obj.relative_url
-      end
-    end
-  end
-end

data/lib/bridgetown-core/excerpt.rb

@@ -1,200 +0,0 @@
-# frozen_string_literal: true
-
-module Bridgetown
-  class Excerpt
-    extend Forwardable
-    include LiquidRenderable
-
-    attr_accessor :doc
-    attr_accessor :content, :ext
-    attr_writer   :output
-
-    def_delegators :@doc,
-                   :site, :name, :ext, :extname,
-                   :collection, :related_posts, :type,
-                   :yaml_file?,
-                   :url, :next_doc, :previous_doc
-
-    private :yaml_file?
-
-    # Initialize this Excerpt instance.
-    #
-    # doc - The Document.
-    #
-    # Returns the new Excerpt.
-    def initialize(doc)
-      self.doc = doc
-      self.content = extract_excerpt(doc.content)
-    end
-
-    # Fetch YAML front-matter data from related doc, without layout key
-    #
-    # Returns Hash of doc data
-    def data
-      @data ||= doc.data.dup
-      @data.delete("layout")
-      @data.delete("excerpt")
-      @data
-    end
-
-    def trigger_hooks(*); end
-
-    # 'Path' of the excerpt.
-    #
-    # Returns the path for the doc this excerpt belongs to with #excerpt appended
-    def path
-      File.join(doc.path, "#excerpt")
-    end
-
-    # 'Relative Path' of the excerpt.
-    #
-    # Returns the relative_path for the doc this excerpt belongs to with #excerpt appended
-    def relative_path
-      @relative_path ||= File.join(doc.relative_path, "#excerpt")
-    end
-
-    # Check if excerpt includes a string
-    #
-    # Returns true if the string passed in
-    def include?(something)
-      output&.include?(something) || content.include?(something)
-    end
-
-    # The UID for this doc (useful in feeds).
-    # e.g. /2008/11/05/my-awesome-doc
-    #
-    # Returns the String UID.
-    def id
-      "#{doc.id}#excerpt"
-    end
-
-    def to_s
-      output || content
-    end
-
-    def to_liquid
-      Bridgetown::Drops::ExcerptDrop.new(self)
-    end
-
-    # Returns the shorthand String identifier of this doc.
-    def inspect
-      "<#{self.class} id=#{id}>"
-    end
-
-    def output
-      @output || (
-        Renderer.new(doc.site, self).run
-        @output
-      )
-    end
-
-    def place_in_layout?
-      false
-    end
-
-    protected
-
-    # Internal: Extract excerpt from the content
-    #
-    # By default excerpt is your first paragraph of a doc: everything before
-    # the first two new lines:
-    #
-    #     ---
-    #     title: Example
-    #     ---
-    #
-    #     First paragraph with [link][1].
-    #
-    #     Second paragraph.
-    #
-    #     [1]: http://example.com/
-    #
-    # This is fairly good option for Markdown and Textile files. But might cause
-    # problems for HTML docs (which is quite unusual for Bridgetown). If default
-    # excerpt delimiter is not good for you, you might want to set your own via
-    # configuration option `excerpt_separator`. For example, following is a good
-    # alternative for HTML docs:
-    #
-    #     # file: bridgetown.config.yml
-    #     excerpt_separator: "<!-- more -->"
-    #
-    # Notice that all markdown-style link references will be appended to the
-    # excerpt. So the example doc above will have this excerpt source:
-    #
-    #     First paragraph with [link][1].
-    #
-    #     [1]: http://example.com/
-    #
-    # Excerpts are rendered same time as content is rendered.
-    #
-    # Returns excerpt String
-
-    LIQUID_TAG_REGEX = %r!{%-?\s*(\w+)\s*.*?-?%}!m.freeze
-    MKDWN_LINK_REF_REGEX = %r!^ {0,3}(?:(\[[^\]]+\])(:.+))$!.freeze
-
-    def extract_excerpt(doc_content)
-      head, _, tail = doc_content.to_s.partition(doc.excerpt_separator)
-      return head if tail.empty?
-
-      head = sanctify_liquid_tags(head) if head.include?("{%")
-      definitions = extract_markdown_link_reference_defintions(head, tail)
-      return head if definitions.empty?
-
-      head << "\n\n" << definitions.join("\n")
-    end
-
-    private
-
-    # append appropriate closing tag(s) (for each Liquid block), to the `head` if the
-    # partitioning resulted in leaving the closing tag somewhere in the `tail` partition.
-    def sanctify_liquid_tags(head)
-      modified  = false
-      tag_names = head.scan(LIQUID_TAG_REGEX)
-      tag_names.flatten!
-      tag_names.reverse_each do |tag_name|
-        next unless liquid_block?(tag_name)
-        next if endtag_regex_stash(tag_name).match?(head)
-
-        modified = true
-        head << "\n{% end#{tag_name} %}"
-      end
-
-      print_build_warning if modified
-      head
-    end
-
-    def extract_markdown_link_reference_defintions(head, tail)
-      [].tap do |definitions|
-        tail.scan(MKDWN_LINK_REF_REGEX).each do |segments|
-          definitions << segments.join if head.include?(segments[0])
-        end
-      end
-    end
-
-    def endtag_regex_stash(tag_name)
-      @endtag_regex_stash ||= {}
-      @endtag_regex_stash[tag_name] ||= %r!{%-?\s*end#{tag_name}.*?\s*-?%}!m
-    end
-
-    def liquid_block?(tag_name)
-      return false unless tag_name.is_a?(String)
-      return false unless Liquid::Template.tags[tag_name]
-
-      Liquid::Template.tags[tag_name].ancestors.include?(Liquid::Block)
-    rescue NoMethodError
-      Bridgetown.logger.error "Error:", "A Liquid tag in the excerpt of" \
-                              " #{doc.relative_path} couldn't be parsed."
-      raise
-    end
-
-    def print_build_warning
-      Bridgetown.logger.warn "Warning:", "Excerpt modified in #{doc.relative_path}!"
-      Bridgetown.logger.warn "", "Found a Liquid block containing the excerpt separator" \
-                         " #{doc.excerpt_separator.inspect}. "
-      Bridgetown.logger.warn "", "The block has been modified with the appropriate closing tag."
-      Bridgetown.logger.warn "", "Feel free to define a custom excerpt or excerpt_separator in the"
-      Bridgetown.logger.warn "", "document's Front Matter if the generated excerpt is" \
-                                " unsatisfactory."
-    end
-  end
-end

data/lib/bridgetown-core/readers/data_reader.rb

@@ -1,89 +0,0 @@
-# frozen_string_literal: true
-
-module Bridgetown
-  # TODO: to be retired once the Resource engine is made official
-  class DataReader
-    attr_reader :site, :content
-
-    def initialize(site)
-      @site = site
-      @content = {}
-      @entry_filter = EntryFilter.new(site)
-    end
-
-    # Read all the files in <dir> and adds them to @content
-    #
-    # dir - The String relative path of the directory to read.
-    #
-    # Returns @content, a Hash of the .yaml, .yml,
-    # .json, and .csv files in the base directory
-    def read
-      base = site.in_source_dir(site.config.data_dir)
-      read_data_to(base, @content)
-      merge_environment_specific_metadata!
-      @content = @content.with_dot_access
-    end
-
-    # Read and parse all .yaml, .yml, .json, .csv and .tsv
-    # files under <dir> and add them to the <data> variable.
-    #
-    # dir - The string absolute path of the directory to read.
-    # data - The variable to which data will be added.
-    #
-    # Returns nothing
-    def read_data_to(dir, data)
-      return unless File.directory?(dir)
-
-      entries = Dir.chdir(dir) do
-        Dir["*.{yaml,yml,json,csv,tsv}"] + Dir["*"].select { |fn| File.directory?(fn) }
-      end
-
-      entries.each do |entry|
-        path = @site.in_source_dir(dir, entry)
-
-        if File.directory?(path)
-          read_data_to(
-            path,
-            data[sanitize_filename(entry)] = {}
-          )
-        else
-          key = sanitize_filename(File.basename(entry, ".*"))
-          data[key] = read_data_file(path)
-        end
-      end
-    end
-
-    # Determines how to read a data file.
-    #
-    # Returns the contents of the data file.
-    def read_data_file(path)
-      case File.extname(path).downcase
-      when ".csv"
-        CSV.read(path,
-                 headers: true,
-                 encoding: site.config["encoding"]).map(&:to_hash)
-      when ".tsv"
-        CSV.read(path,
-                 col_sep: "\t",
-                 headers: true,
-                 encoding: site.config["encoding"]).map(&:to_hash)
-      else
-        YAMLParser.load_file(path)
-      end
-    end
-
-    def merge_environment_specific_metadata!
-      if @content["site_metadata"]
-        @content["site_metadata"][Bridgetown.environment]&.each_key do |k|
-          @content["site_metadata"][k] = @content["site_metadata"][Bridgetown.environment][k]
-        end
-        @content["site_metadata"].delete(Bridgetown.environment)
-      end
-    end
-
-    def sanitize_filename(name)
-      name.gsub(%r![^\w\s-]+|(?<=^|\b\s)\s+(?=$|\s?\b)!, "")
-        .gsub(%r!\s+!, "_")
-    end
-  end
-end

data/lib/bridgetown-core/readers/page_reader.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-module Bridgetown
-  # TODO: to be retired once the Resource engine is made official
-  class PageReader
-    attr_reader :site, :dir, :unfiltered_content
-
-    def initialize(site, dir)
-      @site = site
-      @dir = dir
-      @unfiltered_content = []
-    end
-
-    # Create a new `Bridgetown::Page` object for each entry in a given array.
-    #
-    # files - An array of file names inside `@dir`
-    #
-    # Returns an array of publishable `Bridgetown::Page` objects.
-    def read(files)
-      files.each do |page|
-        @unfiltered_content << Page.new(@site, @site.source, @dir, page)
-      end
-      @unfiltered_content.select { |page| site.publisher.publish?(page) }
-    end
-  end
-end

data/lib/bridgetown-core/readers/post_reader.rb

@@ -1,109 +0,0 @@
-# frozen_string_literal: true
-
-module Bridgetown
-  # TODO: to be retired once the Resource engine is made official
-  class PostReader
-    attr_reader :site, :unfiltered_content
-
-    def initialize(site)
-      @site = site
-    end
-
-    # Read all the files in <source>/<dir>/_posts and create a new Document
-    # object with each one.
-    #
-    # dir - The String relative path of the directory to read.
-    #
-    # Returns nothing.
-    def read_posts(dir)
-      read_publishable(dir, "_posts", Document::DATE_FILENAME_MATCHER)
-    end
-
-    # Read all the files in <source>/<dir>/<magic_dir> and create a new
-    # Document object with each one insofar as it matches the regexp matcher.
-    #
-    # @param dir [String] relative path of the directory to read.
-    #
-    # @return [Array<Document, StaticFile>]
-    def read_publishable(dir, magic_dir, matcher)
-      read_content(dir, magic_dir, matcher)
-        .tap { |items| items.select { |item| item.respond_to?(:read) }.each(&:read) }
-        .select { |item| item_added_to_site?(item) }
-    end
-
-    # Read all the content files from <source>/<dir>/magic_dir
-    #   and return them with the type klass.
-    #
-    # dir - The String relative path of the directory to read.
-    # magic_dir - The String relative directory to <dir>,
-    #   looks for content here.
-    # klass - The return type of the content.
-    #
-    # Returns klass type of content files
-    def read_content(dir, magic_dir, matcher)
-      @site.reader.get_entries(dir, magic_dir).map do |entry|
-        path = @site.in_source_dir(File.join(dir, magic_dir, entry))
-
-        if matcher.match?(entry) || Utils.has_yaml_header?(path)
-          # Process as Document
-          Document.new(path,
-                       site: @site,
-                       collection: @site.collections.posts)
-        else
-          # Process as Static File
-          read_static_file(
-            path,
-            File.join(dir, magic_dir, File.dirname(entry).sub(".", ""))
-          )
-        end
-      end.reject(&:nil?)
-    end
-
-    private
-
-    def read_static_file(full_path, relative_dir)
-      StaticFile.new(
-        site,
-        site.source,
-        relative_dir,
-        File.basename(full_path),
-        @site.collections.posts
-      )
-    end
-
-    def processable?(item)
-      return true if item.is_a?(StaticFile)
-
-      if item.content.nil?
-        Bridgetown.logger.debug "Skipping:", "Content in #{item.relative_path} is nil"
-        false
-      elsif !item.content.valid_encoding?
-        Bridgetown.logger.debug "Skipping:", "#{item.relative_path} is not valid UTF-8"
-        false
-      else
-        publishable?(item)
-      end
-    end
-
-    def publishable?(item)
-      site.publisher.publish?(item).tap do |will_publish|
-        if !will_publish && site.publisher.hidden_in_the_future?(item)
-          Bridgetown.logger.warn "Skipping:", "#{item.relative_path} has a future date"
-        end
-      end
-    end
-
-    def item_added_to_site?(item)
-      return false unless processable?(item)
-
-      if item.is_a?(Document)
-        site.collections.posts.docs << item
-      elsif item.is_a?(StaticFile)
-        site.collections.posts.static_files << item
-        site.static_files << item
-      end
-
-      true
-    end
-  end
-end