ad_hoc_template 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 77dedc981af5ec62410d30504f9d41bb01fb78b3
-  data.tar.gz: 090b330043f0d60d385e613dc50a617d85fe6dba
+  metadata.gz: a41e80d33bd430c264ac2704bf7850baf3bcebc7
+  data.tar.gz: f10b0463f915e33987e5ac04e4928737eba11fc2
 SHA512:
-  metadata.gz: e96dd5a5f56ded725d6fd1d5c8a02ec5855dbed793200da55e4594ac9f832a441383963eee8f2f46b61dcd21002295264f5f3ddbae891ee6f3ebba2ee41c0c0b
-  data.tar.gz: 46682a5ae8479d813c14b5019ba7150d4db4a1e5199f2a1252ed1a971faec73ed9ba832327761998ccc631925a95047ea4efdc22b30b26d53c06fc85792a23e9
+  metadata.gz: 0b423fd73c6d59c11975fadddccdf56697a15f9784510277b23c4011c66b0d235b111285201ca24659c72b1456294990939a172bfd8998e86a441c57e16ac426
+  data.tar.gz: bfb7de0f42fd16cba6e2c75ee0e2d7764c86cd2e4d135e38f1cc05cc271b9dc45681a351ddc84d68175d85c6019df23c99b94202efc650f981ce2b1063a56f10

data/README.md

