devver-germinate 1.0.0

data/spec/germinate/pipeline_spec.rb

@@ -0,0 +1,24 @@
+require File.expand_path(
+    File.join(File.dirname(__FILE__), %w[.. .. lib germinate]))
+
+module Germinate
+  describe Pipeline, "given a set of processes" do
+    before :each do 
+      @intput   = stub("Input")
+      @output1  = stub("Output 1")
+      @output2  = stub("Output 2")
+      @output3  = stub("Output 3")
+      @process1 = stub("Process 1", :call => @output1)
+      @process2 = stub("Process 2", :call => @output2)
+      @process3 = stub("Process 3", :call => @output3)
+      @it = Germinate::Pipeline.new([@process1, @process2, @process3])
+    end
+
+    it "should compose the processes into a pipeline" do
+      @process1.should_receive(:call).with(@input).and_return(@output1)
+      @process2.should_receive(:call).with(@output1).and_return(@output2)
+      @process3.should_receive(:call).with(@output2).and_return(@output3)
+      @it.call(@input).should == @output3
+    end
+  end
+end

data/spec/germinate/process_spec.rb

@@ -0,0 +1,64 @@
+require File.expand_path(
+    File.join(File.dirname(__FILE__), %w[.. .. lib germinate]))
+
+module Germinate
+  describe Process do
+    before :each do
+      @input   = Germinate::Hunk.new(
+        ["line 1\n", "line 2\n"], 
+        :comment_prefix => "//")
+      @output  = ["1 enil\n", "2 enil\n"]
+      @command = stub("Command", :readlines => @output).as_null_object
+      IO.stub!(:popen).and_yield(@command)
+    end
+
+    context "given a command 'mycommand'" do
+      before :each do
+        @it = Germinate::Process.new("myproc", "mycommand")
+      end
+      
+      context "when called on a hunk of text" do
+        it "should pipe the input through the command" do
+          @command.should_receive(:<<).with("line 1\n").ordered
+          @command.should_receive(:<<).with("line 2\n").ordered
+          @command.should_receive(:close_write).ordered
+          @command.should_receive(:readlines).ordered.
+            and_return(["a\n", "b\n"])
+          IO.should_receive(:popen).with("mycommand", "r+").and_yield(@command)
+          output = @it.call(@input)
+          output.should == ["a\n", "b\n"]
+        end
+        
+        it "should preserve hunk attributes" do
+          output = @it.call(@input)
+          output.comment_prefix.should == "//"
+        end
+      end
+    end
+
+    context "given a command 'mycommand %f' and called on some text" do
+      before :each do
+        @it = Germinate::Process.new("myproc", "mycommand %f")
+      end
+
+      it "should create a temporary file and pass the name to the command" do
+        @tempfile = stub("Temp File", :path => "TEMP_PATH")
+        Tempfile.should_receive(:open).with("germinate_hunk").and_yield(@tempfile)
+        @tempfile.should_receive(:<<).with("line 1\n").ordered
+        @tempfile.should_receive(:<<).with("line 2\n").ordered
+        @tempfile.should_receive(:close).ordered
+        IO.should_receive(:popen).
+          with("mycommand 'TEMP_PATH'", "r").
+          and_yield(@command)
+        
+        @it.call(@input).should == @output
+      end
+
+      it "should preserve hunk attributes" do
+        output = @it.call(@input)
+        output.comment_prefix.should == "//"
+      end
+
+    end
+  end
+end

data/spec/germinate/reader_spec.rb

