sheng 0.3.2

data/lib/sheng/block.rb

@@ -0,0 +1,59 @@
+module Sheng
+  class Block < MergeFieldSet
+    class MissingEndTag < StandardError; end
+    class ImproperNesting < StandardError; end
+
+    def initialize(merge_field)
+      @start_field = merge_field
+      @key = merge_field.key
+      @xml_document = merge_field.xml_document
+      @xml_fragment, @end_field = get_node_set_and_end_field
+    end
+
+    def raw_key
+      @start_field.raw_key
+    end
+
+    def extract_mergefields(fragment)
+      if fragment.name == "fldSimple"
+        return [MergeField.new(fragment)]
+      end
+      fragment.xpath(".//#{mergefield_element_path}|.//#{new_mergefield_element_path}").map do |field_simple|
+        unless field_simple.at('.//w:checkBox')
+          MergeField.new(field_simple)
+        end
+      end.compact
+    end
+
+    def get_node_set_and_end_field
+      node_set = Nokogiri::XML::NodeSet.new(@start_field.xml_document)
+      next_node, end_field = @start_field, nil
+      embedded_starts = [@start_field]
+      while !end_field
+        next_node = next_node.next_element
+
+        if next_node.nil?
+          raise MissingEndTag, "no end tag for #{@start_field.block_prefix}:#{key}"
+        end
+
+        extract_mergefields(next_node).each do |mergefield|
+          if mergefield.is_start?
+            embedded_starts.push mergefield
+          elsif mergefield.is_end?
+            last_start = embedded_starts.pop
+            if last_start.key != mergefield.key
+              raise ImproperNesting, "expected end tag for #{last_start.block_prefix}:#{last_start.key}, got #{mergefield.block_prefix}:#{mergefield.key}"
+            elsif embedded_starts.empty?
+              end_field = mergefield
+            end
+          end
+        end
+
+        unless end_field
+          node_set << next_node
+        end
+      end
+      [node_set, end_field]
+    end
+  end
+end

data/lib/sheng/check_box.rb

@@ -0,0 +1,43 @@
+module Sheng
+  class CheckBox
+    attr_reader :element, :xml_document
+
+    class << self
+      def from_element(element)
+        new(element)
+      end
+    end
+
+    def initialize(element = nil)
+      @element = element
+      @xml_document = element.document
+    end
+
+    def ==(other)
+      other.is_a?(self.class) && other.element == element
+    end
+
+    def key
+      @element.xpath('.//w:name').first['w:val']
+    end
+
+    def raw_key
+      key
+    end
+
+    def interpolate(data_set)
+      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
+      # 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.
+      nil
+    end
+
+    def value_is_truthy?(value)
+      ['true', '1', 'yes'].include? value.to_s.downcase
+    end
+  end
+end

data/lib/sheng/conditional_block.rb

@@ -0,0 +1,30 @@
+require_relative "block"
+
+module Sheng
+  class ConditionalBlock < Block
+    def interpolate(data_set)
+      variable = data_set.fetch(key, :default => nil)
+      @start_field.remove
+      @end_field.remove
+      if criterion_met?(variable)
+        merge_field_set = MergeFieldSet.new("#{conditional_type}_#{key}", xml_fragment)
+        merge_field_set.interpolate(data_set)
+      else
+        xml_fragment.remove
+      end
+    end
+
+    def conditional_type
+      @start_field.block_prefix
+    end
+
+    def criterion_met?(variable)
+      variable_exists = variable && (variable == true || !variable.empty?)
+      if conditional_type == "if"
+        variable_exists
+      else
+        !variable_exists
+      end
+    end
+  end
+end

data/lib/sheng/data_set.rb

