ad_hoc_template 0.0.1 → 0.1.0

data/spec/ad_hoc_template_spec.rb

@@ -2,139 +2,14 @@ require 'spec_helper'
 require 'ad_hoc_template'
 
 describe AdHocTemplate do
+
   it 'should have a version number' do
     expect(AdHocTemplate::VERSION).to_not be_nil
   end
 
-  describe AdHocTemplate::Parser do
-    it "returns a tree of TagNode and Leaf" do
-      expect(AdHocTemplate::Parser.parse("a test string with tags (<% the first tag %> and <% the second tag %>) in it")).to eq([["a test string with tags ("],
-                                                                                                                                 [[" the first tag "]],
-                                                                                                                                 [" and "],
-                                                                                                                                 [[" the second tag "]],
-                                                                                                                                 [") in it"]])
-    end
-
-    it "allows to have a nested tag" do
-      expect(AdHocTemplate::Parser.parse("a test string with a nested tag; <% an outer tag and <% an inner tag %> %>")).to eq([["a test string with a nested tag; "],
-                                                                                                                                [[" an outer tag and "],
-                                                                                                                                 [[" an inner tag "]],
-                                                                                                                                 [" "]]])
-    end
-
-    it "may have iteration tags." do
-      tree = AdHocTemplate::Parser.parse("a test string with a nested tag: <%# an iteration tag and <% an inner tag %> #%> and <% another tag %>")
-      expect(tree).to eq([["a test string with a nested tag: "],
-                          [[" an iteration tag and "],
-                           [[" an inner tag "]],
-                           [" "]],
-                          [" and "],
-                         [[" another tag "]]])
-      expect(tree[1]).to be_a_kind_of(AdHocTemplate::Parser::IterationTagNode)
-    end
-  end
-
-  describe AdHocTemplate::RecordReader do
-    it "can read several header type configurations at once." do
-      data = <<CONFIGS
-
-key1-1: value1-1
-key1-2: value1-2
-
-key2-1: value2-1
-key2-2: value2-2
-
-key3-1: value3-1
-key3-2: value3-2
-
-CONFIGS
-
-config = {}
-AdHocTemplate::RecordReader.read_iteration_block(data.each_line.to_a, config, "#configs")
-      expect(config).to eq({"#configs"=>[{"key1-1"=>"value1-1", "key1-2"=>"value1-2"},
-                                         {"key2-1"=>"value2-1", "key2-2"=>"value2-2"},
-                                         {"key3-1"=>"value3-1", "key3-2"=>"value3-2"}]})
-    end
-
-    it "reads configuration data and turns them into a hash object" do
-      data = <<CONFIG
-key1: value1
-key2: value2
-key3: value3
-
-//@block1
-
-the first line of block1
-the second line of block1
-
-the second paragraph in block1
-
-//@block2
-the first line of block2
-the second line of block2
-
-the second paragraph of block2
-CONFIG
-
-expected_config = {
-        "key1" => "value1",
-        "key2" => "value2",
-        "key3" => "value3",
-        "block1" => "the first line of block1\nthe second line of block1\n\nthe second paragraph in block1\n",
-        "block2" => "the first line of block2\nthe second line of block2\n\nthe second paragraph of block2\n"
-      }
-      expect(AdHocTemplate::RecordReader.read_record(data)).to eq(expected_config)
-    end
-
-    it "can read configuration data with 3 different kind of sections" do
-      data = <<CONFIG
-key1: value1
-key2: value2
-key3: value3
-
-//@#subconfigs
-
-key1-1: value1-1
-key1-2: value1-2
-
-key2-1: value2-1
-key2-2: value2-2
-
-//@block
-
-the first line of block
-the second line of block
-
-the second paragraph in block
-
-CONFIG
-
-expected_config = {
-        "key1" => "value1",
-        "key2" => "value2",
-        "key3" => "value3",
-        "#subconfigs" => [{"key1-1"=>"value1-1", "key1-2"=>"value1-2"}, {"key2-1"=>"value2-1", "key2-2"=>"value2-2"}],
-        "block" => "the first line of block\nthe second line of block\n\nthe second paragraph in block\n"
-      }
-      expect(AdHocTemplate::RecordReader.read_record(data)).to eq(expected_config)
-    end
-  end
-
-  describe AdHocTemplate::Converter do
-    it "returns the result of conversion." do
-      template = "a test string with tags (<%= key1 %> and <%= key2 %>) in it"
-      config_data = <<CONFIG
-key1: value1
-key2: value2
-CONFIG
-
-      tree = AdHocTemplate::Parser.parse(template)
-      config = AdHocTemplate::RecordReader.read_record(config_data)
-      expect(AdHocTemplate::Converter.new(config).format(tree)).to eq("a test string with tags (value1 and value2) in it")
-    end
-
-    it "accepts a template with an iteration block and evaluate repeatedly the block" do
-      template = <<TEMPLATE
+  describe AdHocTemplate::DataLoader do
+    before do
+      @template_with_an_iteration_block = <<TEMPLATE
 a test string with tags (<%= key1 %> and <%= key2 %>) in it
 
 <%#iteration_block
