sheng 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a8b81b58b522c27f9eae0f86940da9f8b92743d5
-  data.tar.gz: 5ba6ec64dd3891eb409550801fde1dbe95cdb4f5
+  metadata.gz: 7c3fd415b575d840f656d108d59c7877453e4b21
+  data.tar.gz: cdfe674b6cc940344dc11a98bc7cd6b049b477e3
 SHA512:
-  metadata.gz: 9c40035114fcc183da71cb81b1e38e315163399fe7925ef1080f35e414d0f8dd800157e0b027ceb3aafdb5f7eb54b90c1d71d9a9e0374e133d969f008a41173e
-  data.tar.gz: 50dc168d3817c280d37e916d77893b8d66ebc81b4c201ce6e1fa90eb4676b9357bb7a2699c7cf20d75672d45fb0aa53c574d12b9e692a3a7161cd7a78a7f18f7
+  metadata.gz: 22bd647f4447af076046039d90c0b51ef5394e93b26032b960db3724b33566e93aafc6d4bf2f2eefc18185433d47980f85f187d578c7eda9befc9614367cdaca
+  data.tar.gz: e63a965701379ab2e5c7082cc88b46909c3945580558adf446a7dbb3d6d43345e900688b5d1e914ebb8721f6105dfefb985bd35f5b3cbe0cf0b53fae9db1a8b4

data/lib/sheng/block.rb

@@ -1,7 +1,7 @@
 module Sheng
   class Block < MergeFieldSet
-    class MissingEndTag < StandardError; end
-    class ImproperNesting < StandardError; end
+    class MissingEndTag < Docx::TemplateError; end
+    class ImproperNesting < Docx::TemplateError; end
 
     def initialize(merge_field)
       @start_field = merge_field

data/lib/sheng/check_box.rb

@@ -1,6 +1,6 @@
 module Sheng
   class CheckBox
-    attr_reader :element, :xml_document
+    attr_reader :element, :xml_document, :errors
 
     class << self
       def from_element(element)
@@ -11,6 +11,7 @@ module Sheng
     def initialize(element = nil)
       @element = element
       @xml_document = element.document
+      @errors = []
     end
 
     def ==(other)
@@ -29,7 +30,8 @@ module Sheng
       value = data_set.fetch(key)
       checked_attribute = @element.search('.//w:default').first.attribute('val')
       checked_attribute.value = value_is_truthy?(value) ? '1' : '0'
-    rescue DataSet::KeyNotFound
+    rescue DataSet::KeyNotFound => e
+      @errors << e
       # Ignore this error; if the key for this checkbox is not found in the
       # data set, we don't want to uncheck the checkbox; we just want to leave
       # it alone.

data/lib/sheng/data_set.rb

@@ -1,6 +1,6 @@
 module Sheng
   class DataSet
-    class KeyNotFound < StandardError; end
+    class KeyNotFound < Sheng::Error; end
 
     attr_accessor :raw_hash
 
@@ -29,7 +29,7 @@ module Sheng
           if options.has_key?(:default)
             value = options[:default]
           else
-            raise KeyNotFound, "did not find in dataset: #{key} (#{key_part} not found)"
+            raise KeyNotFound, "#{key} (at #{key_part})"
           end
         end
         if (i + 1) < key_parts.length

data/lib/sheng/docx.rb

@@ -4,8 +4,10 @@
 #
 module Sheng
   class Docx
-    class InvalidFile < StandardError; end
-    class FileAlreadyExists < StandardError; end
+    class InvalidFile < Sheng::Error; end
+    class TemplateError < Sheng::Error; end
+    class OutputPathAlreadyExists < Sheng::Error; end
+    class MergeError < Sheng::Error; end
 
     WMLFileNamePatterns = [
       /word\/document.xml/,
@@ -14,9 +16,12 @@ module Sheng
       /word\/footer(\d)*.xml/
     ]
 
+    attr_reader :errors
+
     def initialize(input_file_path, params)
       @input_zip_file = Zip::File.new(input_file_path)
       @data_set = DataSet.new(params)
+      @errors = {}
     rescue Zip::Error => e
       raise InvalidFile.new(e.message)
     end
@@ -39,10 +44,22 @@ module Sheng
 
     def generate(path, force: false)
       if File.exists?(path) && !force
-        raise FileAlreadyExists, "File at #{path} already exists"
+        raise OutputPathAlreadyExists, "File at #{path} already exists"
+      end
+
+      output_buffer = generate_output_buffer
+
+      if errors.present?
+        raise MergeError.new(errors)
       end
 
