RubyGems - jekyll_pages_api - Versions diffs - 0.1.4 → 0.1.5 - Mend

jekyll_pages_api 0.1.4 → 0.1.5

Files changed (12) hide show

checksums.yaml +4 -4
data/README.md +4 -0
data/bin/jekyll_pages_api +49 -0
data/lib/jekyll_pages_api.rb +5 -0
data/lib/jekyll_pages_api/generated_page.rb +34 -0
data/lib/jekyll_pages_api/generated_page_parser.rb +121 -0
data/lib/jekyll_pages_api/generated_site.rb +46 -0
data/lib/jekyll_pages_api/version.rb +1 -1
data/spec/generated_page_parser_spec.rb +181 -0
data/spec/generated_page_spec.rb +86 -0
data/spec/generated_site_spec.rb +58 -0
metadata +14 -3

checksums.yaml CHANGED Viewed

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 165870f35595456ebb5c185976419aa41650dcc3
-  data.tar.gz: 8665a9c9c4e2d0c3caaf33d264f29eee1b9d75cf
+  metadata.gz: 63259d15c6f30bdddfb3a67d17462c200f006a35
+  data.tar.gz: ce08cd1149ab684423f129329412ed8a7593dec8
 SHA512:
-  metadata.gz: ae0bf9b1c790a930caddb014292fdfd635e2df275e46fb5e7d60c7982475ef0dae327268db27a8a1be4e029175d2b1d90507ae0a5662bb545e4e3e746821ac9a
-  data.tar.gz: 82ff7e227cba6611f48acb6dd6ee5dc27a43bc4522060f0b7ee3cedfcb14efafd27af8b4ca5b4041187dce2d7601adf9aae12340c13a63c1242d29a15dd38636
+  metadata.gz: 6aa6643cbd4053ba3344fd26d0201c8a0887a74c0a754affb65287361e6248415aeac19b0b292a3d91a7f6560830744c7e79669dab37ad91d963342ca1073643
+  data.tar.gz: 150a483db15cf7692f3d8356ff7075cd67ddd4f8efe03f9baa61fb8c8477cd96179a703172c0517a3b19dd3a1ad275afeed59d8a2ddb7aa5d44856fedbe28624

data/README.md CHANGED Viewed