@@ -145,7 +20,7 @@ the value of sub_key2 is <%= sub_key2 %>
 <%= block %>
 TEMPLATE
 
-      config_data = <<CONFIG
+      @config_data_with_an_iteration_block = <<CONFIG
 key1: value1
 key2: value2
 key3: value3
@@ -167,7 +42,7 @@ the second paragraph in block
 
 CONFIG
 
-expected_result = <<RESULT
+      @expected_result_with_an_iteration_block = <<RESULT
 a test string with tags (value1 and value2) in it
 
 the value of sub_key1 is value1-1
@@ -176,16 +51,34 @@ the value of sub_key2 is value1-2
 the value of sub_key1 is value2-1
 the value of sub_key2 is value2-2
 
-
 the first line of block
 the second line of block
 
 the second paragraph in block
 
 RESULT
+    end
+
+    it "returns the result of conversion." do
+      template = "a test string with tags (<%= key1 %> and <%= key2 %>) in it"
+      config_data = <<CONFIG
+key1: value1
+key2: value2
+CONFIG
+
       tree = AdHocTemplate::Parser.parse(template)
       config = AdHocTemplate::RecordReader.read_record(config_data)
-      expect(AdHocTemplate::Converter.new(config).format(tree)).to eq(expected_result)
+      expect(AdHocTemplate::DataLoader.new(config).format(tree)).to eq("a test string with tags (value1 and value2) in it")
+    end
+
+    it "accepts a template with an iteration block and evaluate repeatedly the block" do
+      template = @template_with_an_iteration_block
+      config_data = @config_data_with_an_iteration_block
+      expected_result = @expected_result_with_an_iteration_block
+
+      tree = AdHocTemplate::Parser.parse(template)
+      config = AdHocTemplate::RecordReader.read_record(config_data)
+      expect(AdHocTemplate::DataLoader.new(config).format(tree)).to eq(expected_result)
     end
 
     it "may contains iteration blocks without key label." do
@@ -220,30 +113,304 @@ the second paragraph in block
 
 CONFIG
 
-expected_result = <<RESULT
+      expected_result = <<RESULT
 a test string with tags (value1 and value2) in it
 
 the value of key1 is value1
 the value of key2 is value2
 
+the first line of block
+the second line of block
+
+the second paragraph in block
+
+RESULT
+
+      tree = AdHocTemplate::Parser.parse(template)
+      config = AdHocTemplate::RecordReader.read_record(config_data)
+      expect(AdHocTemplate::DataLoader.new(config).format(tree)).to eq(expected_result)
+    end
+
+    it "offers .format method for convenience" do
+      template = @template_with_an_iteration_block
+      config_data = @config_data_with_an_iteration_block
+      expected_result = @expected_result_with_an_iteration_block
+
+      tree = AdHocTemplate::Parser.parse(template)
+      config = AdHocTemplate::RecordReader.read_record(config_data)
+      tag_formatter = AdHocTemplate::DefaultTagFormatter.new
+      expect(AdHocTemplate::DataLoader.format(tree, config, tag_formatter)).to eq(expected_result)
+    end
 