-      buffer = Zip::OutputStream.write_buffer do |out|
+      File.open(path, "w") { |f| f.write(output_buffer.string) }
+    end
+
+  private
+
+    def generate_output_buffer
+      Zip::OutputStream.write_buffer do |out|
         begin
           @input_zip_file.entries.each do |entry|
             write_converted_zip_file_to_buffer(entry, out)
@@ -51,18 +68,15 @@ module Sheng
           out.close_buffer
         end
       end
-
-      File.open(path, "w") { |f| f.write(buffer.string) }
     end
 
-  private
-
     def write_converted_zip_file_to_buffer(entry, buffer)
       contents = entry.get_input_stream.read
       buffer.put_next_entry(entry.name)
       if is_wml_file?(entry.name)
         wml_file = WMLFile.new(entry.name, contents)
         buffer.write wml_file.interpolate(@data_set)
+        errors.merge!(wml_file.errors)
       else
         buffer.write contents
       end

data/lib/sheng/filters.rb

@@ -1,6 +1,6 @@
 module Sheng
   module Filters
-    class UnsupportedFilterError < StandardError; end
+    class UnsupportedFilterError < Sheng::Error; end
 
     class << self
       def registry

data/lib/sheng/merge_field.rb

@@ -8,7 +8,7 @@ module Sheng
       key_string: /^(?<prefix>start:|end:|if:|end_if:|unless:|end_unless:)?\s*(?<key>[^\|]+)\s*\|?(?<filters>.*)?/
     }
 
-    class NotAMergeFieldError < StandardError; end
+    class NotAMergeFieldError < Sheng::Error; end
 
     class << self
       def from_element(element)
@@ -18,12 +18,13 @@ module Sheng
       end
     end
 
-    attr_reader :element, :xml_document
+    attr_reader :element, :xml_document, :errors
 
     def initialize(element)
       @element = element
       @xml_document = element.document
       @instruction_text = Sheng::Support.extract_mergefield_instruction_text(element)
+      @errors = []
     end
 
     def ==(other)
@@ -240,7 +241,8 @@ module Sheng
     def interpolate(data_set)
       value = get_value(data_set)
       replace_mergefield(filter_value(value))
-    rescue DataSet::KeyNotFound, Dentaku::UnboundVariableError, Filters::UnsupportedFilterError
+    rescue DataSet::KeyNotFound, Dentaku::UnboundVariableError, Filters::UnsupportedFilterError => e
+      @errors << e
       # Ignore this error; we'll collect all uninterpolated fields later and
       # raise a new exception, so we can list all the fields in an error
       # message.

data/lib/sheng/merge_field_set.rb

@@ -4,17 +4,25 @@ module Sheng
   class MergeFieldSet
     include PathHelpers
 
-    attr_reader :xml_fragment, :xml_document, :key
+    attr_reader :xml_fragment, :xml_document, :key, :errors
 
     def initialize(key, xml_fragment)
       @key = key
       @xml_fragment = xml_fragment
       @xml_document = xml_fragment.document
+      @errors = {}
     end
 
     def interpolate(data_set)
       nodes.each do |node|
         node.interpolate(data_set)
+        add_errors_from_node(node)
+      end
+    end
+
+    def add_errors_from_node(node)
+      if node.errors.present?
+        errors[node.raw_key] = node.errors
       end
     end
 

data/lib/sheng/version.rb

@@ -1,3 +1,3 @@
 module Sheng
-  VERSION = "0.5.0"
+  VERSION = "0.6.0"
 end

data/lib/sheng/wml_file.rb

@@ -1,37 +1,21 @@
 module Sheng
   class WMLFile
-    class InvalidWML < StandardError; end
-    class MergefieldNotReplacedError < StandardError
-      def initialize(unmerged_fields)
-        unmerged_keys = unmerged_fields.map(&:raw_key)
-        super("Mergefields not replaced: #{unmerged_keys.join(', ')}")
-      end
-    end
+    class InvalidWML < Docx::TemplateError; end
 
-    attr_reader :xml, :filename
+    attr_reader :xml, :filename, :errors
 
     def initialize(filename, xml)
       @filename = filename
       @xml = Nokogiri::XML(xml)
+      @errors = {}
     end
 
     def interpolate(data_set)
       parent_set.interpolate(data_set)
-      check_for_full_interpolation!
+      errors.merge!(parent_set.errors)
       parent_set.xml_fragment.to_s
     end
 
-    def check_for_full_interpolation!
-      modified_parent_set = MergeFieldSet.new('main', xml)
-      unmerged_fields = modified_parent_set.basic_nodes.reject { |node|
-        node.is_a?(CheckBox)
-      }
-
-      unless unmerged_fields.empty?
-        raise MergefieldNotReplacedError.new(unmerged_fields)
-      end
-    end
-
     def parent_set
       @parent_set ||= MergeFieldSet.new('main', xml)
     end

