ad_hoc_template 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a41e80d33bd430c264ac2704bf7850baf3bcebc7
-  data.tar.gz: f10b0463f915e33987e5ac04e4928737eba11fc2
+  metadata.gz: ddd8ddbfdc477efb70980b40c3e16848108df9ea
+  data.tar.gz: fb506b375a6781451f00f32c6a88b58a2fab210c
 SHA512:
-  metadata.gz: 0b423fd73c6d59c11975fadddccdf56697a15f9784510277b23c4011c66b0d235b111285201ca24659c72b1456294990939a172bfd8998e86a441c57e16ac426
-  data.tar.gz: bfb7de0f42fd16cba6e2c75ee0e2d7764c86cd2e4d135e38f1cc05cc271b9dc45681a351ddc84d68175d85c6019df23c99b94202efc650f981ce2b1063a56f10
+  metadata.gz: c5e5ef55188915bd037bf8b20e67b5a3226f54aa1037345510dc5a10319f4cf59711a7627c35c52c716f5633abe3170b9b6f09b56c04ec5b71a90b47c56746d9
+  data.tar.gz: 9246fcb22fabbab24a8866ef612474121d5acc42cb4fa65a333e717aac26cc4dc7a4ebdd9d708c99eb0cdf8294fc207d98c0a43a5c69e2a2459650700dd0598d

data/ad_hoc_template.gemspec

@@ -17,7 +17,7 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
-  spec.add_runtime_dependency "pseudohikiparser", "0.0.5.develop"
+  spec.add_runtime_dependency "pseudohikiparser", "0.0.6.develop"
   spec.add_runtime_dependency "optparse_plus"
 
   spec.add_development_dependency "bundler", "~> 1.3"

data/lib/ad_hoc_template/command_line_interface.rb

@@ -2,9 +2,15 @@
 
 require 'ad_hoc_template'
 require 'optparse_plus'
+require 'ad_hoc_template/config_manager'
+require 'ad_hoc_template/recipe_manager'
+require 'ad_hoc_template/utils'
+
+AdHocTemplate::ConfigManager.require_local_settings
 
 module AdHocTemplate
   class CommandLineInterface
+    include Utils
     attr_accessor :output_filename, :template_data, :record_data, :tag_type, :data_format
     attr_writer :output_empty_entry
 
@@ -25,18 +31,12 @@ module AdHocTemplate
       /\At(sv)?/i => :tsv,
     }
 
-    FILE_EXTENTIONS = {
-      /\.ya?ml\Z/i => :yaml,
-      /\.json\Z/i => :json,
-      /\.csv\Z/i => :csv,
-      /\.tsv\Z/i => :tsv,
-    }
-
     def initialize
       @tag_formatter = AdHocTemplate::DefaultTagFormatter.new
       @output_filename = nil
       @tag_type = :default
       @data_format = nil
+      @force_update = false
     end
 
     def parse_command_line_options
@@ -50,6 +50,10 @@ module AdHocTemplate
         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.on(:init_local_settings) { init_local_settings }
+        opt.on(:recipe_template) { @output_recipe_template = true }
+        opt.on(:cooking_recipe) {|recipe_yaml| @recipe_yaml = recipe_yaml }
+        opt.on(:force_update) { @force_update = true }
 
         opt.parse!
       end
@@ -78,7 +82,26 @@ module AdHocTemplate
 
     def generate_entry_format
       tree = Parser.parse(@template_data, @tag_type)
-      EntryFormatGenerator.extract_labels(tree, @data_format)
+      EntryFormatGenerator.extract_form(tree, @data_format)
+    end
+
+    def init_local_settings
+      AdHocTemplate::ConfigManager.init_local_settings
+      config_dir = File.expand_path(AdHocTemplate::ConfigManager::LOCAL_SETTINGS_DIR)
+      puts "Please edit configuration files created in #{config_dir}"
+      exit
+    end
+
+    def generate_recipe_template(templates)
+      encoding = Encoding.default_external.names[0]
+      AdHocTemplate::EntryFormatGenerator.
+        extract_recipes_from_template_files(templates,
+                                            @tag_type)
+    end
+
+    def update_output_files_in_recipe(recipe)
+      AdHocTemplate::RecipeManager.update_output_files_in_recipe(recipe,
+                                                                 @force_update)
     end
 
     def open_output
@@ -93,8 +116,15 @@ module AdHocTemplate
 
     def execute
       parse_command_line_options
+      return update_output_files_in_recipe(@recipe_yaml) if @recipe_yaml
       read_input_files
