benoit 0.1.0

data/spec/features/page_layouts.feature

@@ -0,0 +1,72 @@
+Feature: Page Layouts
+
+  Background:
+    Given a site
+
+  Scenario: Finds layouts in _layouts
+    Given a site named "test"
+    And a file named "index.html" with content:
+    """
+    {% extends "_layout.html" %}
+
+    {% block content %}boo{% 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 "index.html" should have content:
+    """
+    <section id="main">
+      boo
+    </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
+    !!!
+    """
+
+  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:
+    """
+    {% 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
+    !!!
+    """

data/spec/features/pagination.feature

@@ -0,0 +1,58 @@
+Feature: Content Pagination
+
+  Background:
+    Given a site
+    And 20 files containing metadata:
+    """
+    type: post
+    """
+
+  Scenario: Outputs one file per page
+    Given a file named "page.html" containing metadata:
+    """
+    posts_per_page: 10
+    """
+    When I build the site
+    Then the output file "page1.html" should exist
+    And the output file "page2.html" should exist
+
+  Scenario: Renders 10 posts per page
+    Given a file named "page.html" with content:
+    """
+    ---
+    posts_per_page: 10
+    ---
+
+    {% for post in site.paginated_posts | sort: "page_num" %}{{post.content}}
+    {% endfor %}
+    """
+    When I build the site
+    Then the output file "page1.html" should only contain the first 10 posts
+    And the output file "page2.html" should only contain the last 10 posts
+
+  Scenario: Renders 5 posts per page
+    Given a file named "page.html" with content:
+    """
+    ---
+    posts_per_page: 5
+    ---
+
+    {% for post in site.paginated_posts | sort: "page_num" %}{{post.content}}
+    {% endfor %}
+    """
+    When I build the site
+    Then the output file "page1.html" should only contain the first 5 posts
+    And the output file "page4.html" should only contain the last 5 posts
+
+  Scenario: Keeps path to paginated files
+    Given a file named "dir/page.html" with content:
+    """
+    ---
+    posts_per_page: 5
+    ---
+
+    {% for post in site.paginated_posts | sort: "page_num" %}{{post.content}}
+    {% endfor %}
+    """
+    When I build the site
+    Then the output file "dir/page1.html" should exist

data/spec/features/sass_files.feature

@@ -0,0 +1,30 @@
+Feature: Compiling Sass Files
+
+  Background:
+    Given a site
+
+  Scenario: Converts SCSS files to CSS
+    Given a file named "styles.scss" with content:
+    """
+    $variable: value;
+
+    .test {
+      .nested {
+        attribute: $variable;
+      }
+    }
+    """
+    When I build the site
+    Then the output file "styles.css" should have content:
+    """
+    .test .nested {
+      attribute: value; }
+    """
+
+  Scenario: Makes Compass available
+    Given a file named "styles.scss" with content:
+    """
+    @import "compass/css3";
+    """
+    When I build the site
+    Then the output file "styles.css" should exist

data/spec/features/version.feature

@@ -0,0 +1,5 @@
+Feature: Version Flag
+
+  Scenario: --version flag
+    When I run `benoit --version`
+    Then I see the current Benoit version

data/spec/lib/filters/base_filter_spec.rb

@@ -0,0 +1,141 @@
+require 'spec_helper'
+require 'rake-pipeline'
+require 'benoit/filters/base_filter'
+require 'benoit/page'
+
+describe Benoit::Filters::BaseFilter do
+  MemoryFileWrapper ||= Rake::Pipeline::SpecHelpers::MemoryFileWrapper
+  MemoryManifest ||= Rake::Pipeline::SpecHelpers::MemoryManifest
+
+  let(:basic_filter) do
+    Class.new(described_class)
+  end
+
+  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)
+  end
+
+  def output_file(name)
+    MemoryFileWrapper.new("/path/to/output", name, "UTF-8", Set.new([]))
+  end
+
+  def setup_filter(filter, input_filename='index.html')
+    filter.file_wrapper_class = MemoryFileWrapper
+    filter.manifest = MemoryManifest.new
+    filter.last_manifest = MemoryManifest.new
+    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)
+
+    file = MemoryFileWrapper.files["/path/to/output/index.html"]
+    expect(file.body).to eq(html_input)
+  end
+
+  describe "building output" do
+
+    let(:builder_filter) do
+      Class.new(described_class) do
+        build_output do
+          "blah"
+        end
+      end
+    end
+
+    let(:page_filter) do
+      Class.new(described_class) do
+        build_output do |page|
+          page["content"]
+        end
+      end
+    end
+
+    let(:path_writer) do
+      Class.new(described_class) do
+        build_output do |page,input|
+          input.path
+        end
+      end
+    end
+
+    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)
+
+      file = MemoryFileWrapper.files["/path/to/output/index.html"]
+      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
+      filter = setup_filter path_writer.new
+      input = filter.input_files.first
+
+      setup_final_outputs(filter)
+
+      tasks = filter.generate_rake_tasks
+      tasks.each(&:invoke)
+
+      file = MemoryFileWrapper.files["/path/to/output/index.html"]
+      expect(file.body).to eq(input.path)
+    end
+
+  end
+
+  describe "generating output filename" do
+
+    let(:output_name) do
+      Class.new(described_class) do
+        output_name do
+          "blah.diddy"
+        end
+      end
+    end
+
+    it "gets output filename from calling generator" do
+      filter = setup_filter output_name.new
+
+      expect(filter.output_files).to eq([output_file("blah.diddy")])
+    end
+  end
+
+end

data/spec/lib/filters/markdown_filter_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+require 'rake-pipeline'
+require 'benoit/filters'
+require 'benoit/page'
+
+describe Benoit::Filters::MarkdownFilter do
+  MemoryFileWrapper ||= Rake::Pipeline::SpecHelpers::MemoryFileWrapper
+  MemoryManifest ||= Rake::Pipeline::SpecHelpers::MemoryManifest
+
+  let(:markdown_input) {
+    <<-EOS.unindent
+    [some link](http://www.example.com)
+
+    **strong**
+    _em_
+    EOS
+  }
+
+  let(:expected_output) {
+    <<-EOS.unindent
+    <p><a href="http://www.example.com">some link</a></p>
+
+    <p><strong>strong</strong>
+    <em>em</em></p>
+    EOS
+  }
+
+  def input_file(name, content)
+    MemoryFileWrapper.new("/path/to/input", name, "UTF-8", Set.new([]), content)
+  end
+
+  def output_file(name)
+    MemoryFileWrapper.new("/path/to/output", name, "UTF-8", Set.new([]))
+  end
+
+  def setup_filter(filter, input_filename='page.markdown')
+    filter.file_wrapper_class = MemoryFileWrapper
+    filter.manifest = MemoryManifest.new
+    filter.last_manifest = MemoryManifest.new
+    filter.input_files = [input_file(input_filename, markdown_input)]
+    filter.output_root= "/path/to/output"
+    filter.rake_application = Rake::Application.new
+    filter
+  end
+
+  it "generates the correct output" do
+    filter = setup_filter described_class.new
+
+    input_file = filter.input_files.first
+    output_file = output_file("page.html")
+
+    page = { "content" => markdown_input }
+    filter.current_site = { input_file.path => page, output_file.path => page }
+
+    expect(filter.output_files).to eq([output_file])
+
+    tasks = filter.generate_rake_tasks
+    tasks.each(&:invoke)
+
+    file = MemoryFileWrapper.files["/path/to/output/page.html"]
+    expect(file.body).to eq(expected_output)
+
+    expect(page["content"]).to eq(expected_output)
+  end
+end

data/spec/lib/filters/sass_filter_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+require 'rake-pipeline'
+require 'benoit/filters'
+require 'benoit/page'
+require 'benoit/compiler_error'
+
+describe Benoit::Filters::SassFilter do
+  MemoryFileWrapper ||= Rake::Pipeline::SpecHelpers::MemoryFileWrapper
+  MemoryManifest ||= Rake::Pipeline::SpecHelpers::MemoryManifest
+  FileWrapper ||= Rake::Pipeline::FileWrapper
+
+  let(:scss_input_path) {
+    File.expand_path("spec/support/files/input.scss")
+  }
+
+  let(:expected_output) {
+    str =
+    <<-EOS
+    .test .nested {
+      attribute: value; }
+    EOS
+    str.unindent
+  }
+
+  def input_file
+    path = scss_input_path
+    FileWrapper.new(File.dirname(path), File.basename(path), "UTF-8", Set.new([]))
+  end
+
+  def output_file(name)
+    MemoryFileWrapper.new("/path/to/output", name, "UTF-8", Set.new([]))
+  end
+
+  def setup_filter(filter)
+    filter.file_wrapper_class = MemoryFileWrapper
+    filter.manifest = MemoryManifest.new
+    filter.last_manifest = MemoryManifest.new
+    filter.input_files = [input_file]
+    filter.output_root= "/path/to/output"
+    filter.rake_application = Rake::Application.new
+    filter
+  end
+
+  it "generates the correct output" do
+    filter = setup_filter described_class.new
+
+    input_file = filter.input_files.first
+    output_file = output_file("input.css")
+
+    expect(filter.output_files).to eq([output_file])
+
+    tasks = filter.generate_rake_tasks
+    tasks.each(&:invoke)
+
+    file = MemoryFileWrapper.files["/path/to/output/input.css"]
+    expect(file.body).to eq(expected_output)
+  end
+
+  describe "files ending in .css.scss" do
+
+    let(:scss_input_path) {
+      File.expand_path("spec/support/files/input.css.scss")
+    }
+
+    it "do not end in .css.css" do
+      filter = setup_filter described_class.new
+
+      output_file = output_file("input.css")
+      expect(filter.output_files).to eq([output_file])
+    end
+
+  end
+end