benoit 0.2.2 → 0.4.0

data/lib/benoit/logger.rb

@@ -16,7 +16,7 @@ module Benoit
       message = <<-EOM
       Benoit encountered an error.
 
-      #{ex.message}
+      #{ex}
       #{sub_message}
 
       #{ENV.map { |k,v| "#{k}=#{v}" }.join("\n")}
@@ -33,7 +33,7 @@ module Benoit
       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.to_s
         $stderr.puts ex.backtrace
       end
     end

data/lib/benoit/pipeline_project.rb

@@ -24,36 +24,36 @@ module Benoit
       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
+        # 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)
+        #     #   wrapper = OpenStruct.new(path: output.path, read: input.read, fullpath: input.fullpath)
 
-              paths_map[input.path] = output.path
+        #     #   paths_map[input.path] = output.path
 
-              PageMetadata::Store.current[wrapper]
+        #     #   PageMetadata::Store.current[wrapper]
 
-            end
+        #     # end
 
-            current_site = CurrentSite.load
+        #     current_site = CurrentSite.load
 
-            current_site.paths_map = paths_map
+        #     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
+        #     # 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
 

data/lib/benoit/server.rb

@@ -0,0 +1,47 @@
+require 'rake-pipeline/middleware'
+require 'rack/server'
+
+
+module Benoit
+  class Server < Rack::Server
+
+    require_relative 'server/remote'
+
+    DEFAULT_APP = proc { [404, { "Content-Type" => "text/plain" }, ["not found"]] }
+
+    def initialize(project, options={})
+      @project = project
+      super options
+    end
+
+    def app
+      project = @project.project
+      Rack::Builder.new do
+        use Rack::ShowExceptions
+        use CustomExceptionHandler
+        map "/_remote" do
+          run Benoit::Server::Remote.new(project)
+        end
+        run Rake::Pipeline::Middleware.new DEFAULT_APP, project
+      end.to_app
+    end
+
+  end
+
+  class CustomExceptionHandler
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      @app.call(env)
+    rescue StandardError => ex
+      Benoit::Cleaner.run
+      Logger.error "#{ex.message} (#{ex.class.name})"
+      Logger.error ex.backtrace.join("\n")
+      raise ex
+    end
+
+  end
+end

data/lib/benoit/server/remote.rb

@@ -0,0 +1,29 @@
+module Benoit
+  class Server
+    class Remote
+
+      def initialize(project)
+        @project = project
+      end
+
+      def call(env)
+        code = 200
+
+        case env['PATH_INFO']
+        when '/clean'
+          Benoit::Cleaner.run
+          body = "cleaned"
+        when '/build'
+          @project.invoke
+          body = "built"
+        end
+
+        code = 200 if body
+        body || (body, code = ["not found", 404])
+
+        [code, {"Content-Type" => "application/json"}, {response: body}.to_json]
+      end
+
+    end
+  end
+end

data/lib/benoit/utils/finds_layouts_for_template.rb

@@ -16,33 +16,32 @@ 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 self.first_layout(content, options={})
+          FindsLayoutsForTemplate.new(content, options).lookup_layout
+        end
+
         def initialize(input, options)
-            @load_paths = options.delete(:load_paths) || [""]
-            @root = options.delete(:root)
-            @template_path = input
+          if input.respond_to? :path
             @input = input
+            @template_path = input
+          else
+            @content = input
+          end
+          @load_paths = options.delete(:load_paths) || [""]
+          @root = options.delete(:root)
+        end
+
+        def match_extends_line(content)
+          extends_pattern = /\{% extends "([\.\w-]+)" %\}/
+          match_data = content.match(extends_pattern)
+          return unless match_data
+          match_data.captures[0]
+        end
+
+        def lookup_layout
+          match_extends_line(@content)
         end
 
         def lookup_layouts
@@ -53,24 +52,23 @@ module Benoit::Utils
 
         def recursively_lookup_layouts_for_file(input, template_list=[])
 
-            parent_template = call_strategy_for_file input, root
+            parent_template = match_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?
+                input = Rake::Pipeline::FileWrapper.new(Dir.pwd, normalized_path)
                 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
