polytexnic 1.0.beta3 → 1.0.beta4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 673231bbe5f9155e189f7260d998c86d82f97737
-  data.tar.gz: 906c18815f66d4f82892065795d63f9808ffe19e
+  metadata.gz: 77cd3da83721b462b620c6264b757009d7764242
+  data.tar.gz: 66afdad9074a52e82885ab4c59de356b41aefc27
 SHA512:
-  metadata.gz: 2d0e7a95a6d8740cf1052b2b32903816894063249589f92ad8e25812e88d509018bfb66f6727d8cf20b47b9587e7bcaa3df2d659cdcc9d135d34055d12e418cf
-  data.tar.gz: ac81b31f5cf10c84cbc127e4fee1211a7782ee7acceb0c5eb2a868d85399418e21ecaab9f21a719245110771af93889f8fef1d2dc61de89c25f66b6da63e73c3
+  metadata.gz: 6fc1fd9be6e8abca50d1974632eb8240a4cc1d2e0d9eb97f0c82fd38796a969f44477c426d54926f654b84325936e6ddd4825ea7ffd5b9d2ab924fb341a59a2d
+  data.tar.gz: 333b985f56228ca304ace76eb0ee5b578fc01068c0c955e8d8cfb9f84f81b9983115ae9a0ca36022491561827ab28d6481ac9f88166df102b39f291472627c94

data/lib/polytexnic/code_inclusion.rb

@@ -1,35 +1,95 @@
 module CodeInclusion
   class CodeInclusionException < Exception; end;
+  class RetrievalException     < CodeInclusionException; end;
+  class SubsetException        < CodeInclusionException; end;
 
-  class Code
-    CODE_REGEX = /^\s*%=\s+<<\s*\(                # opening
-                   \s*([^\s]+?)                   # path to file
-                   (?:\[(.+?)\])?                 # optional section name
-                   (?:,\s*tag:\s*([\w\.\/\-]+?))? # optional git tag
-                   (?:,\s*lang:\s*(\w+))?         # optional lang
-                   (,\s*options:\s*.*)?           # optional options
-                   \s*\)                          # closing paren
-                   /x
 
+  # Converts the input line into:
+  #   Retrieval Args:
+  #    filename:     filename           # required
+  #    git:          { tag: tagname }   # optional
+  #    section:      sectionname,       # 'section:' and 'line_numbers:'
+  #    line_numbers: 1,4-6,8,14         # are optional and mutually exclusive
+  #
+  #  Render Args:
+  #    custom_language: 'ruby'
+  #    hightlight:      '"hl_lines": [1, 2], "linenos": true'
+  class Args
+    CODE_REGEX =
+     /^\s*%=\s+<<\s*\(                      # opening
+       \s*([^\s]+?)                         # path to file
+       (?:\[(.+?)\])?                       # optional section or line numbers
+       (?:,\s*git:\s*([ \w\.\/\-\{\}:]+?))? # optional git tag
+       (?:,\s*lang:\s*(\w+))?               # optional lang
+       (,\s*options:\s*.*)?                 # optional options
+       \s*\)                                # closing paren
+       /x
+
+    attr_reader :input, :retrieval, :render, :match
+
+    def initialize(input)
+      @input     = input
+      @retrieval = {}
+      @render    = {}
+      @match     = parse
+
+      extract
+    end
+
+    def extract
+      return unless code_inclusion_line?
+
+      retrieval[:filename]       = match[1]
+
+      if specifies_line_numbers?
+        retrieval[:line_numbers] = match[2]
+      else
+        retrieval[:section]      = match[2]
+      end
+
+      retrieval[:git]            = extract_git(match[3]) if match[3]
+
+      render[:custom_language]   = match[4]
+      render[:highlight]         = match[5]
+    end
+
+    def specifies_line_numbers?
+      whitespace_digits_dashes_and_commas.match(match[2])
+    end
+
+    def parse
+      CODE_REGEX.match(input)
+    end
+
+    def code_inclusion_line?
+      !match.nil?
+    end
+
+    def whitespace_digits_dashes_and_commas
+      /\s*\d[-,\d\s]*$/
+    end
+
+    def extract_git(git_args)
+      # only expect tag:, but could easily extract branch: or repo:
+      tag = /\s?{\s?tag:\s(.*)\s?}/.match(git_args)[1]
+      {tag: tag}
+    end
+  end
+
+
+  class Code
     DEFAULT_LANGUAGE = 'text'
 
     # Returns an instance of CodeInclusion::Code or nil
     def self.for(line)
