ad_hoc_template 0.3.0 → 0.4.0

data/lib/ad_hoc_template/recipe_manager.rb

@@ -0,0 +1,168 @@
+#!/usr/bin/env ruby
+
+require 'ad_hoc_template'
+require 'ad_hoc_template/utils'
+
+module AdHocTemplate
+  class RecipeManager
+    include Utils
+
+    attr_reader :output_file, :template_encoding, :template
+    attr_reader :records, :recipe
+
+    def self.update_output_files_in_recipe(recipe, force_update=false)
+      recipe_source = open(File.expand_path(recipe)) {|file| file.read }
+      recipes = YAML.load_stream(recipe_source)
+      recipes.each do |recipe|
+        manager = new(recipe)
+        if manager.modified_after_last_output? or force_update
+          manager.update_output_file
+        end
+      end
+    end
+
+    def initialize(recipe_source)
+      @default = {}
+      read_recipe(recipe_source)
+    end
+
+    def read_recipe(recipe_source)
+      @recipe = if recipe_source.kind_of? String
+                  RecordReader::YAMLReader.read_record(recipe_source)
+                else
+                  recipe_source
+                end
+      setup_default!(@recipe)
+      @template_encoding = @default['template_encoding']
+      @output_file = @default['output_file']
+      @recipe
+    end
+
+    def load_records
+      @records = prepare_block_data(@recipe).tap do |main_block|
+        @recipe['blocks'].each do |block_source|
+          block = prepare_block_data(block_source)
+          block.keys.each do |key|
+            main_block[key] ||= block[key]
+          end
+        end
+      end
+    end
+
+    def prepare_block_data(block)
+      determine_data_format!(block)
+      return {} unless block['data']
+      data_source = read_file(block['data'],
+                              block['data_encoding'])
+      data_format = prepare_data_format(block)
+      RecordReader.read_record(data_source, data_format)
+    end
+
+    def parse_template
+      template_path = File.expand_path(@recipe['template'])
+      template_source = open(template_path,
+                             open_mode(@template_encoding)) do |file|
+        file.read
+      end
+      tag_type = @recipe['tag_type'] || :default
+      tag_type = tag_type.to_sym unless tag_type.kind_of? Symbol
+      @template = Parser.parse(template_source, tag_type)
+    end
+
+    def update_output_file
+      @records ||= load_records
+      parse_template
+      content = AdHocTemplate::DataLoader.format(@template, @records)
+      mode = @template_encoding ? "wb:#{@template_encoding}" : 'wb'
+      if @output_file
+        open(File.expand_path(@output_file), mode) {|file| file.print content }
+      else
+        STDOUT.print content
+      end
+    end
+
+    def modified_after_last_output?
+      return true unless @output_file
+      output_path = File.expand_path(@output_file)
+      return true unless File.exist? output_path
+      output_time = File.mtime(output_path)
+      return true if modified_time(@recipe['template']) >= output_time
+      data_files = @recipe['blocks'].map {|block| block['data'] }
+      data_files.unshift(@recipe['data'])
+      data_files.any? {|data_file| modified_time(data_file) >= output_time }
+    end
+
+    private
+
+    def setup_default!(recipe)
+      recipe.each do |key, val|
+        @default[key] = val unless val.kind_of? Array
+      end
+
+      setup_sub_blocks!(recipe)
+      setup_main_label
+    end
+
+    def setup_sub_blocks!(recipe)
+      unless recipe['blocks']
+        recipe['blocks'] = []
+        return
+      end
+
+      recipe['blocks'].each do |block|
+        @default.keys.each do |key|
+          block[key] ||= @default[key]
+        end
+      end
+    end
+
+    def setup_main_label
+      if data_format = @default['data_format'] and
+          [:csv, :tsv].include? data_format
+        @default['label'] ||= RecordReader::CSVReader::HEADER_POSITION::LEFT
+      end
+    end
+
+    def determine_data_format!(block)
+      data_format = block['data_format']
+      if not data_format and block['data']
+        data_format = guess_file_format(block['data'])
+      end
+
+      block['data_format'] ||= data_format
+    end
+
+    def read_file(file_name, encoding)
+      open(File.expand_path(file_name),
+           open_mode(encoding)) do |file|
+        file.read
+      end
+    end
+
+    def open_mode(encoding)
+      encoding ||= Encoding.default_external.names[0]
+      mode = "rb"
+      return mode unless encoding and not encoding.empty?
+      bom = /\AUTF/i =~ encoding ? 'BOM|' : ''
+      mode += ":#{bom}#{encoding}"
+    end
+
+    def prepare_data_format(block)
+      data_format = block['data_format']
+      if not data_format or data_format.empty?
+        data_format = :default
+      end
+      data_format = data_format.to_sym
+      return data_format unless [:csv, :tsv].include? data_format
+      if label = block['label']
+        label = label.sub(/\A#/, '')
+        data_format = { data_format => label }
+      end
+      data_format
+    end
+
+    def modified_time(filename)
+      File.mtime(File.expand_path(filename))
+    end
+  end
+end

data/lib/ad_hoc_template/record_reader.rb

@@ -8,7 +8,7 @@ module AdHocTemplate
   module RecordReader
     module YAMLReader
       def self.read_record(yaml_data)
-        YAML.load(yaml_data)
+        RecordReader.convert_values_to_string(YAML.load(yaml_data))
       end
 
       def self.dump(config_data)
@@ -19,7 +19,7 @@ module AdHocTemplate
 
     module JSONReader
       def self.read_record(json_data)
-        JSON.parse(json_data)
+        RecordReader.convert_values_to_string(JSON.parse(json_data))
       end
 
       def self.dump(config_data)
@@ -34,19 +34,21 @@ module AdHocTemplate
         tsv: "\t"
       }
 
