sablon 0.0.21 → 0.0.22

data/lib/sablon/html/ast_builder.rb

@@ -0,0 +1,90 @@
+module Sablon
+  class HTMLConverter
+    # Converts a nokogiri HTML fragment into an equivalent AST structure
+    class ASTBuilder
+      attr_reader :nodes
+
+      def self.html_to_ast(env, nodes, properties)
+        builder = new(env, nodes, properties)
+        builder.nodes
+      end
+
+      private
+
+      def initialize(env, nodes, properties)
+        @env = env
+        @nodes = process_nodes(nodes, properties).compact
+      end
+
+      # Loops over HTML nodes converting them to their configured AST class
+      def process_nodes(html_nodes, properties)
+        html_nodes.flat_map do |node|
+          # get tags from config
+          parent_tag = fetch_tag(node.parent.name) if node.parent.name
+          tag = fetch_tag(node.name)
+
+          # remove all text nodes if the tag doesn't accept them
+          node.search('./text()').remove if drop_text?(tag)
+
+          # check node hierarchy
+          validate_structure(parent_tag, tag)
+
+          # merge properties
+          local_props = merge_node_properties(node, tag, properties)
+          if tag.ast_class
+            tag.ast_class.new(@env, node, local_props)
+          else
+            process_nodes(node.children, local_props)
+          end
+        end
+      end
+
+      # retrieves a HTMLTag instance from the cpermitted_html_tags hash or
+      # raises an ArgumentError if the tag is not registered in the hash
+      def fetch_tag(tag_name)
+        tag_name = tag_name.to_sym
+        unless Sablon::Configuration.instance.permitted_html_tags[tag_name]
+          raise ArgumentError, "Don't know how to handle HTML tag: #{tag_name}"
+        end
+        Sablon::Configuration.instance.permitted_html_tags[tag_name]
+      end
+
+      # Checking that the current tag is an allowed child of the parent_tag.
+      # If the parent tag is nil then a block level tag is required.
+      def validate_structure(parent, child)
+        if parent.ast_class == Root && child.type == :inline
+          msg = "#{child.name} needs to be wrapped in a block level tag."
+        elsif parent && !parent.allowed_child?(child)
+          msg = "#{child.name} is not a valid child element of #{parent.name}."
+        else
+          return
+        end
+        raise ContextError, "Invalid HTML structure: #{msg}"
+      end
+
+      # If the node doesn't allow inline elements, or text specifically,
+      # drop all text nodes. This is largely meant to prevent whitespace
+      # between tags from rasing an invalid structure error. Although it
+      # will purge the node whether it contains nonblank characters or not.
+      def drop_text?(child)
+        text = fetch_tag(:text)
+        !child.allowed_child?(text)
+      end
+
+      # Merges node properties in a sppecifc
+      def merge_node_properties(node, tag, parent_properties)
+        # Process any styles, defined on the node into a hash
+        if node['style']
+          style_props = node['style'].split(';').map do |prop|
+            prop.split(':').map(&:strip)
+          end
+          style_props = Hash[style_props]
+        else
+          style_props = {}
+        end
+        # allow inline styles to override parent styles passed down
+        parent_properties.merge(tag.properties).merge(style_props)
+      end
+    end
+  end
+end

data/lib/sablon/html/converter.rb

@@ -3,67 +3,8 @@ require "sablon/html/visitor"
 
 module Sablon
   class HTMLConverter
-    class ASTBuilder
-      Layer = Struct.new(:items, :ilvl)
-
-      def initialize(nodes)
-        @layers = [Layer.new(nodes, false)]
-        @root = Root.new([])
-      end
-
-      def to_ast
-        @root
-      end
-
-      def new_layer(ilvl: false)
-        @layers.push Layer.new([], ilvl)
-      end
-
-      def next
-        current_layer.items.shift
-      end
-
-      def push(node)
-        @layers.last.items.push node
-      end
-
-      def push_all(nodes)
-        nodes.each(&method(:push))
-      end
-
-      def done?
-        !current_layer.items.any?
-      end
-
-      def nested?
-        ilvl > 0
-      end
-
-      def ilvl
-        @layers.select { |layer| layer.ilvl }.size - 1
-      end
-
-      def emit(node)
-        @root.nodes << node
-      end
-
-      private
-      def current_layer
-        if @layers.any?
-          last_layer = @layers.last
-          if last_layer.items.any?
-            last_layer
-          else
-            @layers.pop
-            current_layer
-          end
-        else
-          Layer.new([], false)
-        end
-      end
-    end
-
-    def process(input)
+    def process(input, env)
+      @env = env
       processed_ast(input).to_docx
     end
 