-      if (line =~ CODE_REGEX)
-        opts = {}
-        opts[:tag]             = $3
-        opts[:custom_language] = $4
-        opts[:highlight]       = $5
-        new($1, $2, opts)
-      end
+      args = Args.new(line)
+      new(args.retrieval, args.render) if args.code_inclusion_line?
     end
 
-    attr_reader :filename, :sectionname, :opts
+    attr_reader :retrieval_args, :render_args
 
-    def initialize(filename, sectionname, opts)
-      @filename    = filename
-      @sectionname = sectionname
-      @opts        = opts
+    def initialize(retrieval_args, render_args)
+      @retrieval_args, @render_args = retrieval_args, render_args
     end
 
     # Returns the formatted code or an error message
@@ -37,7 +97,7 @@ module CodeInclusion
       return unless filename
 
       result = []
-      result << "%= lang:#{language}#{opts[:highlight]}"
+      result << "%= lang:#{language}#{highlight}"
       result << '\begin{code}'
       result.concat(raw_code)
       result << '\end{code}'
@@ -46,31 +106,31 @@ module CodeInclusion
         code_error(e.message)
     end
 
+    private
+
     def raw_code
-      reader.read
+      Listing.for(retrieval_args)
     end
 
-    private
+    def filename
+      retrieval_args[:filename]
+    end
 
-    # Manufacture a reader of the appriopriate type
-    def reader
-      @reader ||=
-        if opts[:tag]
-          GitTaggedFileReader.new(filename,
-                                  sectionname,
-                                  opts.delete(:tag),
-                                  opts)
-        elsif sectionname
-          SectionReader.new(filename, sectionname)
-        else
-          FileReader.new(filename)
-        end
+    def highlight
+      render_args[:highlight]
     end
 
-    def language
+    def custom_language
+      render_args[:custom_language]
+    end
+
+    def language_from_extension
       extension_array     = File.extname(filename).scan(/\.(.*)/).first
       lang_from_extension = extension_array.nil? ? nil : extension_array[0]
-      (opts[:custom_language] || lang_from_extension || DEFAULT_LANGUAGE)
+    end
+
+    def language
+      (custom_language || language_from_extension || DEFAULT_LANGUAGE)
     end
 
     def code_error(details)
@@ -78,169 +138,253 @@ module CodeInclusion
     end
   end
 
-
-  # GitTaggedFileReader retrieves code from a
-  # tagged file in your local git repository.
-  #
-  #  Example: <<(lib/polytexnic/literal.rb, tag: v0.9.4)
-  class GitTaggedFileReader
-
-    def self.git
-      Git.new
+# Listing.for takes a set of retrieval args and returns an array of
+#   source code lines to be included in the book.
+#
+# Listing is responsible for retrieving the file you're including
+# (the 'FullListing') and for extracting individual lines from that file
+# (the 'Subset').
+
+# It contains factory methods to choose the correct FullListing and Subset
+# classes and the code to wire them together.  If you add new FullListing or
+# Subset objects, you'll need to wire them together here.
+class Listing
+
+    # Returns the lines of code to be included or
+    #   an exception containing the error message.
+    def self.for(args)
+      new(args).final_listing
     end
 
-    attr_reader :filename, :sectionname, :tagname, :opts, :git
+    attr_reader :args
 
-    def initialize(filename, sectionname, tagname, opts={}, git=self.class.git)
-      @filename    = filename
-      @sectionname = sectionname
-      @tagname     = tagname
-      @opts        = opts
-      @git         = git
+    def initialize(args)
+      @args = args
     end
 
-    def read
-      ensure_tag_exists!
+    def final_listing
+      subset_class.new(full_listing, args).lines
 
-      Dir.mktmpdir {|tmpdir|
-        checkout_file!(tmpdir)
-        read_file(tmpdir)
-      }
+      rescue SubsetException => e
+        raise RetrievalException.new(e.message +
+                                     " in file '#{args[:filename]}'")
     end
 
     private
 
-    def ensure_tag_exists!
-      unless git.tag_exists?(tagname)
-        raise(CodeInclusionException, "Tag '#{tagname}' does not exist.")
-      end
+    def full_listing
+      retrieval_class.new(args).lines
     end
 