+        def match_file(input, root)
+          return unless File.exist?(input.path)
+          content = File.read(input.path)
+          match_extends_line(content)
         end
 
     end

data/lib/benoit/version.rb

@@ -1,3 +1,3 @@
 module Benoit
-  VERSION = "0.2.2"
+  VERSION = "0.4.0"
 end

data/spec/features/build_command.feature

@@ -7,7 +7,7 @@ Feature: benoit build
     When I build the site
     Then a directory named "_build" should exist
 
-  Scenario: Defaults cache path to "~/.benoit/tmpcache/{site}"
+  Scenario: Defaults cache path to "/tmp/.benoit/tmpcache/{site}"
     When I build the site
     Then a cache directory should exist for that site
 

data/spec/features/frontmatter_metadata.feature

@@ -1,5 +1,6 @@
 Feature: Site Context
 
+  @backlog
   Scenario: Groups posts by type
     Given a site named "subpages"
     And a file named "index.html" with content:
@@ -29,6 +30,7 @@ Feature: Site Context
   Scenario: Group arbitrary page types by type
 
 
+  @backlog
   Scenario: Loads content from markdown files
     Given a site named "test"
     And a file named "index.html" with content:
@@ -53,6 +55,7 @@ Feature: Site Context
     This is the content
     """
 
+  @backlog
   Scenario: Parses field named 'date' as a date object for reliable sorting
     Given a site
     And a file containing metadata:
@@ -76,24 +79,3 @@ Feature: Site Context
     2012-12-12
     2022-04-13
     """
-
-  Scenario: Metadata contains rendered Markdown
-    Given a site
-    And a file with an extension of ".markdown" with content:
-    """
-    ---
-    type: post
-    ---
-
-    [a link](http://www.example.com)
-    """
-    And a file named "index.html" with content:
-    """
-    {% for post in site.posts %}{{ post.content }}
-    {% endfor %}
-    """
-    When I build the site
-    Then the output file "index.html" should have content:
-    """
-    <a href="http://www.example.com">a link</a>
-    """

data/spec/features/javascript_files.feature

@@ -3,6 +3,7 @@ Feature: Javascript Files
   Background:
     Given a site
 
