benoit 0.1.0

data/lib/benoit/filters/set_metadata_filter.rb

@@ -0,0 +1,15 @@
+module Benoit::Filters
+  class SetMetadataFilter < Rake::Pipeline::Filter
+      def initialize(metadata={}, &block)
+          @metadata = metadata
+          super &block
+      end
+
+      def generate_output(inputs, output)
+          inputs.each do |input|
+              FrontMatterStore.set_metadata_for_page input.path, @metadata
+              output.write(input.read)
+          end
+      end
+  end
+end

data/lib/benoit/logger.rb

@@ -0,0 +1,69 @@
+require 'syslog'
+
+module Benoit
+  class Logger
+
+    def self.report_error(ex)
+      original_error = ex.original_error if ex.respond_to? :original_error
+
+      sub_message =
+        if original_error
+          "#{original_error.message}\n#{original_error.backtrace.join("\n")}"
+        else
+          ex.backtrace.join("\n")
+        end
+
+      message = <<-EOM
+      Benoit encountered an error.
+
+      #{ex.message}
+      #{sub_message}
+
+      #{ENV.map { |k,v| "#{k}=#{v}" }.join("\n")}
+      EOM
+
+      error message
+
+      if Benoit.config.output_mode == :app
+        $stderr.puts ex.to_json
+      else
+        $stderr.puts message
+      end
+    rescue StandardError => ex
+      if Benoit.config.output_mode == :app
+        $stderr.puts({ line_no: nil, message: ex.message, path: __FILE__ }.to_json)
+      else
+        $stderr.puts ex.message
+        $stderr.puts ex.backtrace
+      end
+    end
+
+    def self.critical(msg)
+      self.log(:crit, msg)
+    end
+
+    def self.error(msg)
+      self.log(:err, msg)
+    end
+
+    def self.warn(msg)
+      self.log(:warning, msg)
+    end
+
+    def self.emergency(*msg)
+      self.log(:emerg, msg)
+    end
+
+    def self.notice(*msg)
+      self.log(:notice, msg)
+    end
+
+    def self.log(level, msg)
+      logger.send(level, '%s', msg)
+    end
+
+    def self.logger
+      @logger ||= Syslog.open("com.densitypop.Benoit", Syslog::LOG_CONS, Syslog::LOG_USER)
+    end
+  end
+end

data/lib/benoit/page.rb

@@ -0,0 +1,88 @@
+module Benoit
+  class Page
+      attr_reader :attrs_hash, :siteContext, :permalink
+
+      def self.from_hash(page_attrs)
+          new(page_attrs)
+      end
+
+      def initialize(attrs)
+          @attr_names = @attrNames = []
+          @original_path = attrs["_original_path"]
+          setFileType!(attrs)
+          set_permalink!(attrs)
+          @metadata = methodsFromAttrs(attrs)
+      end
+
+      def template
+          # For compat with other site generators
+          @template || @layout
+      end
+
+      def has_value?(value)
+        @metadata.has_value?(value)
+      end
+
+      def key?(key)
+        @metadata.key?(key)
+      end
+
+      def [](key)
+        @metadata[key]
+      end
+
+      def []=(key, value)
+        instance_variable_set("@#{key}", value)
+        @metadata[key] = value
+      end
+
+      def keys
+        @metadata.keys
+      end
+
+      def set_permalink!(attrs)
+        @permalink = "/#{@original_path}"
+        @attrNames << :permalink
+      end
+
+      def to_json(options={})
+          attrsFromMethods(@attrNames).to_json
+      end
+
+      def to_hash(options={})
+          attrsFromMethods(@attrNames)
+      end
+
+      private
+
+      def setFileType!(attrs)
+          attrs["_type"] = attrs["type"] || "page"
+      end
+
+      def methodsFromAttrs(attrs)
+          self.class.send :attr_reader, *attrs.keys.map(&:to_sym)
+          attrs.each do |k,v|
+              @attrNames << k.to_sym
+              self.instance_variable_set "@#{k}", v
+          end
+      end
+
+      def attrsFromMethods(attrs, &transformer)
+          attrs.inject({}) do |acc,attr,v|
+              value = send attr
+              acc[attr] = value
+              acc
+          end
+      end
+
+      def pagination_config(attrs, &block)
+        attrs.select do |k,v|
+          keys = k.to_s.scan(/(\w+)_per_page/)
+          if keys.any?
+            block.(v)
+          end
+        end
+      end
+
+  end
+end

data/lib/benoit/page_metadata.rb

@@ -0,0 +1,8 @@
+module Benoit
+  module PageMetadata
+    require_relative "./page_metadata/store"
+    require_relative "./page_metadata/container"
+    require_relative "./page_metadata/json_converter"
+    require_relative "./page_metadata/parser"
+  end
+end

data/lib/benoit/page_metadata/container.rb

@@ -0,0 +1,74 @@
+module Benoit
+  module PageMetadata
+    class Container
+
+      def self.[](hash)
+        hash.inject(new) do |inst,(key,value)|
+          inst[key] = value
+          inst
+        end
+      end
+
+      def []=(key,value)
+        create_method key do
+          value
+        end
+      end
+
+      def [](key)
+        return unless respond_to? key
+        send key
+      end
+
+      def fetch(key)
+        raise KeyError.new(key) unless key?(key)
+        self[key]
+      end
+
+      def keys
+        singleton_class.instance_methods(false)
+      end
+
+      def values
+        keys.map do |key|
+          send key
+        end
+      end
+
+      def delete(key)
+        destroy_method(key)
+      end
+
+      def clear
+        keys.each do |key|
+          delete key
+        end
+      end
+
+      def to_hash
+        Hash[keys.zip(values)]
+      end
+
+      def key?(key)
+        respond_to? key
+      end
+      alias has_key? key?
+
+      private
+
+      def create_method(name, &body)
+        singleton_class.instance_eval do
+          define_method name, &body
+        end
+      end
+
+      def destroy_method(name)
+        singleton_class.instance_eval do
+          remove_method name
+        end
+      end
+
+    end
+  end
+end
+

