sheng 0.3.2

data/spec/lib/sheng/docx_spec.rb

@@ -0,0 +1,146 @@
+describe Sheng::Docx do
+  let(:output_file) { "/tmp/sheng_output_document.docx" }
+  let(:expected_output_file) { fixture_path("docx_files/output_document.docx") }
+  let(:input_file) { fixture_path("docx_files/input_document.docx") }
+  let(:input_hash) { JSON.parse(File.read(fixture_path("inputs/complete.json"))) }
+  let(:mutable_documents) {
+    ['word/document.xml', 'word/numbering.xml', 'word/header1.xml']
+  }
+
+  subject { described_class.new(input_file, input_hash) }
+
+  after(:each) do
+    FileUtils.rm(output_file) if File.exists?(output_file)
+  end
+
+  describe '#generate' do
+    it 'should produce the same document as fixtures output_file' do
+      subject.generate(output_file)
+      in_mutable_wml_files(output_file) do |file_name, output_wml|
+        expected_wml = Zip::File.new(expected_output_file).read(file_name)
+        expect(output_wml).to be_equivalent_to expected_wml
+      end
+    end
+
+    it 'raises an exception if file already exists and force option not given' do
+      File.open(output_file, "w").write("nothing")
+      expect {
+        subject.generate(output_file)
+      }.to raise_error(described_class::FileAlreadyExists)
+    end
+
+    it 'overwrites file if file already exists but force option is true' do
+      File.open(output_file, "w").write("nothing")
+      subject.generate(output_file, force: true)
+      in_mutable_wml_files(output_file) do |file_name, output_wml|
+        expected_wml = Zip::File.new(expected_output_file).read(file_name)
+        expect(output_wml).to be_equivalent_to expected_wml
+      end
+    end
+
+    describe "with older style mergefields" do
+      let(:expected_output_file) { fixture_path("docx_files/old_style/output_document.docx") }
+      let(:input_file) { fixture_path("docx_files/old_style/input_document.docx") }
+
+      it 'still works' do
+        subject.generate(output_file)
+        in_mutable_wml_files(output_file) do |file_name, output_wml|
+          expected_wml = Zip::File.new(expected_output_file).read(file_name)
+          expect(output_wml).to be_equivalent_to expected_wml
+        end
+      end
+    end
+
+    it "should replace all mergefields when given all mergefield values" do
+      subject.generate(output_file)
+      Zip::File.new(output_file).entries.each do |file|
+        if mutable_documents.include?(file.name)
+          Zip::File.open(output_file) do |zip|
+            xml = zip.read(file)
+            expect(Nokogiri::XML(xml).xpath("//w:fldSimple[contains(@w:instr, 'MERGEFIELD')]")).to be_empty
+          end
+        end
+      end
+    end
+
+    it "should raise an error when one or more mergefields isn't merged" do
+      incomplete_hash = JSON.parse(File.read(fixture_path("inputs/incomplete.json")))
+      doc = described_class.new(input_file, incomplete_hash)
+      expect {
+        doc.generate(output_file)
+      }.to raise_error(Sheng::WMLFile::MergefieldNotReplacedError, "Mergefields not replaced: first_name, last_name")
+    end
+
+    shared_examples_for 'a bad document' do |filename, error, error_message = nil|
+      it "should raise #{error} when given #{filename}" do
+        doc = described_class.new(fixture_path("bad_docx_files/#{filename}"), input_hash)
+        expect {
+          doc.generate(output_file)
+        }.to raise_error(error, error_message)
+      end
+    end
+
+    it_should_behave_like 'a bad document', 'with_field_not_in_dataset.docx',
+      Sheng::WMLFile::MergefieldNotReplacedError
+
+    it_should_behave_like 'a bad document', 'with_unended_sequence.docx',
+      Sheng::Sequence::MissingEndTag, "no end tag for start:owner_signature"
+
+    it_should_behave_like 'a bad document', 'with_missing_sequence_start.docx',
+      Sheng::WMLFile::MergefieldNotReplacedError
+
+    it_should_behave_like 'a bad document', 'with_poorly_nested_sequences.docx',
+      Sheng::Sequence::ImproperNesting, "expected end tag for start:birds, got end:animals"
+  end
+
+  describe '#new' do
+    it "should raise an error if zip file not found" do
+      expect {
+        described_class.new('definitely/not/a/real/path', {})
+      }.to raise_error(described_class::InvalidFile, "File definitely/not/a/real/path not found")
+    end
+
+    it "should raise an ArgumentError if params is not a hash" do
+      allow(Sheng::DataSet).to receive(:new).with(:not_a_hash).and_raise(ArgumentError)
+      expect {
+        described_class.new(input_file, :not_a_hash)
+      }.to raise_error(ArgumentError)
+    end
+  end
+
+  context 'with fake document' do
+    let(:zip_double) {
+      entry1 = double(Zip::Entry, :name => 'word/document.xml', :get_input_stream => :document)
+      entry2 = double(Zip::Entry, :name => 'word/footer2.xml', :get_input_stream => :footer2)
+      entry3 = double(Zip::Entry, :name => 'not_wml.xml', :get_input_stream => :not_wml)
+
+      double(Zip::File, :entries => [entry1, entry2, entry3])
+    }
+    subject { described_class.new('a_fake_file.docx', {}) }
+
+    before(:each) do
+      allow(Sheng::WMLFile).to receive(:new).with('word/document.xml', :document).
+        and_return(double(:filename => 'word/document.xml', :to_tree => :document_tree, :required_hash => { :a => [{ :b => 1 }] }))
+      allow(Sheng::WMLFile).to receive(:new).with('word/footer2.xml', :footer2).
+        and_return(double(:filename => 'word/footer2.xml', :to_tree => :footer2_tree, :required_hash => { :a => [{ :c => 2 }] }))
+      allow(Zip::File).to receive(:new).with('a_fake_file.docx').and_return(zip_double)
+    end
+
+    describe '#to_tree' do
+      it "returns trees for every WML file in document" do
+        expect(subject.to_tree).to eq([
+          { :file => 'word/document.xml', :tree => :document_tree },
+          { :file => 'word/footer2.xml', :tree => :footer2_tree }
+        ])
+      end
+    end
+
+    describe '#required_hash' do
+      it "returns deep merged #required_hash values from all WML files" do
+        expect(subject.required_hash).to eq({
+          :a => [{ :b => 1, :c => 2 }]
+        })
+      end
+    end
+  end
+end

