benoit 0.1.0

data/spec/lib/metadata_json_converter_spec.rb

@@ -0,0 +1,65 @@
+require "benoit/page_metadata/store"
+require "benoit/page_metadata/json_converter"
+
+RSpec::Matchers.define :contain_page do |expected|
+  match do |actual|
+    page_name = expected
+    page_name.sub! /\./, "_"
+    expect(actual).to have_page(page_name)
+    value = actual[InputWrapper.new(page_name)]
+    expect(value).to eq(@metadata) if @metadata
+  end
+  chain :with_metadata do |metadata|
+    @metadata = metadata
+  end
+end
+
+include Benoit::PageMetadata
+describe Benoit::PageMetadata do
+
+  let(:index_html_metadata) do
+    { "title" => "blah", "attr1" => "val1" }
+  end
+
+  let(:about_html_metadata) do
+    { "title" => "about", "attr2" => "val2" }
+  end
+
+  let(:existing_metadata) do
+    {
+      "__index_html_metadata" => index_html_metadata,
+      "__about_html_metadata" => about_html_metadata
+    }
+  end
+
+  describe JsonConverter do
+
+    let(:json) { existing_metadata.to_json }
+
+    it "loads all metadata into cache" do
+      JsonConverter.import!(json)
+      store = Benoit::PageMetadata::Store.current
+      expect(store).to contain_page("index.html").with_metadata(index_html_metadata)
+      expect(store).to contain_page("about.html").with_metadata(about_html_metadata)
+    end
+
+    it "exports all metadata currently in the cache" do
+      JsonConverter.import!(json)
+      new_json = JsonConverter.export
+      expect(new_json).to eq(json)
+    end
+
+  end
+
+
+  describe SiteContextConverter do
+
+    it "exports a hash with site paths instead of metadata keys" do
+      JsonConverter.import!(existing_metadata.to_json)
+      exported = SiteContextConverter.export
+      expect(exported.keys).to eq(["index_html", "about_html"])
+    end
+  end
+
+end
+

data/spec/lib/metadata_store_spec.rb

@@ -0,0 +1,148 @@
+require "json"
+require "spec_helper"
+require "spec_helpers/file_helpers"
+require "benoit/page_metadata/store"
+require "benoit/page_metadata/container"
+require "benoit/page_metadata/parser"
+
+class InputWrapper < Struct.new(:path, :read)
+end
+
+RSpec::Matchers.define :have_metadata do |expected|
+  match do |actual|
+    expect(actual).to have_key(expected)
+    expect(actual.fetch(expected)).to eq(@value) if @value
+  end
+  chain :with_value do |actual|
+    @value = actual
+  end
+end
+
+describe Benoit::PageMetadata::Store do
+  include FileHelpers
+
+  let(:content) do
+    <<-EOF.unindent
+    ---
+    title: blah
+    attr1: val1
+    attr2: val2
+    ---
+
+    THE CONTENT
+    EOF
+  end
+
+  let(:new_content) do
+    <<-EOF.unindent
+    ---
+    key1: blah1
+    key2: blah2
+    ---
+
+    THE CONTENT
+    EOF
+  end
+
+  let(:write_page) { write_file(input.path, input.read) }
+  let(:write_new_page) { write_file(input.path, new_content) }
+
+  let(:input) { InputWrapper.new("tmp/index.html", content) }
+
+  let(:store) { described_class.current }
+
+  before(:each) do
+    store.expire!
+  end
+
+  describe "the metadata hash" do
+
+    subject { write_page; store.import_from_page(input) }
+
+    it "contains the original content" do
+      expect(subject).to have_metadata("content").with_value("THE CONTENT\n")
+    end
+
+    it "contains additional attributes" do
+      expect(subject).to have_metadata("title").with_value("blah")
+      expect(subject).to have_metadata("attr1").with_value("val1")
+      expect(subject).to have_metadata("attr2").with_value("val2")
+    end
+
+  end
+
+  describe "without metadata" do
+
+
+    let(:content) { "THE CONTENT" }
+
+    subject { write_page; store.import_from_page(input) }
+
+
+    it "returns only original path" do
+      expect(subject).to eq({"_original_path" => input.path})
+    end
+
+  end
+
+  describe "memoizing" do
+
+    subject { write_page; store.import_from_page(input) }
+
+    it "keeps it from parsing again" do
+      write_new_page
+      new_input = InputWrapper.new("tmp/index.html", new_content)
+      new_metadata = store.import_from_page(new_input)
+      expect(new_metadata).to eq(subject)
+    end
+
+    it "always returns the same hash" do
+      write_new_page
+      new_input = InputWrapper.new("tmp/index.html", new_content)
+      new_metadata = store.import_from_page(new_input)
+      expect(new_metadata.object_id).to eq(subject.object_id)
+    end
+
+  end
+
+  describe "expiring the entire collection" do
+
+    subject { write_page; store.import_from_page(input) }
+
+    it "clears memoized keys, allowing new keys to be written" do
+      subject
+      store.expire!
+      write_new_page
+      new_input = InputWrapper.new("tmp/index.html", new_content)
+      new_metadata = store.import_from_page(new_input)
+      expect(new_metadata).to have_metadata("key1").with_value("blah1")
+      expect(new_metadata).to have_metadata("key2").with_value("blah2")
+    end
+
+  end
+
+  describe "accessing using [] notation" do
+
+    let(:input_no_metadata) { InputWrapper.new("tmp/blah.html", "") }
+    let(:default_hash) {
+      { "_original_path" => input_no_metadata.path }
+    }
+
+    it "caches on the first access" do
+      write_page
+      metadata = store[input]
+      new_metadata = store[input]
+      expect(metadata).to_not be_nil
+      expect(metadata.object_id).to eq(new_metadata.object_id)
+    end
+
+    it "returns default hash for empty pages" do
+      write_file input_no_metadata.path, input_no_metadata.read
+      no_metadata = store[input_no_metadata]
+      expect(no_metadata).to eq(default_hash)
+    end
+
+  end
+
+end
+

