ad_hoc_template 0.4.0 → 0.4.1

data/lib/ad_hoc_template/default_tag_formatter.rb

@@ -1,14 +1,14 @@
-#!/usr/bin/env ruby
+# frozen_string_literal: true
 
 module AdHocTemplate
   class DefaultTagFormatter
     FUNCTION_TABLE = {
-      "=" => :default,
-      "h" => :html_encode
+      '=' => :default,
+      'h' => :html_encode,
     }
 
     def self.assign_format(format_label, &func)
-      if format_label.kind_of? Hash and not func
+      if format_label.kind_of?(Hash) && !func
         func_name, label = format_label.to_a.flatten
         FUNCTION_TABLE[label] = func_name
       else
@@ -17,25 +17,25 @@ module AdHocTemplate
     end
 
     def find_function(format_label)
-      FUNCTION_TABLE[format_label]||:default
+      FUNCTION_TABLE[format_label] || :default
     end
 
     def format(format_label, var, record)
       func = find_function(format_label)
       case func
       when Symbol, String
-        self.send(func, var, record)
+        send(func, var, record)
       else
         func.call(var, record)
       end
     end
 
     def default(var, record)
-      record[var]||"[#{var}]"
+      record[var] || "[#{var}]"
     end
 
     def html_encode(var, record)
-      HtmlElement.escape(record[var]||var)
+      HtmlElement.escape(record[var] || var)
     end
   end
 end

data/lib/ad_hoc_template/entry_format_generator.rb

@@ -1,7 +1,9 @@
-#!/usr/bin/env ruby
+# frozen_string_literal: true
 
 module AdHocTemplate
   module EntryFormatGenerator
+    DEFAULT_ENCODING = Encoding.default_external.names[0]
+
     class LabelChecker
       attr_reader :labels
       def initialize
@@ -22,13 +24,15 @@ module AdHocTemplate
       private
 
       def visit_iteration_tag_node(tree, memo)
-        if iteration_label = tree.type
+        sub_checker = self
+        iteration_label = tree.type
+
+        if iteration_label
           sub_checker = self.class.new
           @labels[iteration_label] = [sub_checker.labels]
-          tree.each { |node| node.accept(sub_checker, memo) }
-        else
-          tree.each {|node| node.accept(self, memo) }
         end
+
+        tree.each {|node| node.accept(sub_checker, memo) }
       end
     end
 
@@ -39,17 +43,23 @@ module AdHocTemplate
       RecordReader.dump(labels, target_format)
     end
 
-    def self.extract_recipes_from_template_files(template_paths, tag_type=:default,
-                                                 encoding=Encoding.default_external.names[0])
-      recipes = template_paths.map do |path|
-        full_path = File.expand_path(path)
-        template_source = open(full_path) {|file| file.read }
-        extract_recipe(template_source, path, tag_type, encoding)
+    def self.extract_recipes_from_template_files(template_paths,
+                                                 tag_type=:default,
+                                                 encoding=DEFAULT_ENCODING)
+      recipes = map_read_files(template_paths, encoding) do |path, src|
+        extract_recipe(src, path, tag_type, encoding)
       end
 
       recipes.join
     end
 
+    def self.map_read_files(paths, encoding=DEFAULT_ENCODING)
+      paths.map do |path|
+        full_path = File.expand_path(path)
+        yield path, File.open(full_path, "rb:BOM|#{encoding}", &:read)
+      end
+    end
+
     def self.extract_recipe(template_source, template_path,
                             tag_type=:default, encoding='UTF-8')
       recipe = recipe_entry(template_path, tag_type, encoding)
@@ -91,7 +101,7 @@ module AdHocTemplate
     end
 
     def self.recipe_entry(template_path, tag_type, encoding)
-      recipe = {
+      {
         'template' => template_path,
         'tag_type' => tag_type,
         'template_encoding' => encoding,
@@ -99,7 +109,7 @@ module AdHocTemplate
         'data_format' => nil,
         'data_encoding' => nil,
         'output_file' => nil,
-        'blocks' => []
+        'blocks' => [],
       }
     end
 
@@ -112,6 +122,7 @@ module AdHocTemplate
       }
     end
 
+    private_class_method :map_read_files
     private_class_method :extract_form_as_ruby_objects
     private_class_method :pull_up_inner_iterations
     private_class_method :each_iteration_label

data/lib/ad_hoc_template/parser.rb

@@ -1,7 +1,7 @@
-#!/usr/bin/env ruby
+# frozen_string_literal: true
 