-      output = @output_empty_entry ? generate_entry_format : render
+      output = if @output_empty_entry
+                 generate_entry_format
+               elsif @output_recipe_template
+                 generate_recipe_template(ARGV)
+               else
+                 render
+               end
       open_output {|out| out.print output }
     end
 
@@ -126,23 +156,6 @@ module AdHocTemplate
       return format if iteration_label.nil? or iteration_label.empty?
       { format => iteration_label }
     end
-
-    def guess_file_format(filename)
-      if_any_regex_match(FILE_EXTENTIONS, filename) do |ext_re, format|
-        return format
-      end
-    end
-
-    def if_any_regex_match(regex_table, target, failure_message=nil)
-      regex_table.each do |re, paired_value|
-        if re =~ target
-          yield re, paired_value
-          return
-        end
-      end
-      STDERR.puts failure_message if failure_message
-      nil
-    end
   end
 end
 
@@ -167,3 +180,17 @@ entry_format:
   short: "-e"
   long: "--entry-format"
   description: "Extract tag labels from a template and generate an empty data entry format"
+init_local_settings:
+  long: "--init-local-settings"
+  description: "Generate configuration files for local settings"
+recipe_template:
+  short: "-R"
+  long: "--recipe-template"
+  description: "Generate recipe entries for template files given on the command line"
+cooking_recipe:
+  short: "-c [recipe_yaml]"
+  long: "--cooking-recipe [=recipe_yaml]"
+  description: "Update output files specified in the recipe file"
+force_update:
+  long: "--force-update"
+  description: "Update output files in recipe, even when they are newer than template/data files"

data/lib/ad_hoc_template/config_manager.rb

@@ -0,0 +1,129 @@
+#!/usr/bin/env ruby
+
+require 'fileutils'
+
+module AdHocTemplate
+  class ConfigManager
+    LOCAL_SETTINGS_DIR = '~/.ad_hoc_template/'
+    SETTINGS_FILE_NAME = 'settings.rb'
+    TAG_DEF_FILE_NAME = 'user_defined_tag.yaml'
+    LOCAL_SETTINGS_FILE = File.join(LOCAL_SETTINGS_DIR,
+                                    SETTINGS_FILE_NAME)
+
+    def self.require_local_settings
+      settings_file = File.expand_path(LOCAL_SETTINGS_FILE)
+      if File.exist? settings_file
+        require settings_file
+      end
+    end
+
+    def self.configure(&config_block)
+      module_eval(&config_block)
+    end
+
+    def self.user_defined_tag(def_yaml_path)
+      yaml_source = File.read(expand_path(def_yaml_path))
+      AdHocTemplate::Parser.register_user_defined_tag_type(yaml_source)
+    end
+
+    def self.assign_format_label(format_label, &func)
+      AdHocTemplate::DefaultTagFormatter.assign_format(format_label, &func)
+    end
+
+    def self.define_label_format(&block)
+      AdHocTemplate::DefaultTagFormatter.module_eval(&block)
+    end
+
+    def self.init_local_settings
+      config_dir = File.expand_path(LOCAL_SETTINGS_DIR)
+      settings_rb = File.expand_path(LOCAL_SETTINGS_FILE)
+      custom_tag_yaml = File.join(config_dir, TAG_DEF_FILE_NAME)
+      FileUtils.mkdir(config_dir) unless File.exist? config_dir
+      create_unless_exist(settings_rb, @local_settings_template)
+      create_unless_exist(custom_tag_yaml, @custom_tag_template)
+    end
+
+    def self.expand_path(path)
+      unless /\A[\.\/]/ =~ path
+        path = File.join(LOCAL_SETTINGS_DIR, path)
+      end
+      File.expand_path(path)
+    end
+
+    def self.create_unless_exist(path, content)
+      return if File.exist? path
+      open(path, "w") {|file| file.print content }
+    end
+
+    private_class_method :expand_path
+    private_class_method :create_unless_exist
+
+    @local_settings_template = <<SETTING_TEMPLATE
+AdHocTemplate.local_settings do
+  ##
+  # If you want to define your own tags for templates,
+  # prepare a definition file in YAML format:
+  #
+  # An example of definition in YAML -----
+  #    ---
+  #    tag_name: :default
+  #    tag: ["<%", "%>"]
+  #    iteration_tag: ["<%#", "#%>"]
+  #    fallback_tag: ["<%*", "*%>"]
+  #    remove_indent: false
+  #
+  # And read the file by "user_defined_tag NAME_OF_YAML_FILE":
+  #
+  user_defined_tag 'user_defined_tag.yaml'
+
+  ##
+  # If you want to define a custom label format,
+  # there are two ways to realize that.
+  # Suppose you have data in YAML and want to
+  # present the value of date field in French style:
+  #
+  # YAML data -----
+  #    ---
+  #    date: 2016/09/28
+  #    other_field: ...
+  #    ...
+  #
+  #  Template -----
+  #
+  #    Today = <%= date %>
+  #    Aujourd'hui = <%fd date %>
+  #
+  #  Expected result -----
+  #
+  #    Today = 2016/09/28
+  #    Aujourd'hui = 28/09/2016
+  #
+  # # The first way -----
+  #
+  # define_label_format do
+  #   def french_date(var, record)
+  #     record[var].split(/\\//).reverse.join('/')
+  #   end
+  #
+  #   assign_format french_date: 'fd'
+  # end
+  #
+  # # The second way -----
+  #
+  # assign_format_label('fd') do |var, record|
+  #   record[var].split(/\\//).reverse.join('/')
+  # end
+  #
+end
+SETTING_TEMPLATE
+
+    @custom_tag_template =<<TAG_TEMPLATE
+---
+tag_name: :default
+tag: ["<%", "%>"]
+iteration_tag: ["<%#", "#%>"]
+fallback_tag: ["<%*", "*%>"]
+remove_indent: false
+TAG_TEMPLATE
+  end
+end