data/lib/sheng.rb

@@ -1,6 +1,14 @@
-
 require 'active_support/inflector'
 require 'active_support/core_ext/hash'
+require 'zip'
+require 'nokogiri'
+require 'fileutils'
+require 'json'
+
+module Sheng
+  class Error < StandardError; end
+end
+
 require 'sheng/support'
 require 'sheng/version'
 require 'sheng/data_set'
@@ -12,11 +20,3 @@ require 'sheng/merge_field'
 require 'sheng/sequence'
 require 'sheng/conditional_block'
 require 'sheng/check_box'
-
-require 'zip'
-require 'nokogiri'
-require 'fileutils'
-require 'json'
-
-module Sheng
-end

data/spec/lib/sheng/check_box_spec.rb

@@ -71,17 +71,21 @@ describe Sheng::CheckBox do
       expect(default_checked.xml_document).to be_equivalent_to fragment_with_unchecked_box(default_checked.xml_document)
     end
 
-    it "does not check the checkbox if key is not found in dataset" do
-      dataset = Sheng::DataSet.new({})
+    it "records error and does not check the checkbox if key is not found in dataset" do
+      allow(dataset).to receive(:fetch).with("goats").and_raise(Sheng::DataSet::KeyNotFound, "uhoh")
       subject.interpolate(dataset)
       expect(subject.xml_document).to be_equivalent_to fragment_with_unchecked_box(subject.xml_document)
+      expect(subject.errors.first).to be_a(Sheng::DataSet::KeyNotFound)
+      expect(subject.errors.first.message).to eq("uhoh")
     end
 
-    it "does not uncheck a checked checkbox if key is not found in dataset" do
-      dataset = Sheng::DataSet.new({})
+    it "records error and does not uncheck a checked checkbox if key is not found in dataset" do
+      allow(dataset).to receive(:fetch).with("goats").and_raise(Sheng::DataSet::KeyNotFound, "uhoh")
       default_checked = described_class.new(fragment_with_checked_box(subject.xml_document))
       default_checked.interpolate(dataset)
       expect(default_checked.xml_document).to be_equivalent_to xml_fragment('output/check_box/check_box')
+      expect(default_checked.errors.first).to be_a(Sheng::DataSet::KeyNotFound)
+      expect(default_checked.errors.first.message).to eq("uhoh")
     end
   end
 end

data/spec/lib/sheng/data_set_spec.rb

@@ -43,7 +43,7 @@ describe Sheng::DataSet do
     it 'raises a KeyNotFound error if key not found' do
       expect {
         subject.fetch('rabbits.funky')
-      }.to raise_error(described_class::KeyNotFound, "did not find in dataset: rabbits.funky (funky not found)")
+      }.to raise_error(described_class::KeyNotFound, "rabbits.funky (at funky)")
     end
 
     it 'does not raise error on key not found if default given' do

data/spec/lib/sheng/docx_spec.rb

@@ -26,7 +26,7 @@ describe Sheng::Docx do
       File.open(output_file, "w").write("nothing")
       expect {
         subject.generate(output_file)
-      }.to raise_error(described_class::FileAlreadyExists)
+      }.to raise_error(described_class::OutputPathAlreadyExists)
     end
 
     it 'overwrites file if file already exists but force option is true' do
@@ -63,12 +63,14 @@ describe Sheng::Docx do
       end
     end
 
-    it "should raise an error when one or more mergefields isn't merged" do
+    it "should raise an exception and set errors 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")
+      }.to raise_error(Sheng::Docx::MergeError)
+      expect(doc.errors.keys).to eq(["first_name", "last_name"])
+      expect(doc.errors["first_name"].map(&:message)).to eq(["first_name (at first_name)"])
     end
 
     shared_examples_for 'a bad document' do |filename, error, error_message = nil|
@@ -81,16 +83,16 @@ describe Sheng::Docx do
     end
 
     it_should_behave_like 'a bad document', 'with_field_not_in_dataset.docx',
-      Sheng::WMLFile::MergefieldNotReplacedError
+      Sheng::Docx::MergeError, {"extra_name"=>[Sheng::DataSet::KeyNotFound.new("extra_name (at extra_name)")] }.to_s
 
     it_should_behave_like 'a bad document', 'with_unended_sequence.docx',
-      Sheng::Sequence::MissingEndTag, "no end tag for start:owner_signature"
+      Sheng::Docx::TemplateError, "no end tag for start:owner_signature"
 
     it_should_behave_like 'a bad document', 'with_missing_sequence_start.docx',
