lm_docstache 1.3.10 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 58addacdd5e64a7a54ca48ea1a811e310b3ef0d3e7a2084f41244ae8f5b39cbf
-  data.tar.gz: 40471c6fcceb845dcfadb81dbf30a260eb15f0f37c444ff796fcaa3c08f1edb2
+  metadata.gz: 805d05c9872a3562ac59527ada43842f4f28412d4a273d3010986f1182ee8421
+  data.tar.gz: 1c0ecd9d43788420553310cefcba6bcca8fe24cd6dc14ff3cbac27f2cfb8ac8f
 SHA512:
-  metadata.gz: d9e6329eaafd68058293052d339c7a0edff0ec0fb3cf309757b16c13eb42428ea22d0ae121b8eaf6fb3ab430ccc3ea4b93d9d5068403bd53a385df22056ed755
-  data.tar.gz: ac48fc982b1a1e38a8ff7c6a4207aa7e6558d3b79ebd8ef8bfb437234ebddd458ae5ec1674f942f4de370dd4660127f160ffa7c58b7487bd22caf494cfc594a6
+  metadata.gz: 66881d21495aa30890ebfc392e4292bfd6ef0bccb9b31d147381b606478996707d82cb745d3dd387f98a793b743f54d695be7149282add2b4707438262bc1a0e
+  data.tar.gz: 0a75364125a98fbd22150cbcde7e3826ab2a8d28705e321e0a471290838867d211ebda8a9181fcf7bf4a1428c6351fa1e93fc0ad33c200f850ae71bed3a0808d

data/.github/workflows/{ruby.yml → rspec.yml}

@@ -5,7 +5,7 @@
 # This workflow will download a prebuilt Ruby version, install dependencies and run tests with Rake
 # For more information see: https://github.com/marketplace/actions/setup-ruby-jruby-and-truffleruby
 
-name: Ruby
+name: rspec
 
 on: push
 
@@ -17,10 +17,7 @@ jobs:
     steps:
     - uses: actions/checkout@v2
     - name: Set up Ruby
-    # To automatically get bug fixes and new Ruby versions for ruby/setup-ruby,
-    # change this to (see https://github.com/ruby/setup-ruby#versioning):
-    # uses: ruby/setup-ruby@v1
-      uses: ruby/setup-ruby@ec106b438a1ff6ff109590de34ddc62c540232e0
+      uses: ruby/setup-ruby@v1
       with:
         ruby-version: 2.6
     - name: Install dependencies

data/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## 2.0.0
+
+### Breaking changes
+
+* Remove `Document#role_tags` and `Document#unusable_role_tags` methods;
+* Remove support for `:loop` block type;
+* Delete internal classes `DataScope` and `Block`;
+* Third parameter of `Renderer#render_file` has changed: it's not the boolean
+  field `remove_role_tags` anymore, but the `render_options` with default set
+  to `{}`, where there is only one option for it so far, which is
+  `special_variable_replacements` (with default value also set to `{}`). For the
+  possible values for this `Hash` check the explanation for it on top of
+  `Parser#initialize`.
+
+### Improvements and bugfixes
+
+* Improve overall template parsing and evaluation, which makes conditional
+  blocks parsing more stable, reliable and bug free. There were lots of bugs
+  happening related to conditional blocks being ignored and not properly parsed.
+
 ## 1.3.10
 * Fix close tag encoding bug.
 

data/README.md

@@ -1,4 +1,5 @@
 [![Gem Version](https://badge.fury.io/rb/lm_docstache.svg)](http://badge.fury.io/rb/lm_docstache)
+![rspec](https://github.com/boost-legal/lm-docstache/workflows/rspec/badge.svg)
 
 # LM-Docstache
 

data/lib/lm_docstache.rb

@@ -1,9 +1,10 @@
 require 'nokogiri'
 require 'zip'
 require "lm_docstache/version"
-require "lm_docstache/data_scope"
 require "lm_docstache/document"
-require "lm_docstache/block"
+require "lm_docstache/parser"
+require "lm_docstache/condition"
+require "lm_docstache/conditional_block"
 require "lm_docstache/renderer"
 
 module LMDocstache; end

data/lib/lm_docstache/condition.rb

@@ -0,0 +1,37 @@
+module LMDocstache
+  class Condition
+    InvalidOperator = Class.new(StandardError)
+
+    ALLOWED_OPERATORS = %w(== ~=).freeze
+    STARTING_QUOTES = %w(' " “)
+    ENDING_QUOTES = %w(' " ”)
+
+    attr_reader :left_term, :right_term, :operator, :negation, :original_match
+
+    def initialize(left_term:, right_term:, operator:, negation: false, original_match: nil)
+      @left_term = left_term
+      @right_term = remove_quotes(right_term)
+      @operator = operator
+      @negation = negation
+      @original_match = original_match
+
+      unless ALLOWED_OPERATORS.include?(operator)
+        raise InvalidOperator, "Operator '#{operator}' is invalid"
+      end
+    end
+
+    def truthy?(value)
+      result = value.to_s.send(operator, right_term)
+      negation ? !result : result
+    end
+
+    private
+
+    def remove_quotes(value)
+      start_position = STARTING_QUOTES.include?(value[0]) ? 1 : 0
+      end_position = ENDING_QUOTES.include?(value[-1]) ? -2 : -1
+
+      value[start_position..end_position]
+    end
+  end
+end

data/lib/lm_docstache/conditional_block.rb

@@ -0,0 +1,105 @@
+require 'strscan'
+
+module LMDocstache
+  class ConditionalBlock
+    BLOCK_MATCHER = LMDocstache::Parser::BLOCK_MATCHER
+
+    attr_reader :elements, :condition, :value
+
+    def initialize(elements:, condition:, content: nil)
+      @elements = elements
+      @condition = condition
+      @content = content
+      @evaluated = false
+    end
+
+    def content
+      return @content if inline?
+    end
+
+    def evaluate_with_value!(value)
+      return false if evaluated?
+
+      inline? ? evaluate_inline_block!(value) : evaluate_multiple_nodes_block!(value)
+
+      @evaluated = true
+    end
+
+    def evaluated?
+      !!@evaluated
+    end
+
+    def inline?
+      @elements.size == 1
+    end
+
+    def self.inline_blocks_from_paragraph(paragraph)
+      node_set = Nokogiri::XML::NodeSet.new(paragraph.document, [paragraph])
+      conditional_blocks = []
+      scanner = StringScanner.new(paragraph.text)
+      matches = []
+
+      # This loop will iterate through all existing inline conditional blocks
+      # inside a given paragraph node.
+      while scanner.scan_until(BLOCK_MATCHER)
+        next if matches.include?(scanner.matched)
+
+        # +scanner.matched+ holds the whole regex-matched string, which could be
+        # represented by the following string:
+        #
+        #    {{#variable == value}}content{{/variable}}
+        #
+        # While +scanner.captures+ holds the group matches referenced in the
+        # +BLOCK_MATCHER+ regex, and it's basically comprised as the following:
+        #
+        #   [
+        #     '#',
+        #     'variable',
+        #     '==',
+        #     'value'
+        #   ]
+        #
+        content = scanner.captures[4]
+        condition = Condition.new(
+          left_term: scanner.captures[1],
+          right_term: scanner.captures[3],
+          operator: scanner.captures[2],
+          negation: scanner.captures[0] == '^',
+          original_match: scanner.matched
+        )
+
+        matches << scanner.matched
+        conditional_blocks << new(
+          elements: node_set,
+          condition: condition,
+          content: content
+        )
+      end
+
+      conditional_blocks
+    end
+
+    private
+
+    # Normally we expect that both starting and closing block paragraph elements
+    # contain only one +<w:r />+ and one +<w:t />+ elements.
+    def evaluate_multiple_nodes_block!(value)
+      return elements.unlink unless condition.truthy?(value)
+
+      Nokogiri::XML::NodeSet.new(
+        elements.first.document,
+        [elements.first, elements.last]
+      ).unlink
+    end
+
+    def evaluate_inline_block!(value)
+      elements.first.css('w|t').each do |text_node|
+        replaced_text = text_node.text.gsub(condition.original_match) do |match|
+          condition.truthy?(value) ? content : ''
+        end
+
+        text_node.content = replaced_text
+      end
+    end
+  end
+end

data/lib/lm_docstache/document.rb

@@ -1,27 +1,24 @@
 module LMDocstache
   class Document
-    TAGS_REGEXP = /\{\{.+?\}\}/
+    TAGS_REGEXP = /{{.+?}}/
     ROLES_REGEXP = /(\{\{(sig|sigfirm|date|check|text|initial)\|(req|noreq)\|(.+?)\}\})/
+
     def initialize(*paths)
       raise ArgumentError if paths.empty?
+
       @path = paths.shift
       @zip_file = Zip::File.open(@path)
-      load_references
       @document = Nokogiri::XML(unzip_read(@zip_file, "word/document.xml"))
-      zip_files = paths.map{|p| Zip::File.open(p)}
-      documents = zip_files.map{|f| Nokogiri::XML(unzip_read(f, "word/document.xml"))}
+      zip_files = paths.map { |path| Zip::File.open(path) }
+      documents = zip_files.map { |f| Nokogiri::XML(unzip_read(f, "word/document.xml")) }
+
+      load_references
       documents.each do |doc|
-        @document.css('w|p').last.add_next_sibling(page_break)
-        @document.css('w|p').last.add_next_sibling(doc.css('w|body > *:not(w|sectPr)'))
+        @document.css('w|p').last.after(page_break)
+        @document.css('w|p').last.after(doc.css('w|body > *:not(w|sectPr)'))
       end
-      find_documents_to_interpolate
-    end
 
-    def role_tags
-      @documents.values.flat_map do |document|
-        document.text.strip.scan(ROLES_REGEXP)
-          .map {|r| r.first }
-      end
+      find_documents_to_interpolate
     end
 
     def usable_role_tags
@@ -35,15 +32,6 @@ module LMDocstache
       end
     end
 
-    def unusable_role_tags
-      unusable_signature_tags = role_tags
-      usable_role_tags.each do |usable_tag|
-        index = unusable_signature_tags.index(usable_tag)
-        unusable_signature_tags.delete_at(index) if index
-      end
-      return unusable_signature_tags
-    end
-
     def tags
       @documents.values.flat_map do |document|
         document.text.strip.scan(TAGS_REGEXP)
@@ -51,15 +39,15 @@ module LMDocstache
     end
 
     def usable_tags
-      @documents.values.flat_map do |document|
-        document.css('w|t')
-          .select { |tag| tag.text =~ TAGS_REGEXP }
-          .flat_map { |tag| tag.text.scan(TAGS_REGEXP) }
+      @documents.values.reduce([]) do |tags, document|
+        document.css('w|t').reduce(tags) do |document_tags, text_node|
+          document_tags.push(*text_node.text.scan(TAGS_REGEXP))
+        end
       end
     end
 
     def usable_tag_names
-      self.usable_tags.select {|t| !(t =~ ROLES_REGEXP)}.map do |tag|
+      usable_tags.reject { |tag| tag =~ ROLES_REGEXP }.map do |tag|
         tag.scan(/\{\{[\/#^]?(.+?)(?:(\s((?:==|~=))\s?.+?))?\}\}/)
         $1
       end.compact.uniq
@@ -67,11 +55,13 @@ module LMDocstache
 
     def unusable_tags
       unusable_tags = tags
+
       usable_tags.each do |usable_tag|
         index = unusable_tags.index(usable_tag)
         unusable_tags.delete_at(index) if index
       end
-      return unusable_tags
+
+      unusable_tags
     end
 
     def fix_errors
@@ -87,68 +77,64 @@ module LMDocstache
       File.open(path, "w") { |f| f.write buffer.string }
     end
 
-    def render_file(output, data={}, remove_role_tags = false)
-      rendered_documents = Hash[
-        @documents.map do |(path, document)|
-          [path, LMDocstache::Renderer.new(document.dup, data, remove_role_tags).render]
-        end
-      ]
-      buffer = zip_buffer(rendered_documents)
+    def render_file(output, data = {}, render_options = {})
+      buffer = zip_buffer(render_documents(data, nil, render_options))
       File.open(output, "w") { |f| f.write buffer.string }
     end
 
     def render_replace(output, text)
-      rendered_documents = Hash[
-        @documents.map do |(path, document)|
-          [path, LMDocstache::Renderer.new(document.dup, {}).render_replace(text)]
-        end
-      ]
-      buffer = zip_buffer(rendered_documents)
+      buffer = zip_buffer(render_documents({}, text))
       File.open(output, "w") { |f| f.write buffer.string }
     end
 
-    def render_stream(data={})
-      rendered_documents = Hash[
-        @documents.map do |(path, document)|
-          [path, LMDocstache::Renderer.new(document.dup, data).render]
-        end
-      ]
-      buffer = zip_buffer(rendered_documents)
+    def render_stream(data = {})
+      buffer = zip_buffer(render_documents(data))
       buffer.rewind
-      return buffer.sysread
+      buffer.sysread
     end
 
-    def render_xml(data={})
-      rendered_documents = Hash[
+    def render_xml(data = {})
+      render_documents(data)
+    end
+
+    private
+
+    def render_documents(data, text = nil, render_options = {})
+      Hash[
         @documents.map do |(path, document)|
-          [path, LMDocstache::Renderer.new(document.dup, data).render]
+          [path, render_document(document, data, text, render_options)]
         end
       ]
-
-      rendered_documents
     end
 
-    private
+    def render_document(document, data, text, render_options)
+      renderer = LMDocstache::Renderer.new(document.dup, data, render_options)
+      text ? renderer.render_replace(text) : renderer.render
+    end
 
     def problem_paragraphs
       unusable_tags.flat_map do |tag|
         @documents.values.inject([]) do |tags, document|
-          tags + document.css('w|p').select {|t| t.text =~ /#{Regexp.escape(tag)}/}
+          faulty_paragraphs = document
+            .css('w|p')
+            .select { |paragraph| paragraph.text =~ /#{Regexp.escape(tag)}/ }
+
+          tags + faulty_paragraphs
         end
       end
     end
 
-    def flatten_paragraph(p)
-      runs = p.css('w|r')
+    def flatten_paragraph(paragraph)
+      run_nodes = paragraph.css('w|r')
+      host_run_node = run_nodes.shift
 
-      host_run = runs.shift
-      until host_run.at_css('w|t').present? || runs.size == 0 do
-        host_run = runs.shift
+      until host_run_node.at_css('w|t') || run_nodes.size == 0
+        host_run_node = run_nodes.shift
       end
 
-      runs.each do |run|
-        host_run.at_css('w|t').content += run.text
-        run.unlink
+      run_nodes.each do |run_node|
+        host_run_node.at_css('w|t').content += run_node.text
+        run_node.unlink
       end
     end
 
@@ -156,38 +142,42 @@ module LMDocstache
       file = zip.find_entry(zip_path)
       contents = ""
       file.get_input_stream { |f| contents = f.read }
-      return contents
+
+      contents
     end
 
     def zip_buffer(documents)
-      Zip::OutputStream.write_buffer do |out|
-        @zip_file.entries.each do |e|
-          unless documents.keys.include?(e.name)
-            out.put_next_entry(e.name)
-            out.write(e.get_input_stream.read)
-          end
+      Zip::OutputStream.write_buffer do |output|
+        @zip_file.entries.each do |entry|
+          next if documents.keys.include?(entry.name)
+
+          output.put_next_entry(entry.name)
+          output.write(entry.get_input_stream.read)
         end
+
         documents.each do |path, document|
-          out.put_next_entry(path)
-          out.write(document.to_xml(indent: 0).gsub("\n", ""))
+          output.put_next_entry(path)
+          output.write(document.to_xml(indent: 0).gsub("\n", ""))
         end
       end
     end
 
     def page_break
-      p = Nokogiri::XML::Node.new("p", @document)
-      p.namespace = @document.at_css('w|p:last').namespace
-      r = Nokogiri::XML::Node.new("r", @document)
-      p.add_child(r)
-      br = Nokogiri::XML::Node.new("br", @document)
-      r.add_child(br)
-      br['w:type'] = "page"
-      return p
+      Nokogiri::XML::Node.new('p', @document).tap do |paragraph_node|
+        paragraph_node.namespace = @document.at_css('w|p:last').namespace
+        run_node = Nokogiri::XML::Node.new('r', @document)
+        page_break_node = Nokogiri::XML::Node.new('br', @document)
+        page_break_node['w:type'] = 'page'
+
+        paragraph_node << run_node
+        paragraph_node << page_break_node
+      end
     end
 
     def load_references
       @references = {}
       ref_xml = Nokogiri::XML(unzip_read(@zip_file, "word/_rels/document.xml.rels"))
+
       ref_xml.css("Relationship").each do |ref|
         id = ref.attributes["Id"].value
         @references[id] = {
@@ -199,12 +189,14 @@ module LMDocstache
     end
 
     def find_documents_to_interpolate
-      @documents = {"word/document.xml" => @document}
+      @documents = { "word/document.xml" => @document }
+
       @document.css("w|headerReference, w|footerReference").each do |header_ref|
-        if @references.has_key?(header_ref.attributes["id"].value)
-          ref = @references[header_ref.attributes["id"].value]
-          @documents["word/#{ref[:target]}"] = Nokogiri::XML(unzip_read(@zip_file, "word/#{ref[:target]}"))
-        end
+        next unless @references.has_key?(header_ref.attributes["id"].value)
+
+        ref = @references[header_ref.attributes["id"].value]
+        document_path = "word/#{ref[:target]}"
+        @documents[document_path] = Nokogiri::XML(unzip_read(@zip_file, document_path))
       end
     end
   end

data/lib/lm_docstache/parser.rb

@@ -0,0 +1,178 @@
+module LMDocstache
+  class Parser
+    BLOCK_TYPE_PATTERN = '(#|\^)\s*'
+    BLOCK_VARIABLE_PATTERN = '([^\s~=]+)'
+    BLOCK_OPERATOR_PATTERN = '\s*(~=|==)\s*'
+    BLOCK_VALUE_PATTERN = '([^\}]+?)\s*'
+    BLOCK_START_PATTERN = "{{#{BLOCK_TYPE_PATTERN}#{BLOCK_VARIABLE_PATTERN}"\
+                          "#{BLOCK_OPERATOR_PATTERN}#{BLOCK_VALUE_PATTERN}}}"
+    BLOCK_CONTENT_PATTERN = '(.*?)'
+    BLOCK_CLOSE_PATTERN = '{{/\s*\k<2>\s*}}'
+    BLOCK_NAMED_CLOSE_PATTERN = '{{/\s*%{tag_name}\s*}}'
+    BLOCK_PATTERN = "#{BLOCK_START_PATTERN}#{BLOCK_CONTENT_PATTERN}"\
+                    "#{BLOCK_CLOSE_PATTERN}"
+
+    BLOCK_START_MATCHER = /#{BLOCK_START_PATTERN}/
+    BLOCK_CLOSE_MATCHER = /{{\/\s*.+?\s*}}/
+    BLOCK_MATCHER = /#{BLOCK_PATTERN}/
+    VARIABLE_MATCHER = /{{([^#\^\/].*?)}}/
+
+    attr_reader :document, :data, :blocks, :special_variable_replacements
+
+    # The +special_variable_replacements+ option is a +Hash+ where the key is
+    # expected to be either a +Regexp+ or a +String+ representing the pattern
+    # of more specific type of variables that deserves a special treatment. The
+    # key must not contain the `{{}}` part, but only the pattern characters
+    # inside of it. As for the values of the +Hash+, it tells the replacement
+    # algorithm what to do with the matched string and there are the options:
+    #
+    # * +false+ -> in this case the matched variable will be kept without
+    #   replacement
+    # * +Proc+ -> when a +Proc+ instance is provided, it's expected it to be
+    #   able to receive the matched string and to return the string that will be
+    #   used as replacement
+    # * any other value that will be turned into a string -> in this case, this
+    #   will be the value that will replace the matched string
+    #
+    def initialize(document, data, options = {})
+      @document = document
+      @data = data.transform_keys(&:to_s)
+      @special_variable_replacements = options.fetch(:special_variable_replacements, {})
+    end
+
+    def parse_and_update_document!
+      find_blocks
+      replace_conditional_blocks_in_document!
+      replace_variables_in_document!
+    end
+
+    private
+
+    def find_blocks
+      return @blocks if instance_variable_defined?(:@blocks)
+      return @blocks = [] unless document.text =~ BLOCK_MATCHER
+
+      @blocks = []
+      paragraphs = document.css('w|p')
+
+      while paragraph = paragraphs.shift do
+        content = paragraph.text
+        full_match = BLOCK_MATCHER.match(content)
+        start_match = !full_match && BLOCK_START_MATCHER.match(content)
+
+        next unless full_match || start_match
+
+        if full_match
+          @blocks.push(*ConditionalBlock.inline_blocks_from_paragraph(paragraph))
+        else
+          condition = condition_from_match_data(start_match)
+          comprised_paragraphs = all_block_elements(start_match[2], paragraph, paragraphs)
+
+          # We'll ignore conditional blocks that have no correspondent closing tag
+          next unless comprised_paragraphs
+
+          @blocks << ConditionalBlock.new(
+            elements: comprised_paragraphs,
+            condition: condition
+          )
+        end
+      end
+
+      @blocks
+    end
+
+    # Evaluates all conditional blocks inside the given XML document and keep or
+    # remove their content inside the document, depending on the truthiness of
+    # the condition on each given conditional block.
+    def replace_conditional_blocks_in_document!
+      blocks.each do |conditional_block|
+        value = data[conditional_block.condition.left_term]
+        conditional_block.evaluate_with_value!(value)
+      end
+    end
+
+    # It simply replaces all the referenced variables inside document by their
+    # correspondent values provided in the attributes hash +data+.
+    def replace_variables_in_document!
+      document.css('w|t').each do |text_node|
+        text = text_node.text
+
+        next unless text =~ VARIABLE_MATCHER
+        next if has_skippable_variable?(text)
+
+        variable_replacement = special_variable_replacement(text)
+
+        text.gsub!(VARIABLE_MATCHER) do |_match|
+          next data[$1].to_s unless variable_replacement
+
+          variable_replacement.is_a?(Proc) ?
+            variable_replacement.call($1) :
+            variable_replacement.to_s
+        end
+
+        text_node.content = text
+      end
+    end
+
+    def has_skippable_variable?(text)
+      !!special_variable_replacements.find do |(pattern, value)|
+        pattern = pattern.is_a?(String) ? /{{#{pattern}}}/ : /{{#{pattern.source}}}/
+        text =~ pattern && value == false
+      end
+    end
+
+    def special_variable_replacement(text)
+      Array(
+        special_variable_replacements.find do |(pattern, value)|
+          pattern = pattern.is_a?(String) ? /{{#{pattern}}}/ : /{{#{pattern.source}}}/
+          text =~ pattern && !!value
+        end
+      ).last
+    end
+
+    # This method created a +Condition+ instance for a partial conditional
+    # block, which in this case it's the start block part of it, represented by
+    # a string like the following:
+    #
+    #    {{#variable == value}}
+    #
+    # @param match [MatchData]
+    #
+    # If converted into an +Array+, +match+ could be represented as follows:
+    #
+    #    [
+    #      '{{#variable == value}}',
+    #      '#',
+    #      'variable',
+    #      '==',
+    #      'value'
+    #    ]
+    #
+    def condition_from_match_data(match)
+      Condition.new(
+        left_term: match[2],
+        right_term: match[4],
+        operator: match[3],
+        negation: match[1] == '^',
+        original_match: match[0]
+      )
+    end
+
+    # Gets all the XML nodes that involve a non-inline conditonal block,
+    # starting from the element that contains the conditional block start up
+    # to the element containing the conditional block ending
+    def all_block_elements(tag_name, initial_element, next_elements)
+      closing_block_pattern = BLOCK_NAMED_CLOSE_PATTERN % { tag_name: tag_name }
+      closing_block_matcher = /#{closing_block_pattern}/
+      paragraphs = Nokogiri::XML::NodeSet.new(document, [initial_element])
+
+      return unless next_elements.text =~ closing_block_matcher
+
+      until (paragraph = next_elements.shift).text =~ closing_block_matcher do
+        paragraphs << paragraph
+      end
+
+      paragraphs << paragraph
+    end
+  end
+end

data/lib/lm_docstache/renderer.rb

@@ -2,16 +2,15 @@ module LMDocstache
   class Renderer
     BLOCK_REGEX = /\{\{([\#\^])([\w\.]+)(?:(\s(?:==|~=)\s?.+?))?\}\}.+?\{\{\/\k<2>\}\}/m
 
-    def initialize(xml, data, remove_role_tags = false)
+    attr_reader :parser
+
+    def initialize(xml, data, options = {})
       @content = xml
-      @data = DataScope.new(data)
-      @remove_role_tags = remove_role_tags
+      @parser = Parser.new(xml, data, options.slice(:special_variable_replacements))
     end
 
     def render
-      find_and_expand_blocks
-      replace_tags(@content, @data)
-      remove_role_tags if @remove_role_tags
+      parser.parse_and_update_document!
       @content
     end
 
@@ -23,127 +22,5 @@ module LMDocstache
       end
       @content
     end
-
-    private
-
-    def find_and_expand_blocks
-      blocks = @content.text.scan(BLOCK_REGEX)
-      found_blocks = blocks.uniq.flat_map do |block|
-        inverted = block[0] == "^"
-        Block.find_all(name: block[1], elements: @content.elements, data: @data, inverted: inverted, condition: block[2])
-      end
-      found_blocks.each do |block|
-        if block.inline
-          replace_conditionals
-        else
-          expand_and_replace_block(block) if block.present?
-        end
-      end
-    end
-
-    def expand_and_replace_block(block)
-      case block.type
-      when :conditional
-        condition = get_condition(block.name, block.condition, block.inverted)
-        unless condition
-          block.content_elements.each(&:unlink)
-        end
-      when :loop
-        set = @data.get(block.name, condition: block.condition)
-        content = set.map do |item|
-          data = DataScope.new(item, @data)
-          elements = block.content_elements.map(&:clone)
-          replace_tags(Nokogiri::XML::NodeSet.new(@content, elements), data)
-        end
-        content.each do |els|
-          el = els[0]
-          els[1..-1].each do |next_el|
-            el.after(next_el)
-            el = next_el
-          end
-          block.closing_element.before(els[0])
-        end
-        block.content_elements.each(&:unlink)
-      end
-      block.opening_element.unlink
-      block.closing_element.unlink
-    end
-
-    def replace_conditionals
-      @content.css('w|t').each do |text_el|
-        rendered_string = text_el.text
-
-        if !(results = rendered_string.scan(/{{#(.*?)}}(.*?){{\/(.*?)}}/)).empty?
-          results.each do |r|
-            vals = r[0].split('==')
-            condition = get_condition(vals[0].strip, "== #{vals[1]}")
-            if condition
-              rendered_string.sub!("{{##{r[0]}}}", "")
-              rendered_string.sub!("{{/#{r[2]}}}", "")
-            else
-              rendered_string.sub!("{{##{r[0]}}}#{r[1]}{{/#{r[2]}}}", "")
-            end
-          end
-        end
-
-        # the only difference in this code block is caret instead of pound in three places,
-        # the inverted value passed to get_condition, and the condition being inverted. maybe combine them?
-        if !(results = rendered_string.scan(/{{\^(.*?)}}(.*?){{\/(.*?)}}/)).empty?
-          results.each do |r|
-            vals = r[0].split('==')
-            condition = get_condition(vals[0].strip, "== #{vals[1]}", true)
-            if condition
-              rendered_string.sub!("{{^#{r[0]}}}", "")
-              rendered_string.sub!("{{/#{r[2]}}}", "")
-            else
-              rendered_string.sub!("{{^#{r[0]}}}#{r[1]}{{/#{r[2]}}}", "")
-            end
-          end
-        end
-
-        text_el.content = rendered_string
-      end
-    end
-
-    def replace_tags(elements, data)
-      elements.css('w|t').select {|t| !(t.text =~ Document::ROLES_REGEXP)}.each do |text_el|
-        if !(results = text_el.text.scan(/\{\{([\w\.\|]+)\}\}/).flatten).empty? &&
-          rendered_string = text_el.text
-          results.each do |r|
-            rendered_string.gsub!("{{#{r}}}", data.get(r).to_s)
-          end
-          text_el.content = rendered_string
-        end
-      end
-      elements
-    end
-
-    def remove_role_tags
-      @content.css('w|t').each do |text_el|
-        results = text_el.text.scan(Document::ROLES_REGEXP).map {|r| r.first }
-        unless results.empty?
-          rendered_string = text_el.text
-          results.each do |result|
-            padding = "".ljust(result.size, " ")
-            rendered_string.gsub!(result, padding)
-          end
-          text_el.content = rendered_string
-        end
-      end
-    end
-
-    private
-
-    def get_condition(name, condition, inverted = false)
-      case condition = @data.get(name, condition: condition)
-      when Array
-        condition = !condition.empty?
-      else
-        condition = !!condition
-      end
-      condition = !condition if inverted
-
-      condition
-    end
   end
 end

data/lib/lm_docstache/version.rb

@@ -1,3 +1,3 @@
 module LMDocstache
-  VERSION = "1.3.10"
+  VERSION = "2.0.0"
 end

data/lm_docstache.gemspec

@@ -5,8 +5,8 @@ require "lm_docstache/version"
 Gem::Specification.new do |s|
   s.name        = "lm_docstache"
   s.version     = LMDocstache::VERSION
-  s.authors     = ["Roey Chasman", "Frederico Assunção", "Jonathan Stevens", "Will Cosgrove"]
-  s.email       = ["roey@lawmatics.com", "fred@lawmatics.com", "jonathan@lawmatics.com", "will@willcosgrove.com"]
+  s.authors     = ["Roey Chasman", "Frederico Assunção", "Jonathan Stevens", "Leandro Camargo", "Will Cosgrove"]
+  s.email       = ["roey@lawmatics.com", "fred@lawmatics.com", "jonathan@lawmatics.com", "leandro@lawmatics.com", "will@willcosgrove.com"]
   s.homepage    = "https://www.lawmatics.com"
   s.summary     = %q{Merges Hash of Data into Word docx template files using mustache syntax}
   s.description = %q{Integrates data into MS Word docx template files. Processing supports loops and replacement of strings of data both outside and within loops.}

data/spec/integration_spec.rb

@@ -67,10 +67,6 @@ describe 'integration test', integration: true do
       expect(document.usable_tags.count).to be(30)
     end
 
-    it 'has the expected amount of role tags' do
-      expect(document.role_tags.count).to be(6)
-    end
-
     it 'has the expected amount of usable roles tags' do
       document.fix_errors
       expect(document.usable_role_tags.count).to be(6)

metadata

@@ -1,17 +1,18 @@
 --- !ruby/object:Gem::Specification
 name: lm_docstache
 version: !ruby/object:Gem::Version
-  version: 1.3.10
+  version: 2.0.0
 platform: ruby
 authors:
 - Roey Chasman
 - Frederico Assunção
 - Jonathan Stevens
+- Leandro Camargo
 - Will Cosgrove
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-11-17 00:00:00.000000000 Z
+date: 2021-02-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -95,12 +96,13 @@ email:
 - roey@lawmatics.com
 - fred@lawmatics.com
 - jonathan@lawmatics.com
+- leandro@lawmatics.com
 - will@willcosgrove.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".github/workflows/ruby.yml"
+- ".github/workflows/rspec.yml"
 - ".gitignore"
 - CHANGELOG.md
 - Gemfile
@@ -108,15 +110,14 @@ files:
 - README.md
 - Rakefile
 - lib/lm_docstache.rb
-- lib/lm_docstache/block.rb
-- lib/lm_docstache/data_scope.rb
+- lib/lm_docstache/condition.rb
+- lib/lm_docstache/conditional_block.rb
 - lib/lm_docstache/document.rb
+- lib/lm_docstache/parser.rb
 - lib/lm_docstache/renderer.rb
 - lib/lm_docstache/version.rb
 - lm_docstache.gemspec
 - spec/conditional_block_spec.rb
-- spec/data_scope_spec.rb
-- spec/empty_data_scope_spec.rb
 - spec/example_input/ExampleTemplate.docx
 - spec/example_input/blank.docx
 - spec/integration_spec.rb
@@ -147,8 +148,6 @@ specification_version: 4
 summary: Merges Hash of Data into Word docx template files using mustache syntax
 test_files:
 - spec/conditional_block_spec.rb
-- spec/data_scope_spec.rb
-- spec/empty_data_scope_spec.rb
 - spec/example_input/ExampleTemplate.docx
 - spec/example_input/blank.docx
 - spec/integration_spec.rb

data/lib/lm_docstache/block.rb

@@ -1,71 +0,0 @@
-module LMDocstache
-  class Block
-    attr_reader :name, :opening_element, :content_elements, :closing_element, :inverted, :condition, :inline
-    def initialize(name:, data:, opening_element:, content_elements:, closing_element:, inverted:, condition: nil, inline: false)
-      @name = name
-      @data = data
-      @opening_element = opening_element
-      @content_elements = content_elements
-      @closing_element = closing_element
-      @inverted = inverted
-      @condition = condition
-      @inline = inline
-    end
-
-    def type
-      @type ||= if @inverted
-        :conditional
-      else
-        if @data.get(@name).is_a? Array
-          :loop
-        else
-          :conditional
-        end
-      end
-    end
-
-    def loop?
-      type == :loop
-    end
-
-    def conditional?
-      type == :conditional
-    end
-
-    def self.find_all(name:, data:, elements:, inverted:, condition: nil, ignore_missing: true, child: false)
-      inverted_op = inverted ? '\^' : '\#'
-      full_tag_regex = /\{\{#{inverted_op}(#{name})\s?#{condition}\}\}.+?\{\{\/\k<1>\}\}/m
-      start_tag_regex = /\{\{#{inverted_op}#{name}\s?#{condition}\}\}/m
-      close_tag_regex = /\{\{\/#{name}\}\}/
-
-      if elements.text.match(full_tag_regex)
-        if elements.any? { |e| e.text.match(full_tag_regex) }
-          matches = elements.select { |e| e.text.match(full_tag_regex) }
-          return matches.flat_map do |match|
-            if match.elements.any?
-              find_all(name: name, data: data, elements: match.elements, inverted: inverted, condition: condition, child: true)
-            else
-              extract_block_from_element(name, data, match, inverted, condition)
-            end
-          end
-        else
-          opening = elements.find { |e| e.text.match(start_tag_regex) }
-          content = []
-          next_sibling = opening.next
-          while !next_sibling.text.match(close_tag_regex)
-            content << next_sibling
-            next_sibling = next_sibling.next
-          end
-          closing = next_sibling
-          return Block.new(name: name, data: data, opening_element: opening, content_elements: content, closing_element: closing, inverted: inverted, condition: condition)
-        end
-      else
-        raise "Block not found in given elements" unless ignore_missing
-      end
-    end
-
-    def self.extract_block_from_element(name, data, element, inverted, condition)
-      return Block.new(name: name, data: data, opening_element: element.parent.previous, content_elements: [element.parent], closing_element: element.parent.next, inverted: inverted, condition: condition, inline: true)
-    end
-  end
-end

data/lib/lm_docstache/data_scope.rb

@@ -1,67 +0,0 @@
-module LMDocstache
-  class DataScope
-
-    def initialize(data, parent=EmptyDataScope.new)
-      @data = data
-      @parent = parent
-    end
-
-    def get(key, hash: @data, original_key: key, condition: nil)
-      symbolize_keys!(hash)
-      tokens = key.split('.')
-      if tokens.length == 1
-        result = hash.fetch(key.to_sym) { |_| @parent.get(original_key) }
-        unless result.respond_to?(:select)
-          return result if evaluate_condition(condition, result)
-        else
-          return result.select { |el| evaluate_condition(condition, el) }
-        end
-      elsif tokens.length > 1
-        key = tokens.shift
-        subhash = hash.fetch(key.to_sym) { |_| @parent.get(original_key) }
-        return get(tokens.join('.'), hash: subhash, original_key: original_key)
-      end
-    end
-
-    private
-
-    def symbolize_keys!(hash)
-      hash.transform_keys!{ |key| key.to_sym rescue key }
-    end
-
-    def evaluate_condition(condition, data)
-      return true if condition.nil?
-      condition = condition.match(/(==|~=)\s*(.+)/)
-      operator = condition[1]
-      expression = condition[2]
-      case condition[1]
-      when "=="
-        # Equality condition
-        expression = evaluate_expression(expression, data)
-        return data == expression
-      else
-        # Matches condition
-        expression = evaluate_expression(expression, data)
-        right = Regex.new(expression.match(/\/(.+)\//)[1])
-        return data.match(right)
-      end
-    end
-
-    def evaluate_expression(expression, data)
-      if expression.match(/(["'“]?)(.+)(\k<1>|”)/)
-        $2
-      elsif data.respond_to?(:select)
-        get(expression, hash: data)
-      else
-        false
-      end
-    end
-  end
-
-  class EmptyDataScope
-    def get(_)
-      return nil
-    end
-  end
-
-end

data/spec/data_scope_spec.rb

@@ -1,56 +0,0 @@
-require 'spec_helper'
-
-describe LMDocstache::DataScope do
-  describe "#get" do
-    context "main body" do
-      let(:data_scope) {
-        LMDocstache::DataScope.new({foo: "bar1", bar: {baz: "bar2", qux: {quux: "bar3"}}})
-      }
-      it "should resolve keys with no nesting" do
-        expect(data_scope.get('foo')).to eq("bar1")
-      end
-
-      it "should resolve nested keys" do
-        expect(data_scope.get('bar.baz')).to eq("bar2")
-      end
-
-      it "should resolve super nested keys" do
-        expect(data_scope.get('bar.qux.quux')).to eq("bar3")
-      end
-    end
-
-    context "loop" do
-      let(:parent_data_scope) {
-        LMDocstache::DataScope.new({
-          users: [ {
-            id: 1, name: "John Smith", brother: {id: 3, name: "Will Smith"}
-          }], id: 2, foo: "bar", brother: {baz: "qux"}}) }
-
-      let(:data_scope) {
-        LMDocstache::DataScope.new({
-          id: 1, name: "John Smith", brother: {id: 3, name: "Will Smith"}}, parent_data_scope)
-      }
-
-      it "should resolve keys with no nesting" do
-        expect(data_scope.get("id")).to eq(1)
-      end
-
-      it "should resolve nested keys" do
-        expect(data_scope.get("brother.id")).to eq(3)
-      end
-
-      it "should fall back to parent scope if key not found" do
-        expect(data_scope.get("foo")).to eq("bar")
-      end
-
-      it "should fall back to parent even during a partial match" do
-        expect(data_scope.get("brother.baz")).to eq("qux")
-      end
-
-      it "should return nil for no match" do
-        expect(data_scope.get("bat")).to be_nil
-        expect(data_scope.get("brother.qux")).to be_nil
-      end
-    end
-  end
-end

data/spec/empty_data_scope_spec.rb

@@ -1,10 +0,0 @@
-require 'spec_helper'
-
-describe LMDocstache::EmptyDataScope do
-  let(:empty_data_scope) { LMDocstache::EmptyDataScope.new }
-  describe '#get' do
-    it "should always return nil" do
-      expect(empty_data_scope.get('foo')).to be_nil
-    end
-  end
-end