data/lib/ad_hoc_template/default_tag_formatter.rb

@@ -8,7 +8,12 @@ module AdHocTemplate
     }
 
     def self.assign_format(format_label, &func)
-      FUNCTION_TABLE[format_label] = func
+      if format_label.kind_of? Hash and not func
+        func_name, label = format_label.to_a.flatten
+        FUNCTION_TABLE[label] = func_name
+      else
+        FUNCTION_TABLE[format_label] = func
+      end
     end
 
     def find_function(format_label)

data/lib/ad_hoc_template/entry_format_generator.rb

@@ -8,42 +8,113 @@ module AdHocTemplate
         @labels = {}
       end
 
-      def visit(tree)
+      def visit(tree, memo)
         case tree
-        when Parser::IterationTagNode, Parser::FallbackTagNode
-          visit_iteration_tag_node(tree)
+        when Parser::IterationNode, Parser::FallbackNode
+          visit_iteration_tag_node(tree, memo)
         when Parser::TagNode
           @labels[tree.join.strip] = nil
         when Parser::Node
-          tree.each {|node| node.accept(self) }
+          tree.each {|node| node.accept(self, memo) }
         end
       end
 
       private
 
-      def visit_iteration_tag_node(tree)
+      def visit_iteration_tag_node(tree, memo)
         if iteration_label = tree.type
           sub_checker = self.class.new
           @labels[iteration_label] = [sub_checker.labels]
-          tree.each { |node| node.accept(sub_checker) }
+          tree.each { |node| node.accept(sub_checker, memo) }
         else
-          tree.each {|node| node.accept(self) }
+          tree.each {|node| node.accept(self, memo) }
         end
       end
     end
 
-    def self.extract_labels(parsed_template, target_format=nil)
-      labels = extract_labels_as_ruby_objects(parsed_template)
+    def self.extract_form(parsed_template, target_format=nil, memo=nil)
+      labels = extract_form_as_ruby_objects(parsed_template, memo)
+      labels = pull_up_inner_iterations(labels)
 
       RecordReader.dump(labels, target_format)
     end
 
-    def self.extract_labels_as_ruby_objects(parsed_template)
+    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)
+      end
+
+      recipes.join
+    end
+
+    def self.extract_recipe(template_source, template_path,
+                            tag_type=:default, encoding='UTF-8')
+      recipe = recipe_entry(template_path, tag_type, encoding)
+      parsed_template = Parser.parse(template_source, tag_type)
+      extract_iteration_labels(parsed_template).each do |label|
+        recipe['blocks'].push recipe_block_entry(label) if label.start_with? '#'
+      end
+
+      RecordReader.dump(recipe, :yaml)
+    end
+
+    def self.extract_iteration_labels(parsed_template, memo=nil)
+      labels = extract_form_as_ruby_objects(parsed_template, memo)
+      pull_up_inner_iterations(labels).keys
+    end
+
+    def self.extract_form_as_ruby_objects(parsed_template, memo)
       label_checker = LabelChecker.new
-      parsed_template.accept(label_checker)
+      parsed_template.accept(label_checker, memo)
       label_checker.labels
     end
 