data/spec/lib/sheng/merge_field_set_spec.rb

@@ -0,0 +1,165 @@
+describe Sheng::MergeFieldSet do
+  let(:fragment) { xml_fragment('input/merge_field_set/merge_field_set') }
+  subject { described_class.new('key', fragment) }
+
+  describe '#interpolate' do
+    it 'iterates through nodes and calls interpolate on each' do
+      node1, node2 = double('Node'), double('Node')
+      expect(node1).to receive(:interpolate).with(:the_data_set)
+      expect(node2).to receive(:interpolate).with(:the_data_set)
+      allow(subject).to receive(:nodes).and_return([node1, node2])
+      subject.interpolate(:the_data_set)
+    end
+
+    context "with fields that are not valid mergefields" do
+      let(:fragment) { xml_fragment('input/merge_field_set/with_non_mergefield_fields') }
+
+      it "ignores the non-mergefield fields and interpolates the rest" do
+        dataset = Sheng::DataSet.new({ :color => "browns" })
+
+        subject.interpolate(dataset)
+        expect(subject.xml_fragment).to be_equivalent_to xml_fragment('output/merge_field_set/with_non_mergefield_fields')
+      end
+    end
+
+    it 'returns expected interpolated fragment' do
+      dataset = Sheng::DataSet.new({
+        :person => {
+          :first_name => 'Brad',
+          :last_name => 'Tucklemoof',
+          :socks => [
+            { :color => 'Green', :size => 'Stumungous' },
+            { :color => 'Whitish', :size => 'Teensy' }
+          ]
+        },
+        :veggies => { :green => { :spinach => true } }
+      })
+
+      subject.interpolate(dataset)
+      expect(subject.xml_fragment).to be_equivalent_to xml_fragment('output/merge_field_set/merge_field_set')
+    end
+
+    context "with complex nesting and reuse" do
+      let(:fragment) { xml_fragment('input/merge_field_set/complex_nesting_and_reuse') }
+      it 'works' do
+        dataset = Sheng::DataSet.new({
+          :people => [
+            {
+              :first_name => "Bringo",
+              :last_name => "Brango",
+              :favorites => {
+                :color => "Ghost",
+                :numbers => [1, "maybe", 0],
+                :loves_candy => false
+              }
+            },
+            {
+              :first_name => "Uncle",
+              :last_name => "Hork",
+              :favorites => {
+                :color => "Xi",
+                :numbers => ["unicorn", "paper"],
+                :loves_candy => true
+              }
+            }
+          ],
+          :frogs => [
+            {
+              :warts => "bioluminescent",
+              :legs => "yak",
+              :feelings => ["insignificant", "worthless"]
+            },
+            {
+              :warts => 198,
+              :legs => "silky smooth",
+              :feelings => ["stylish", "nap"]
+            }
+          ],
+          :king => {
+            :house => {
+              :windows => "bony",
+              :doors => "pig"
+            }
+          }
+        })
+
+        subject.interpolate(dataset)
+        expect(subject.xml_fragment).to be_equivalent_to xml_fragment('output/merge_field_set/complex_nesting_and_reuse')
+      end
+    end
+  end
+
+  describe '#to_tree' do
+    it 'returns array of nodes for set, with nested sequences' do
+      expect(subject.to_tree).to eq tree_fixture('merge_field_set')
+    end
+
+    it 'returns proper tree with embedded sequence' do
+      subject = described_class.new('key', xml_fragment('input/sequence/embedded_sequence'))
+      expect(subject.to_tree).to eq tree_fixture('embedded_sequence')
+    end
+
+    it 'throws exception if sequence missing end tag' do
+      subject = described_class.new('key', xml_fragment('input/sequence/bad/unclosed_sequence'))
+      expect {
+        subject.to_tree
+      }.to raise_error(Sheng::Sequence::MissingEndTag, "no end tag for start:library.books")
+    end
+
+    it 'throws exception if sequence nesting is wrong' do
+      subject = described_class.new('key', xml_fragment('input/sequence/bad/badly_nested_sequence'))
+      expect {
+        subject.to_tree
+      }.to raise_error(Sheng::Sequence::ImproperNesting, "expected end tag for start:birds, got end:animals")
+    end
+  end
+
+  describe '#required_hash' do
+    it 'returns skeleton hash demonstrating required data for interpolation' do
+      expect(subject.required_hash).to eq({
+        "person" => { "first_name" => nil, "last_name" => nil, "socks" => [{"color"=>nil, "size"=>nil}] },
+        "veggies"=> { "green" => { "spinach" => nil } }
+      })
+    end
+
+    it 'uses given value as placeholder for mergefields/checkboxes' do
+      expect(subject.required_hash(:foo)).to eq({
+        "person" => { "first_name" => :foo, "last_name" => :foo, "socks" => [{"color"=>:foo, "size"=>:foo}] },
+        "veggies"=> { "green" => { "spinach" => :foo } }
+      })
+    end
+
+    context "with multiple blocks using the same variable" do
+      let(:fragment) { xml_fragment('input/merge_field_set/complex_nesting_and_reuse') }
+
+      it 'properly merges all requirements when multiple blocks reuse the same variable' do
+        expect(subject.required_hash).to eq({
+          "people" => [
+            {
+              "first_name" => nil,
+              "last_name" => nil,
+              "favorites" => {
+                "color" => nil,
+                "numbers" => [],
+                "loves_candy" => nil
+              }
+            }
+          ],
+          "frogs" => [
+            {
+              "warts" => nil,
+              "legs" => nil,
+              "feelings" => []
+            }
+          ],
+          "king" => {
+            "house" => {
+              "windows" => nil,
+              "doors" => nil
+            }
+          }
+        })
+      end
+    end
+  end
+end