-require "pseudohiki/inlineparser"
-require "htmlelement"
+require 'pseudohiki/inlineparser'
+require 'htmlelement'
 
 module AdHocTemplate
   LINE_END_RE = /(?:\r?\n|\r)/
@@ -13,7 +13,7 @@ module AdHocTemplate
 
       def push(node=TreeStack::Node.new)
         first_leaf = node[0]
-        node[0] = assign_value_to_type(first_leaf) if empty? and first_leaf
+        node[0] = assign_value_to_type(first_leaf) if empty? && first_leaf
         super
       end
 
@@ -27,19 +27,35 @@ module AdHocTemplate
         each_tag_node {|node| return true if node.contains_any_value_tag? }
       end
 
+      def contains_any_fallback_tag?
+        any? {|sub_node| sub_node.kind_of? Parser::FallbackNode }
+      end
+
       def inner_iteration_tag_labels
         names = []
         each_tag_node do |node|
           next unless node.kind_of? IterationNode
           names.push node.type if node.type
-          if inner_names = node.inner_iteration_tag_labels
-            names.concat inner_names
-          end
+          inner_names = node.inner_iteration_tag_labels
+          names.concat inner_names if inner_names
         end
 
         names unless names.empty?
       end
 
+      def cast(node_type=Parser::TagNode)
+        node_type.new.concat(clone)
+      end
+
+      def select_fallback_nodes
+        nodes = select {|sub_node| sub_node.kind_of? Parser::FallbackNode }
+        nodes.empty? ? nil : nodes
+      end
+
+      def format_sub_nodes(data_loader, memo)
+        map {|leaf| leaf.accept(data_loader, memo) }.join
+      end
+
       private
 
       def each_tag_node
@@ -48,11 +64,11 @@ module AdHocTemplate
       end
 
       def assign_value_to_type(first_leaf)