@@ -44,6 +44,10 @@ This endpoint will be re-generated any time your site is rebuilt.
 The [Jekyll Pages API Search plugin](https://github.com/18F/jekyll_pages_api_search) uses this plugin to build a search index. Add `skip_index: true` to the front matter of any documents you wish to exclude from this index.
+### Running standalone
+If you wish to generate a `pages.json` file when using a site generation tool other than Jekyll, you can run the `jekyll_pages_api` executable as a post-generation step. Run `jekyll_pages_api -h` for instructions.
 ## Developing
 * Run `bundle` to install any necessary gems.

data/bin/jekyll_pages_api ADDED Viewed

@@ -0,0 +1,49 @@
+#! /usr/bin/env ruby
+# Author: Mike Bland <michael.bland@gsa.gov>
+# Date:   2015-06-21
+require_relative '../lib/jekyll_pages_api'
+USAGE=<<END_USAGE
+#{$0}: generate Jekyll Pages API output from a pregenerated site
+Usage:
+  #{$0} baseurl basedir title_prefix body_element_tag > pages.json
+  #{$0} -h
+Arguments:
+  -h
+    Print this help message
+  baseurl
+    URL prefix of every page of the generated site
+  basedir
+    Path to the generated site's root directory
+  title_prefix
+    Prefix to strip from page titles
+  body_element_tag
+    Tag (or tag prefix) identifying the main content element within the <body>
+    element of each document. Can be a complete tag (ending in '>'), or the
+    prefix of a longer tag. Used to strip boilerplate out of the content
+    exported via the API.
+END_USAGE
+if ARGV.length == 1 && ARGV[0] == '-h'
+  puts USAGE
+  exit
+end
+if ARGV.length != 4
+  $stderr.puts USAGE
+  exit 1
+end
+baseurl, basedir, title_prefix, body_element_tag = ARGV
+unless Dir.exist?(basedir)
+  $stderr.puts "#{basedir} does not exist"
+  exit 1
+end
+generator = ::JekyllPagesApi::Generator.new(
+  ::JekyllPagesApi::GeneratedSite.new(
+    baseurl, basedir, title_prefix, body_element_tag))
+puts generator.page.output

data/lib/jekyll_pages_api.rb CHANGED Viewed

@@ -1,2 +1,7 @@
+require 'jekyll_pages_api/filters'
+require 'jekyll_pages_api/generated_site'
+require 'jekyll_pages_api/generator'
+require 'jekyll_pages_api/page'
+require 'jekyll_pages_api/page_without_a_file'
 require 'jekyll_pages_api/version'
 require_relative 'jekyll/site'

data/lib/jekyll_pages_api/generated_page.rb ADDED Viewed

@@ -0,0 +1,34 @@
+# @author Mike Bland (michael.bland@gsa.gov)
+require_relative 'generated_page_parser'
+module JekyllPagesApi
+  # Used by GeneratedSite to mimic a Jekyll page object when processing an
+  # already-generated site using the Generator.
+  class GeneratedPage
+    attr_reader :path, :relative_path, :data, :content
+    # @param path [String] full path to the generated page's file
+    # @param basedir see {GeneratedSite#initialize}
+    # @param title_prefix see {GeneratedSite#initialize}
+    # @param body_element_tag see {GeneratedSite#initialize}
+    # @param content [String] HTML content of the generated page's file
+    # @raises [RuntimError] if path does not begin with basedir
+    def initialize(path, basedir, title_prefix, body_element_tag, content)
+      unless path.start_with? basedir
+        raise "#{path} does not start with #{basedir}"
+      end
+      @path = path
+      basedir_len = basedir.size
+      basedir_len -= File::SEPARATOR.size if basedir.end_with? File::SEPARATOR
+      end_path = path.size
+      index_suffix = File.join "", "index.html"
+      end_path -= index_suffix.size if path.end_with? index_suffix
+      @relative_path = (path[basedir_len..end_path] || "")
+      @data, @content = GeneratedPageParser.parse_generated_page(
+        content, title_prefix, body_element_tag)
+    end
+  end
+end

data/lib/jekyll_pages_api/generated_page_parser.rb ADDED Viewed

@@ -0,0 +1,121 @@
+# @author Mike Bland (michael.bland@gsa.gov)
+module JekyllPagesApi
+  # Contains helper methods for parsing values from HTML.
+  class GeneratedPageParser
+    # Parses elements from a generated page's content needed by GeneratedPage.
+    # @param content see {GeneratedPage#initialize}
+    # @param title_prefix see {GeneratedSite#initialize}
+    # @param body_element_tag see {GeneratedSite#initialize}
+    # @return [Hash<String, String>, String] the metadata hash containing the
+    #   `title`, `tags`, and `skip-index` elements; and the body content
+    #   stripped of boilerplate
+    def self.parse_generated_page(content, title_prefix, body_element_tag)
+      data = {}
+      head_element = self.parse_basic_tag 'head', content
+      return data, "" if head_element.nil?
+      title = self.parse_basic_tag 'title', head_element
+      if !title.nil? && title.start_with?(title_prefix)
+        title = title[title_prefix.size..title.size]
+      end
+      data['title'] = title
+      data.merge!(self.parse_meta_tags head_element)
+      return data, self.parse_content_from_body(content, body_element_tag)
+    end
+    # Parses a value from content from between tags that cannot be nested,
+    # e.g. <head>, <body>, <title>.
+    # @param tag_name [String] name of the tag to parse
+    # @param content [String] HTML content from which to parse a value
+    # @return [String] if a value is successfully parsed
+    # @return [nil] if the tag isn't present in content, or is not well-formed
+    def self.parse_basic_tag(tag_name, content)
+      open_tag = "<#{tag_name}"
+      close_tag = "</#{tag_name}>"
+      open_i = content.index open_tag
+      return nil if open_i.nil?
+      open_i = content.index('>', open_i + open_tag.size) + 1
+      close_i = content.index close_tag, open_i
+      return nil if close_i.nil?
+      content[open_i..close_i-1]
+    end
+    # Parses the (name, content) pairs from <meta> tags in the <head> element.
+    # Note that it parses _only_ the `name` and `content` fields.
+    # @param head_element [String] <head> element from an HTML document
+    # @return [Hash<String, String>] a collection of (name, content) values
+    def self.parse_meta_tags(head_element)
+      open_tag = "<meta "
+      open_i = head_element.index open_tag
+      meta_tags = {}
+      until open_i.nil? do
+        # -1 to remove the space at the end.
+        open_i += open_tag.size - 1
+        close_i = head_element.index '>', open_i
+        return meta_tags if close_i.nil?
+        current = head_element[open_i..close_i]
+        attrs = {'name' => nil, 'content' => nil}
+        attrs.keys.each do |attr|
+          attr_begin = " #{attr}="
+          attr_begin_i = current.index attr_begin
+          unless attr_begin_i.nil?
+            attr_begin_i += attr_begin.size + 1
+            delim = current[attr_begin_i-1]
+            attr_end_i = current.index delim, attr_begin_i
+            next if attr_end_i.nil?
+            attr_end_i -= 1
+            attrs[attr] = current[attr_begin_i..attr_end_i]
+          end
+        end
+        meta_name = attrs['name']
+        meta_tags[meta_name] = attrs['content'] unless meta_name.nil?
+        close_i += 1
+        open_i = head_element.index open_tag, close_i
+      end
+      meta_tags
+    end
+    # Parse actual content from an HTML page, leaving out boilerplate.
+    # @param content [String] content of an HTML document
+    # @param body_element_tag see {GeneratedSite#initialize}
+    def self.parse_content_from_body(content, body_element_tag)
+      body = parse_basic_tag 'body', content
+      return content if body.nil?
+      start_body = body.index body_element_tag unless body_element_tag.empty?
+      return body if start_body.nil?
+      start_body += 1
+      end_name_i = body.index ' ', start_body
+      bracket_i = body.index '>', start_body
+      end_name_i = bracket_i if bracket_i < end_name_i
+      tag_name = body[start_body..end_name_i-1]
+      open_tag = "<#{tag_name}"
+      end_tag = "</#{tag_name}>"
+      start_body = bracket_i + 1
+      search_i = start_body
+      open_tag_i = body.index open_tag, search_i
+      end_tag_i = body.index end_tag, search_i
+      depth = 1
+      until depth == 0
+        if end_tag_i.nil?
+          raise "End tag missing: #{end_tag}"
+        end
+        if !open_tag_i.nil? && open_tag_i < end_tag_i
+          depth += 1
+          search_i = open_tag_i + open_tag.size
+          open_tag_i = body.index open_tag, search_i
+        else
+          depth -= 1
+          search_i = end_tag_i + end_tag.size
+          end_tag_i = body.index end_tag, search_i unless depth == 0
+        end
+      end
+      body[start_body..end_tag_i-1]
+    end
+  end
+end

data/lib/jekyll_pages_api/generated_site.rb ADDED Viewed

@@ -0,0 +1,46 @@
+# @author Mike Bland (michael.bland@gsa.gov)
+require_relative 'generated_page'
+module JekyllPagesApi
+  # Used by the standalone executable to mimic a Jekyll::Site when processing
+  # an already-generated site using the Generator.
+  class GeneratedSite
+    # @see #initialize
+    attr_reader :baseurl, :basedir, :title_prefix, :body_element_tag
+    # @return [Array<>] a dummy empty Array
+    attr_accessor :pages
+    # @param baseurl [String] URL prefix of every page of the generated site
+    # @param basedir [String] Path to the generated site's root directory
+    # @param title_prefix [String] Prefix to strip from page titles
+    # @param body_element_tag [String] Tag (or tag prefix) identifying the
+    #   main content element within the <body> element of each document. Can
+    #   be a complete tag (ending in '>'), or the prefix of a longer tag. Used
+    #   to strip boilerplate out of the content exported via the API.
+    def initialize(baseurl, basedir, title_prefix, body_element_tag)
+      @baseurl = baseurl
+      @basedir = basedir
+      @title_prefix = title_prefix
+      @body_element_tag = body_element_tag
+      @pages = []
+    end
+    # Generator yielding each HTML page (as a {GeneratedPage}) that should be
+    # exported via the API.
+    def each_site_file
+      Dir.glob(File.join(self.basedir, '**', '*')) do |f|
+        next unless f.end_with? '.html'
+        begin
+          page = GeneratedPage.new(f, self.basedir, self.title_prefix,
+            self.body_element_tag, File.read(f))
+          yield page unless page.data['title'].nil?
+        rescue
+          $stderr.puts "Error while processing #{f}:"
+          raise
+        end
+      end
+    end
+  end
+end

data/lib/jekyll_pages_api/version.rb CHANGED Viewed

@@ -1,3 +1,3 @@
 module JekyllPagesApi
-  VERSION = '0.1.4'
+  VERSION = '0.1.5'
 end

data/spec/generated_page_parser_spec.rb ADDED Viewed

@@ -0,0 +1,181 @@
+module JekyllPagesApi
+  describe GeneratedPageParser do
+    describe '#parse_basic_tag' do
+      it "returns nil if content is empty" do
+        expect(GeneratedPageParser.parse_basic_tag('', '')).to eq(nil)
+      end
+      it "returns nil if the tag is not present" do
+        expect(GeneratedPageParser.parse_basic_tag(
+          'title', 'foobar')).to eq(nil)
+      end
+      it "returns nil if the tag is not closed" do
+        expect(GeneratedPageParser.parse_basic_tag(
+          'title', '<title>foobar')).to eq(nil)
+      end
+      it "returns the content of the tag" do
+        expect(GeneratedPageParser.parse_basic_tag(
+          'title', '<title>foobar</title>')).to eq('foobar')
+      end
+    end
+    describe '#parse_meta_tags' do
+      it "returns an empty hash if the head_element is empty" do
+        expect(GeneratedPageParser.parse_meta_tags('')).to eq({})
+      end
+      it "returns an empty hash if a meta tag isn't closed properly" do
+        expect(GeneratedPageParser.parse_meta_tags(
+          '<meta name="foo" content="bar"')).to eq({})
+      end
+      it "returns an empty hash if the only meta tag lacks a name" do
+        expect(GeneratedPageParser.parse_meta_tags(
+          '<meta not_a_name="foo" content="bar">')).to eq({})
+      end
+      it "returns a valid hash for a well-formed meta tag" do
+        expect(GeneratedPageParser.parse_meta_tags(
+          '<meta name="foo" content="bar">')).to eq("foo" => "bar")
+      end
+      it "returns a valid hash for a self-closing meta tag" do
+        expect(GeneratedPageParser.parse_meta_tags(
+          '<meta name="foo" content="bar"/>')).to eq("foo" => "bar")
+      end
+      it "returns a valid hash for a meta tag with single-quote delimiters" do
+        expect(GeneratedPageParser.parse_meta_tags(
+          "<meta name='foo' content='bar'/>")).to eq("foo" => "bar")
+      end
+      it "returns a valid hash for a meta tag with mixed-quote delimiters" do
+        expect(GeneratedPageParser.parse_meta_tags(
+          "<meta name='foo' content=\"bar\"/>")).to eq("foo" => "bar")
+      end
+      it "returns a valid hash regardless of attribute order" do
+        expect(GeneratedPageParser.parse_meta_tags(
+          '<meta content="bar" name="foo" />')).to eq("foo" => "bar")
+      end
+      it "returns a valid hash for multiple meta tags" do
+        expect(GeneratedPageParser.parse_meta_tags(
+          '<meta name="foo" content="bar"/>'+
+          "<meta name='baz' content='quux' other=\"don't care\" >" +
+          '<meta content="plugh" name="xyzzy" />')
+          ).to eq("foo" => "bar", "baz" => "quux", "xyzzy" => "plugh")
+      end
+    end
+    describe '#parse_content_from_body' do
+      it "returns the empty string if passed all empty strings" do
+        expect(GeneratedPageParser.parse_content_from_body("", "")).to eq("")
+      end
+      it "returns the original content if there are no body tags" do
+        expect(GeneratedPageParser.parse_content_from_body(
+          "foobar", "")).to eq("foobar")
+      end
+      it "returns the original content if the body tag isn't closed" do
+        expect(GeneratedPageParser.parse_content_from_body(
+          "<body>foobar", "")).to eq("<body>foobar")
+      end
+      it "returns the full body content if the body_element_tag is empty" do
+        expect(GeneratedPageParser.parse_content_from_body(
+          "<body>header<div class='content'>foobar</div>footer</body>", "")
+          ).to eq("header<div class='content'>foobar</div>footer")
+      end
+      it "returns only the body content within the body_element_tag" do
+        expect(GeneratedPageParser.parse_content_from_body(
+          "<body><div>header</div>"+
+          "<div class='content'>foobar</div>"+
+          "<div>footer</div></body>",
+          "<div class='content'>")).to eq("foobar")
+      end
+      it "returns only the body content when body_element_tag is a prefix" do
+        expect(GeneratedPageParser.parse_content_from_body(
+          "<body><div>header</div>"+
+          "<div class='content' plus='blah blah woof woof'>foobar</div>"+
+          "<div>footer</div></body>",
+          "<div class='content'")).to eq("foobar")
+      end
+      it "handles nested divs within the body content" do
+        expect(GeneratedPageParser.parse_content_from_body(
+          "<body><div>header</div>"+
+          "<div class='content' plus='blah blah woof woof'>"+
+          "blah blah"+
+          "<div>plus<div>some</div><div>nested</div>divs</div>"+
+          "woof woof"+
+          "</div>"+
+          "<div>footer</div></body>",
+          "<div class='content'")
+        ).to eq(
+          "blah blah"+
+          "<div>plus<div>some</div><div>nested</div>divs</div>"+
+          "woof woof"
+        )
+      end
+    end
+    describe '#parse_generated_page' do
+      it "returns empty values when passed all empty strings" do
+        data, content = GeneratedPageParser.parse_generated_page "", "", ""
+        expect(data).to eq({})
+        expect(content).to eq("")
+      end
+      it "returns empty values when the head element isn't present" do
+        data, content = GeneratedPageParser.parse_generated_page(
+          "<body>foobar</body>", "", "")
+        expect(data).to eq({})
+        expect(content).to eq("")
+      end
+      it "returns a nil title and all body content" do
+        data, content = GeneratedPageParser.parse_generated_page(
+          "<head></head>"+
+          "<body><div>header</div>"+
+          "<div class='content'>foobar</div>"+
+          "<div>footer</div></body>", "", "")
+        expect(data).to eq({"title" => nil})
+        expect(content).to eq(
+          "<div>header</div><div class='content'>foobar</div><div>footer</div>")
+      end
+      it "returns the title and only body content within body_element_tag" do
+        data, content = GeneratedPageParser.parse_generated_page(
+          "<head><title>Blah Blah Woof Woof</title></head>"+
+          "<body><div>header</div>"+
+          "<div class='content'>foobar</div>"+
+          "<div>footer</div></body>", "", "<div class='content'")
+        expect(data).to eq({"title" => "Blah Blah Woof Woof"})
+        expect(content).to eq("foobar")
+      end
+      it "returns the stripped title body content and metadata" do
+        data, content = GeneratedPageParser.parse_generated_page(
+          "<head><title>18F &mdash; Blah Blah Woof Woof</title>"+
+          "<meta name='skip-index' content='true'>"+
+          "<meta content='baz,quux,xyzzy,plugh' name=\"tags\" />"+
+          "</head>"+
+          "<body><div>header</div>"+
+          "<div class='content'>foobar</div>"+
+          "<div>footer</div></body>", "18F &mdash; ", "<div class='content'")
+        expect(data).to eq(
+          "title" => "Blah Blah Woof Woof",
+          "skip-index" => "true",
+          "tags" => "baz,quux,xyzzy,plugh",
+        )
+        expect(content).to eq("foobar")
+      end
+    end
+  end
+end

data/spec/generated_page_spec.rb ADDED Viewed

@@ -0,0 +1,86 @@
+module JekyllPagesApi
+  describe GeneratedPage do
+    describe '#initialize' do
+      it "handles all empty strings correctly" do
+        page = GeneratedPage.new "", "", "", "", ""
+        expect(page.path).to eq("")
+        expect(page.relative_path).to eq("")
+        expect(page.data).to eq({})
+        expect(page.content).to eq("")
+      end
+      it "parses the relative path when basedir ends in SEPARATOR" do
+        path = File.join "foo", "bar", "baz.html"
+        basedir = File.join "foo", ""
+        page = GeneratedPage.new path, basedir, "", "", ""
+        expect(page.path).to eq("foo/bar/baz.html")
+        expect(page.relative_path).to eq("/bar/baz.html")
+        expect(page.data).to eq({})
+        expect(page.content).to eq("")
+      end
+      it "parses the relative path when basedir doesn't end in SEPARATOR" do
+        path = File.join "foo", "bar", "baz.html"
+        basedir = "foo"
+        page = GeneratedPage.new path, basedir, "", "", ""
+        expect(page.path).to eq("foo/bar/baz.html")
+        expect(page.relative_path).to eq("/bar/baz.html")
+        expect(page.data).to eq({})
+        expect(page.content).to eq("")
+      end
+      it "raises RuntimeError when path does not begin with basedir" do
+        path = File.join "foo", "bar", "baz.html"
+        basedir = File.join "quux", ""
+        expect{GeneratedPage.new path, basedir, "", "", ""
+          }.to raise_error(
+            RuntimeError, "#{path} does not start with #{basedir}")
+      end
+      it "parses out index.html suffix and leaves trailing slash" do
+        path = File.join "foo", "bar", "index.html"
+        basedir = File.join "foo", ""
+        page = GeneratedPage.new path, basedir, "", "", ""
+        expect(page.path).to eq("foo/bar/index.html")
+        expect(page.relative_path).to eq("/bar/")
+        expect(page.data).to eq({})
+        expect(page.content).to eq("")
+      end
+      it "parses out index.html suffix and leaves trailing slash for root" do
+        path = File.join "foo", "index.html"
+        basedir = File.join "foo", ""
+        page = GeneratedPage.new path, basedir, "", "", ""
+        expect(page.path).to eq("foo/index.html")
+        expect(page.relative_path).to eq("/")
+        expect(page.data).to eq({})
+        expect(page.content).to eq("")
+      end
+      it "parses content correctly" do
+        path = File.join "foo", "bar", "index.html"
+        basedir = File.join "foo", ""
+        title_prefix = "18F &mdash; "
+        body_element_tag = "<div class='content'"
+        content = "<head><title>18F &mdash; Blah Blah Woof Woof</title>"+
+          "<meta name='skip-index' content='true'>"+
+          "<meta content='baz,quux,xyzzy,plugh' name=\"tags\" />"+
+          "</head>"+
+          "<body><div>header</div>"+
+          "<div class='content'>foobar</div>"+
+          "<div>footer</div></body>"
+        page = GeneratedPage.new(path, basedir, title_prefix,
+          body_element_tag, content)
+        expect(page.path).to eq("foo/bar/index.html")
+        expect(page.relative_path).to eq("/bar/")
+        expect(page.data).to eq(
+          "title" => "Blah Blah Woof Woof",
+          "skip-index" => "true",
+          "tags" => "baz,quux,xyzzy,plugh",
+        )
+        expect(page.content).to eq("foobar")
+      end
+    end
+  end
+end

data/spec/generated_site_spec.rb ADDED Viewed

@@ -0,0 +1,58 @@
+require 'fileutils'
+require 'tmpdir'
+module JekyllPagesApi
+  describe GeneratedPage do
+    describe '#each_site_file' do
+      before :each do
+        @test_tmpdir = Dir.mktmpdir
+      end
+      after :each do
+        FileUtils.remove_entry @test_tmpdir
+      end
+      it "should only select .html files containing a title" do
+        basedir = File.join @test_tmpdir, "foo"
+        FileUtils.mkdir_p basedir
+        content_dir = File.join(basedir, "bar")
+        FileUtils.mkdir_p content_dir
+        File.open(File.join(content_dir, "baz.txt"), "w") do |f|
+          f << "Text file that should be excluded."
+        end
+        File.open(File.join(content_dir, "quux.html"), "w") do |f|
+          f << "<html><head><title>18F &mdash; Include me!</title></head>"
+          f << "<body><div>header</div>"
+          f << "<div class='content'>This page should be included.</div>"
+          f << "<div>footer</div></body></html>"
+        end
+        File.open(File.join(content_dir, "xyzzy.html"), "w") do |f|
+          f << "<html><head></head><body>"
+          f << "This page shouldn't be included because it lacks a title."
+          f << "</body></html>"
+        end
+        paths = ['baz.txt', 'quux.html', 'xyzzy.html'].sort.map do |f|
+          File.join content_dir, f
+        end
+        expect(Dir.glob(File.join(content_dir, '**', '*'))).to eq(paths)
+        site = GeneratedSite.new("https://unused/", basedir,
+          "18F &mdash; ", "<div class='content'")
+        pages = []
+        site.each_site_file {|f| pages << f}
+        expect(pages.size).to eq(1)
+        page = pages.first
+        expect(page.path).to eq(File.join content_dir, 'quux.html')
+        expect(page.relative_path).to eq("/bar/quux.html")
+        expect(page.data).to eq("title" => "Include me!")
+        expect(page.content).to eq("This page should be included.")
+      end
+    end
+  end
+end

metadata CHANGED Viewed

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jekyll_pages_api
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.5
 platform: ruby
 authors:
 - Aidan Feldman
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2015-06-06 00:00:00.000000000 Z
+date: 2015-06-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: htmlentities
@@ -89,7 +89,8 @@ dependencies:
 description:
 email:
 - aidan.feldman@gsa.gov
-executables: []
+executables:
+- jekyll_pages_api
 extensions: []
 extra_rdoc_files: []
 files:
@@ -101,17 +102,24 @@ files:
 - LICENSE.md
 - README.md
 - Rakefile
+- bin/jekyll_pages_api
 - gemfiles/jekyll_2.gemfile
 - gemfiles/jekyll_3.gemfile
 - jekyll_pages_api.gemspec
 - lib/jekyll/site.rb
 - lib/jekyll_pages_api.rb
 - lib/jekyll_pages_api/filters.rb
+- lib/jekyll_pages_api/generated_page.rb
+- lib/jekyll_pages_api/generated_page_parser.rb
+- lib/jekyll_pages_api/generated_site.rb
 - lib/jekyll_pages_api/generator.rb
 - lib/jekyll_pages_api/page.rb
 - lib/jekyll_pages_api/page_without_a_file.rb
 - lib/jekyll_pages_api/version.rb
 - spec/filters_spec.rb
+- spec/generated_page_parser_spec.rb
+- spec/generated_page_spec.rb
+- spec/generated_site_spec.rb
 - spec/integration_spec.rb
 - spec/page_spec.rb
 - spec/site/.gitignore
@@ -163,6 +171,9 @@ summary: A Jekyll Plugin that generates a JSON file with data for all the Pages
   your Site.
 test_files:
 - spec/filters_spec.rb
+- spec/generated_page_parser_spec.rb
+- spec/generated_page_spec.rb
+- spec/generated_site_spec.rb
 - spec/integration_spec.rb
 - spec/page_spec.rb
 - spec/site/.gitignore