+    it("should not add a newline at the head of IterationTagNode when the type of the node is not specified") do
+      template = <<TEMPLATE
+a test string with tags
+<%#iteration_block
+the value of sub_key1 is <%= sub_key1 %>
+<%#
+  the value of sub_key2 is <%= sub_key2 %>
+#%>
+
+#%>
+<%= block %>
+TEMPLATE
+
+      config_data = <<CONFIG
+//@#iteration_block
+
+sub_key1: value1-1
+sub_key2: value1-2
+
+sub_key1: value2-1
 
+//@block
 
 the first line of block
-the second line of block
+CONFIG
 
-the second paragraph in block
+      expected_result = <<RESULT
+a test string with tags
+the value of sub_key1 is value1-1
+  the value of sub_key2 is value1-2
+
+the value of sub_key1 is value2-1
+
+the first line of block
 
 RESULT
       tree = AdHocTemplate::Parser.parse(template)
       config = AdHocTemplate::RecordReader.read_record(config_data)
-      expect(AdHocTemplate::Converter.new(config).format(tree)).to eq(expected_result)
+      tag_formatter = AdHocTemplate::DefaultTagFormatter.new
+      expect(AdHocTemplate::DataLoader.format(tree, config, tag_formatter)).to eq(expected_result)
     end
 