@@ -75,68 +16,7 @@ module Sablon
 
     def build_ast(input)
       doc = Nokogiri::HTML.fragment(input)
-      @builder = ASTBuilder.new(doc.children)
-
-      while !@builder.done?
-        ast_next_paragraph
-      end
-      @builder.to_ast
-    end
-
-    private
-    def ast_next_paragraph
-      node = @builder.next
-      if node.name == 'div'
-        @builder.new_layer
-        @builder.emit Paragraph.new('Normal', ast_text(node.children))
-      elsif node.name == 'p'
-        @builder.new_layer
-        @builder.emit Paragraph.new('Paragraph', ast_text(node.children))
-      elsif node.name =~ /h(\d+)/
-        @builder.new_layer
-        @builder.emit Paragraph.new("Heading#{$1}", ast_text(node.children))
-      elsif node.name == 'ul'
-        @builder.new_layer ilvl: true
-        unless @builder.nested?
-          @definition = Sablon::Numbering.instance.register('ListBullet')
-        end
-        @builder.push_all(node.children)
-      elsif node.name == 'ol'
-        @builder.new_layer ilvl: true
-        unless @builder.nested?
-          @definition = Sablon::Numbering.instance.register('ListNumber')
-        end
-        @builder.push_all(node.children)
-      elsif node.name == 'li'
-        @builder.new_layer
-        @builder.emit ListParagraph.new(@definition.style, ast_text(node.children), @definition.numid, @builder.ilvl)
-      elsif node.text?
-        # SKIP?
-      else
-        raise ArgumentError, "Don't know how to handle node: #{node.inspect}"
-      end
-    end
-
-    def ast_text(nodes, format: TextFormat.default)
-      runs = nodes.flat_map do |node|
-        if node.text?
-          Text.new(node.text, format)
-        elsif node.name == 'br'
-          Newline.new
-        elsif node.name == 'strong' || node.name == 'b'
-          ast_text(node.children, format: format.with_bold).nodes
-        elsif node.name == 'em' || node.name == 'i'
-          ast_text(node.children, format: format.with_italic).nodes
-        elsif node.name == 'u'
-          ast_text(node.children, format: format.with_underline).nodes
-        elsif ['ul', 'ol', 'p', 'div'].include?(node.name)
-          @builder.push(node)
-          nil
-        else
-          raise ArgumentError, "Don't know how to handle node: #{node.inspect}"
-        end
-      end
-      Collection.new(runs.compact)
+      Root.new(@env, doc)
     end
   end
 end

data/lib/sablon/numbering.rb

@@ -1,6 +1,5 @@
 module Sablon
   class Numbering
-    include Singleton
     attr_reader :definitions
 
     Definition = Struct.new(:numid, :style) do
@@ -10,10 +9,6 @@ module Sablon
     end
 
     def initialize
-      reset!
-    end
-
-    def reset!
       @numid = 1000
       @definitions = []
     end

data/lib/sablon/operations.rb

@@ -2,9 +2,9 @@
 module Sablon
   module Statement
     class Insertion < Struct.new(:expr, :field)
-      def evaluate(context)
-        if content = expr.evaluate(context)
-          field.replace(Sablon::Content.wrap(content))
+      def evaluate(env)
+        if content = expr.evaluate(env.context)
+          field.replace(Sablon::Content.wrap(content), env)
         else
           field.remove
         end
@@ -12,24 +12,24 @@ module Sablon
     end
 
     class Loop < Struct.new(:list_expr, :iterator_name, :block)
-      def evaluate(context)
-        value = list_expr.evaluate(context)
+      def evaluate(env)
+        value = list_expr.evaluate(env.context)
         value = value.to_ary if value.respond_to?(:to_ary)
         raise ContextError, "The expression #{list_expr.inspect} should evaluate to an enumerable but was: #{value.inspect}" unless value.is_a?(Enumerable)
 
         content = value.flat_map do |item|
-          iteration_context = context.merge(iterator_name => item)
-          block.process(iteration_context)
+          iter_env = env.alter_context(iterator_name => item)
+          block.process(iter_env)
         end
         block.replace(content.reverse)
       end
     end
 
     class Condition < Struct.new(:conditon_expr, :block, :predicate)
-      def evaluate(context)
-        value = conditon_expr.evaluate(context)
+      def evaluate(env)
+        value = conditon_expr.evaluate(env.context)
         if truthy?(predicate ? value.public_send(predicate) : value)
-          block.replace(block.process(context).reverse)
+          block.replace(block.process(env).reverse)
         else
           block.replace([])
         end
@@ -46,7 +46,7 @@ module Sablon
     end
 
     class Comment < Struct.new(:block)
-      def evaluate(context)
+      def evaluate(_env)
         block.replace []
       end
     end

