benoit 0.1.0

data/lib/benoit/pipeline_project.rb

@@ -0,0 +1,81 @@
+require 'rake-pipeline'
+
+module Rake
+  class Pipeline
+    class FileWrapper
+      include Benoit::FileWrapperExtensions
+
+    end
+  end
+end
+
+module Benoit
+  class PipelineProject
+    attr_reader :assetfile_path, :output_dir, :tmp_cache_dir, :project
+
+    def initialize(assetfile_path, output_dir=nil, tmp_cache_dir=nil)
+        @assetfile_path = assetfile_path
+        @output_dir = output_dir || default_output_dir
+        @tmp_cache_dir = tmp_cache_dir || default_cache_dir
+        @project = build_project!
+    end
+
+    def invoke
+      if Benoit.config.clean_before_build?
+        Benoit::Cleaner.run
+      end
+        project.pipelines.each do |pipeline|
+          pipeline.register_invocation_hook :after_task, BuildNotifiers::FileBuiltNotifier
+          pipeline.register_invocation_hook :before_filter, BuildNotifiers::ProgressNotifier
+          pipeline.register_invocation_hook :filters_ready, ->(pipeline){
+            require 'ostruct'
+            paths_map = {}
+            pipeline.output_files.each do |output|
+              input = output.original_inputs.first
+
+              wrapper = OpenStruct.new(path: output.path, read: input.read, fullpath: input.fullpath)
+
+              paths_map[input.path] = output.path
+
+              PageMetadata::Store.current[wrapper]
+
+            end
+
+            current_site = CurrentSite.load
+
+            current_site.paths_map = paths_map
+
+            # Load ALL filters (including filters within filters)
+            filters = recursively_load_filters_from_pipeline(pipeline)
+            filters.each do |filter|
+              if filter.respond_to? :current_site=
+                filter.current_site = current_site
+              end
+            end
+          }
+        end
+        project.invoke
+    end
+
+    private
+
+    def recursively_load_filters_from_pipeline(pipeline)
+      pipeline.filters.map do |filter|
+        if filter.respond_to? :filters
+          recursively_load_filters_from_pipeline(filter)
+        else
+          filter
+        end
+      end.flatten
+    end
+
+    def build_project!
+        output, tmp = [output_dir, tmp_cache_dir]
+        Rake::Pipeline::Project.new(@assetfile_path) do
+            output output
+            tmpdir tmp if tmp
+        end
+    end
+
+  end
+end

data/lib/benoit/site_context.rb

@@ -0,0 +1,123 @@
+#
+#  LoadsSiteContent.rb
+#  Benoit
+#
+#  Created by Joseph Fiorini on 10/22/12.
+#  Copyright 2012 densitypop. All rights reserved.
+#
+
+require 'json'
+require 'inflecto'
+require 'cadenza/context_object'
+
+module Benoit
+  class SiteContext
+
+    class ContextObject < ::Cadenza::ContextObject
+      def initialize(site)
+        @site = site
+        @pages = site.pages
+      end
+
+      def lookup_resource_collection(name)
+        singular_name = Inflecto.singularize(name)
+        collection = @pages.select do |page|
+          page["_type"] == singular_name
+        end
+
+        collection.map!(&:to_hash)
+      end
+
+      def paginated_collection(name)
+        potential_collection = @site.paginated_collections[name].last
+        if potential_collection.respond_to? :at_end?
+          potential_collection.rewind_list! if potential_collection.at_end?
+          return potential_collection
+        end
+
+        per_page = @site.paginated_collections[name].first
+        collection = lookup_resource_collection(name)
+
+        collection.paginate(per_page).tap do |coll|
+          @site.paginated_collections[name] << coll
+        end
+      end
+
+      def resource_collection(name)
+        lookup_resource_collection(name)
+      end
+
+      def method_missing(msg,*args)
+        name = msg.to_s
+        parsed_name = Inflecto.singularize(name).sub(/paginated_/, "")
+
+        valid_page = @pages.any? { |page| page.has_value?(parsed_name) }
+
+        if valid_page and name.start_with? "paginated_"
+          return paginated_collection(parsed_name)
+        elsif valid_page
+          return resource_collection(name)
+        else
+          super
+        end
+
+      end
+      alias_method :missing_context_method, :method_missing
+
+    end
+
+      def self.from_hash(context_attrs)
+          page_contexts = context_attrs.values.map do |context|
+              Page.from_hash(context)
+          end
+          new(page_contexts)
+      end
+
+    attr_reader :pages
+
+    attr_accessor :paths_map
+
+      def initialize(pages)
+          @pages = pages
+      end
+
+      def [](key)
+        key = paths_map[key] if paths_map.key?(key)
+        page_with_path(key)
+      end
+
+      def page_with_path(path)
+        @pages.find do |page|
+          page.permalink == "/#{path}"
+        end
+      end
+
+      def to_context
+        @context ||= ContextObject.new(self)
+      end
+
+      def paginated_collections
+        self.class.paginated_collections
+      end
+
+      def paginated_collection?(key)
+        unless self.class.paginated_collections.nil?
+          self.class.paginated_collections.key?(key)
+        end
+      end
+
+      def self.paginate_collection(collection, per_page)
+        @paginated_collections ||= Hash.new([])
+        @paginated_collections[collection] << per_page
+      end
+
+      def self.paginated_collections
+        @paginated_collections
+      end
+
+      def self.clear_paginated_collections!
+        @paginated_collections.clear if @paginated_collections
+      end
+
+    end
+  end