+      module HEADER_POSITION
+        TOP = '__header_top__'
+        LEFT = '__header_left__'
+      end
+
       class NotSupportedError < StandardError; end
 
       def self.read_record(csv_data, config={ csv: nil })
         label, sep  = parse_config(config)
-        header, *data = CSV.new(csv_data, col_sep: sep).to_a
-        records = data.map {|row| convert_to_hash(header, row) }
-        if label
-          { '#' + label => records }
-        elsif records.length == 1
-          records[0]
-        else
-          records
+        header, *data = csv_to_array(csv_data, sep, label)
+        csv_records = data.map {|row| convert_to_hash(header, row) }
+        if label and label.index('|')
+          return compose_inner_iteration_records(csv_records, label)
         end
+        compose_record(csv_records, label)
       end
 
       def self.dump(config_data, col_sep=COL_SEP[:csv])
@@ -84,8 +86,51 @@ module AdHocTemplate
         return label, col_sep
       end
 
+      def self.csv_to_array(csv_data, col_sep, label)
+        array = CSV.new(csv_data, col_sep: col_sep).to_a
+        if not label or label == HEADER_POSITION::LEFT
+          array = array.transpose
+        end
+        array
+      end
+
+      def self.compose_record(csv_records, label)
+        if label
+          { '#' + label => csv_records }
+        elsif csv_records.length == 1
+          csv_records[0]
+        else
+          csv_records
+        end
+      end
+
+      def self.compose_inner_iteration_records(csv_records, given_label,
+                                               main_record={})
+        outer_label, inner_label, key = ('#' + given_label).split(/\|/, 3)
+        values = inner_iteration_records(csv_records, key)
+        labels = inner_iteration_labels(outer_label, inner_label, values.keys)
+        unless main_record[outer_label]
+          main_record[outer_label] = values.keys.map {|k| { key => k } }
+        end
+        values.keys.each {|k| main_record[labels[k]] = values[k] }
+        main_record
+      end
+
+      def self.inner_iteration_records(csv_records, key)
+        values = Hash.new {|h, k| h[k] = [] }
+        csv_records.each {|record| values[record[key]].push record }
+        values
+      end
+
+      def self.inner_iteration_labels(outer_label, inner_label, keys)
+        labels = keys.inject({}) do |h, key|
+          h[key] = [outer_label, inner_label, key].join('|')
+          h
+        end
+      end
+
       def self.csv_compatible_format?(data)
-        iteration_blocks_count = data.values.select {|v| v.kind_of? Array }.size
+        iteration_blocks_count = data.values.count {|v| v.kind_of? Array }
         iteration_blocks_count == 0 or (iteration_blocks_count == 1 && data.size == 1)
       end
 