-        if first_leaf.kind_of? String and /\A\s/ =~ first_leaf
-          return first_leaf.sub(/\A#{LINE_END_STR}/, "")
+        if first_leaf.kind_of?(String) && /\A\s/ =~ first_leaf
+          return first_leaf.sub(/\A#{LINE_END_STR}/, '')
         end
         @type, first_leaf_content = split_by_newline_or_spaces(first_leaf)
-        first_leaf_content||""
+        first_leaf_content || ''
       end
 
       def split_by_newline_or_spaces(first_leaf)
@@ -62,12 +78,30 @@ module AdHocTemplate
     end
 
     class IterationNode < TagNode
+      class InnerLabel
+        attr_reader :inner_label
+
+        def self.labels(inner_labels, cur_label)
+          inner_labels.map {|label| new(label, cur_label) }
+        end
+
+        def initialize(inner_label, cur_label)
+          @inner_label = inner_label
+          @label, @key = inner_label.sub(/\A#/, '').split(/\|/, 2)
+          @cur_label = cur_label
+        end
+
+        def full_label(record)
+          [@cur_label, @label, record[@key]].join('|')
+        end
+      end
+
       def assign_value_to_type(first_leaf)
         return first_leaf unless first_leaf.kind_of? String
 
         if /\A[^\s:]*:\s/ =~ first_leaf
           @type, remaining_part = first_leaf.split(/:(?:#{LINE_END_STR}|\s)/, 2)
-          @type = @type.empty? ? nil : '#'.freeze + @type
+          @type = @type.empty? ? nil : '#' + @type
           return remaining_part
         end
 
@@ -81,13 +115,19 @@ module AdHocTemplate
         end
       end
 
+      def inner_labels
+        return unless @type
+        labels = inner_iteration_tag_labels
+        InnerLabel.labels(labels, @type) if labels
+      end
+
       private
 
       def not_empty_sub_records?(record)
         sub_records = record[type]
-        return false if sub_records.nil? or sub_records.empty?
+        return false if sub_records.nil? || sub_records.empty?
         sub_records.each do |rec|
-          return true if rec.values.any? {|val| val and not val.empty? }
+          return true if rec.values.any? {|val| val && !val.empty? }
         end
         false
       end
@@ -99,15 +139,20 @@ module AdHocTemplate
         first_leaf.sub(/\A#{LINE_END_STR}/, '')
       end
 
-      def contains_any_value_assigned_tag_node?(record)
+      def contains_any_value_assigned_tag_node?(_record)
         false
       end
+
+      def format_sub_nodes(data_loader, memo)
+        node = cast(Parser::IterationNode)
+        node.contains_any_value_tag? ? node.accept(data_loader, memo) : node.join
+      end
     end
 
     class ValueNode < TagNode
       def contains_any_value_assigned_tag_node?(record)
-        val = record[self.join.strip]
-        val and not val.empty?
+        val = record[join.strip]
+        val && !val.empty?
       end
 
       def contains_any_value_tag?
@@ -118,7 +163,34 @@ module AdHocTemplate
     class Leaf < Parser::Leaf; end
 
     class TagType
-      attr_reader :head, :tail, :token_pat, :remove_iteration_indent
+      PREDEFINED = {
+        default: [
+          ['<%', '%>'], ['<%#', '#%>'],
+          ['<%*', '*%>'], false,
+        ],
+        square_brackets: [
+          ['[[', ']]'], ['[[#', '#]]'],
+          ['[[*', '*]]'], false,
+        ],
+        curly_brackets: [
+          ['{{', '}}'], ['{{#', '#}}'],
+          ['{{*', '*}}'], false,
+        ],
+        xml_like1: [
+          ['<!--%', '%-->'], ['<iterate>', '</iterate>'],
+          ['<fallback>', '</fallback>'], true,
+        ],
+        xml_like2: [
+          ['<fill>', '</fill>'], ['<iterate>', '</iterate>'],
+          ['<fallback>', '</fallback>'], true,
+        ],
+        xml_comment_like: [
+          ['<!--%', '%-->'], ['<!--%iterate%-->', '<!--%/iterate%-->'],
+          ['<!--%fallback%-->', '<!--%/fallback%-->'], true,
+        ],
+      }.freeze
+
+      attr_reader :head, :tail, :token_pat, :strip_iteration_indent
       attr_reader :head_of, :tail_of
       @types = {}
 
@@ -126,60 +198,59 @@ module AdHocTemplate
         @types[tag_name]
       end
 
-      def self.register(tag_name=:default, tag=["<%", "%>"], iteration_tag=["<%#", "#%>"],
-                        fallback_tag=["<%*", "*%>"], remove_iteration_indent=false)
-        @types[tag_name] = new(tag, iteration_tag, fallback_tag, remove_iteration_indent)
+      def self.register(tag_name, tag, iteration_tag,
+                        fallback_tag, strip_iteration_indent=false)
+        @types[tag_name] = new(tag, iteration_tag,
+                               fallback_tag, strip_iteration_indent)
       end
 
-      def initialize(tag, iteration_tag, fallback_tag, remove_iteration_indent)
+      def initialize(tag, iteration_tag, fallback_tag, strip_iteration_indent)
         assign_type(tag, iteration_tag, fallback_tag)
         @token_pat = PseudoHiki.compile_token_pat(@head.keys, @tail.keys)
-        @remove_iteration_indent = remove_iteration_indent
+        @strip_iteration_indent = strip_iteration_indent
       end
 
       def assign_type(tag, iteration_tag, fallback_tag)
         node_tag_pairs = [
           [ValueNode, *tag],
           [IterationNode, *iteration_tag],
-          [FallbackNode, *fallback_tag]
+          [FallbackNode, *fallback_tag],
         ]
 
-        @head, @tail, @head_of, @tail_of = PseudoHiki.associate_nodes_with_tags(node_tag_pairs)
+        @head, @tail, @head_of, @tail_of = map_nodes_to_tags(node_tag_pairs)
+      end
+
+      def map_nodes_to_tags(node_tag_pairs)
+        PseudoHiki.associate_nodes_with_tags(node_tag_pairs)
       end
 
-      register
-      register(:square_brackets, ["[[", "]]"], ["[[#", "#]]"], ["[[*", "*]]"])
-      register(:curly_brackets, ["{{", "}}"], ["{{#", "#}}"], ["{{*", "*}}"])
-      register(:xml_like1, ["<!--%", "%-->"], ["<iterate>", "</iterate>"], ["<fallback>", "</fallback>"], true)
-      register(:xml_like2, ["<fill>", "</fill>"], ["<iterate>", "</iterate>"], ["<fallback>", "</fallback>"], true)
-      register(:xml_comment_like, ["<!--%", "%-->"], ["<!--%iterate%-->", "<!--%/iterate%-->"], ["<!--%fallback%-->", "<!--%/fallback%-->"], true)
+      private :map_nodes_to_tags
+
+      PREDEFINED.each {|tag_name, tags| register(tag_name, *tags) }
     end
 
     class UserDefinedTagTypeConfigError < StandardError; end
 
     def self.parse(str, tag_name=:default)
       str = remove_indents_and_newlines_if_necessary(str, tag_name)
-      new(str, TagType[tag_name]).parse.tree
+      new(str, TagType[tag_name]).parse!.tree
     end
 
     def self.register_user_defined_tag_type(config_source)
-      config = YAML.load(config_source)
-      %w(tag_name tag iteration_tag fallback_tag).each do |item|
-        config[item] || raise(UserDefinedTagTypeConfigError,
-                              "\"#{item}\" should be defined.")
-      end
-      TagType.register(registered_tag_name = config["tag_name"].to_sym,
-                       config["tag"],
-                       config["iteration_tag"],
-                       config["fallback_tag"],
-                       config["remove_indent"] || false)
+      config = YAML.safe_load(config_source, [Symbol])
+      check_validity_of_config(config)
+      TagType.register(registered_tag_name = config['tag_name'].to_sym,
+                       config['tag'],
+                       config['iteration_tag'],
+                       config['fallback_tag'],
+                       config['remove_indent'] || false)
       registered_tag_name
     end
 
     def self.remove_indents_and_newlines_if_necessary(str, tag_name)
       node_types = [IterationNode, FallbackNode]
       tag_type = TagType[tag_name]
-      if TagType[tag_name].remove_iteration_indent
+      if TagType[tag_name].strip_iteration_indent
         str = remove_indent_before_iteration_tags(str, tag_type)
         str = remove_indent_before_fallback_tags(str, tag_type)
       end
@@ -187,20 +258,19 @@ module AdHocTemplate
     end
 
     def self.remove_indent_before_iteration_tags(template_source, tag_type)
-      start_tag, end_tag = [
-        tag_type.head_of[IterationNode],
-        tag_type.tail_of[IterationNode],
-      ].map {|tag| Regexp.escape(tag) }
-      template_source.gsub(/^([ \t]+#{start_tag}\S*#{LINE_END_STR})/) {|s| s.lstrip }
-        .gsub(/^([ \t]+#{end_tag}#{LINE_END_STR})/) {|s| s.lstrip }
+      start_tag, end_tag = regexp_escape_tag_pair(tag_type, IterationNode)
+      template_source.gsub(/^([ \t]+#{start_tag}\S*#{LINE_END_STR})/, &:lstrip)
+        .gsub(end_tag_alone_re(end_tag), &:lstrip)
     end
 
     def self.remove_indent_before_fallback_tags(template_source, tag_type)
-      tag_re_str = [
-        tag_type.head_of[FallbackNode],
-        tag_type.tail_of[FallbackNode],
-      ].map {|tag| Regexp.escape(tag) }.join('|')
-      template_source.gsub(/^([ \t]+(?:#{tag_re_str})#{LINE_END_STR})/) {|s| s.lstrip }
+      tag_re_str = regexp_escape_tag_pair(tag_type, FallbackNode).join('|')
+      template_source.gsub(end_tag_alone_re(tag_re_str), &:lstrip)
+    end
+
+    def self.regexp_escape_tag_pair(tag_type, node_class)
+      [tag_type.head_of[node_class],
+       tag_type.tail_of[node_class],].map {|tag| Regexp.escape(tag) }
     end
 
     def self.remove_trailing_newline_of_end_tags(node_types, source, tag_type)
@@ -210,10 +280,24 @@ module AdHocTemplate
       end
     end
 
+    def self.end_tag_alone_re(tag)
+      /^([ \t]+(?:#{tag})#{LINE_END_STR})/
+    end
+
+    def self.check_validity_of_config(config)
+      %w[tag_name tag iteration_tag fallback_tag].each do |item|
+        config[item] || raise(UserDefinedTagTypeConfigError,
+                              "\"#{item}\" should be defined.")
+      end
+    end
+
     private_class_method(:remove_indents_and_newlines_if_necessary,
                          :remove_indent_before_iteration_tags,
                          :remove_indent_before_fallback_tags,
-                         :remove_trailing_newline_of_end_tags)
+                         :regexp_escape_tag_pair,
+                         :remove_trailing_newline_of_end_tags,
+                         :end_tag_alone_re,
+                         :check_validity_of_config)
 
     def initialize(source, tag)
       @tag = tag
@@ -221,13 +305,14 @@ module AdHocTemplate
       super()
     end
 
-    def parse
-      while token = @tokens.shift
-        next if @tag.tail[token] == current_node.class and self.pop
-        next if @tag.head[token] and self.push @tag.head[token].new
-        self.push Leaf.create(token)
+    def parse!
+      @tokens.each do |token|
+        next if @tag.tail[token] == current_node.class && pop
+        next if @tag.head[token] && push(@tag.head[token].new)
+        push Leaf.create(token)
       end
 
+      @tokens = nil
       self
     end
   end