data/lib/benoit/page_metadata/json_converter.rb

@@ -0,0 +1,28 @@
+module Benoit
+  module PageMetadata
+    class JsonConverter
+
+      def self.import!(json, store=Store.current)
+        hash = JSON.parse(json)
+        store.import_all!(hash)
+      end
+
+      def self.export(store=Store.current)
+        store.to_hash.to_json
+      end
+
+    end
+
+    class SiteContextConverter
+
+      def self.export(store=Store.current)
+        store.to_hash.inject({}) do |ctxt,(key,metadata)|
+          new_key = store.path_from_key(key)
+          ctxt.merge(new_key => metadata)
+        end
+      end
+
+    end
+  end
+end
+

data/lib/benoit/page_metadata/parser.rb

@@ -0,0 +1,38 @@
+require 'psych'
+require 'frontmatter'
+require 'kronic'
+
+module Benoit
+  module PageMetadata
+    class Parser
+
+      KEY_CONVERTERS = {
+        "date" => ->(value){
+          Kronic.parse(value)
+        }
+      }
+
+      def self.should_parse?(path)
+        FrontMatter.file_might_have_frontmatter?(path) ||
+          FrontMatter.file_has_frontmatter?(path)
+      end
+
+      def self.parse(input)
+        content = input.read
+        if FrontMatter.has_frontmatter?(content)
+          response = FrontMatter.parse(content)
+          response.merge(response) do |key,original_value|
+            if KEY_CONVERTERS.key?(key)
+              KEY_CONVERTERS[key].(original_value)
+            else
+              original_value
+            end
+          end
+        else
+          {}
+        end
+      end
+
+    end
+  end
+end

data/lib/benoit/page_metadata/store.rb

@@ -0,0 +1,75 @@
+require 'singleton'
+
+module Benoit
+  module PageMetadata
+
+    class Store
+      include Singleton
+
+      class << self
+        alias current instance
+      end
+
+      def initialize
+        @container = container_class.new
+      end
+
+      def import_from_page(input)
+        metadata = Parser.parse(input)
+        metadata["_original_path"] = input.path
+        import_metadata(input.path, metadata)
+      end
+
+      def import_all!(hash)
+        @container = container_class[hash]
+      end
+
+      def import_metadata(path, metadata)
+        key = path_to_key(path)
+        if @container.respond_to?(:key?) and @container.key?(key)
+          @container[key]
+        else
+          @container ||= container_class.new
+          @container[key] = metadata
+        end
+      end
+
+      def [](wrapper)
+        import_from_page(wrapper) unless has_page?(wrapper.path)
+        @container[path_to_key(wrapper.path)] || {}
+      end
+
+      def has_page?(page_name)
+        return unless @container
+        @container.key?(path_to_key(page_name))
+      end
+
+      def to_hash
+        return unless @container
+        @container.to_hash
+      end
+
+      def expire!
+        @container.clear
+        @container = container_class.new
+      end
+
+      def path_from_key(key)
+        key.to_s.sub /__(.+)_metadata/ do |match,blah|
+          $1
+        end
+      end
+
+      def path_to_key(path)
+        :"__#{path}_metadata"
+      end
+
+      private
+
+      def container_class
+        Class.new(Container)
+      end
+
+    end
+  end
+end

data/lib/benoit/pipeline.rb

@@ -0,0 +1 @@
+require_relative "./pipeline/pagination_matcher"

data/lib/benoit/pipeline/dsl_extensions.rb

@@ -0,0 +1,8 @@
+class Rake::Pipeline::DSL::PipelineDSL
+  def needs_pagination(pattern, &block)
+    matcher = pipeline.copy Benoit::Pipeline::PaginationMatcher, &block
+    matcher.glob = pattern
+    matcher.add_filter Benoit::Filters::PaginationFilter.new
+    pipeline.add_filter matcher
+  end
+end

data/lib/benoit/pipeline/pagination_matcher.rb

@@ -0,0 +1,53 @@
+module Benoit
+  module Pipeline
+    class PaginationMatcher < Rake::Pipeline::Matcher
+      attr_reader :previous_input_files, :per_page_counts, :collection_totals
+
+      def setup_filters
+        @previous_input_files = pipeline.input_files
+        calculate_collection_totals
+        calculate_per_page_counts
+        super
+      end
+
+      def output_files
+        super + input_files
+      end
+
+      def eligible_input_files
+        per_page_counts.keys
+      end
+
+      private
+
+      def calculate_collection_totals
+        @collection_totals ||=
+          previous_input_files.group_by do |i|
+            i.read.scan(/type: (\w+)/).flatten.first
+          end.delete_if do |key,_|
+            key.nil?
+          end.reduce({}) do |acc,(key,val)|
+            acc.merge(key => val.length)
+          end
+      end
+
+      def calculate_per_page_counts
+        @per_page_counts =
+          previous_input_files.reduce([]) do |acc,i|
+            collection, count = i.read.scan(/(\w+)_per_page: (\d+)/).flatten
+            if collection
+              count = count.to_i
+              Benoit::SiteContext.paginate_collection collection, count
+              collection = Inflecto.singularize(collection)
+              acc << [i, collection, count]
+            end
+            acc
+          end.reduce({}) do |acc,(input,collection,count)|
+            total = collection_totals[collection]
+            acc.merge(input => total / count + total % count)
+          end
+      end
+
+    end
+  end
+end