@@ -0,0 +1,306 @@
+require File.expand_path(
+    File.join(File.dirname(__FILE__), %w[.. .. lib germinate]))
+
+module Germinate
+  describe Reader do
+    before :each do
+      @librarian = stub("Librarian", :comment_prefix_known? => false).
+        as_null_object
+      @it        = Reader.new(@librarian)
+    end
+
+    it "should start in the :initial state" do
+      @it.state.should == :initial
+    end
+
+    it "should start out with a section count of 0" do
+      @it.section_count.should == 0
+    end
+
+    it "should start out with current section SECTION0" do
+      @it.current_section.should == "SECTION0"
+    end
+
+    context "when section count is incremented" do
+
+      before :each do
+        @it.increment_section_count!
+      end
+
+      it "should increment section count by one" do
+        @it.section_count.should == 1
+      end
+
+      it "should update current section" do
+        @it.current_section.should == "SECTION1"
+      end
+
+    end
+
+    CONTROL_LINES = [
+      # Line                  Comment  Args
+      [":TEXT:\n",            nil,     []],
+      ["# :CUT: \n",          "#",     []],
+      ["  ; :TEXT: foo\n",    ";",     ["foo"]],
+      ["//:SAMPLE:\n",        "//",    []],
+      ["$>:END: ",            "$>",    []],
+      [":SAMPLE: bar, { a: 1, b: 2 }", nil, ["bar", {"a"=>1, "b"=>2}]],
+      [':BRACKET_CODE:',      nil,     []],
+      [':INSERT: @sel',       nil,     ["@sel"]],
+      [':PROCESS: foo, bar',  nil,     ["foo", "bar"]],
+    ]
+
+    CONTROL_LINES.each do |(line, comment, args)|
+      context "when given the line #{line}" do
+        if comment
+          it "should set the comment character to '#{comment}'" do
+            @librarian.should_receive(:comment_prefix=).with(comment)
+            @it << line
+          end
+        else
+          it "should not set a comment prefix" do
+            @librarian.should_not_receive(:comment_prefix=)
+            @it << line
+          end
+        end
+
+        it "should store the line as a control line" do
+          @librarian.should_receive(:add_control!).with(line)
+          @it << line
+        end
+      end
+    end
+
+    context "given a BRACKET_CODE control line" do
+      before :each do 
+        @line = ':BRACKET_CODE: "<<<", ">>>"'
+      end
+
+      it "should store the brackets" do
+        @librarian.should_receive(:code_open_bracket=).with("<<<")
+        @librarian.should_receive(:code_close_bracket=).with(">>>")
+        @it << @line
+      end
+
+    end
+
+    context "before the first line of text" do
+      it "should treat non-keyword lines as front matter" do
+        @librarian.should_receive(:add_front_matter!, "TEST")
+        @it << "TEST"
+      end
+    end
+
+    context "after an initial line of text" do
+      before :each do
+        @it << "\n"
+      end
+
+      it "should be in the :front_matter state" do
+        @it.state.should == :front_matter
+      end
+
+      it "should record non-keyword lines as more front matter" do
+        @librarian.should_receive(:add_front_matter!, "TEST")
+        @it << "TEST"
+      end
+    end
+
+    context "after the :TEXT: keyword" do
+      before :each do
+        @it << ":TEXT:\n"
+      end
+
+      it "should be in the :text state" do
+        @it.state.should == :text
+      end
+
+      it "should place following text lines into a section" do
+        @librarian.should_receive(:add_text!).with("SECTION1", "blah blah blah")
+        @it << "blah blah blah"
+      end
+
+      context "given an escaped directive" do
+        it "should add the directive line as text" do
+          @librarian.should_receive(:add_text!).with("SECTION1", ":TEXT: abc")
+          @it << "\\:TEXT: abc"
+        end
+      end
+    end
+
+    context "after two anonymous :TEXT: sections" do
+      before :each do
+        @it << ":TEXT:\n"
+        @it << ":TEXT:\n"
+      end
+
+      it "should be in SECTION2" do
+        @it.current_section.should == "SECTION2"
+      end
+    end
+
+    context "after a named :TEXT: keyword" do
+      before :each do
+        @it << ":TEXT: foo\n"
+      end
+
+      it "should be in the :text state" do
+        @it.state.should == :text
+      end
+
+      it "should place following text lines into the named section" do
+        @librarian.should_receive(:add_text!).with("foo", "yadda yadda")
+        @it << "yadda yadda"
+      end
+
+      it "should name following code lines after the section" do
+        @librarian.should_receive(:add_code!).with("foo", "this is code")
+        @it << "yadda yadda\n"
+        @it << ":SAMPLE:\n"
+        @it << "this is code"
+      end
+    end
+
+    context "after text is ended by a :CUT:" do
+      before :each do
+        @it << ":TEXT:\n"
+        @it << ":CUT:\n"
+      end
+
+      it "should be in the :code state" do
+        @it.state.should == :code
+      end
+
+      it "should add following lines to a code sample" do
+        @librarian.should_receive(:add_code!).with("SECTION2", "this is code")
+        @it << "this is code"
+      end
+    end
+
+    context "after a :TEXT: keyword prefixed with '#'" do
+      before :each do
+        @it << "# :TEXT:\n"
+      end
+
+      it "should be in the :text state" do
+        @it.state.should == :text
+      end
+
+    end
+
+    context "after a :TEXT: keyword prefixed with ';'" do
+      before :each do
+        @it << " ; :TEXT:\n"
+      end
+
+      it "should be in the :text state" do
+        @it.state.should == :text
+      end
+
+    end
+
+    context "given a :SAMPLE: keyword with a name" do
+      before :each do
+        @it << ":SAMPLE: foobar"
+      end
+
+      it "should file following code lines under the given name" do
+        @librarian.should_receive(:add_code!).with("foobar", "line 1")
+        @librarian.should_receive(:add_code!).with("foobar", "line 2")
+
+        @it << "line 1"
+        @it << "line 2"
+      end
+
+      context "given an escaped directive" do
+        it "should add the directive line as code" do
+          @librarian.should_receive(:add_code!).with("foobar", " # :TEXT: abc")
+          @it << " # \\:TEXT: abc"
+        end
+      end
+    end
+
+    context "given a :SAMPLE: keyword with custom brackets" do
+      before :each do
+        @line = ':SAMPLE: foobar, { brackets: ["<<", ">>"] }'
+      end
+
+      it "should assign custom bracket attributes to the sample" do
+        @librarian.should_receive(:set_code_attributes!).
+          with("foobar", 
+          { 
+            :code_open_bracket  => "<<", 
+            :code_close_bracket => ">>" 
+          })
+
+        @it << @line
+      end
+    end
+
+    context "in text section with comment set" do
+      before :each do
+        @librarian.stub!(:comment_prefix_known?).and_return(true)
+        @librarian.stub!(:comment_prefix).and_return("#")
+        @it << "# :TEXT:\n"
+        @section = @it.current_section
+      end
+      
+      it "should treat a commented line as more of the same section" do
+        @librarian.should_receive(:add_text!).
+          with(@section, "# commented text\n")
+        @it << "# commented text\n"
+      end
+
+      it "should treat a commented blank line as more of the same section" do
+        @librarian.should_receive(:add_text!).
+          with(@section, "# \n")
+        @it << "# \n"
+      end
+
+      it "should treat an uncommented blank line as more of the same section" do
+        @librarian.should_receive(:add_text!).
+          with(@section, " \n")
+        @it << " \n"
+      end
+
+      it "should treat an uncommented line as the start of code" do
+        @librarian.should_receive(:add_code!).
+          with(@section, "uncommented text\n")
+        @it << "uncommented text\n"
+      end
+    end
+
+    context "given an insertion with an explicit selector" do
+      before :each do
+        @it << ":TEXT: mysection"
+        @line = ":INSERT: foo"
+      end
+      
+      it "should add an insertion to the current section" do
+        @librarian.should_receive(:add_insertion!).with("mysection", anything)
+        @it << @line
+      end
+
+      it "should pass a selector object to the librarian" do
+        @librarian.should_receive(:add_insertion!) do |section, selector|
+          selector.should be_a_kind_of(Selector)
+          selector.string.should == "foo"
+          selector.default_key.should == "mysection"
+        end
+        @it << @line
+      end
+    end
+
+    context "given a process directive" do
+      before :each do
+        @line = ' # :PROCESS: sortail, "sort | tail"'
+      end
+
+      it "should add the process to the library" do
+        @librarian.should_receive(:add_process!).with("sortail", "sort | tail")
+        @it << @line
+      end
+    end
+
+  end
+end 