data/lib/benoit/utils/finds_layouts_for_template.rb

@@ -0,0 +1,77 @@
+#
+#  TemplateLayoutLookup.rb
+#  Benoit
+#
+#  Created by Joseph Fiorini on 10/29/12.
+#  Copyright 2012 densitypop. All rights reserved.
+#
+
+def FindsLayoutsForTemplate(input, options={})
+    Benoit::Utils::FindsLayoutsForTemplate.new(input, options).lookup_layouts
+end
+
+module Benoit::Utils
+
+
+    class FindsLayoutsForTemplate
+
+
+        FrontMatterLookupStrategy = ->(input) {
+            input =
+              if input.respond_to? :final_output and input.final_output
+                input.final_output
+              else
+                input
+              end
+              metadata = Benoit::PageMetadata::Store.current[input]
+              return unless metadata
+              metadata["layout"] || metadata["template"]
+        }
+
+        CadenzaInheritanceLookupStrategy = ->(input) {
+            extends_pattern = /\{% extends "([\.\w_-]+)" %\}/
+            return unless File.exist?(input.path)
+            match_data = File.read(input.path).match(extends_pattern)
+            return unless match_data
+            match_data.captures[0]
+        }
+
+        attr_reader :root, :template_path, :load_paths, :input
+
+        def initialize(input, options)
+            @load_paths = options.delete(:load_paths) || [""]
+            @root = options.delete(:root)
+            @template_path = input
+            @input = input
+        end
+
+        def lookup_layouts
+            recursively_lookup_layouts_for_file(input)
+        end
+
+        private
+
+        def recursively_lookup_layouts_for_file(input, template_list=[])
+
+            parent_template = call_strategy_for_file input, root
+
+            if parent_template
+                normalized_path = NormalizesPathToTemplate(parent_template, load_paths)
+                template_list << normalized_path
+                input = Rake::Pipeline::FileWrapper.new(Dir.pwd, normalized_path)
+                # TODO: Not a fan of Dir.pwd here, but it will always work. Is there a better way to get the correct input root?
+                recursively_lookup_layouts_for_file(input, template_list)
+            end
+
+            template_list
+        end
+
+        def call_strategy_for_file(input, root)
+            strategies = [FrontMatterLookupStrategy]
+            strategies.inject(nil) do |parent_template,strategy|
+                strategy.call(input) || parent_template
+            end
+        end
+
+    end
+end

data/lib/benoit/utils/normalizes_path_to_template.rb