data/spec/lib/sheng/merge_field_spec.rb

@@ -0,0 +1,276 @@
+describe Sheng::MergeField do
+  let(:fragment) { xml_fragment('input/merge_field/merge_field') }
+  let(:element) { fragment.xpath("//w:fldSimple[contains(@w:instr, 'MERGEFIELD')]").first }
+  subject { described_class.new(element) }
+
+  describe ".from_element" do
+    it "returns a new MergeField for the given element" do
+      expect(described_class.from_element(element)).to eq(subject)
+    end
+
+    context "when given a new-style non-mergefield" do
+      let(:fragment) { xml_fragment('input/merge_field/bad/not_a_real_mergefield_new') }
+      let(:element) { fragment.xpath("//w:fldChar[contains(@w:fldCharType, 'begin')]").first }
+
+      it "returns nil" do
+        expect(described_class.from_element(element)).to be_nil
+      end
+    end
+
+    context "when given an old-style non-mergefield" do
+      let(:fragment) { xml_fragment('input/merge_field/bad/not_a_real_mergefield_old') }
+      let(:element) { fragment.xpath("//w:fldSimple").first }
+
+      it "returns nil" do
+        expect(described_class.from_element(element)).to be_nil
+      end
+    end
+  end
+
+  describe "new style merge field" do
+    let(:fragment) { xml_fragment('input/merge_field/new_merge_field') }
+    let(:element) { fragment.xpath("//w:fldChar[contains(@w:fldCharType, 'begin')]").first }
+
+    describe '#raw_key' do
+      it 'returns the mergefield name from the element' do
+        expect(subject.raw_key).to eq 'ocean.fishy'
+      end
+    end
+
+    describe '#interpolate' do
+      it 'interpolates values from dataset into mergefield' do
+        dataset = Sheng::DataSet.new({
+          :ocean => { :fishy => "scrumblefish" }
+        })
+
+        allow(subject).to receive(:filter_value).with("scrumblefish").and_return("l33tphish")
+        subject.interpolate(dataset)
+        expect(subject.xml_document).to be_equivalent_to xml_fragment('output/merge_field/merge_field')
+      end
+    end
+
+    describe "#xml" do
+      it "returns full nodeset surrounding element" do
+        expect(subject.xml.count).to eq(5)
+        expect(subject.xml[0]).to eq(element.ancestors[0])
+      end
+    end
+
+    describe "with split mergefield instruction text runs" do
+      let(:fragment) { xml_fragment('input/merge_field/split_merge_field') }
+
+      describe '#interpolate' do
+        it 'works' do
+          dataset = Sheng::DataSet.new({
+            :persimmon_face => "Lavender"
+          })
+
+          subject.interpolate(dataset)
+          expect(subject.xml_document).to be_equivalent_to xml_fragment('output/merge_field/split_merge_field')
+        end
+      end
+    end
+
+    describe "with mergefields in line with other text" do
+      let(:fragment) { xml_fragment('input/merge_field/inline_merge_field') }
+
+      describe '#interpolate' do
+        it 'works' do
+          dataset = Sheng::DataSet.new({
+            :prefix => "snuffle"
+          })
+
+          subject.interpolate(dataset)
+          expect(subject.xml_document).to be_equivalent_to xml_fragment('output/merge_field/inline_merge_field')
+        end
+      end
+    end
+
+    describe "with badly formed mergefield tags" do
+      let(:fragment) { xml_fragment('input/merge_field/bad/unclosed_merge_field') }
+
+      describe ".new" do
+        it "raises an exception" do
+          expect {
+            subject
+          }.to raise_error(described_class::NotAMergeFieldError, "MERGEFIELD  this_has_a_beginning_but_no_")
+        end
+      end
+    end
+
+    context "when not an actual mergefield" do
+      let(:fragment) { xml_fragment('input/merge_field/bad/not_a_real_mergefield_new') }
+
+      describe ".new" do
+        it "raises an exception" do
+          expect {
+            subject
+          }.to raise_error(described_class::NotAMergeFieldError, "PAGE   \\* MERGEFORMAT ")
+        end
+      end
+    end
+  end
+
+  describe ".new" do
+    context "when not actually a mergefield" do
+      let(:fragment) { xml_fragment('input/merge_field/bad/not_a_real_mergefield_old') }
+      let(:element) { fragment.xpath("//w:fldSimple").first }
+
+      it "raises an exception" do
+        expect {
+          subject
+        }.to raise_error(described_class::NotAMergeFieldError, " PAGE  \\* MERGEFORMAT ")
+      end
+    end
+  end
+
+  describe '#interpolate' do
+    it 'interpolates filtered values from dataset into mergefield' do
+      dataset = Sheng::DataSet.new({
+        :ocean => { :fishy => "scrumblefish" }
+      })
+
+      allow(subject).to receive(:filter_value).with("scrumblefish").and_return("l33tphish")
+      subject.interpolate(dataset)
+      expect(subject.xml_document).to be_equivalent_to xml_fragment('output/merge_field/merge_field')
+    end
+  end
+
+  describe "#xml" do
+    it "returns element" do
+      expect(subject.xml).to eq(subject.element)
+    end
+  end
+
+  describe '#raw_key' do
+    it 'returns the mergefield name from the element' do
+      expect(subject.raw_key).to eq 'ocean.fishy'
+    end
+  end
+
+  describe '#key' do
+    it 'returns the raw key with start/end metadata stripped off' do
+      allow(subject).to receive(:raw_key).and_return('start:whipple.dooter')
+      expect(subject.key).to eq 'whipple.dooter'
+      allow(subject).to receive(:raw_key).and_return('end:smunch.dooter')
+      expect(subject.key).to eq 'smunch.dooter'
+    end
+
+    it 'returns the raw key with filters stripped off' do
+      allow(subject).to receive(:raw_key).and_return("whumpies | cook | dress(frock)")
+      expect(subject.key).to eq 'whumpies'
+    end
+  end
+
+  describe "#filters" do
+    it "returns filters extracted from raw_key" do
+      allow(subject).to receive(:raw_key).and_return("whumpies | cook | dress(frock)")
+      expect(subject.filters).to eq(["cook", "dress(frock)"])
+    end
+
+    it "doesn't care about whitespace" do
+      allow(subject).to receive(:raw_key).and_return("whumpies|cook|dress(frock)")
+      expect(subject.filters).to eq(["cook", "dress(frock)"])
+    end
+
+    it "returns empty array if no filters in raw key" do
+      allow(subject).to receive(:raw_key).and_return("whatever.this.is")
+      expect(subject.filters).to eq([])
+    end
+  end
+
+  describe "#is_start?" do
+    it "returns true if mergefield is start of block" do
+      allow(subject).to receive(:raw_key).and_return("start:whatever")
+      expect(subject.is_start?).to be_truthy
+      allow(subject).to receive(:raw_key).and_return("if:whatever")
+      expect(subject.is_start?).to be_truthy
+      allow(subject).to receive(:raw_key).and_return("unless:whatever")
+      expect(subject.is_start?).to be_truthy
+    end
+
+    it "returns false if mergefield is end of block" do
+      allow(subject).to receive(:raw_key).and_return("end:whatever")
+      expect(subject.is_start?).to be_falsy
+    end
+
+    it "returns false if mergefield is not a block bracket" do
+      allow(subject).to receive(:raw_key).and_return("whatever")
+      expect(subject.is_start?).to be_falsy
+    end
+  end
+
+  describe "#is_end?" do
+    it "returns true if mergefield is end of block" do
+      allow(subject).to receive(:raw_key).and_return("end:whatever")
+      expect(subject.is_end?).to be_truthy
+      allow(subject).to receive(:raw_key).and_return("end_if:whatever")
+      expect(subject.is_end?).to be_truthy
+      allow(subject).to receive(:raw_key).and_return("end_unless:whatever")
+      expect(subject.is_end?).to be_truthy
+    end
+
+    it "returns false if mergefield is start of block" do
+      allow(subject).to receive(:raw_key).and_return("start:whatever")
+      expect(subject.is_end?).to be_falsy
+    end
+
+    it "returns false if mergefield is not a block bracket" do
+      allow(subject).to receive(:raw_key).and_return("whatever")
+      expect(subject.is_end?).to be_falsy
+    end
+  end
+
+  describe "#filter_value" do
+    it "can upcase" do
+      allow(subject).to receive(:filters).and_return(["upcase"])
+      expect(subject.filter_value("HorSes")).to eq("HORSES")
+    end
+
+    it "can downcase" do
+      allow(subject).to receive(:filters).and_return(["downcase"])
+      expect(subject.filter_value("HorSes")).to eq("horses")
+    end
+
+    it "can reverse" do
+      allow(subject).to receive(:filters).and_return(["reverse"])
+      expect(subject.filter_value("Maple")).to eq("elpaM")
+    end
+
+    it "can titleize" do
+      allow(subject).to receive(:filters).and_return(["titleize"])
+      expect(subject.filter_value("ribbons are grand")).to eq("Ribbons Are Grand")
+    end
+
+    it "can capitalize" do
+      allow(subject).to receive(:filters).and_return(["capitalize"])
+      expect(subject.filter_value("ribbons are grand")).to eq("Ribbons are grand")
+    end
+
+    it "works with multiple filters" do
+      allow(subject).to receive(:filters).and_return(["reverse", "capitalize"])
+      expect(subject.filter_value("maple")).to eq("Elpam")
+    end
+
+    it "does nothing if filter not recognized" do
+      allow(subject).to receive(:filters).and_return(["elephantize"])
+      expect(subject.filter_value("ribbons are grand")).to eq("ribbons are grand")
+    end
+
+    it "does nothing if value doesn't respond to filter" do
+      allow(subject).to receive(:filters).and_return(["upcase"])
+      expect(subject.filter_value(130)).to eq(130)
+    end
+  end
+
+  describe "#iteration_variable" do
+    it "returns :item" do
+      expect(subject.iteration_variable).to eq(:item)
+    end
+
+    it "can be overridden with an 'as' filter" do
+      allow(subject).to receive(:raw_key).and_return("lunch.parts | as(tasties)")
+      expect(subject.iteration_variable).to eq(:tasties)
+    end
+  end
+end