data/lib/sablon/parser/mail_merge.rb

@@ -13,10 +13,11 @@ module Sablon
         end
 
         private
-        def replace_field_display(node, content)
+
+        def replace_field_display(node, content, env)
           paragraph = node.ancestors(".//w:p").first
           display_node = get_display_node(node)
-          content.append_to(paragraph, display_node)
+          content.append_to(paragraph, display_node, env)
           display_node.remove
         end
 
@@ -35,8 +36,8 @@ module Sablon
           separate_node && get_display_node(pattern_node) && expression
         end
 
-        def replace(content)
-          replace_field_display(pattern_node, content)
+        def replace(content, env)
+          replace_field_display(pattern_node, content, env)
           (@nodes - [pattern_node]).each(&:remove)
         end
 
@@ -72,9 +73,9 @@ module Sablon
           @raw_expression = @node["w:instr"]
         end
 
-        def replace(content)
+        def replace(content, env)
           remove_extra_runs!
-          replace_field_display(@node, content)
+          replace_field_display(@node, content, env)
           @node.replace(@node.children)
         end
 

data/lib/sablon/processor/document.rb

@@ -2,9 +2,9 @@
 module Sablon
   module Processor
     class Document
-      def self.process(xml_node, context, properties = {})
+      def self.process(xml_node, env, properties = {})
         processor = new(parser)
-        processor.manipulate xml_node, Sablon::Context.transform(context)
+        processor.manipulate xml_node, env
         processor.write_properties xml_node, properties if properties.any?
         xml_node
       end
@@ -17,10 +17,10 @@ module Sablon
         @parser = parser
       end
 
-      def manipulate(xml_node, context)
+      def manipulate(xml_node, env)
         operations = build_operations(@parser.parse_fields(xml_node))
         operations.each do |step|
-          step.evaluate context
+          step.evaluate env
         end
         cleanup(xml_node)
         xml_node
@@ -56,10 +56,10 @@ module Sablon
           block_class.new start_field, end_field
         end
 
-        def process(context)
+        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, context
+          Processor::Document.process replaced_node, env
           replaced_node.children
         end
 
@@ -69,7 +69,7 @@ module Sablon
         end
 
         def remove_control_elements
-          body.each &:remove
+          body.each(&:remove)
           start_node.remove
           end_node.remove
         end
@@ -123,7 +123,7 @@ module Sablon
         end
 
         def remove_control_elements
-          body.each &:remove
+          body.each(&:remove)
           start_field.remove
           end_field.remove
         end
@@ -171,7 +171,7 @@ module Sablon
           when /([^ ]+):if/
             block = consume_block("#{$1}:endIf")
             Statement::Condition.new(Expression.parse($1), block)
-          when /comment/
+          when /^comment$/
             block = consume_block("endComment")
             Statement::Comment.new(block)
           end

data/lib/sablon/processor/numbering.rb

@@ -7,9 +7,9 @@ module Sablon
         </w:num>
       XML
 
-      def self.process(doc)
+      def self.process(doc, env)
         processor = new(doc)
-        processor.manipulate
+        processor.manipulate env
         doc
       end
 
@@ -17,8 +17,8 @@ module Sablon
         @doc = doc
       end
 
-      def manipulate
-        Sablon::Numbering.instance.definitions.each do |definition|
+      def manipulate(env)
+        env.numbering.definitions.each do |definition|
           abstract_num_ref = find_definition(definition.style)
           abstract_num_copy = abstract_num_ref.dup
           abstract_num_copy['w:abstractNumId'] = definition.numid

data/lib/sablon/template.rb

@@ -17,8 +17,9 @@ module Sablon
     end
 
     private
+
     def render(context, properties = {})
-      Sablon::Numbering.instance.reset!
+      env = Sablon::Environment.new(self, context)
       Zip.sort_entries = true # required to process document.xml before numbering.xml
       Zip::OutputStream.write_buffer(StringIO.new) do |out|
         Zip::File.open(@path).each do |entry|
@@ -26,11 +27,11 @@ module Sablon
           out.put_next_entry(entry_name)
           content = entry.get_input_stream.read
           if entry_name == 'word/document.xml'
-            out.write(process(Processor::Document, content, context, properties))
+            out.write(process(Processor::Document, content, env, properties))
           elsif entry_name =~ /word\/header\d*\.xml/ || entry_name =~ /word\/footer\d*\.xml/
-            out.write(process(Processor::Document, content, context))
+            out.write(process(Processor::Document, content, env))
           elsif entry_name == 'word/numbering.xml'
-            out.write(process(Processor::Numbering, content))
+            out.write(process(Processor::Numbering, content, env))
           else
             out.write(content)
           end