@@ -111,6 +156,10 @@ module AdHocTemplate
       end
 
       private_class_method :convert_to_hash, :parse_config
+      private_class_method :csv_to_array, :compose_record
+      private_class_method :compose_inner_iteration_records
+      private_class_method :inner_iteration_records
+      private_class_method :inner_iteration_labels
       private_class_method :csv_compatible_format?, :hashes_to_arrays
       private_class_method :find_sub_records, :array_to_csv
     end
@@ -134,6 +183,7 @@ module AdHocTemplate
       ITERATION_HEAD = /\A\/\/\/@#/o
       EMPTY_LINE = /\A#{LINE_END_STR}\Z/o
       ITERATION_MARK = /\A#/o
+      COMMENT_HEAD = /\A\/\/\/\//
       READERS_RE = {
         key_value: SEPARATOR,
         iteration: ITERATION_HEAD,
@@ -274,6 +324,7 @@ module AdHocTemplate
         end
 
         def read(line)
+          return if COMMENT_HEAD =~ line
           key, value = line.split(SEPARATOR, 2)
           @stack.current_record[key] = value.chomp
         end
@@ -294,7 +345,7 @@ module AdHocTemplate
           case line
           when BLOCK_HEAD
             setup_new_block(line, String.new)
-          when EMPTY_LINE
+          when EMPTY_LINE, COMMENT_HEAD
             block_value << line unless block_value.empty?
           else
             block_value << line
@@ -405,10 +456,16 @@ module AdHocTemplate
     end
 
     def self.parse_if_necessary(source)
-      if source.kind_of? String
-        RecordReader.read_record(source)
-      else
-        source
+      source.kind_of?(String) ? read_record(source) : source
+    end
+
+    def self.convert_values_to_string(data)
+      data.each do |k, v|
+        if v.kind_of? Array
+          v.each {|sub_rec| convert_values_to_string(sub_rec) }
+        elsif v and not v.kind_of? String
+          data[k] = v.to_s
+        end
       end
     end
   end

data/lib/ad_hoc_template/utils.rb

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+
+module AdHocTemplate
+  module Utils
+        FILE_EXTENTIONS = {
+      /\.ya?ml\Z/i => :yaml,
+      /\.json\Z/i => :json,
+      /\.csv\Z/i => :csv,
+      /\.tsv\Z/i => :tsv,
+    }
+
+    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

data/lib/ad_hoc_template/version.rb

@@ -1,3 +1,3 @@
 module AdHocTemplate
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

data/lib/ad_hoc_template.rb

@@ -4,9 +4,28 @@ 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"
+require "ad_hoc_template/config_manager"
 
 module AdHocTemplate
   class DataLoader
+    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#/, ''.freeze).split(/\|/, 2)
+        @cur_label = cur_label
+      end
+
+      def full_label(record)
+        [@cur_label, @label, record[@key]].join('|')
+      end
+    end
+
     def self.format(template, record, tag_formatter=DefaultTagFormatter.new)
       if record.kind_of? Array
         return format_multi_records(template, record, tag_formatter)
@@ -26,45 +45,42 @@ module AdHocTemplate
       @tag_formatter = tag_formatter
     end
 
-    def visit(tree)
+    def visit(tree, memo)
       case tree
-      when Parser::IterationTagNode
-        format_iteration_tag(tree)
-      when Parser::FallbackTagNode
+      when Parser::IterationNode
+        format_iteration_tag(tree, memo)
+      when Parser::FallbackNode
         ''.freeze
-      when Parser::TagNode
-        format_tag(tree)
+      when Parser::ValueNode
+        format_value_tag(tree, memo)
       when Parser::Leaf
         tree.join
       else
-        tree.map {|node| node.accept(self) }
+        tree.map {|node| node.accept(self, memo) }
       end
     end
 
-    def format_iteration_tag(tag_node)
-      sub_records = @record[tag_node.type]||[@record]
-      tag_node = cast(tag_node)
-      fallback_nodes = tag_node.select {|sub_node| sub_node.kind_of? Parser::FallbackTagNode }
+    def format_iteration_tag(iteration_tag_node, memo)
+      tag_node = cast(iteration_tag_node)
 
-      sub_records.map do |record|
+      prepare_sub_records(iteration_tag_node).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)
+          visit_with_sub_record(tag_node, record, memo)
+        elsif fallback_nodes = select_fallback_nodes(tag_node)
+          format_fallback_tags(fallback_nodes, record, memo)
         else
           "".freeze
         end
       end
     end
 
