bridgetown-core 0.7.0 → 0.7.1

data/lib/bridgetown-core/generator.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  Generator = Class.new(Plugin)
+end

data/lib/bridgetown-core/hooks.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  module Hooks
+    DEFAULT_PRIORITY = 20
+
+    # compatibility layer for octopress-hooks users
+    PRIORITY_MAP = {
+      :low    => 10,
+      :normal => 20,
+      :high   => 30,
+    }.freeze
+
+    # initial empty hooks
+    @registry = {
+      :site      => {
+        :after_init  => [],
+        :after_reset => [],
+        :post_read   => [],
+        :pre_render  => [],
+        :post_render => [],
+        :post_write  => [],
+      },
+      :pages     => {
+        :post_init   => [],
+        :pre_render  => [],
+        :post_render => [],
+        :post_write  => [],
+      },
+      :posts     => {
+        :post_init   => [],
+        :pre_render  => [],
+        :post_render => [],
+        :post_write  => [],
+      },
+      :documents => {
+        :post_init   => [],
+        :pre_render  => [],
+        :post_render => [],
+        :post_write  => [],
+      },
+      :clean     => {
+        :on_obsolete => [],
+      },
+    }
+
+    # map of all hooks and their priorities
+    @hook_priority = {}
+
+    NotAvailable = Class.new(RuntimeError)
+    Uncallable = Class.new(RuntimeError)
+
+    # register hook(s) to be called later, public API
+    def self.register(owners, event, priority: DEFAULT_PRIORITY, &block)
+      Array(owners).each do |owner|
+        register_one(owner, event, priority_value(priority), &block)
+      end
+    end
+
+    # Ensure the priority is a Fixnum
+    def self.priority_value(priority)
+      return priority if priority.is_a?(Integer)
+
+      PRIORITY_MAP[priority] || DEFAULT_PRIORITY
+    end
+
+    # register a single hook to be called later, internal API
+    def self.register_one(owner, event, priority, &block)
+      @registry[owner] ||= {
+        :post_init   => [],
+        :pre_render  => [],
+        :post_render => [],
+        :post_write  => [],
+      }
+
+      unless @registry[owner][event]
+        raise NotAvailable, "Invalid hook. #{owner} supports only the " \
+          "following hooks #{@registry[owner].keys.inspect}"
+      end
+
+      raise Uncallable, "Hooks must respond to :call" unless block.respond_to? :call
+
+      insert_hook owner, event, priority, &block
+    end
+
+    def self.insert_hook(owner, event, priority, &block)
+      @hook_priority[block] = [-priority, @hook_priority.size]
+      @registry[owner][event] << block
+    end
+
+    # interface for Bridgetown core components to trigger hooks
+    def self.trigger(owner, event, *args)
+      # proceed only if there are hooks to call
+      hooks = @registry.dig(owner, event)
+      return if hooks.nil? || hooks.empty?
+
+      # sort and call hooks according to priority and load order
+      hooks.sort_by { |h| @hook_priority[h] }.each do |hook|
+        hook.call(*args)
+      end
+    end
+  end
+end

data/lib/bridgetown-core/layout.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  class Layout
+    include Convertible
+
+    # Gets the Site object.
+    attr_reader :site
+
+    # Gets the name of this layout.
+    attr_reader :name
+
+    # Gets the path to this layout.
+    attr_reader :path
+
+    # Gets the path to this layout relative to its base
+    attr_reader :relative_path
+
+    # Gets/Sets the extension of this layout.
+    attr_accessor :ext
+
+    # Gets/Sets the Hash that holds the metadata for this layout.
+    attr_accessor :data
+
+    # Gets/Sets the content of this layout.
+    attr_accessor :content
+
+    # Initialize a new Layout.
+    #
+    # site - The Site.
+    # base - The String path to the source.
+    # name - The String filename of the post file.
+    def initialize(site, base, name)
+      @site = site
+      @base = base
+      @name = name
+
+      @base_dir = site.source
+      @path = site.in_source_dir(base, name)
+      @relative_path = @path.sub(@base_dir, "")
+
+      self.data = {}
+
+      process(name)
+      read_yaml(base, name)
+    end
+
+    # Extract information from the layout filename.
+    #
+    # name - The String filename of the layout file.
+    #
+    # Returns nothing.
+    def process(name)
+      self.ext = File.extname(name)
+    end
+  end
+end

data/lib/bridgetown-core/liquid_extensions.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  module LiquidExtensions
+    # Lookup a Liquid variable in the given context.
+    #
+    # context  - the Liquid context in question.
+    # variable - the variable name, as a string.
+    #
+    # Returns the value of the variable in the context
+    #   or the variable name if not found.
+    def lookup_variable(context, variable)
+      lookup = context
+
+      variable.split(".").each do |value|
+        lookup = lookup[value]
+      end
+
+      lookup || variable
+    end
+  end
+end