@@ -0,0 +1,45 @@
+module Sheng
+  class DataSet
+    class KeyNotFound < StandardError; end
+
+    attr_accessor :raw_hash
+
+    def initialize(hsh)
+      raise ArgumentError.new("must be initialized with a Hash") unless hsh.is_a?(Hash)
+      @raw_hash = hsh.deep_symbolize_keys
+    end
+
+    def raise_key_too_long(key, key_part)
+      raise KeyNotFound, "in #{key}, #{key_part} did not return a Hash"
+    end
+
+    def raise_key_too_short(key)
+      raise KeyNotFound, "result at #{key} is a Hash"
+    end
+
+    def fetch(key, **options)
+      raise ArgumentError.new("must provide a string") unless key.is_a?(String)
+      key_parts = key.split(/\./)
+      current_result = raw_hash
+
+      key_parts.each_with_index do |key_part, i|
+        begin
+          value = current_result.fetch(key_part.to_sym)
+        rescue KeyError
+          if options.has_key?(:default)
+            value = options[:default]
+          else
+            raise KeyNotFound, "did not find in dataset: #{key} (#{key_part} not found)"
+          end
+        end
+        if (i + 1) < key_parts.length
+          raise_key_too_long(key, key_part) if !(value.is_a?(Hash))
+        end
+        current_result = value
+      end
+
+      raise_key_too_short(key) if current_result.is_a?(Hash)
+      current_result
+    end
+  end
+end

data/lib/sheng/docx.rb

@@ -0,0 +1,75 @@
+#
+# Sheng::Docx - is a base Mediator which delegates responsibilities
+# to another sheng singleton classes, which replace their part of xml.
+#
+module Sheng
+  class Docx
+    class InvalidFile < StandardError; end
+    class FileAlreadyExists < StandardError; end
+
+    WMLFileNamePatterns = [
+      /word\/document.xml/,
+      /word\/numbering.xml/,
+      /word\/header(\d)*.xml/,
+      /word\/footer(\d)*.xml/
+    ]
+
+    def initialize(input_file_path, params)
+      @input_zip_file = Zip::File.new(input_file_path)
+      @data_set = DataSet.new(params)
+    rescue Zip::Error => e
+      raise InvalidFile.new(e.message)
+    end
+
+    def wml_files
+      @wml_files ||= @input_zip_file.entries.map do |entry|
+        if is_wml_file?(entry.name)
+          WMLFile.new(entry.name, entry.get_input_stream)
+        end
+      end.compact
+    end
+
+    def to_tree
+      wml_files.map { |wml| { :file => wml.filename, :tree => wml.to_tree } }
+    end
+
+    def required_hash
+      wml_files.inject({}) { |memo, wml| Sheng::Support.merge_required_hashes(memo, wml.required_hash) }
+    end
+
+    def generate(path, force: false)
+      if File.exists?(path) && !force
+        raise FileAlreadyExists, "File at #{path} already exists"
+      end
+
+      buffer = Zip::OutputStream.write_buffer do |out|
+        begin
+          @input_zip_file.entries.each do |entry|
+            write_converted_zip_file_to_buffer(entry, out)
+          end
+        ensure
+          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)
+      else
+        buffer.write contents
+      end
+    end
+
+    def is_wml_file?(file_name)
+      WMLFileNamePatterns.any? { |regex| file_name.match(regex) }
+    end
+  end
+end

data/lib/sheng/merge_field.rb