-    def format_tag(tag_node)
-      leafs = tag_node.map {|leaf| leaf.accept(self) }
+    def format_value_tag(tag_node, memo)
+      leafs = tag_node.map {|leaf| leaf.accept(self, memo) }
       @tag_formatter.format(tag_node.type, leafs.join.strip, @record)
     end
 
-    def format(tree)
-      tree.accept(self).join
+    def format(tree, memo=nil)
+      tree.accept(self, memo).join
     end
 
     private
@@ -73,12 +89,44 @@ module AdHocTemplate
       node_type.new.concat(node.clone)
     end
 
-    def format_fallback_tags(fallback_nodes, record)
+    def prepare_sub_records(tag_node)
+      cur_label = tag_node.type
+      sub_records = @record[cur_label]||[@record]
+      return sub_records unless cur_label
+      inner_labels = tag_node.inner_iteration_tag_labels
+      return sub_records unless inner_labels
+      inner_labels = InnerLabel.labels(inner_labels, cur_label)
+      sub_records.map do |record|
+        prepare_inner_iteration_records(record, inner_labels)
+      end
+    end
+
+    def prepare_inner_iteration_records(record, inner_labels)
+      new_record = nil
+      inner_labels.each do |label|
+        if inner_data = @record[label.full_label(record)]
+          new_record ||= record.dup
+          new_record[label.inner_label] = inner_data
+        end
+      end
+      new_record || record
+    end
+
+    def visit_with_sub_record(tag_node, record, memo)
+      data_loader = AdHocTemplate::DataLoader.new(record, @tag_formatter)
+      tag_node.map {|leaf| leaf.accept(data_loader, memo) }.join
+    end
+
+    def select_fallback_nodes(tag_node)
+      tags = tag_node.select {|sub_node| sub_node.kind_of? Parser::FallbackNode }
+      tags.empty? ? nil : tags
+    end
+
+    def format_fallback_tags(fallback_nodes, record, memo)
       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
+      fallback_nodes.map do |fallback_node|
+        node = cast(fallback_node, Parser::IterationNode)
+        node.contains_any_value_tag? ? node.accept(data_loader, memo) : node.join
       end
     end
   end
@@ -89,4 +137,8 @@ module AdHocTemplate
     record = RecordReader.read_record(record_data, data_format)
     DataLoader.format(tree, record, tag_formatter)
   end
+
+  def self.local_settings(&config_block)
+    ConfigManager.configure(&config_block)
+  end
 end

data/samples/en/inner_iteration/data.aht

@@ -0,0 +1,21 @@
+///@#authors
+
+name: Albert Camus
+
+name: Marcel Aymé
+
+///@#authors|works|Albert Camus
+
+title: L'Étranger
+year: 1942
+
+title: La Peste
+year: 1947
+
+///@#authors|works|Marcel Aymé
+
+title: Le Passe-muraille
+year: 1943
+
+title: Les Contes du chat perché
+year: 1934-1946

data/samples/en/inner_iteration/data.csv

@@ -0,0 +1,5 @@
+name,title,year
+Albert Camus,L'Étranger,1942
+Albert Camus,La Peste,1947
+Marcel Aymé,Le Passe-muraille,1943
+Marcel Aymé,Les Contes du chat perché,1934-1946

data/samples/en/inner_iteration/data.yaml

@@ -0,0 +1,14 @@
+---
+"#authors":
+- name: Albert Camus
+- name: Marcel Aymé
+"#authors|works|Albert Camus":
+- title: L'Étranger
+  year: 1942
+- title: La Peste
+  year: 1947
+"#authors|works|Marcel Aymé":
+- title: Le Passe-muraille
+  year: 1943
+- title: Les Contes du chat perché
+  year: 1934-1946

data/samples/en/inner_iteration/data2.yaml