data/lib/bridgetown-core/liquid_renderer.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require_relative "liquid_renderer/file"
+require_relative "liquid_renderer/table"
+
+module Bridgetown
+  class LiquidRenderer
+    extend Forwardable
+
+    private def_delegator :@site, :in_source_dir, :source_dir
+
+    def initialize(site)
+      @site = site
+      Liquid::Template.error_mode = @site.config["liquid"]["error_mode"].to_sym
+      reset
+    end
+
+    def reset
+      @stats = {}
+      @cache = {}
+    end
+
+    def file(filename)
+      filename.match(filename_regex)
+      filename = Regexp.last_match(2)
+      LiquidRenderer::File.new(self, filename).tap do
+        @stats[filename] ||= new_profile_hash
+      end
+    end
+
+    def increment_bytes(filename, bytes)
+      @stats[filename][:bytes] += bytes
+    end
+
+    def increment_time(filename, time)
+      @stats[filename][:time] += time
+    end
+
+    def increment_count(filename)
+      @stats[filename][:count] += 1
+    end
+
+    def stats_table(num_of_rows = 50)
+      LiquidRenderer::Table.new(@stats).to_s(num_of_rows)
+    end
+
+    def self.format_error(error, path)
+      "#{error.message} in #{path}"
+    end
+
+    # A persistent cache to store and retrieve parsed templates based on the filename
+    # via `LiquidRenderer::File#parse`
+    #
+    # It is emptied when `self.reset` is called.
+    def cache
+      @cache ||= {}
+    end
+
+    private
+
+    def filename_regex
+      @filename_regex ||= begin
+        %r!\A(#{Regexp.escape(source_dir)}/|/*)(.*)!i
+      end
+    end
+
+    def new_profile_hash
+      Hash.new { |hash, key| hash[key] = 0 }
+    end
+  end
+end

data/lib/bridgetown-core/liquid_renderer/file.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  class LiquidRenderer
+    class File
+      def initialize(renderer, filename)
+        @renderer = renderer
+        @filename = filename
+      end
+
+      def parse(content)
+        measure_time do
+          @renderer.cache[@filename] ||= Liquid::Template.parse(content, :line_numbers => true)
+        end
+        @template = @renderer.cache[@filename]
+
+        self
+      end
+
+      def render(*args)
+        measure_time do
+          measure_bytes do
+            measure_counts do
+              @template.render(*args)
+            end
+          end
+        end
+      end
+
+      # This method simply 'rethrows any error' before attempting to render the template.
+      def render!(*args)
+        measure_time do
+          measure_bytes do
+            measure_counts do
+              @template.render!(*args)
+            end
+          end
+        end
+      end
+
+      def warnings
+        @template.warnings
+      end
+
+      private
+
+      def measure_counts
+        @renderer.increment_count(@filename)
+        yield
+      end
+
+      def measure_bytes
+        yield.tap do |str|
+          @renderer.increment_bytes(@filename, str.bytesize)
+        end
+      end
+
+      def measure_time
+        before = Time.now
+        yield
+      ensure
+        after = Time.now
+        @renderer.increment_time(@filename, after - before)
+      end
+    end
+  end
+end

data/lib/bridgetown-core/liquid_renderer/table.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  class LiquidRenderer
+    class Table
+      GAUGES = [:count, :bytes, :time].freeze
+
+      def initialize(stats)
+        @stats = stats
+      end
+
+      def to_s(num_of_rows = 50)
+        tabulate(data_for_table(num_of_rows))
+      end
+
+      private
+
+      def tabulate(data)
+        require "terminal-table"
+
+        header = data.shift
+        footer = data.pop
+        output = +"\n"
+
+        table = Terminal::Table.new do |t|
+          t << header
+          t << :separator
+          data.each { |row| t << row }
+          t << :separator
+          t << footer
+          t.style = { :alignment => :right, :border_top => false, :border_bottom => false }
+          t.align_column(0, :left)
+        end
+
+        output << table.to_s << "\n"
+      end
+
+      # rubocop:disable Metrics/AbcSize
+      def data_for_table(num_of_rows)
+        sorted = @stats.sort_by { |_, file_stats| -file_stats[:time] }
+        sorted = sorted.slice(0, num_of_rows)
+
+        table  = [header_labels]
+        totals = Hash.new { |hash, key| hash[key] = 0 }
+
+        sorted.each do |filename, file_stats|
+          GAUGES.each { |gauge| totals[gauge] += file_stats[gauge] }
+          row = []
+          row << filename
+          row << file_stats[:count].to_s
+          row << format_bytes(file_stats[:bytes])
+          row << format("%.3f", file_stats[:time])
+          table << row
+        end
+
+        footer = []
+        footer << "TOTAL (for #{sorted.size} files)"
+        footer << totals[:count].to_s
+        footer << format_bytes(totals[:bytes])
+        footer << format("%.3f", totals[:time])
+        table  << footer
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      def header_labels
+        GAUGES.map { |gauge| gauge.to_s.capitalize }.unshift("Filename")
+      end
+
+      def format_bytes(bytes)
+        bytes /= 1024.0
+        format("%.2fK", bytes)
+      end
+    end
+  end
+end

data/lib/bridgetown-core/log_adapter.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+module Bridgetown
+  class LogAdapter
+    attr_reader :writer, :messages, :level
+
+    LOG_LEVELS = {
+      :debug => ::Logger::DEBUG,
+      :info  => ::Logger::INFO,
+      :warn  => ::Logger::WARN,
+      :error => ::Logger::ERROR,
+    }.freeze
+
+    # Public: Create a new instance of a log writer
+    #
+    # writer - Logger compatible instance
+    # log_level - (optional, symbol) the log level
+    #
+    # Returns nothing
+    def initialize(writer, level = :info)
+      @messages = []
+      @writer = writer
+      self.log_level = level
+    end
+
+    # Public: Set the log level on the writer
+    #
+    # level - (symbol) the log level
+    #
+    # Returns nothing
+    def log_level=(level)
+      writer.level = level if level.is_a?(Integer) && level.between?(0, 3)
+      writer.level = LOG_LEVELS[level] ||
+        raise(ArgumentError, "unknown log level")
+      @level = level
+    end
+
+    def adjust_verbosity(options = {})
+      # Quiet always wins.
+      if options[:quiet]
+        self.log_level = :error
+      elsif options[:verbose]
+        self.log_level = :debug
+      end
+      debug "Logging at level:", LOG_LEVELS.key(writer.level).to_s
+      debug "Bridgetown Version:", Bridgetown::VERSION
+    end
+
+    # Public: Print a debug message
+    #
+    # topic - the topic of the message, e.g. "Configuration file", "Deprecation", etc.
+    # message - the message detail
+    #
+    # Returns nothing
+    def debug(topic, message = nil, &block)
+      write(:debug, topic, message, &block)
+    end
+
+    # Public: Print a message
+    #
+    # topic - the topic of the message, e.g. "Configuration file", "Deprecation", etc.
+    # message - the message detail
+    #
+    # Returns nothing
+    def info(topic, message = nil, &block)
+      write(:info, topic, message, &block)
+    end
+
+    # Public: Print a message
+    #
+    # topic - the topic of the message, e.g. "Configuration file", "Deprecation", etc.
+    # message - the message detail
+    #
+    # Returns nothing
+    def warn(topic, message = nil, &block)
+      write(:warn, topic, message, &block)
+    end
+
+    # Public: Print an error message
+    #
+    # topic - the topic of the message, e.g. "Configuration file", "Deprecation", etc.
+    # message - the message detail
+    #
+    # Returns nothing
+    def error(topic, message = nil, &block)
+      write(:error, topic, message, &block)
+    end
+
+    # Public: Print an error message and immediately abort the process
+    #
+    # topic - the topic of the message, e.g. "Configuration file", "Deprecation", etc.
+    # message - the message detail (can be omitted)
+    #
+    # Returns nothing
+    def abort_with(topic, message = nil, &block)
+      error(topic, message, &block)
+      abort
+    end
+
+    # Internal: Build a topic method
+    #
+    # topic - the topic of the message, e.g. "Configuration file", "Deprecation", etc.
+    # message - the message detail
+    #
+    # Returns the formatted message
+    def message(topic, message = nil)
+      raise ArgumentError, "block or message, not both" if block_given? && message
+
+      message = yield if block_given?
+      message = message.to_s.gsub(%r!\s+!, " ")
+      topic = formatted_topic(topic, block_given?)
+      out = topic + message
+      messages << out
+      out
+    end
+
+    # Internal: Format the topic
+    #
+    # topic - the topic of the message, e.g. "Configuration file", "Deprecation", etc.
+    # colon -
+    #
+    # Returns the formatted topic statement
+    def formatted_topic(topic, colon = false)
+      "#{topic}#{colon ? ": " : " "}".rjust(20)
+    end
+
+    # Internal: Check if the message should be written given the log level.
+    #
+    # level_of_message - the Symbol level of message, one of :debug, :info, :warn, :error
+    #
+    # Returns whether the message should be written.
+    def write_message?(level_of_message)
+      LOG_LEVELS.fetch(level) <= LOG_LEVELS.fetch(level_of_message)
+    end
+
+    # Internal: Log a message.
+    #
+    # level_of_message - the Symbol level of message, one of :debug, :info, :warn, :error
+    # topic - the String topic or full message
+    # message - the String message (optional)
+    # block - a block containing the message (optional)
+    #
+    # Returns false if the message was not written, otherwise returns the value of calling
+    # the appropriate writer method, e.g. writer.info.
+    def write(level_of_message, topic, message = nil, &block)
+      return false unless write_message?(level_of_message)
+
+      writer.public_send(level_of_message, message(topic, message, &block))
+    end
+  end
+end