-      Sheng::WMLFile::MergefieldNotReplacedError
+      Sheng::Docx::MergeError, {"end:owner_signature"=>[Sheng::DataSet::KeyNotFound.new("owner_signature (at owner_signature)")] }.to_s
 
     it_should_behave_like 'a bad document', 'with_poorly_nested_sequences.docx',
-      Sheng::Sequence::ImproperNesting, "expected end tag for start:birds, got end:animals"
+      Sheng::Docx::TemplateError, "expected end tag for start:birds, got end:animals"
   end
 
   describe '#new' do

data/spec/lib/sheng/merge_field_set_spec.rb

@@ -4,11 +4,35 @@ describe Sheng::MergeFieldSet do
 
   describe '#interpolate' do
     it 'iterates through nodes and calls interpolate on each' do
-      node1, node2 = double('Node'), double('Node')
+      node1, node2 = double('Node', errors: []), double('Node', errors: [])
       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)
+      expect(subject.errors).to be_empty
+    end
+
+    context "with mergefields that raise errors on interpolation" do
+      it "should compile all errors" do
+        node1, node2, node3 =
+          double('Node', raw_key: "node1"),
+          double('Node', raw_key: "node2"),
+          double('Node', raw_key: "node3")
+        allow(node1).to receive(:interpolate).with(:the_data_set)
+        allow(node2).to receive(:interpolate).with(:the_data_set)
+        allow(node3).to receive(:interpolate).with(:the_data_set)
+        allow(node1).to receive(:errors).and_return(["stupid", "oops"])
+        allow(node2).to receive(:errors).and_return({ "node4" => ["uhoh", "darnit"] })
+        allow(node3).to receive(:errors).and_return([])
+        allow(subject).to receive(:nodes).and_return([node1, node2, node3])
+        subject.interpolate(:the_data_set)
+        expect(subject.errors).to eq({
+          "node1" => ["stupid", "oops"],
+          "node2" => {
+            "node4" => ["uhoh", "darnit"]
+          }
+        })
+      end
     end
 
     context "with fields that are not valid mergefields" do

data/spec/lib/sheng/merge_field_spec.rb

@@ -212,23 +212,34 @@ describe Sheng::MergeField do
       expect(subject.xml_document).to be_equivalent_to xml_fragment('output/merge_field/merge_field')
     end
 
-    it "does not replace and returns nil if any keys not found" do
-      allow(subject).to receive(:get_value).with(:a_dataset).and_raise(Sheng::DataSet::KeyNotFound)
+    it "does not replace, records error, and returns nil if any keys not found" do
+      allow(subject).to receive(:get_value).with(:a_dataset).and_raise(Sheng::DataSet::KeyNotFound.new("horses"))
       expect(subject).to receive(:replace_mergefield).never
       expect(subject.interpolate(:a_dataset)).to be_nil
+      expect(subject.errors.first).to be_a(Sheng::DataSet::KeyNotFound)
+      expect(subject.errors.first.message).to eq("horses")
     end
 
-    it "does not replace and returns nil if calculation error encountered" do
-      allow(subject).to receive(:get_value).with(:a_dataset).and_raise(Dentaku::UnboundVariableError.new([]))
+    it "does not replace, records error, and returns nil if calculation error encountered" do
+      allow(subject).to receive(:get_value).with(:a_dataset).and_raise(Dentaku::UnboundVariableError.new([:foo, :bar]))
       expect(subject).to receive(:replace_mergefield).never
       expect(subject.interpolate(:a_dataset)).to be_nil
+      expect(subject.errors.first).to be_a(Dentaku::UnboundVariableError)
+      expect(subject.errors.first.unbound_variables).to eq([:foo, :bar])
     end
 
-    it "does not replace and returns nil if unsupported filter requested" do
+    it "does not replace, records error, and returns nil if unsupported filter requested" do
       allow(subject).to receive(:get_value).with(:a_dataset).and_return(:got_value)
-      allow(subject).to receive(:filter_value).with(:got_value).and_raise(Sheng::Filters::UnsupportedFilterError)
+      allow(subject).to receive(:filter_value).with(:got_value).and_raise(Sheng::Filters::UnsupportedFilterError.new("woof"))
       expect(subject).to receive(:replace_mergefield).never
       expect(subject.interpolate(:a_dataset)).to be_nil
+      expect(subject.errors.first).to be_a(Sheng::Filters::UnsupportedFilterError)
+      expect(subject.errors.first.message).to eq("woof")
+    end
+
+    it "does not rescue other exceptions" do
+      allow(subject).to receive(:get_value).with(:a_dataset).and_raise(NoMethodError)
+      expect { subject.interpolate(:a_dataset) }.to raise_error(NoMethodError)
     end
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sheng
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Ravi Gadad
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-24 00:00:00.000000000 Z
+date: 2016-05-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler