sablon 0.2.1 → 0.3.0

data/lib/sablon/processor/document/blocks.rb

@@ -0,0 +1,134 @@
+module Sablon
+  module Processor
+    class Document
+      class Block
+        attr_accessor :start_field, :end_field
+
+        def self.enclosed_by(start_field, end_field)
+          @blocks ||= [ImageBlock, RowBlock, ParagraphBlock, InlineParagraphBlock]
+          block_class = @blocks.detect { |klass| klass.encloses?(start_field, end_field) }
+          block_class.new start_field, end_field
+        end
+
+        def self.encloses?(start_field, end_field)
+          parent(start_field) && parent(end_field)
+        end
+
+        def self.parent(node)
+          node.ancestors(parent_selector).first
+        end
+
+        def self.parent_selector
+          './/w:p'
+        end
+
+        def initialize(start_field, end_field)
+          @start_field = start_field
+          @end_field = end_field
+
+          # update reference counts for control fields
+          @start_field.block_reference_count += 1
+          @end_field.block_reference_count += 1
+        end
+
+        def process(env)
+          replaced_node = Nokogiri::XML::Node.new("tmp", start_node.document)
+          replaced_node.children = Nokogiri::XML::NodeSet.new(start_node.document, body.map(&:dup))
+          Processor::Document.process replaced_node, env
+          replaced_node.children
+        end
+
+        def replace(content)
+          content.each { |n| start_node.add_next_sibling n }
+          remove_control_elements
+        end
+
+        def remove_control_elements
+          body.each(&:remove)
+          # we only want to remove the start and end nodes if they belong
+          # to a single block.
+          start_field.remove_parent(self.class.parent_selector)
+          end_field.remove_parent(self.class.parent_selector)
+        end
+
+        def body
+          return @body if defined?(@body)
+          @body = []
+          node = start_node
+          while (node = node.next_element) && node != end_node
+            @body << node
+          end
+          @body
+        end
+
+        def start_node
+          @start_node ||= self.class.parent(start_field)
+        end
+
+        def end_node
+          @end_node ||= self.class.parent(end_field)
+        end
+      end
+
+      class RowBlock < Block
+        def self.parent_selector
+          './/w:tr'
+        end
+
+        def self.encloses?(start_field, end_field)
+          super && parent(start_field) != parent(end_field)
+        end
+      end
+
+      class ParagraphBlock < Block
+        def self.encloses?(start_field, end_field)
+          super && parent(start_field) != parent(end_field)
+        end
+      end
+
+      class ImageBlock < ParagraphBlock
+        def self.encloses?(start_field, end_field)
+          start_field.expression.start_with?('@')
+        end
+
+        def replace(image)
+          # we need to include the start and end nodes incase the image is
+          # inline with the merge fields
+          nodes = [start_node] + body + [end_node]
+          #
+          if image
+            nodes.each do |node|
+              pic_prop = node.at_xpath('.//pic:cNvPr', pic: 'http://schemas.openxmlformats.org/drawingml/2006/picture')
+              pic_prop.attributes['name'].value = image.name if pic_prop
+              blip = node.at_xpath('.//a:blip', a: 'http://schemas.openxmlformats.org/drawingml/2006/main')
+              blip.attributes['embed'].value = image.local_rid if blip
+            end
+          end
+          #
+          start_field.remove
+          end_field.remove
+        end
+      end
+
+      class InlineParagraphBlock < Block
+        def self.encloses?(start_field, end_field)
+          super && parent(start_field) == parent(end_field)
+        end
+
+        def remove_control_elements
+          body.each(&:remove)
+          start_field.remove
+          end_field.remove
+        end
+
+        def start_node
+          @start_node ||= start_field.end_node
+        end
+
+        def end_node
+          @end_node ||= end_field.start_node
+        end
+      end
+    end
+  end
+end

data/lib/sablon/processor/document/field_handlers.rb

@@ -0,0 +1,117 @@
+module Sablon
+  module Processor
+    class Document
+      # This class is used to setup field handlers to process different
+      # merge field expressions based on the expression text. The #handles?
+      # and #build_statement methods form the standard FieldHandler API and can
+      # be implemented however they are needed to be as long as the call
+      # signature stays the same.
+      class FieldHandler
+        # Used when registering processors. The pattern tells the handler
+        # what expression text to search for.
+        def initialize(pattern)
+          @pattern = pattern
+        end
+
+        # Returns a non-nil value if the field expression matches the pattern
+        def handles?(field)
+          field.expression.match(@pattern)
+        end
+
+        # Uses the provided arguments to construct a Statement object.
+        # The constructor is an instance of the OperationConstruction class,
+        # the field is the current merge field being evaluated and the options
+        # hash defines any other parameters passed in during
+        # OperationConstruction#consume. Currently the only option passed is
+        # `:allow_insertion`.
+        def build_statement(constructor, field, options = {}); end
+      end
+
+      # Handles simple text insertion
+      class InsertionHandler < FieldHandler
+        def initialize
+          super(/^=/)
+        end
+
+        def build_statement(_constructor, field, options = {})
+          return unless options[:allow_insertion]
+          #
+          expr = Expression.parse(field.expression.gsub(/^=/, ''))
+          Statement::Insertion.new(expr, field)
+        end
+      end
+
+      # Handles each loops in the template
+      class EachLoopHandler < FieldHandler
+        def initialize
+          super(/([^ ]+):each\(([^ ]+)\)/)
+        end
+
+        def build_statement(constructor, field, _options = {})
+          expr_name, item_name = field.expression.match(@pattern).to_a[1..2]
+          block = constructor.consume_block("#{expr_name}:endEach")
+          Statement::Loop.new(Expression.parse(expr_name), item_name, block)
+        end
+      end
+
+      # Handles conditional blocks in the template
+      class ConditionalHandler < FieldHandler
+        def initialize
+          super(/([^ ]+):if(?:\(([^)]+)\))?/)
+        end
+
+        def build_statement(constructor, field, _options = {})
+          expr_name = field.expression.match(@pattern).to_a[1]
+          args = [
+            # end expression (first arg)
+            "#{expr_name}:endIf",
+            # sub block patterns to check for
+            /(#{expr_name}):els[iI]f(?:\(([^)]+)\))?/,
+            /(#{expr_name}):else/
+          ]
+          blocks = process_blocks(constructor.consume_multi_block(*args))
+          Statement::Condition.new(blocks)
+        end
+
+        private
+
+        # Processes the main expression from each start field block to
+        # simplify usage in Statement
+        def process_blocks(blocks)
+          blocks.map do |block|
+            pattern = /([^ ]+):(?:if|els[iI]f|else)(?:\(([^)]+)\))?/
+            expr, pred = block.start_field.expression.match(pattern).to_a[1..2]
+            expr = Expression.parse(expr)
+            #
+            { condition_expr: expr, predicate: pred, block: block }
+          end
+        end
+      end
+
+      # Handles image insertion fields
+      class ImageHandler < FieldHandler
+        def initialize
+          super(/^@([^ ]+):start/)
+        end
+
+        def build_statement(constructor, field, _options = {})
+          expr_name = field.expression.match(@pattern).to_a[1]
+          block = constructor.consume_block("@#{expr_name}:end")
+          Statement::Image.new(Expression.parse(expr_name), block)
+        end
+      end
+
+      # Handles comment blocks in the template
+      class CommentHandler < FieldHandler
+        def initialize
+          super(/^comment$/)
+        end
+
+        def build_statement(constructor, _field, _options = {})
+          block = constructor.consume_block('endComment')
+          Statement::Comment.new(block)
+        end
+      end
+    end
+  end
+end

data/lib/sablon/processor/document/operation_construction.rb

@@ -0,0 +1,71 @@
+module Sablon
+  module Processor
+    class Document
+      class OperationConstruction
+        def initialize(fields, field_handlers, default_handler)
+          @fields = fields
+          @field_handlers = field_handlers
+          @default_handler = default_handler
+          @operations = []
+        end
+
+        def operations
+          @operations << consume(true) while @fields.any?
+          @operations.compact
+        end
+
+        def consume(allow_insertion)
+          return unless (@field = @fields.shift)
+          #
+          # step over provided handlers to see if any can process the field
+          handler = @field_handlers.detect(proc { @default_handler }) do |fh|
+            fh.handles?(@field)
+          end
+          return if handler.nil?
+          #
+          # process and return
+          handler.build_statement(self, @field, allow_insertion: allow_insertion)
+        end
+
+        def consume_block(end_expression)
+          start_field = end_field = @field
+          while end_field && end_field.expression != end_expression
+            consume(false)
+            end_field = @field
+          end
+
+          unless end_field
+            raise TemplateError, "Could not find end field for «#{start_field.expression}». Was looking for «#{end_expression}»"
+          end
+          Block.enclosed_by(start_field, end_field) if end_field
+        end
+
+        # Creates multiple blocks based on the sub expression patterns supplied
+        # while searching for the end expresion. The start and end fields
+        # of adjacent blocks are shared. For example in an if-else-endif
+        # block the else field is the end for the if clause block and the
+        # start of the else clause block.
+        def consume_multi_block(end_expression, *sub_expr_patterns)
+          start_field = end_field = @field
+          blocks = []
+          while end_field && end_field.expression != end_expression
+            consume(false)
+            break unless (end_field = @field)
+            if sub_expr_patterns.any? { |pat| end_field.expression =~ pat }
+              blocks << Block.enclosed_by(start_field, end_field)
+              start_field = end_field
+            end
+          end
+
+          # raise error if no final end field
+          unless end_field
+            raise TemplateError, "Could not find end field for «#{start_field.expression}». Was looking for «#{end_expression}»"
+          end
+
+          # add final block and return
+          blocks << Block.enclosed_by(start_field, end_field)
+        end
+      end
+    end
+  end
+end

data/lib/sablon/version.rb

@@ -1,3 +1,3 @@
 module Sablon
-  VERSION = "0.2.1"
+  VERSION = "0.3.0"
 end

data/test/custom_field_handler_test.rb

@@ -0,0 +1,106 @@
+require 'test_helper'
+
+class SablonCustomFieldHandlerTest < Sablon::TestCase
+  #
+  # This class supports more advanced conditional expressions and crafted
+  # by @moritzgloeckl in PR #73
+  class OperatorCondition < Sablon::Statement::Condition
+    def eval_conditional_blocks(env)
+      #
+      # evaluate each expression until a true one is found, false blocks
+      # are cleared from the document.
+      until @conditions.empty?
+        condition = @conditions.shift
+        conditon_expr = condition[:condition_expr]
+        predicate = condition[:predicate]
+        block = condition[:block]
+        #
+        # determine valeu of conditional expression + predicate
+        value = eval_condition_expr(conditon_expr, predicate, env.context)
+        #
+        # manipulate block based on truthy-ness of value
+        if truthy?(value)
+          block.replace(block.process(env).reverse)
+          break true
+        else
+          block.replace([])
+        end
+      end
+    end
+
+    def eval_condition_expr(conditon_expr, predicate, context)
+      value = conditon_expr.evaluate(context)
+      #
+      if predicate.to_s =~ /^[!=]=/
+        operator = predicate[0..1]
+        cmpr_val = predicate[2..-1].tr("'", '')
+        compare_values(value.to_s, cmpr_val, operator)
+      elsif predicate
+        value.public_send(predicate)
+      else
+        value
+      end
+    end
+
+    def compare_values(value_a, value_b, operator)
+      case operator
+      when '!='
+        value_a != value_b
+      when '=='
+        value_a == value_b
+      end
+    end
+  end
+
+  # Handles conditional blocks in the template that use an operator
+  class OperatorConditionalHandler < Sablon::Processor::Document::ConditionalHandler
+    def build_statement(constructor, field, _options = {})
+      expr_name = field.expression.match(@pattern).to_a[1]
+      args = [
+        # end expression (first arg)
+        "#{expr_name}:endIf",
+        # sub block patterns to check for
+        /(#{expr_name}):els[iI]f(?:\(([^)]+)\))?/,
+        /(#{expr_name}):else/
+      ]
+      blocks = process_blocks(constructor.consume_multi_block(*args))
+      OperatorCondition.new(blocks)
+    end
+  end
+
+  def setup
+    super
+    @base_path = Pathname.new(File.expand_path('../', __FILE__))
+    @template_path = @base_path + 'fixtures/custom_field_handlers_template.docx'
+    @output_path = @base_path + 'sandbox/custom_field_handlers.docx'
+    @sample_path = @base_path + 'fixtures/custom_field_handlers_sample.docx'
+    #
+    # register new handlers to allow insertion without equals sign and
+    # advanced conditionals
+    klass = Sablon::Processor::Document
+    @orig_conditional_handler = klass.remove_field_handler :conditional
+    klass.register_field_handler :default, klass.field_handlers[:insertion]
+    klass.register_field_handler :conditional, OperatorConditionalHandler.new
+  end
+
+  def teardown
+    # remove extra handlers
+    Sablon::Processor::Document.remove_field_handler :default
+    Sablon::Processor::Document.replace_field_handler :conditional, @orig_conditional_handler
+  end
+
+  def test_generate_document_from_template
+    template = Sablon.template @template_path
+    context = {
+      normal_field: 'success1',
+      no_leading_equals: 'success2',
+      inside_if_no_op: 'success3',
+      no_operator: OpenStruct.new(test: 'success4'),
+      equals_operator: 'test',
+      inside_if_equals_op: 'success5'
+    }
+    #
+    template.render_to_file @output_path, context
+    assert_docx_equal @sample_path, @output_path
+  end
+end

data/test/fixtures/xml/conditional_inline_with_elsif_else_clauses.xml

@@ -0,0 +1,40 @@
+<w:p>
+  <w:r><w:t>Before</w:t></w:r>
+  <w:r><w:t xml:space="preserve"> </w:t></w:r>
+  <w:fldSimple w:instr=" MERGEFIELD object:if(method_a) \* MERGEFORMAT ">
+    <w:r>
+      <w:rPr><w:noProof/></w:rPr>
+      <w:t>«object:if(method_a)»</w:t>
+    </w:r>
+  </w:fldSimple>
+  <w:r>
+    <w:t>Method A was true</w:t>
+  </w:r>
+  <w:fldSimple w:instr=" MERGEFIELD object:elsif(method_b) \* MERGEFORMAT ">
+    <w:r>
+      <w:rPr><w:noProof/></w:rPr>
+      <w:t>«object:elsif(method_b)»</w:t>
+    </w:r>
+  </w:fldSimple>
+  <w:r>
+    <w:t>Method B was true</w:t>
+  </w:r>
+  <w:fldSimple w:instr=" MERGEFIELD object:else \* MERGEFORMAT ">
+    <w:r>
+      <w:rPr><w:noProof/></w:rPr>
+      <w:t>«object:else»</w:t>
+    </w:r>
+  </w:fldSimple>
+  <w:r>
+    <w:t>Method A and B were false</w:t>
+  </w:r>
+  <w:fldSimple w:instr=" MERGEFIELD object:endIf \* MERGEFORMAT ">
+    <w:r>
+      <w:rPr><w:noProof/></w:rPr>
+      <w:t>object:endIf»</w:t>
+    </w:r>
+  </w:fldSimple>
+  <w:r>
+    <w:t>After</w:t>
+  </w:r>
+</w:p>