@@ -0,0 +1,208 @@
+module Sheng
+  class MergeField
+    AllowedFilters = [:upcase, :downcase, :capitalize, :titleize, :reverse]
+    InstructionTextRegex = /^\s*MERGEFIELD(.*)\\\* MERGEFORMAT\s*$/
+    KeyRegex = /^(start:|end:|if:|end_if:|unless:|end_unless:)?\s*([^\|\s]+)\s*\|?(.*)?/
+
+    class NotAMergeFieldError < StandardError; end
+
+    class << self
+      def from_element(element)
+        new(element)
+      rescue NotAMergeFieldError => e
+        nil
+      end
+    end
+
+    attr_reader :element, :xml_document
+
+    def initialize(element)
+      @element = element
+      @xml_document = element.document
+      @instruction_text = mergefield_instruction_text
+    end
+
+    def ==(other)
+      other.is_a?(self.class) && other.element == element
+    end
+
+    def new_style?
+      element.name == 'fldChar'
+    end
+
+    def key
+      raw_key.gsub(KeyRegex, '\2')
+    end
+
+    def filters
+      match = raw_key.match(KeyRegex)
+      match.captures[2].split("|").map(&:strip)
+    end
+
+    def raw_key
+      @raw_key ||= mergefield_instruction_text.gsub(InstructionTextRegex, '\1').strip
+    end
+
+    def mergefield_instruction_text
+      Sheng::Support.extract_mergefield_instruction_text(element)
+    end
+
+    def styling_paragraph
+      return nil if inline?
+      containing_element.at_xpath(".//w:pPr")
+    end
+
+    def styling_run
+      if new_style?
+        separator_field = element.ancestors[1].at_xpath(".//w:fldChar[contains(@w:fldCharType, 'separate')]")
+        if separator_field
+          separator_field.parent.next_element.at_xpath(".//w:rPr")
+        end
+      else
+        element.at_xpath(".//w:rPr")
+      end
+    end
+
+    def start_key
+      if is_start?
+        "#{block_prefix}:#{key}"
+      elsif block_prefix == "end"
+        "start:#{key}"
+      else
+        "#{block_prefix.gsub(/^end_/, '')}:#{key}"
+      end
+    end
+
+    def block_type
+      return nil unless block_prefix
+      if ["start", "end"].include?(block_prefix)
+        Sequence
+      else
+        ConditionalBlock
+      end
+    end
+
+    def block_prefix
+      @potential_prefix ||= begin
+        potential_prefix = raw_key.match(KeyRegex).captures[0]
+        potential_prefix && potential_prefix.gsub(/\:$/, '')
+      end
+    end
+
+    def is_start?
+      block_prefix && !block_prefix.match(/^end/)
+    end
+
+    def iteration_variable
+      if filters.detect { |f| f =~ /^as\((.*)\)$/ }
+        $1.to_sym
+      else
+        :item
+      end
+    end
+
+    def series_with_commas?
+      filters.detect { |f| f =~ /^series_with_commas/ }
+    end
+
+    def comma_series_conjunction
+      if filters.detect { |f| f =~ /^series_with_commas\((.*)\)$/ }
+        $1
+      else
+        "and"
+      end
+    end
+
+    def is_end?
+      block_prefix && block_prefix.match(/^end/)
+    end
+
+    def remove
+      if inline?
+        xml.remove
+      elsif is_table_row_marker?
+        containing_element.ancestors[1].remove
+      else
+        containing_element.remove
+      end
+    end
+
+    def containing_element
+      parents_until_container = new_style? ? 2 : 1
+      element.ancestors[parents_until_container - 1]
+    end
+
+    def is_table_row_marker?
+      in_table_row? && (is_start? || is_end?)
+    end
+
+    def in_table_row?
+      containing_element.ancestors[1] && containing_element.ancestors[1].name == "tr"
+    end
+
+    def inline?
+      containing_element.children.text != xml.text
+    end
+
+    def add_previous_sibling(fragment_to_add)
+      if inline?
+        [xml].flatten.first.add_previous_sibling(fragment_to_add)
+      elsif is_table_row_marker?
+        containing_element.ancestors[1].add_previous_sibling(fragment_to_add)
+      else
+        containing_element.add_previous_sibling(fragment_to_add)
+      end
+    end
+
+    def next_element
+      if inline?
+        [xml].flatten.last.next_element
+      elsif is_table_row_marker?
+        containing_element.ancestors[1].next_element
+      else
+        containing_element.next_element
+      end
+    end
+
+    def xml
+      return element unless new_style?
+      nodeset = Nokogiri::XML::NodeSet.new(xml_document)
+      current_node = element.parent
+      nodeset << current_node
+      loop do
+        current_node = current_node.next_element
+        nodeset << current_node
+        break if current_node.at_xpath("./w:fldChar[contains(@w:fldCharType, 'end')]")
+      end
+      nodeset
+    end
+
+    def replace_mergefield(value)
+      new_run = Sheng::Support.new_text_run(
+        value, xml_document: xml_document, style_run: styling_run
+      )
+      xml.before(new_run)
+      xml.remove
+    end
+
+    def interpolate(data_set)
+      value = data_set.fetch(key)
+      replace_mergefield(filter_value(value))
+    rescue DataSet::KeyNotFound
+      # 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.
+      nil
+    end
+
+    def filter_value(value)
+      filters.inject(value) { |val, filter|
+        if AllowedFilters.include?(filter.to_sym) && val.respond_to?(filter.to_sym)
+          val.send(filter)
+        else
+          val
+        end
+      }
+    end
+  end
+end