@@ -27,7 +27,7 @@ The following is an example of template format:
 ```
 a test string with tags (<%= key1 %> and <%= key2 %>) in it
 
-<%#iteration_block
+<%#iteration_block:
 the value of sub_key1 is <%= sub_key1 %>
 the value of sub_key2 is <%= sub_key2 %>
 

data/lib/ad_hoc_template.rb

@@ -3,6 +3,7 @@ require "ad_hoc_template/parser"
 require "ad_hoc_template/record_reader"
 require "ad_hoc_template/default_tag_formatter"
 require "ad_hoc_template/pseudohiki_formatter"
+require "ad_hoc_template/entry_format_generator"
 
 module AdHocTemplate
   class DataLoader
@@ -29,6 +30,8 @@ module AdHocTemplate
       case tree
       when Parser::IterationTagNode
         format_iteration_tag(tree)
+      when Parser::FallbackTagNode
+        ''.freeze
       when Parser::TagNode
         format_tag(tree)
       when Parser::Leaf
@@ -40,12 +43,15 @@ module AdHocTemplate
 
     def format_iteration_tag(tag_node)
       sub_records = @record[tag_node.type]||[@record]
-      tag_node = Parser::TagNode.new.concat(tag_node.clone)
+      tag_node = cast(tag_node)
+      fallback_nodes = tag_node.select {|sub_node| sub_node.kind_of? Parser::FallbackTagNode }
 
       sub_records.map do |record|
         if tag_node.contains_any_value_assigned_tag_node?(record)
           data_loader = AdHocTemplate::DataLoader.new(record, @tag_formatter)
           tag_node.map {|leaf| leaf.accept(data_loader) }.join
+        elsif not fallback_nodes.empty?
+          format_fallback_tags(fallback_nodes, record)
         else
           "".freeze
         end
@@ -60,10 +66,25 @@ module AdHocTemplate
     def format(tree)
       tree.accept(self).join
     end
+
+    private
+
+    def cast(node, node_type=Parser::TagNode)
+      node_type.new.concat(node.clone)
+    end
+
+    def format_fallback_tags(fallback_nodes, record)
+      data_loader = AdHocTemplate::DataLoader.new(record, @tag_formatter)
+      fallback_nodes = fallback_nodes.map {|node| cast(node, Parser::IterationTagNode) }
+      fallback_nodes = cast(fallback_nodes)
+      fallback_nodes.map do |node|
+        node.contains_any_value_tag? ? node.accept(data_loader) : node.join
+      end
+    end
   end
 
-  def self.convert(record_data, template, tag_type=:default, data_format=:default,
-                   tag_formatter=DefaultTagFormatter.new)
+  def self.render(record_data, template, tag_type=:default, data_format=:default,
+                  tag_formatter=DefaultTagFormatter.new)
     tree = Parser.parse(template, tag_type)
     record = RecordReader.read_record(record_data, data_format)
     DataLoader.format(tree, record, tag_formatter)

data/lib/ad_hoc_template/command_line_interface.rb

@@ -6,6 +6,7 @@ require 'optparse_plus'
 module AdHocTemplate
   class CommandLineInterface
     attr_accessor :output_filename, :template_data, :record_data, :tag_type, :data_format
+    attr_writer :output_empty_entry
 
     TAG_RE_TO_TYPE = {
       /\Ad(efault)?/i => :default,
@@ -13,6 +14,7 @@ module AdHocTemplate
       /\As(quare_brackets)?/i => :square_brackets,
       /\Axml_like1/i => :xml_like1,
       /\Axml_like2/i => :xml_like2,
+      /\Axml_comment_like/i => :xml_comment_like,
     }
 
     FORMAT_RE_TO_FORMAT = {
@@ -47,6 +49,7 @@ module AdHocTemplate
         opt.on(:tag_type) {|given_type| choose_tag_type(given_type) }
         opt.on(:data_format) {|data_format| choose_data_format(data_format) }
         opt.on(:tag_config) {|tag_config_yaml| register_user_defined_tag_type(tag_config_yaml) }
+        opt.on(:entry_format) {|entry_format| @output_empty_entry = true }
 
         opt.parse!
       end
@@ -68,11 +71,16 @@ module AdHocTemplate
       @record_data = record ? File.read(record) : ARGF.read
     end
 
-    def convert
-      AdHocTemplate.convert(@record_data, @template_data, @tag_type,
+    def render
+      AdHocTemplate.render(@record_data, @template_data, @tag_type,
                             @data_format, @tag_formatter)
     end
 
+    def generate_entry_format
+      tree = Parser.parse(@template_data, @tag_type)
+      EntryFormatGenerator.extract_labels(tree, @data_format)
+    end
+
     def open_output
       if @output_filename
         open(@output_filename, "wb") do |out|
@@ -86,22 +94,26 @@ module AdHocTemplate
     def execute
       parse_command_line_options
       read_input_files
-      open_output {|out| out.print convert }
+      output = @output_empty_entry ? generate_entry_format : render
+      open_output {|out| out.print output }
     end
 
     private
 
     def choose_tag_type(given_type)
-      if_any_regex_match(TAG_RE_TO_TYPE, given_type,
-                         "The given type is not found. The default tag is chosen.") do |re, tag_type|
+      err_msg = "The given type is not found. The default tag is chosen."
+
+      if_any_regex_match(TAG_RE_TO_TYPE, given_type, err_msg) do |re, tag_type|
         @tag_type = tag_type
       end
     end
 
     def choose_data_format(data_format)
-      if_any_regex_match(FORMAT_RE_TO_FORMAT, data_format,
-                         "The given format is not found. The default format is chosen.") do |re, format|
-        @data_format = [:csv, :tsv].include?(format) ? make_csv_option(data_format, format) : format
+      err_msg = "The given format is not found. The default format is chosen."
+      format_part, label_part = data_format.split(/:/, 2)
+
+      if_any_regex_match(FORMAT_RE_TO_FORMAT, format_part, err_msg) do |re, format|
+        @data_format = [:csv, :tsv].include?(format) ? make_csv_option(label_part, format) : format
       end
     end
 
@@ -110,9 +122,9 @@ module AdHocTemplate
       @tag_type = Parser.register_user_defined_tag_type(config)
     end
 
-    def make_csv_option(data_format, format)
-      iteration_label = data_format.sub(/\A(csv|tsv):?/, "")
-      iteration_label.empty? ? format : { format => iteration_label }
+    def make_csv_option(iteration_label, format)
+      return format if iteration_label.nil? or iteration_label.empty?
+      { format => iteration_label }
     end
 
     def guess_file_format(filename)
@@ -151,3 +163,7 @@ tag_config:
   short: "-u [tag_config.yaml]"
   long: "--user-defined-tag [=tag_config.yaml]"
   description: "Configure a user-defined tag. The configuration file is in YAML format."
+entry_format:
+  short: "-e"
+  long: "--entry-format"
+  description: "Extract tag labels from a template and generate an empty data entry format"

data/lib/ad_hoc_template/entry_format_generator.rb

@@ -0,0 +1,49 @@
+#!/usr/bin/env ruby
+
+module AdHocTemplate
+  module EntryFormatGenerator
+    class LabelChecker
+      attr_reader :labels
+      def initialize
+        @labels = {}
+      end
+
+      def visit(tree)
+        case tree
+        when Parser::IterationTagNode, Parser::FallbackTagNode
+          visit_iteration_tag_node(tree)
+        when Parser::TagNode
+          @labels[tree.join.strip] = nil
+        when Parser::Node
+          tree.each {|node| node.accept(self) }
+        end
+      end
+
+      private
+
+      def visit_iteration_tag_node(tree)
+        if iteration_label = tree.type
+          sub_checker = self.class.new
+          @labels[iteration_label] = [sub_checker.labels]
+          tree.each { |node| node.accept(sub_checker) }
+        else
+          tree.each {|node| node.accept(self) }
+        end
+      end
+    end
+
+    def self.extract_labels(parsed_template, target_format=nil)
+      labels = extract_labels_as_ruby_objects(parsed_template)
+
+      RecordReader.dump(labels, target_format)
+    end
+
+    def self.extract_labels_as_ruby_objects(parsed_template)
+      label_checker = LabelChecker.new
+      parsed_template.accept(label_checker)
+      label_checker.labels
+    end
+
+    private_class_method :extract_labels_as_ruby_objects
+  end
+end

data/lib/ad_hoc_template/parser.rb

@@ -4,30 +4,19 @@ require "pseudohiki/inlineparser"
 require "htmlelement"
 
 module AdHocTemplate
+  LINE_END_RE = /(?:\r?\n|\r)/
+  LINE_END_STR = '(?:\r?\n|\r)'
+
   class Parser < TreeStack
     class TagNode < Parser::Node
       attr_reader :type
 
       def push(node=TreeStack::Node.new)
-        node[0] = assign_type(node[0]) if self.empty?
+        first_leaf = node[0]
+        node[0] = assign_value_to_type(first_leaf) if empty? and first_leaf
         super
       end
 
-      def assign_type(first_leaf)
-        if not first_leaf.kind_of? String or /\A\s/ =~ first_leaf
-          return first_leaf.sub(/\A(?:\r?\n|\r)/, "")
-        end
-        @type, first_leaf_content = split_by_newline_or_spaces(first_leaf)
-        @type = '#'.freeze + @type if kind_of? IterationTagNode
-        first_leaf_content||""
-      end
-
-      def split_by_newline_or_spaces(first_leaf)
-        sep = /\A\S*(?:\r?\n|\r)/ =~ first_leaf ? /(?:\r?\n|\r)/ : /\s+/
-        first_leaf.split(sep, 2)
-      end
-      private :assign_type, :split_by_newline_or_spaces
-
       def contains_any_value_assigned_tag_node?(record)
         self.select {|n| n.kind_of?(TagNode) }.each do |node|
           if node.kind_of? IterationTagNode
@@ -40,8 +29,33 @@ module AdHocTemplate
         false
       end
 
+      def contains_any_value_tag?
+        select {|n| n.kind_of?(TagNode) }.each do |node|
+          case node
+          when IterationTagNode, FallbackTagNode
+            return node.contains_any_value_tag?
+          when TagNode
+            return true
+          end
+        end
+        false
+      end
+
       private
 
+      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}/, "")
+        end
+        @type, first_leaf_content = split_by_newline_or_spaces(first_leaf)
+        first_leaf_content||""
+      end
+
+      def split_by_newline_or_spaces(first_leaf)
+        sep = /\A\S*#{LINE_END_STR}/ =~ first_leaf ? LINE_END_RE : /\s+/
+        first_leaf.split(sep, 2)
+      end
+
       def empty_sub_records?(record, node)
         sub_records = record[node.type]
         return true if sub_records.nil? or sub_records.empty?
@@ -53,18 +67,40 @@ module AdHocTemplate
       def any_value_assigned_to_iteration_tag?(tag_node, record)
         if tag_node.type
           not empty_sub_records?(record, tag_node)
+        elsif tag_node.kind_of? FallbackTagNode
+          false
         else
           tag_node.contains_any_value_assigned_tag_node?(record)
         end
       end
     end
 
-    class IterationTagNode < TagNode; end
+    class IterationTagNode < TagNode
+      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(/:\s/, 2)
+          @type = @type.empty? ? nil : '#'.freeze + @type
+          return remaining_part
+        end
+
+        first_leaf.sub(/\A#{LINE_END_STR}/, '')
+      end
+    end
+
+    class FallbackTagNode < TagNode
+      def assign_value_to_type(first_leaf)
+        return first_leaf unless first_leaf.kind_of? String
+        first_leaf.sub(/\A#{LINE_END_STR}/, '')
+      end
+    end
+
     class Leaf < Parser::Leaf; end
 
     class TagType
       attr_reader :head, :tail, :token_pat, :remove_iteration_indent
-      attr_reader :iteration_start, :iteration_end
+      attr_reader :head_of, :tail_of
       @types = {}
 
       def self.[](tag_name)
@@ -72,72 +108,111 @@ module AdHocTemplate
       end
 
       def self.register(tag_name=:default, tag=["<%", "%>"], iteration_tag=["<%#", "#%>"],
-                        remove_iteration_indent=false)
-        @types[tag_name] = new(tag, iteration_tag, remove_iteration_indent)
+                        fallback_tag=["<%*", "*%>"], remove_iteration_indent=false)
+        @types[tag_name] = new(tag, iteration_tag, fallback_tag, remove_iteration_indent)
       end
 
-      def initialize(tag, iteration_tag, remove_iteration_indent)
-        assign_type(tag, iteration_tag)
+      def initialize(tag, iteration_tag, fallback_tag, remove_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
       end
 
-      def assign_type(tag, iteration_tag)
-        @iteration_start, @iteration_end = iteration_tag
-        @head, @tail = {}, {}
-        [
+      def assign_type(tag, iteration_tag, fallback_tag)
+        node_tag_pairs = [
           [TagNode, tag],
-          [IterationTagNode, iteration_tag]
-        ].each do |node_type, head_tail|
-          head, tail = head_tail
-          @head[head] = node_type
-          @tail[tail] = node_type
+          [IterationTagNode, iteration_tag],
+          [FallbackTagNode, fallback_tag]
+        ]
+
+        setup_attributes(node_tag_pairs)
+      end
+
+      private
+
+      def setup_attributes(node_tag_pairs)
+        @head, @tail, @head_of, @tail_of = {}, {}, {}, {}
+
+        node_tag_pairs.each do |node, tag|
+          head, tail = tag
+          @head[head] = node
+          @tail[tail] = node
+          @head_of[node] = head
+          @tail_of[node] = tail
         end
       end
 
       register
-      register(:square_brackets, ["[[", "]]"], ["[[#", "#]]"])
-      register(:curly_brackets, ["{{", "}}"], ["{{#", "#}}"])
-      register(:xml_like1, ["<!--%", "%-->"], ["<iterate>", "</iterate>"], true)
-      register(:xml_like2, ["<fill>", "</fill>"], ["<iterate>", "</iterate>"], true)
-      register(:xml_comment_like, ["<!--%", "%-->"], ["<!--%iterate%-->", "<!--%/iterate%-->"], true)
+      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)
     end
 
     class UserDefinedTagTypeConfigError < StandardError; end
 
     def self.parse(str, tag_name=:default)
-      if TagType[tag_name].remove_iteration_indent
-        str = remove_indent_before_iteration_tags(str, TagType[tag_name])
-      end
+      str = remove_indents_and_newlines_if_necessary(str, tag_name)
       new(str, TagType[tag_name]).parse.tree
     end
 
-    def self.remove_indent_before_iteration_tags(template_source, tag_type)
-      start_tag, end_tag = [
-        tag_type.iteration_start,
-        tag_type.iteration_end
-      ].map {|tag| Regexp.escape(tag) }
-      template_source.gsub(/^([ \t]+#{start_tag}\S*(?:\r?\n|\r))/) {|s| s.lstrip }
-        .gsub(/^([ \t]+#{end_tag}(?:\r?\n|\r))/) {|s| s.lstrip }
-    end
-
     def self.register_user_defined_tag_type(config_source)
       config = YAML.load(config_source)
-      %w(tag_name tag iteration_tag).each do |item|
+      %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)
       registered_tag_name
     end
 
-    def initialize(str, tag)
+    def self.remove_indents_and_newlines_if_necessary(str, tag_name)
+      node_types = [IterationTagNode, FallbackTagNode]
+      tag_type = TagType[tag_name]
+      if TagType[tag_name].remove_iteration_indent
+        str = remove_indent_before_iteration_tags(str, tag_type)
+        str = remove_indent_before_fallback_tags(str, tag_type)
+      end
+      remove_trailing_newline_of_end_tags(node_types, str, tag_type)
+    end
+
+    def self.remove_indent_before_iteration_tags(template_source, tag_type)
+      start_tag, end_tag = [
+        tag_type.head_of[IterationTagNode],
+        tag_type.tail_of[IterationTagNode],
+      ].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 }
+    end
+
+    def self.remove_indent_before_fallback_tags(template_source, tag_type)
+      tag_re_str = [
+        tag_type.head_of[FallbackTagNode],
+        tag_type.tail_of[FallbackTagNode],
+      ].map {|tag| Regexp.escape(tag) }.join('|')
+      template_source.gsub(/^([ \t]+(?:#{tag_re_str})#{LINE_END_STR})/) {|s| s.lstrip }
+    end
+
+    def self.remove_trailing_newline_of_end_tags(node_types, source, tag_type)
+      node_types.inject(source) do |s, node_type|
+        end_tag = tag_type.tail_of[node_type]
+        s.gsub(/#{Regexp.escape(end_tag)}#{LINE_END_STR}/, end_tag)
+      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)
+
+    def initialize(source, tag)
       @tag = tag
-      str = remove_trailing_newline_of_iteration_end_tag(str, @tag.iteration_end)
-      @tokens = PseudoHiki.split_into_tokens(str, @tag.token_pat)
+      @tokens = PseudoHiki.split_into_tokens(source, @tag.token_pat)
       super()
     end
 
@@ -150,11 +225,5 @@ module AdHocTemplate
 
       self
     end
-
-    private
-
-    def remove_trailing_newline_of_iteration_end_tag(str, iteration_end_tag)
-      str.gsub(/#{Regexp.escape(iteration_end_tag)}(?:\r?\n|\r)/, iteration_end_tag)
-    end
   end
 end