data/spec/lib/page_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+require 'benoit/page'
+
+describe Benoit::Page do
+
+  let(:metadata) { { "blah" => "diddy" } }
+  subject { described_class.new(metadata) }
+
+  describe "page metadata" do
+    it "is accessible via []" do
+      expect(subject["blah"]).to eq("diddy")
+    end
+    it "allows changing attributes via []" do
+      subject["blah"] = "doo"
+      expect(subject["blah"]).to eq("doo")
+    end
+  end
+
+end

data/spec/lib/site_context_spec.rb

@@ -0,0 +1,106 @@
+require 'spec_helper'
+require 'benoit/page'
+require 'benoit/site_context'
+require 'benoit/utils/paginated_list'
+
+include Benoit
+
+describe SiteContext do
+
+  subject { described_class.new(pages) }
+
+  describe "looking up pages" do
+    let(:output_page) { Page.new("_original_path" => output_path) }
+    let(:pages) { [output_page] }
+    let(:output_path) { "blah" }
+
+    it "uses paths map to normalize input paths to output paths" do
+      subject.paths_map = { "input" => output_path }
+      expect(subject["input"]).to eq(output_page)
+    end
+
+  end
+
+end
+
+RSpec::Matchers.define :be_pointing_at_first_page do
+  match do |expected|
+    expected.peek == [pages.first]
+  end
+end
+
+describe SiteContext::ContextObject do
+
+  let(:type) { "post" }
+  let(:page) { {"_type" => type} }
+  let(:num_pages) { 2 }
+  let(:site) { SiteContext.new(pages) }
+  let(:context) { site.to_context }
+  let(:pages) do
+    (1..num_pages).map do |i|
+      page.merge("page" => i)
+    end
+  end
+
+  subject { context.posts }
+
+  after do
+    SiteContext.clear_paginated_collections!
+  end
+
+  it "returns posts from content collection via method call" do
+    expect(subject).to eq(pages)
+  end
+
+  describe "returns other types of content" do
+    let(:type) { "comic" }
+    subject { context.comics }
+
+    it { should eq(pages) }
+  end
+
+  describe "for non-existant collections" do
+    subject { context.blah }
+    it "raises an error" do
+      expect(->{subject}).to raise_error(NoMethodError)
+    end
+  end
+
+  describe "pagination" do
+    let(:num_pages) { 3 }
+    subject { context.paginated_posts }
+
+    before do
+      SiteContext.paginate_collection("posts", 1)
+      pages << {"posts_per_page" => 1}
+    end
+
+    it "collects resource names with per_page count" do
+      expect(site.paginated_collections["posts"]).to eq([1])
+    end
+
+    it "returns the collection sliced by page" do
+      collection = subject.each
+      expect(collection.next.first).to eq(pages.first)
+      expect(collection.next.first).to eq(pages[1])
+      expect(collection.next.first).to eq(pages[2])
+    end
+
+    it "returns the existing list if already set" do
+      list = context.paginated_collection("posts")
+      expect(context.paginated_collection("posts")).to eq(list)
+    end
+
+    it "rewinds the list if it is at the end" do
+      # Fast-forward list to end
+      1.upto(num_pages) do
+        subject.each{|p|}
+      end
+      new_list = context.paginated_posts
+      expect{new_list.peek}.to_not raise_error(StopIteration)
+      expect(new_list).to be_pointing_at_first_page
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+require "bundler/setup"
+require 'rake'
+
+require "pry"
+require "pry-nav"
+
+require "spec_helpers/memory_file_wrapper"
+require "spec_helpers/memory_manifest"
+
+
+class String
+  def unindent
+    gsub(/^#{scan(/^\s*/).min_by{|l|l.length}}/, "")
+  end
+end
+

data/spec/steps/output_file_steps.rb

@@ -0,0 +1,45 @@
+module OutputFileSteps
+  extend Turnip::DSL
+
+  step "the output file should have content:" do |content|
+    step 'the output file "%s" should have content:' % @page.name, content
+  end
+
+  step "the output file should only have content:" do |content|
+    step 'the output file "%s" should only have content:' % @page.name, content
+  end
+
+  step "the output file :file_name should only contain the :ordinal :num :type" do |file_name,ordinal,num,type|
+    pages =
+      case ordinal
+      when "first"
+        @site.pages[0, num.to_i]
+      when "last"
+        @site.pages[-1 * num.to_i, num.to_i]
+      end
+    content = pages.map(&:content).join("\n") + "\n"
+    step 'the output file "%s" should only have content:' % file_name, content
+  end
+
+  step "the output file :file_name should exist" do |file_name|
+    file_name = File.join("_build", file_name)
+    step 'a file named "%s" should exist' % file_name
+  end
+
+  step "the output file :file_name should have content:" do |file_name, content|
+    file_name = File.join("_build", file_name)
+    step 'the file "%s" should contain:' % file_name, content
+  end
+
+  step "the output file :file_name should only have content:" do |file_name, content|
+    file_name = File.join("_build", file_name)
+    step 'the file "%s" should contain exactly:' % file_name, content
+  end
+
+  step "the output file :file_name should match :pattern" do |file_name, pattern|
+    file_name = File.join("_build", file_name)
+    step 'the file "%s" should match /%s/' % [file_name, pattern]
+  end
+
+
+end

data/spec/steps/run_steps.rb

@@ -0,0 +1,71 @@
+module RunSteps
+  extend ::Turnip::DSL
+
+  step "I run :cmd" do |cmd|
+    run_simple(unescape(cmd), false)
+  end
+
+  step "I successfully run :cmd" do |cmd|
+    run_simple(unescape(cmd))
+  end
+
+  step "a directory named :directory should exist" do |directory|
+    if directory =~ /^~/
+      directory = File.expand_path(directory)
+    end
+    check_directory_presence([directory], true)
+  end
+
+  step "an empty file named :file_name" do |file_name|
+    write_file(file_name, "")
+  end
+
+  step "a file named :file_name with content:" do |file_name, content|
+    write_file(file_name, content)
+  end
+
+  step "the file :file_name should contain exactly:" do |file_name, partial_content|
+    check_exact_file_content(file_name, partial_content)
+  end
+
+  step "the file :file_name should contain:" do |file_name, partial_content|
+    check_file_content(file_name, partial_content, true)
+  end
+
+  step "the file :file_name should match :pattern" do |file_name, pattern|
+    check_file_content(file_name, /#{pattern}/, true)
+  end
+
+  step "I cd to :directory" do |directory|
+    cd directory
+  end
+
+  step "I remove the file :file_name" do |file_name|
+    remove_file(file_name)
+  end
+
+  step "a :size byte file named :file_name should exist" do |file_size, file_name|
+    check_file_size([[file_name, file_size.to_i]])
+  end
+
+  step "a file named :file_name should exist" do |file_name|
+    check_file_presence([file_name], true)
+  end
+
+  step "a file named :file_name should not exist" do |file_name|
+    check_file_presence([file_name], false)
+  end
+
+  placeholder :cmd do
+    match /`([^`]*)`/ do |cmd|
+      cmd
+    end
+  end
+
+  placeholder :pattern do
+    match /\/([^\/]*)\/$/ do |pattern|
+      pattern
+    end
+  end
+
+end