data/spec/germinate/selector_spec.rb

@@ -0,0 +1,65 @@
+require File.expand_path(
+    File.join(File.dirname(__FILE__), %w[.. .. lib germinate]))
+
+module Germinate
+  describe Selector do
+    EXAMPLE_SELECTORS = [
+      # selector       type      key        delim  start end length pipeline
+      [ "@A",          :code,    "A",       '..',  1,    -1, nil,   []     ],
+      [ "@A:1",        :code,    "A",       nil,   1,    1,  nil,   []     ],
+      [ "",            :code,    "DEFAULT", '..',  1,    -1, nil,   []     ],
+      [ nil,           :code,    "DEFAULT", '..',  1,    -1, nil,   []     ],
+      [ ":2..4",       :code,    "DEFAULT", '..',  2,    4,  nil,   []     ],
+      [ ":2...4",      :code,    "DEFAULT", '...', 2,    4,  nil,   []     ],
+      [ "@B:2,5",      :code,    "B",       ',',   2,    nil,5,     []     ],
+      [ "@B:/z/,6",    :code,    "B",       ',',   /z/,  nil,6,     []     ],
+      [ "@_:/z/../x/", :code,    "_",       '..',  /z/,  /x/,nil,   []     ],
+      [ "@B:2,4|fnord",:code,    "B",       ',',   2,    nil,4,     ["fnord"]],
+      [ "$FOO",        :special, "FOO",     '..',  1,    -1, nil,   []     ],
+      [ "@A|foo|bar",  :code,    "A",       '..',  1,    -1, nil,   ["foo", "bar"]],
+    ]
+
+    EXAMPLE_SELECTORS.each do |selector_attributes| 
+      selector_string = selector_attributes[0]
+      type            = selector_attributes[1]
+      key             = selector_attributes[2]
+      delimiter       = selector_attributes[3]
+      start           = selector_attributes[4]
+      end_offset      = selector_attributes[5]
+      length          = selector_attributes[6]
+      pipeline        = selector_attributes[7]
+
+      context "given selector '#{selector_attributes[0]}'" do
+        before :each do
+          @it = Germinate::Selector.new(selector_string, "DEFAULT")
+        end
+
+        it "should have string #{selector_string}" do
+          @it.string.should == selector_string
+        end
+
+        it "should have type #{type.inspect}" do
+          @it.selector_type.should == type 
+        end
+        it "should have key #{key.inspect}" do
+          @it.key.should == key 
+        end
+        it "should start at #{start.inspect}" do
+          @it.start_offset.should == start 
+        end
+        it "should end at #{end_offset.inspect}" do 
+          @it.end_offset.should == end_offset
+        end
+        it "should have length #{length.inspect}" do
+          @it.length.should == length 
+        end
+        it "should have pipeline #{pipeline.inspect}" do
+          @it.pipeline.should == pipeline 
+        end
+        it "should have delimiter #{delimiter.inspect}" do
+          @it.delimiter.should == delimiter
+        end
+      end
+    end
+  end
+end