data/lib/sheng/merge_field_set.rb

@@ -0,0 +1,90 @@
+require_relative "path_helpers"
+
+module Sheng
+  class MergeFieldSet
+    include PathHelpers
+
+    attr_reader :xml_fragment, :xml_document, :key
+
+    def initialize(key, xml_fragment)
+      @key = key
+      @xml_fragment = xml_fragment
+      @xml_document = xml_fragment.document
+    end
+
+    def interpolate(data_set)
+      nodes.each do |node|
+        node.interpolate(data_set)
+      end
+    end
+
+    def to_tree
+      nodes.map do |node|
+        hsh = {
+          :type => node.class.name.underscore.gsub(/^sheng\//, ''),
+          :key => node.raw_key
+        }
+        if node.is_a? MergeFieldSet
+          hsh[:nodes] = node.to_tree
+        end
+        hsh
+      end
+    end
+
+    def required_hash(placeholder = nil)
+      return nil if is_a?(Sequence) && array_of_primitives_expected?
+      nodes.inject({}) do |node_list, node|
+        hsh = if node.is_a?(ConditionalBlock)
+          node.required_hash(placeholder)
+        else
+          value = node.is_a?(Block) ? [node.required_hash(placeholder)].compact : placeholder
+          key_parts = node.key.split(/\./)
+          last_key = key_parts.pop
+          key_parts.reverse.inject(last_key => value) do |memo, key|
+            memo = { key => memo }; memo
+          end
+        end
+        Sheng::Support.merge_required_hashes(node_list, hsh)
+      end
+    end
+
+    # Returns an array of nodes for interpolation, which can be a mix of
+    # MergeField, CheckBox, ConditionalBlock, and Sequence instances.
+    def nodes
+      @nodes ||= begin
+        current_block_key = nil
+        basic_nodes.map do |node|
+          next if node.is_a?(CheckBox) && current_block_key
+          if node.is_a? MergeField
+            if current_block_key
+              if node.is_end? && node.start_key == current_block_key
+                current_block_key = nil
+              end
+              next
+            elsif node.is_start?
+              current_block_key = node.start_key
+              node = node.block_type.new(node)
+            end
+          end
+          node
+        end.compact
+      end
+    end
+
+    def basic_nodes
+      basic_node_elements.map { |element|
+        if element.xpath('.//w:checkBox').first
+          CheckBox.from_element(element)
+        else
+          MergeField.from_element(element)
+        end
+      }.compact
+    end
+
+    def basic_node_elements
+      child_nodes = xml_fragment.xpath(".//#{mergefield_element_path}|.//#{new_mergefield_element_path}|.//#{checkbox_element_path}").to_a
+      child_nodes += xml_fragment.select { |element| element.name == "fldSimple" }
+      child_nodes
+    end
+  end
+end

data/lib/sheng/path_helpers.rb

@@ -0,0 +1,15 @@
+module Sheng
+  module PathHelpers
+    def new_mergefield_element_path
+      "w:fldChar[contains(@w:fldCharType, 'begin')]"
+    end
+
+    def mergefield_element_path
+      "w:fldSimple[contains(@w:instr, 'MERGEFIELD')]"
+    end
+
+    def checkbox_element_path
+      "w:checkBox/.."
+    end
+  end
+end

data/lib/sheng/sequence.rb

@@ -0,0 +1,66 @@
+require_relative "block"
+
+module Sheng
+  class Sequence < Block
+    def interpolate(data_set)
+      collection = data_set.fetch(key)
+      if collection.respond_to?(:each_with_index)
+        collection.each_with_index do |item, i|
+          add_sequence_element(item, i, last: i == collection.length - 1)
+        end
+        clean_up
+      end
+    rescue DataSet::KeyNotFound
+      nil
+    end
+
+    def array_of_primitives_expected?
+      return true if nodes.map(&:key).uniq == ["item"]
+      @start_field.iteration_variable != :item
+    end
+
+    def add_sequence_element(member, index, last: false)
+      if series_with_commas? && index > 0
+        @start_field.add_previous_sibling(serial_comma_node(index, last: last))
+      end
+      new_node_set = @start_field.add_previous_sibling(dup_node_set)
+      merge_field_set = MergeFieldSet.new("#{key}_#{index}", new_node_set)
+      member = { @start_field.iteration_variable => member } unless member.is_a?(Hash)
+      merge_field_set.interpolate(DataSet.new(member))
+      if index == 0 || last
+        copy_section_formatting(new_node_set, side: last ? "end" : "start")
+      end
+    end
+
+    def copy_section_formatting(node_set, side:)
+      field = instance_variable_get(:"@#{side}_field")
+      if field.styling_paragraph && field.styling_paragraph.at_xpath(".//w:sectPr")
+        existing_ppr = node_set.at_xpath(".//w:pPr")
+        existing_ppr && existing_ppr.remove
+        node_set.first.prepend_child(field.styling_paragraph.dup)
+      end
+    end
+
+    def clean_up
+      [@start_field, @end_field, xml_fragment].map(&:remove)
+    end
+
+    def dup_node_set
+      xml_fragment.each_with_object(Nokogiri::XML::NodeSet.new(xml_document)) do |child, dup_content|
+        dup_content << child.dup
+      end
+    end
+
+    def series_with_commas?
+      @start_field.series_with_commas?
+    end
+
+    def serial_comma_node(index, last: false)
+      content = ", #{last ? "#{@start_field.comma_series_conjunction} " : ""}"
+      content.gsub!(/\,/, '') if last && index == 1
+      Sheng::Support.new_text_run(
+        content, xml_document: xml_document, space_preserve: true
+      )
+    end
+  end
+end

data/lib/sheng/support.rb

@@ -0,0 +1,57 @@
+module Sheng
+  module Support
+    class << self
+      def merge_required_hashes(hsh1, hsh2)
+        hsh1.merge(hsh2) do |key, old_value, new_value|
+          if [old_value, new_value].all? { |v| v.is_a?(Hash) }
+            merge_required_hashes(old_value, new_value)
+          elsif [old_value, new_value].all? { |v| v.is_a?(Array) } && !old_value.empty?
+            [merge_required_hashes(old_value.first, new_value.first)]
+          else
+            new_value
+          end
+        end
+      end
+
+      def new_text_run(value, xml_document:, style_run: nil, space_preserve: false)
+        r_tag = new_tag('r', xml_document: xml_document)
+        if style_run
+          r_tag.add_child(style_run)
+        end
+        t_tag = new_tag('t', xml_document: xml_document)
+        if space_preserve
+          t_tag["xml:space"] = "preserve"
+        end
+        t_tag.content = value
+        r_tag.add_child(t_tag)
+        r_tag
+      end
+
+      def new_tag(tag_name, xml_document:)
+        tag = Nokogiri::XML::Node.new(tag_name, xml_document)
+        tag.namespace = xml_document.root.namespace_definitions.find { |ns| ns.prefix == "w" }
+        tag
+      end
+
+      def extract_mergefield_instruction_text(element)
+        if element.name == 'fldSimple'
+          label = element['w:instr']
+        else
+          current_element = element.parent.next_element
+          label = current_element.at_xpath(".//w:instrText").text
+          loop do
+            current_element = current_element.next_element
+            next if ["bookmarkStart", "bookmarkEnd"].include?(current_element.name)
+            label_part = current_element.at_xpath(".//w:instrText")
+            break unless label_part
+            label << label_part.text
+          end
+        end
+        unless label.match(MergeField::InstructionTextRegex)
+          raise MergeField::NotAMergeFieldError.new(label)
+        end
+        label
+      end
+    end
+  end
+end

data/lib/sheng/version.rb

@@ -0,0 +1,3 @@
+module Sheng
+  VERSION = "0.3.2"
+end