@@ -0,0 +1,14 @@
+---
+"#authors":
+- name: Albert Camus
+  "#works|name":
+  - title: L'Étranger
+    year: 1942
+  - title: La Peste
+    year: 1947
+- name: Marcel Aymé
+  "#works|name":
+  - title: Le Passe-muraille
+    year: 1943
+  - title: Les Contes du chat perché
+    year: 1934-1946

data/samples/en/inner_iteration/for_csv.sh

@@ -0,0 +1,3 @@
+#!/bin/sh
+
+ad_hoc_template -t xml_comment_like -d 'csv:authors|works|name' template.html data.csv

data/samples/en/inner_iteration/template.html

@@ -0,0 +1,18 @@
+<h1>Authors</h1>
+
+<!--%iterate%-->authors:
+<h2><!--%h name %--></h2>
+
+<table summary="List of <!--%h name %-->&#39;s famous works with publication year">
+  <caption>Famous works</caption>
+  <thead>
+    <tr><th scope="col">Title</th><th scope="col">Publication Year</th></tr>
+  </thead>
+  <tbody>
+    <!--%iterate%-->works|name:
+    <tr><td><!--%h title %--></td><td><!--%h year %--></td></tr>
+    <!--%/iterate%-->
+  </tbody>
+</table>
+
+<!--%/iterate%-->

data/samples/en/recipe/main.aht

@@ -0,0 +1,9 @@
+country: French
+
+///@#authors
+
+name: Albert Camus
+birth_year: 1913
+
+name: Marcel Aymé
+birth_year: 1902

data/samples/en/recipe/template.html

@@ -0,0 +1,20 @@
+<h1>Famous authors of <!--%h country %--> literature</h1>
+
+<!--%iterate%-->authors:
+<h2><!--%h name %--></h2>
+
+<p>Born in <!--%h birth_year %--></p>
+
+<table summary="List of <!--%h name %-->&#39;s famous works with publication year">
+  <caption>Famous works</caption>
+  <thead>
+    <tr><th scope="col">Title</th><th scope="col">Publication Year</th></tr>
+  </thead>
+  <tbody>
+    <!--%iterate%-->works|name:
+    <tr><td><!--%h title %--></td><td><!--%h year %--></td></tr>
+    <!--%/iterate%-->
+  </tbody>
+</table>
+
+<!--%/iterate%-->

data/samples/for_recipe.sh

@@ -0,0 +1,3 @@
+#!/bin/sh
+
+ad_hoc_template -c recipe.yaml

data/samples/ja/inner_iteration/data.aht

@@ -0,0 +1,21 @@
+///@#authors
+
+name: アルベール・カミユ
+
+name: マルセル・エイメ
+
+///@#authors|works|アルベール・カミユ
+
+title: 異邦人
+year: 1942
+
+title: ペスト
+year: 1947
+
+///@#authors|works|マルセル・エイメ
+
+title: 壁抜け男
+year: 1943
+
+title: おにごっこ物語
+year: 1934-1946

data/samples/ja/inner_iteration/data.csv

@@ -0,0 +1,5 @@
+name,title,year
+アルベール・カミユ,異邦人,1942
+アルベール・カミユ,ペスト,1947
+マルセル・エイメ,壁抜け男,1943
+マルセル・エイメ,おにごっこ物語,1934-1946

data/samples/ja/inner_iteration/data.yaml

@@ -0,0 +1,14 @@
+---
+"#authors":
+- name: "アルベール・カミユ"
+- name: "マルセル・エイメ"
+"#authors|works|アルベール・カミユ":
+- title: "異邦人"
+  year: '1942'
+- title: "ペスト"
+  year: '1947'
+"#authors|works|マルセル・エイメ":
+- title: "壁抜け男"
+  year: '1943'
+- title: "おにごっこ物語"
+  year: 1934-1946

data/samples/ja/inner_iteration/data2.yaml

@@ -0,0 +1,14 @@
+---
+"#authors":
+- name: "アルベール・カミユ"
+  "#works|name":
+  - title: "異邦人"
+    year: '1942'
+  - title: "ペスト"
+    year: '1947'
+- name: "マルセル・エイメ"
+  "#works|name":
+  - title: "壁抜け男"
+    year: '1943'
+  - title: "おにごっこ物語"
+    year: 1934-1946