+  @backlog
   Scenario: Concatenates multiple scripts
     Given a file named "js/a.js" with content:
     """

data/spec/features/markdown_files.feature

@@ -0,0 +1,41 @@
+Feature: Markdown Files
+
+  Benoit converts Markdown files to HTML (Markdown files are those that end in ".markdown", ".md", ".mkdown" or ".mdown"). It uses the RedCarpet engine for rendering Markdown. Currently, there is no way to configure Markdown settings ([want this? Let me know!][feedback])
+
+  If you use a layout for your site, you can use the regular {% extends ... %} tag and {% block ... %} tags just like you do in HTML files. If you need to use more template features than just the layouts, then you will need to use HTML rather than Markdown.
+
+  Scenario: Converts Markdown to HTML
+    Given a file named "cadenza.markdown" with content:
+    """
+    [blah](http://www.google.com)
+    """
+    When I build the site
+    Then the output file "cadenza.html" should only have content:
+    """
+    <p><a href="http://www.google.com">blah</a></p>
+
+    """
+
+  Scenario: Properly wraps Markdown files in specified layout
+    Given a file named "cadenza.markdown" with content:
+    """
+    {% extends "_layout.html" %}
+    {% block content %}
+    [this is my content](http://www.google.com)
+    {% endblock %}
+    """
+    And a file named "_layouts/_layout.html" with content:
+    """
+    <section id="main">
+    {% block content %}{% endblock %}
+    </section>
+    """
+    When I run `benoit build`
+    Then the output file "cadenza.html" should have content:
+    """
+    <section id="main">
+
+    <a href="http://www.google.com">this is my content</a>
+
+    </section>
+    """

data/spec/features/output_filters.feature

@@ -4,14 +4,9 @@ Feature: format_like Output Filter
     Given a site
 
   Scenario: Formats simple dates according to passed example
-    Given a file containing metadata:
+    Given a file with an extension of ".html" with content:
     """
-    date: 2012-12-23
-    type: post
-    """
-    And that file has content:
-    """
-    {{page.date|format_like:"March 23, 2012"}}
+    {{"2012-12-23"|format_like:"March 23, 2012"}}
     """
     When I build the site
     Then the output file should have content:

data/spec/features/page_layouts.feature

@@ -25,36 +25,12 @@ Feature: Page Layouts
     </section>
     """
 
-  Scenario: Reads layout from metadata in .html files
-    Given a file with an extension of ".html" containing metadata:
-    """
-    layout: _layout
-    """
-    And that file has content:
-    """
-    {% block content %}CONTENT{% endblock %}
-    """
-    And a layout named "_layout" with content:
-    """
-    !!!
-    {% block content %}{% endblock %}
-    !!!
-    """
-    When I build the site
-    Then the output file should have content:
-    """
-    !!!
-    CONTENT
-    !!!
-    """
-
+  @backlog
   Scenario: Doesn't require layouts prefixed with underscore
-    Given a file with an extension of ".html" containing metadata:
-    """
-    layout: layout
-    """
-    And that file has content:
+    Given a file with an extension of ".html" with content:
     """
+    {% extends "layout.html" %}
+
     {% block content %}CONTENT{% endblock %}
     """
     And a layout named "_layout" with content:

data/spec/features/pagination.feature

@@ -1,3 +1,4 @@
+@backlog
 Feature: Content Pagination
 
   Background:

data/spec/lib/filters/base_filter_spec.rb

@@ -14,11 +14,11 @@ describe Benoit::Filters::BaseFilter do
   let(:html_input) { "<html><head></head><body><h1>TESTING</h1></body></html>" }
 
   def input_file(name, content)
-    MemoryFileWrapper.new("/path/to/input", name, "UTF-8", Set.new([]), content)
+    MemoryFileWrapper.new("/path/to/input", name, "UTF-8", content)
   end
 
   def output_file(name)
-    MemoryFileWrapper.new("/path/to/output", name, "UTF-8", Set.new([]))
+    MemoryFileWrapper.new("/path/to/output", name, "UTF-8")
   end
 
   def setup_filter(filter, input_filename='index.html')
@@ -28,25 +28,14 @@ describe Benoit::Filters::BaseFilter do
     filter.input_files = [input_file(input_filename, html_input)]
     filter.output_root= "/path/to/output"
     filter.rake_application = Rake::Application.new
-    filter.current_site = {}
     filter
   end
 
-  def setup_final_outputs(filter)
-    filter.input_files.each_with_index do |input,i|
-      output = filter.output_files[i]
-      filter.current_site.merge!(input.path => { "content" => input.read })
-      filter.current_site.merge!(output.path => { "content" => input.read })
-    end
-  end
-
   it "generates output directly from the input" do
     filter = setup_filter basic_filter.new
 
     expect(filter.output_files).to eq([output_file("index.html")])
 
-    setup_final_outputs(filter)
-
     tasks = filter.generate_rake_tasks
     tasks.each(&:invoke)
 
@@ -74,7 +63,7 @@ describe Benoit::Filters::BaseFilter do
 
     let(:path_writer) do
       Class.new(described_class) do
-        build_output do |page,input|
+        build_output do |input|
           input.path
         end
       end
@@ -83,8 +72,6 @@ describe Benoit::Filters::BaseFilter do
     it "gets output from calling builder" do
       filter = setup_filter builder_filter.new
 
-      setup_final_outputs(filter)
-
       tasks = filter.generate_rake_tasks
       tasks.each(&:invoke)
 
@@ -92,26 +79,10 @@ describe Benoit::Filters::BaseFilter do
       expect(file.body).to eq("blah")
     end
 
-    it "passes page object to builder" do
-      filter = setup_filter page_filter.new
-
-      setup_final_outputs(filter)
-
-      page = filter.current_site[filter.output_files.first.path]
-
-      tasks = filter.generate_rake_tasks
-      tasks.each(&:invoke)
-
-      file = MemoryFileWrapper.files["/path/to/output/index.html"]
-      expect(file.body).to eq(page["content"])
-    end
-
-    it "passes input to builder when needed" do
+    it "passes input to builder" do
       filter = setup_filter path_writer.new
       input = filter.input_files.first
 
-      setup_final_outputs(filter)
-
       tasks = filter.generate_rake_tasks
       tasks.each(&:invoke)