-    private_class_method :extract_labels_as_ruby_objects
+    def self.pull_up_inner_iterations(labels)
+      each_iteration_label(labels) do |label|
+        labels[label].each do |record|
+          each_iteration_label(record) do |key|
+            inner_label = [label, key.sub(/\A#/, '')].join('|')
+            labels[inner_label] = record.delete(key)
+          end
+        end
+      end
+      labels
+    end
+
+    def self.each_iteration_label(labels)
+      labels.keys.each do |label|
+        yield label if labels[label].kind_of? Array
+      end
+    end
+
+    def self.recipe_entry(template_path, tag_type, encoding)
+      recipe = {
+        'template' => template_path,
+        'tag_type' => tag_type,
+        'template_encoding' => encoding,
+        'data' => nil,
+        'data_format' => nil,
+        'data_encoding' => nil,
+        'output_file' => nil,
+        'blocks' => []
+      }
+    end
+
+    def self.recipe_block_entry(label)
+      {
+        'label' => label,
+        'data' => nil,
+        'data_format' => nil,
+        'data_encoding' => nil,
+      }
+    end
+
+    private_class_method :extract_form_as_ruby_objects
+    private_class_method :pull_up_inner_iterations
+    private_class_method :each_iteration_label
+    private_class_method :recipe_entry, :recipe_block_entry
   end
 end

data/lib/ad_hoc_template/parser.rb

@@ -18,31 +18,35 @@ module AdHocTemplate
       end
 
       def contains_any_value_assigned_tag_node?(record)
-        self.select {|n| n.kind_of?(TagNode) }.each do |node|
-          if node.kind_of? IterationTagNode
-            return true if any_value_assigned_to_iteration_tag?(node, record)
-          else
-            val = record[node.join.strip]
-            return true if val and not val.empty?
-          end
+        each_tag_node do |node|
+          return true if node.contains_any_value_assigned_tag_node?(record)
         end
-        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
+        each_tag_node {|node| return true if node.contains_any_value_tag? }
+      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
         end
-        false
+
+        names unless names.empty?
       end
 
       private
 
+      def each_tag_node
+        each {|node| yield node if node.kind_of?(TagNode) }
+        false
+      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}/, "")
@@ -55,45 +59,60 @@ module AdHocTemplate
         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?
-        sub_records.each do |rec|
-          return false if rec.values.find {|val| val and not val.empty? }
-        end
-      end
-
-      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
+    class IterationNode < 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, remaining_part = first_leaf.split(/:(?:#{LINE_END_STR}|\s)/, 2)
           @type = @type.empty? ? nil : '#'.freeze + @type
           return remaining_part
         end
 
         first_leaf.sub(/\A#{LINE_END_STR}/, '')
       end
+
+      def contains_any_value_assigned_tag_node?(record)
+        return not_empty_sub_records?(record) if type
+        each_tag_node do |node|
+          return true if node.contains_any_value_assigned_tag_node?(record)
+        end
+      end
+
+      private
+
+      def not_empty_sub_records?(record)
+        sub_records = record[type]
+        return false if sub_records.nil? or sub_records.empty?
+        sub_records.each do |rec|
+          return true if rec.values.any? {|val| val and not val.empty? }
+        end
+        false
+      end
     end
 
-    class FallbackTagNode < TagNode
+    class FallbackNode < 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
+
+      def contains_any_value_assigned_tag_node?(record)
+        false
+      end
+    end
+
+    class ValueNode < TagNode
+      def contains_any_value_assigned_tag_node?(record)
+        val = record[self.join.strip]
+        val and not val.empty?
+      end
+
+      def contains_any_value_tag?
+        true
+      end
     end
 
     class Leaf < Parser::Leaf; end
@@ -120,26 +139,12 @@ module AdHocTemplate
 
       def assign_type(tag, iteration_tag, fallback_tag)
         node_tag_pairs = [
-          [TagNode, tag],
-          [IterationTagNode, iteration_tag],
-          [FallbackTagNode, fallback_tag]
+          [ValueNode, *tag],
+          [IterationNode, *iteration_tag],
+          [FallbackNode, *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
+        @head, @tail, @head_of, @tail_of = PseudoHiki.associate_nodes_with_tags(node_tag_pairs)
       end
 
       register
@@ -172,7 +177,7 @@ module AdHocTemplate
     end
 
     def self.remove_indents_and_newlines_if_necessary(str, tag_name)
-      node_types = [IterationTagNode, FallbackTagNode]
+      node_types = [IterationNode, FallbackNode]
       tag_type = TagType[tag_name]
       if TagType[tag_name].remove_iteration_indent
         str = remove_indent_before_iteration_tags(str, tag_type)
@@ -183,8 +188,8 @@ module AdHocTemplate
 
     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],
+        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 }
@@ -192,8 +197,8 @@ module AdHocTemplate
 
     def self.remove_indent_before_fallback_tags(template_source, tag_type)
       tag_re_str = [
-        tag_type.head_of[FallbackTagNode],
-        tag_type.tail_of[FallbackTagNode],
+        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 }
     end