-    it 'can convert &"<> into character entities' do
-      result = AdHocTemplate::Converter.convert('characters: &, ", < and >',
-                                       'a string with characters (<%h characters %>) that should be represented as character entities.')
-      expect(result).to eq('a string with characters (&amp;, &quot;, &lt; and &gt;) that should be represented as character entities.')
+    describe "iteration block" do
+      before do
+        @template =<<TEMPLATE
+The first line in the main part
+
+<%#
+The first line in the iteration part
+
+<%#iteration_block
+The value of key1 is <%= key1 %>
+#%>
+
+#%>
+TEMPLATE
+
+        @template_with_nested_iteration_tag =<<TEMPLATE
+The first line in the main part
+
+<%#
+The first line in the iteration part
+
+Key value: <%= key %>
+Optinal values: <%# <%= optional1 %> and <%= optional2 %> are in the record.
+#%>
+
+<%#iteration_block
+The value of key1 is <%= key1 %>
+<%#
+The value of optional key2 is <%= key2 %>
+#%>
+#%>
+
+#%>
+TEMPLATE
+
+        @expected_result_when_data_provided =<<RESULT
+The first line in the main part
+
+The first line in the iteration part
+
+The value of key1 is value1
+The value of key1 is value1
+
+RESULT
+
+        @expected_result_for_nested_iteration_tag_when_data_provided =<<RESULT
+The first line in the main part
+
+The first line in the iteration part
+
+Key value: value
+Optinal values:  optinal value1 and [optional2] are in the record.
+
+The value of key1 is value1
+The value of key1 is value1
+The value of optional key2 is value2
+
+RESULT
+      end
+
+      describe "with data in default format" do
+        it "should not ignore the content of an iteration block when some data are provided" do
+          config_data = <<CONFIG
+//@#iteration_block
+
+key1: value1
+
+key1: value1
+CONFIG
+
+          expected_result = @expected_result_when_data_provided
+
+          tree = AdHocTemplate::Parser.parse(@template)
+          config = AdHocTemplate::RecordReader.read_record(config_data)
+          tag_formatter = AdHocTemplate::DefaultTagFormatter.new
+
+          expect(AdHocTemplate::DataLoader.format(tree, config, tag_formatter)).to eq(expected_result)
+        end
+
+        it "should ignore the content of an iteration block if no thing is provided" do
+          config_data = <<CONFIG
+//@#iteration_block
+
+CONFIG
+
+          expected_result =<<RESULT
+The first line in the main part
+
+RESULT
+
+          tree = AdHocTemplate::Parser.parse(@template)
+          config = AdHocTemplate::RecordReader.read_record(config_data)
+          tag_formatter = AdHocTemplate::DefaultTagFormatter.new
+
+          expect(AdHocTemplate::DataLoader.format(tree, config, tag_formatter)).to eq(expected_result)
+        end
+
+        it "may contain nested iteration blocks" do
+          config_data = <<CONFIG
+key: value
+optional1: optinal value1
+
+//@#iteration_block
+
+key1: value1
+
+key1: value1
+key2: value2
+CONFIG
+
+          expected_result = @expected_result_for_nested_iteration_tag_when_data_provided
+
+          tree = AdHocTemplate::Parser.parse(@template_with_nested_iteration_tag)
+          config = AdHocTemplate::RecordReader.read_record(config_data)
+          tag_formatter = AdHocTemplate::DefaultTagFormatter.new
+
+          expect(AdHocTemplate::DataLoader.format(tree, config, tag_formatter)).to eq(expected_result)
+        end
+
+        it "should ignore nested iteration blocks unless data are provided" do
+          config_data = <<CONFIG
+key: 
+optional1: 
+
+//@#iteration_block
+
+key1: 
+
+key1: 
+key2: 
+CONFIG
+
+          expected_result =<<RESULT
+The first line in the main part
+
+RESULT
+
+          tree = AdHocTemplate::Parser.parse(@template_with_nested_iteration_tag)
+          config = AdHocTemplate::RecordReader.read_record(config_data)
+          tag_formatter = AdHocTemplate::DefaultTagFormatter.new
+
+          expect(AdHocTemplate::DataLoader.format(tree, config, tag_formatter)).to eq(expected_result)
+        end
+      end
+
+      describe "with data in YAML format" do
+        it "should not ignore the content of an iteration block when some data are provided" do
+          config_data = <<CONFIG
+'#iteration_block':
+  - key1: value1
+  - key1: value1
+CONFIG
+
+          expected_result = @expected_result_when_data_provided
+
+          tree = AdHocTemplate::Parser.parse(@template)
+          config = AdHocTemplate::RecordReader.read_record(config_data, :yaml)
+          tag_formatter = AdHocTemplate::DefaultTagFormatter.new
+
+          expect(AdHocTemplate::DataLoader.format(tree, config, tag_formatter)).to eq(expected_result)
+        end
+
+        it "should ignore the content of an iteration block if no thing is provided" do
+          config_data = <<CONFIG
+'#iteration_block':
+
+CONFIG
+
+          expected_result =<<RESULT
+The first line in the main part
+
+RESULT
+
+          tree = AdHocTemplate::Parser.parse(@template)
+          config = AdHocTemplate::RecordReader.read_record(config_data, :yaml)
+          tag_formatter = AdHocTemplate::DefaultTagFormatter.new
+
+          expect(AdHocTemplate::DataLoader.format(tree, config, tag_formatter)).to eq(expected_result)
+        end
+
+        it "may contain nested iteration blocks" do
+          config_data = <<CONFIG
+key: value
+optional1: optinal value1
+'#iteration_block':
+  - key1: value1
+  - key1: value1
+    key2: value2
+CONFIG
+
+          expected_result = @expected_result_for_nested_iteration_tag_when_data_provided
+
+          tree = AdHocTemplate::Parser.parse(@template_with_nested_iteration_tag)
+          config = AdHocTemplate::RecordReader.read_record(config_data, :yaml)
+          tag_formatter = AdHocTemplate::DefaultTagFormatter.new
+
+          expect(AdHocTemplate::DataLoader.format(tree, config, tag_formatter)).to eq(expected_result)
+        end
+
+        it "should ignore nested iteration blocks unless data are provided" do
+          config_data = <<CONFIG
+key:
+optional1:
+'#iteration_block':
+  - key1:
+  - key1:
+    key2:
+CONFIG
+
+          expected_result =<<RESULT
+The first line in the main part
+
+RESULT
+
+          tree = AdHocTemplate::Parser.parse(@template_with_nested_iteration_tag)
+          config = AdHocTemplate::RecordReader.read_record(config_data, :yaml)
+          tag_formatter = AdHocTemplate::DefaultTagFormatter.new
+
+          expect(AdHocTemplate::DataLoader.format(tree, config, tag_formatter)).to eq(expected_result)
+        end
+      end
     end
   end
+
+  it 'can convert &"<> into character entities' do
+    result = AdHocTemplate.convert('characters: &, ", < and >',
+                                   'a string with characters (<%h characters %>) that should be represented as character entities.')
+    expect(result).to eq('a string with characters (&amp;, &quot;, &lt; and &gt;) that should be represented as character entities.')
+  end
 end