-    def checkout_file!(tmpdir)
-      output = git.checkout(tmpdir, filename, tagname)
-      unless git.checkout_succeeded?
-        raise(CodeInclusionException, improve_error_message(output, tmpdir))
+    def retrieval_class
+      case
+      when args[:git]
+        FullListing::GitTag
+      else
+        FullListing::File
       end
     end
 
-    def read_file(tmpdir)
-      tmpfilename = File.join(tmpdir, filename)
-      CodeInclusion::Code.new(tmpfilename, sectionname, opts).raw_code
+    def subset_class
+      case
+      when args[:line_numbers]
+        Subset::LineNumber
+      when args[:section]
+        Subset::Section
+      else
+        Subset::Everything
+      end
     end
+  end
+
+
+  # FullListing objects retrieve an entire file from some location.
+  module FullListing
+
+    # Return lines contained in a file read from disk.
+    class File
+      attr_reader :filename
+
+      def initialize(args)
+        @filename = args[:filename]
+      end
 
-    def improve_error_message(msg, tmpdir)
-        msg.gsub(/#{tmpdir}/, '').chomp(".\n") + " in tag #{tagname}."
+      def lines
+        ensure_exists!
+        ::File.read(filename).split("\n")
+      end
+
+      private
+
+      def ensure_exists!
+        unless ::File.exist?(filename)
+         raise(RetrievalException, "File '#{filename}' does not exist")
+        end
+      end
     end
 
+    # Return lines contained in a file that's tagged in git.
+    class GitTag
+
+      def self.git_cmd
+        GitCmd.new
+      end
+
+      attr_reader :filename, :tag, :git_cmd
 
-    class Git
-      def checkout(tmpdir, filename, tagname)
-        `git --work-tree=#{tmpdir} checkout #{tagname} #{filename} 2>&1`
+      def initialize(args, git_cmd=self.class.git_cmd)
+        @filename = args[:filename]
+        @tag      = args[:git][:tag]
+        @git_cmd  = git_cmd
       end
 
-      def checkout_succeeded?
-        $? == 0
+      def lines
+        ensure_exists!
+        result = git_cmd.show(filename, tag)
+
+        if git_cmd.succeeded?
+          result.split("\n")
+        else
+          raise(RetrievalException, result)
+        end
       end
 
-      def tags
-        `git tag`
+      private
+
+      def ensure_exists!
+        unless git_cmd.tag_exists?(tag)
+          raise(RetrievalException, "Tag '#{tag}' does not exist.")
+        end
       end
 
-      def tag_exists?(tagname)
-        tags.split("\n").include?(tagname)
+      class GitCmd
+        def show(filename, tagname)
+          `git show #{tagname}:#{filename}`
+        end
+
+        def succeeded?
+          $? == 0
+        end
+
+        def tags
+          `git tag`
+        end
+
+        def tag_exists?(tagname)
+          tags.split("\n").include?(tagname)
+        end
       end
     end
   end
 
 
-  # FileReader retrieves code from a file on disk.
-  #
-  #  Example: <<(lib/polytexnic/literal.rb)
-  class FileReader
-    attr_reader :filename
+  # Subsets reduce an input array of strings to a subset of that array.
+  module Subset
 
-    def initialize(filename)
-      @filename = filename
-    end
+    # Return the lines in the named section.
+    class Section
+      attr_reader :input, :name
 
-    def read
-      ensure_file_exists!
-      File.read(filename).split("\n")
-    end
+      def initialize(input, args)
+        @input = input
+        @name  = args[:section]
+      end
 
-    def ensure_file_exists!
-      unless File.exist?(filename)
-       raise(CodeInclusionException, "File '#{filename}' does not exist")
+      def lines
+        ensure_exists!
+        input.slice(index_of_first_line, length)
       end
-    end
-  end
 
+      private
 
-  # SectionReader retrieves code from a marked section in a file on disk.
-  #
-  #  Example: <<(lib/polytexnic/literal.rb[my_section])
-  #
-  # Sections are delineated by '#// begin section_name' and '#// end',
-  # for example:
-  #
-  #   #// begin my_section
-  #   some code
-  #   #// end
-  class SectionReader < FileReader
-    attr_reader :lines, :sectionname
+      def exist?
+        !!index_of_begin
+      end
 
-    def initialize(filename, sectionname)
-      super(filename)
-      @sectionname = sectionname
-    end
+      def index_of_begin
+        @section_begin_i ||=
+          input.index {|line| clean(line) == begin_text }
+      end
 
-    def read
-      @lines = super
-      ensure_section_exists!
-      lines.slice(index_of_first_line, length)
-    end
+      def index_of_first_line
+        @first_line_i ||= index_of_begin + 1
+      end
 
-    private
-    def exist?
-      !!index_of_section_begin
-    end
+      def length
+        input.slice(index_of_first_line, input.size).index { |line|
+          clean(line) == (end_text)
+        }
+      end
 
-    def index_of_section_begin
-      @section_begin_i ||=
-        lines.index {|line| clean(line) == section_begin_text }
-    end
+      def marker
+        '#//'
+      end
 
-    def index_of_first_line
-      @first_line_i ||= index_of_section_begin + 1
-    end
+      def begin_text
+        "#{marker} begin #{name}"
+      end
 
-    def length
-      lines.slice(index_of_first_line, lines.size).index { |line|
-        clean(line) == (section_end_text)
-      }
-    end
+      def end_text
+        "#{marker} end"
+      end
 
-    def marker
-      '#//'
-    end
+      def clean(str)
+        str.strip.squeeze(" ")
+      end
 
-    def section_begin_text
-      "#{marker} begin #{sectionname}"
+      def ensure_exists!
+        unless exist?
+          section_err = "Could not find section header '#{begin_text}'"
+          raise(SubsetException, section_err)
+        end
+      end
     end
 
-    def section_end_text
-      "#{marker} end"
-    end
+    # Return the lines specified by :line_numbers.
+    # Line numbers are comma separated and may contain ranges, i.e.,
+    #   2, 4-6, 8, 14
+    #
+    # Rules:
+    #   whitespace is ignored
+    #   ranges are included in ascending order (4-6 is the same as 6-4)
+    #   lines numbers higher than the max available are ignored
+    class LineNumber
+      attr_reader :input, :numbers
+      def initialize(input, args)
+        @input   = input
+        @numbers = args[:line_numbers]
+      end
+
+      def lines
+        individual_numbers.collect {|i| input[i - 1]}.compact
+      end
+
+      private
+
+      def individual_numbers
+        clumps.collect {|clump| expand_clump(clump)}.flatten
+      end
 
-    def clean(str)
-      str.strip.squeeze(" ")
+      def clumps
+        numbers.gsub(/ /,'').split(",")
+      end
+
+      def expand_clump(clump)
+        edges = clump.split('-').collect(&:to_i)
+        (edges.min.to_i..edges.max.to_i).to_a
+      end
     end
 
-    def ensure_section_exists!
-      unless exist?
-        section_err = "Could not find section header '#{section_begin_text}'"
-        file_err    = " in file '#{filename}'"
-        raise(CodeInclusionException, section_err + file_err)
+    # Return everything (think of this as the null object subset)
+    class Everything
+      attr_reader :input
+
+      def initialize(input, _=nil)
+        @input = input
+      end
+
+      def lines
+        input
       end
     end
   end

data/lib/polytexnic/version.rb

@@ -1,3 +1,3 @@
 module Polytexnic
-  VERSION = "1.0.beta3"
+  VERSION = "1.0.beta4"
 end

data/spec/to_html/literal_environments/code_inclusion_spec.rb

@@ -0,0 +1,136 @@
+# encoding=utf-8
+require 'spec_helper'
+
+describe "full listing" do
+
+  describe "file" do
+
+    context "exists" do
+      let(:args) { {filename: __FILE__} }
+      subject { CodeInclusion::FullListing::File.new(args).lines }
+
+      it { should eq(File.read(__FILE__).split("\n")) }
+    end
+
+    context "does not exist" do
+      let(:args) { {filename: "badfile"} }
+      subject { lambda { CodeInclusion::FullListing::File.new(args).lines } }
+
+      it { should raise_exception(CodeInclusion::RetrievalException) }
+    end
+
+  end
+
+  describe "git tag" do
+
+    context "file exists" do
+      before(:all) do
+        class FakeGitCmd < CodeInclusion::FullListing::GitTag::GitCmd
+          def show(_, _)
+            "Real data\nsecond line"
+          end
+          def tag_exists?(tagname)
+            true
+          end
+          def succeeded?
+            true
+          end
+        end
+      end
+
+      let(:args) { { filename: "goodfile", git: {tag: "goodtag"} } }
+      subject {
+        CodeInclusion::FullListing::GitTag.new(args, FakeGitCmd.new).lines }
+
+      it { should eq(["Real data", "second line"]) }
+    end
+
+    context "tag does not exist" do
+      before(:all) do
+        class FakeGitCmd < CodeInclusion::FullListing::GitTag::GitCmd
+          def tag_exists?(tagname)
+            false
+          end
+        end
+      end
+
+      let(:args) { { filename: "irreleventfile", git: {tag: "badtag"} } }
+      subject { lambda {
+        CodeInclusion::FullListing::GitTag.new(args, FakeGitCmd.new).lines } }
+
+      it { should raise_exception(
+            CodeInclusion::RetrievalException,
+            "Tag 'badtag' does not exist."
+            ) }
+    end
+
+    context "file does not exist" do
+      before(:all) do
+        class FakeGitCmd < CodeInclusion::FullListing::GitTag::GitCmd
+          def show(filename, tag)
+            "fatal: Path 'badfile' does not exist in 'goodtag'"
+          end
+          def tag_exists?(tagname)
+            true
+          end
+          def succeeded?
+            false
+          end
+        end
+      end
+
+      let(:args) { { filename: "badfile", git: {tag: "goodtag"} } }
+      subject { lambda {
+        CodeInclusion::FullListing::GitTag.new(args, FakeGitCmd.new).lines } }
+
+      it { should raise_exception(
+            CodeInclusion::RetrievalException,
+            "fatal: Path 'badfile' does not exist in 'goodtag'") }
+    end
+
+  end
+end
+
+
+describe "subset" do
+  let(:input) {["line1",
+                "line2",
+                "#// begin sec_AAA",
+                "line4",
+                "line5",
+                "#// end",
+                "line7",
+                "line8",
+                "line9",
+                "line10"]}
+
+  describe "section" do
+
+    context "exists" do
+      let(:args) { {section: "sec_AAA"} }
+      subject { CodeInclusion::Subset::Section.new(input, args).lines }
+
+      it { should eq(["line4", "line5"]) }
+    end
+
+    context "does not exist" do
+      let(:args) { {section: "missing section name"} }
+      subject { lambda {CodeInclusion::Subset::Section.new(input, args).lines} }
+
+      it { should raise_exception(CodeInclusion::SubsetException) }
+    end
+  end
+
+  describe "line numbers" do
+    let(:args) { {line_numbers: "1 , 2-1, 4- 5,10, 42"} }
+    subject { CodeInclusion::Subset::LineNumber.new(input, args).lines }
+
+    it { should eq(["line1", "line1", "line2", "line4", "line5", "line10"]) }
+  end
+
+  describe "everything" do
+    subject { CodeInclusion::Subset::Everything.new(input).lines }
+
+    it { should eq(input)}
+  end
+end

data/spec/to_html/literal_environments/code_spec.rb

@@ -244,24 +244,22 @@ describe Polytexnic::Pipeline do
     context "from a git tag" do
       shared_examples "an inclusion" do
         it "resembles the given output" do
-          allow(CodeInclusion::GitTaggedFileReader).to receive(:git).
-            and_return(FakeGit.new)
+          allow(CodeInclusion::FullListing::GitTag).to receive(:git_cmd).
+            and_return(FakeGitCmd.new)
           expect(processed_text).to resemble(output)
         end
       end
 
       context "the tag and file exist" do
         before(:all) do
-          class FakeGit < CodeInclusion::GitTaggedFileReader::Git
-            # Write fake data to location on disk where git _would_ have placed the file
-            def checkout(tmpdir, filename, tagname)
-              f = File.join(tmpdir, filename)
-              File.open(f, 'w') { |file| file.write("Fake data") }
+          class FakeGitCmd < CodeInclusion::FullListing::GitTag::GitCmd
+            def show(_, _)
+              "Fake data\nsecond line"
             end
             def tag_exists?(tagname)
               true
             end
-            def checkout_succeeded?
+            def succeeded?
               true
             end
           end
@@ -269,7 +267,7 @@ describe Polytexnic::Pipeline do
 
         context "with tag only" do
           let(:polytex) do <<-'EOS'
-            %= <<(tagged_file.rb, tag: fake_tag.1.0)
+            %= <<(tagged_file.rb, git: {tag: fake_tag.1.0})
             EOS
           end
           let(:output) do <<-'EOS'
@@ -277,6 +275,7 @@ describe Polytexnic::Pipeline do
               <div class="highlight">
                 <pre>
                   <span class="no">Fake</span> <span class="n">data</span>
+                  <span class="n">second</span> <span class="n">line</span>
                 </pre>
             </div>
             EOS
@@ -288,7 +287,10 @@ describe Polytexnic::Pipeline do
           let(:output) do <<-'EOS'
             <div class="code">
               <div class="highlight">
-                <pre>Fake data</pre>
+                <pre>
+                  Fake data
+                  second line
+                </pre>
               </div>
             </div>
             EOS
@@ -296,7 +298,7 @@ describe Polytexnic::Pipeline do
 
           context "with tag and lang" do
             let(:polytex) do <<-'EOS'
-              %= <<(tagged_file.rb, tag: slashes/and-dashes-are/ok/too, lang: tex)
+              %= <<(tagged_file.rb, git: {tag: slashes/and-dashes-are/ok/too}, lang: tex)
               EOS
             end
             it_behaves_like "an inclusion"
@@ -304,7 +306,7 @@ describe Polytexnic::Pipeline do
 
           context "with tag, lang and options" do
             let(:polytex) do <<-'EOS'
-              %= <<(tagged_file.rb, tag: v0.9.4, lang: tex, options: "hl_lines": [5])
+              %= <<(tagged_file.rb, git: {tag: v0.9.4}, lang: tex, options: "hl_lines": [5])
               EOS
             end
             it_behaves_like "an inclusion"
@@ -314,20 +316,21 @@ describe Polytexnic::Pipeline do
 
       context "the tag does not exist" do
         before(:all) do
-          class FakeGit < CodeInclusion::GitTaggedFileReader::Git
-            def checkout(tmpdir, filename, tagname)
+          class FakeGitCmd < CodeInclusion::FullListing::GitTag::GitCmd
+            def show(_, _)
+              ''
             end
             def tag_exists?(tagname)
               false
             end
-            def checkout_succeeded?
+            def succeeded?
               false
             end
           end
         end
 
         let(:polytex) do <<-'EOS'
-          %= <<(tagged_file.rb, tag: non_existent_tag)
+          %= <<(tagged_file.rb, git: {tag: non_existent_tag})
           EOS
         end
         let(:output) do <<-'EOS'
@@ -343,27 +346,27 @@ describe Polytexnic::Pipeline do
 
       context "the file does not exist" do
         before(:all) do
-          class FakeGit < CodeInclusion::GitTaggedFileReader::Git
-            def checkout(tmpdir, filename, tagname)
-              "pathspec #{tmpdir}/non_existent_file did not match any file(s) known to git.\n"
+          class FakeGitCmd < CodeInclusion::FullListing::GitTag::GitCmd
+            def show(filename, _)
+              "fatal: Path 'path/to/non_existent_file.rb' does not exist in 'v0.9.9'"
             end
             def tag_exists?(tagname)
               true
             end
-            def checkout_succeeded?
+            def succeeded?
               false
             end
           end
         end
 
         let(:polytex) do <<-'EOS'
-          %= <<(non_existent_file, tag: v0.9.4)
+          %= <<(path/to/non_existent_file.rb, git: {tag: v0.9.4})
           EOS
         end
         let(:output) do <<-'EOS'
           <p>
              <span class="inline_verbatim">
-               ERROR: pathspec /non_existent_file did not match any file(s) known to git in tag v0.9.4.
+               ERROR: fatal: Path 'path/to/non_existent_file.rb' does not exist in 'v0.9.9'
              </span>
            </p>
            EOS

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: polytexnic
 version: !ruby/object:Gem::Version
-  version: 1.0.beta3
+  version: 1.0.beta4
 platform: ruby
 authors:
 - Michael Hartl
@@ -258,6 +258,7 @@ files:
 - spec/to_html/graphics_and_figures_spec.rb
 - spec/to_html/input_spec.rb
 - spec/to_html/lists_spec.rb
+- spec/to_html/literal_environments/code_inclusion_spec.rb
 - spec/to_html/literal_environments/code_spec.rb
 - spec/to_html/literal_environments/math_spec.rb
 - spec/to_html/literal_environments/unicode_spec.rb
@@ -321,6 +322,7 @@ test_files:
 - spec/to_html/graphics_and_figures_spec.rb
 - spec/to_html/input_spec.rb
 - spec/to_html/lists_spec.rb
+- spec/to_html/literal_environments/code_inclusion_spec.rb
 - spec/to_html/literal_environments/code_spec.rb
 - spec/to_html/literal_environments/math_spec.rb
 - spec/to_html/literal_environments/unicode_spec.rb