@@ -0,0 +1,43 @@
+#
+#  NormalizesPathToTemplate.rb
+#  Benoit
+#
+#  Created by Joseph Fiorini on 10/29/12.
+#  Copyright 2012 densitypop. All rights reserved.
+#
+
+def NormalizesPathToTemplate(template, load_paths)
+    Benoit::Utils::NormalizesPathToTemplate.new(template, load_paths).
+        normalize_path
+end
+
+module Benoit
+  module Utils
+    class NormalizesPathToTemplate
+        attr_accessor :template_path, :load_paths
+
+        def initialize(template_path, load_paths)
+            @template_path = template_path
+            @load_paths = load_paths
+        end
+
+        def normalize_path
+            return template_path if File.exist?(template_path) # Already normalized, just return it
+            load_paths.inject(template_path) do |actual_path,load_path|
+                path_to_try = actual_path
+                if not File.basename(path_to_try).start_with? "_"
+                  path_to_try = File.join(File.dirname(path_to_try), "_#{File.basename(path_to_try)}")
+                end
+                path_to_try += ".html" unless File.extname(path_to_try) == ".html"
+                return path_to_try if File.exist?(path_to_try)
+                path_to_try = File.join(load_path, path_to_try)
+                if File.exist?(path_to_try)
+                    path_to_try
+                else
+                    actual_path
+                end
+            end
+        end
+    end
+  end
+end

data/lib/benoit/utils/paginated_list.rb

@@ -0,0 +1,102 @@
+module Enumerable
+  def paginate(per_page)
+    Benoit::Utils::PaginatedList.new(self, per_page)
+  end
+end
+
+module Benoit
+  module Utils
+    class PaginatedList
+      include Enumerable
+
+      attr_reader :per_page, :ops, :source, :enum
+
+      def initialize(list, per_page=nil, &block)
+        @ops = []
+        @list = list
+        @per_page = per_page
+      end
+
+
+      def each(&block)
+        run_queued_operations!
+        return paginate! && @enum unless block_given?
+        paginated.each do |page|
+          block.call(page)
+        end
+      end
+
+      def each_with_index(&block)
+        run_queued_operations!
+        paginated.each_with_index do |p,i|
+          block.call(p, i)
+        end
+      end
+
+      def paginate!
+        @enum ||= @list.each_slice(@per_page)
+      end
+
+      def paginated
+        paginate!
+        @enum.next
+      end
+
+      def sort_by(&block)
+        @ops << ->(list){
+          list.sort_by(&block)
+        }
+        self
+      end
+
+      def map(&block)
+        @ops << ->(list){
+          list.map(&block)
+        }
+        self
+      end
+
+      def take(n)
+        return self if @enum
+        @ops << ->(list){
+          list.take(n)
+        }
+        self
+      end
+
+      def reverse
+        return self if @enum
+        @ops << ->(list){
+          list.reverse
+        }
+        self
+      end
+
+      def peek
+        @enum.peek if @enum
+      end
+
+      def at_end?
+        return false if @enum.nil?
+        @enum.peek
+        false
+      rescue StopIteration
+        true
+      end
+
+      def rewind_list!
+        @enum.rewind
+      end
+
+      private
+
+      def run_queued_operations!
+        @list =
+          @ops.inject(@list) do |l,op|
+            op.call l
+          end
+      end
+
+    end
+  end
+end

data/lib/benoit/version.rb

@@ -0,0 +1,3 @@
+module Benoit
+  VERSION = "0.1.0"
+end

data/lib/build_notifiers/file_built_notifier.rb

@@ -0,0 +1,20 @@
+module BuildNotifiers
+  module FileBuiltNotifier
+
+    def self.call(pipeline,task)
+      if ProgressNotifier.finalizing?
+        path = task.name.sub(pipeline.output_root + "/", "")
+        notify_built(path, "success")
+      end
+    end
+
+    def self.notify_built(path, status="built")
+      if Benoit.config.output_mode == :app
+        puts({ type: status, path: path }.to_json)
+      else
+        puts "Built: #{path}"
+      end
+    end
+
+  end
+end