ad_hoc_template 0.4.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ddd8ddbfdc477efb70980b40c3e16848108df9ea
-  data.tar.gz: fb506b375a6781451f00f32c6a88b58a2fab210c
+  metadata.gz: 0d886560d5c34cfc5a5db65446d0e62b71c70480
+  data.tar.gz: 582cba527d5ecd1e49ff8fb2a1b620c47b58cd02
 SHA512:
-  metadata.gz: c5e5ef55188915bd037bf8b20e67b5a3226f54aa1037345510dc5a10319f4cf59711a7627c35c52c716f5633abe3170b9b6f09b56c04ec5b71a90b47c56746d9
-  data.tar.gz: 9246fcb22fabbab24a8866ef612474121d5acc42cb4fa65a333e717aac26cc4dc7a4ebdd9d708c99eb0cdf8294fc207d98c0a43a5c69e2a2459650700dd0598d
+  metadata.gz: 93aa155f2b7a186c9688bd68d27af013e891f10afe73405d087dea0768cc95d73166a9adbf0c1cb7f301e2988b9357c6c30950f4a2cff24c86a9b78e214a97af
+  data.tar.gz: a91605ac047c69897159b0e20bae32575153f2fcf101a9aeb59ba81775eb740024e2bf4486055035d7346bb175c3b8f30edbab044c929732f525e92754f5249b

data/.rubocop.yml

@@ -0,0 +1,23 @@
+AllCops:
+  TargetRubyVersion: 2.3
+Layout/SpaceInsideBlockBraces:
+  SpaceBeforeBlockParameters: false
+Layout/SpaceAroundEqualsInParameterDefault:
+  EnforcedStyle: no_space
+Layout/MultilineMethodCallIndentation:
+  EnforcedStyle: indented_relative_to_receiver
+Style/ClassCheck:
+  EnforcedStyle: kind_of?
+Style/TrailingCommaInArrayLiteral:
+  EnforcedStyleForMultiline: consistent_comma
+Style/TrailingCommaInHashLiteral:
+  EnforcedStyleForMultiline: consistent_comma
+Style/SpecialGlobalVars:
+  EnforcedStyle: use_perl_names
+Documentation:
+  Enabled: false
+Style/ParallelAssignment:
+  Enabled: false
+Style/FrozenStringLiteralComment:
+  Enabled: true
+  EnforcedStyle: always

data/.travis.yml

@@ -1,3 +1,9 @@
 language: ruby
 rvm:
-  - 1.9.3
+  - 2.1
+  - 2.2
+  - 2.3
+  - 2.4
+  - 2.5
+  - ruby-head
+before_install: gem install bundler -v 1.16.1

data/Gemfile

@@ -2,11 +2,12 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in ad_hoc_template.gemspec
 
-gem 'pseudohikiparser', '0.0.5.develop'
+gem 'pseudohikiparser', '0.0.6.develop'
 gem 'optparse_plus'
 
 group :development do
-  gem "bundler", "~> 1.3"
+  gem "bundler", "~> 1.16"
   gem "rake"
   gem "rspec"
+  gem "rubocop", "~> 0.55"
 end

data/ad_hoc_template.gemspec

@@ -20,7 +20,8 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency "pseudohikiparser", "0.0.6.develop"
   spec.add_runtime_dependency "optparse_plus"
 
-  spec.add_development_dependency "bundler", "~> 1.3"
-  spec.add_development_dependency "rake", "~> 10.1"
-  spec.add_development_dependency "rspec", "~> 3.2"
+  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "rake", "~> 12.3"
+  spec.add_development_dependency "rspec", "~> 3.7"
+  spec.add_development_dependency "rubocop", "~> 0.55"
 end

data/lib/ad_hoc_template.rb

@@ -1,31 +1,15 @@
-require "ad_hoc_template/version"
-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"
-require "ad_hoc_template/config_manager"
+# frozen_string_literal: true
+
+require 'ad_hoc_template/version'
+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'
+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)
@@ -40,6 +24,8 @@ module AdHocTemplate
       end.join
     end
 
+    attr_reader :record, :tag_formatter
+
     def initialize(record, tag_formatter=DefaultTagFormatter.new)
       @record = record
       @tag_formatter = tag_formatter
@@ -48,11 +34,11 @@ module AdHocTemplate
     def visit(tree, memo)
       case tree
       when Parser::IterationNode
-        format_iteration_tag(tree, memo)
+        format_iteration_tag(tree, self, memo)
       when Parser::FallbackNode
-        ''.freeze
+        ''
       when Parser::ValueNode
-        format_value_tag(tree, memo)
+        format_value_tag(tree, self, memo)
       when Parser::Leaf
         tree.join
       else
@@ -60,51 +46,48 @@ module AdHocTemplate
       end
     end
 
-    def format_iteration_tag(iteration_tag_node, memo)
-      tag_node = cast(iteration_tag_node)
+    def format_iteration_tag(iteration_tag_node, data_loader, memo)
+      tag_node = iteration_tag_node.cast
 
-      prepare_sub_records(iteration_tag_node).map do |record|
-        if tag_node.contains_any_value_assigned_tag_node?(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
+      prepare_sub_records(iteration_tag_node, data_loader).map do |record|
+        format_sub_nodes(tag_node, record, data_loader, memo)
       end
     end
 
-    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)
+    def format_value_tag(tag_node, data_loader, memo)
+      leafs = tag_node.format_sub_nodes(data_loader, memo).strip
+      data_loader.tag_formatter.format(tag_node.type, leafs, data_loader.record)
     end
 
     def format(tree, memo=nil)
       tree.accept(self, memo).join
     end
 
-    private
+    def new_with_record(record)
+      self.class.new(record, @tag_formatter)
+    end
 
-    def cast(node, node_type=Parser::TagNode)
-      node_type.new.concat(node.clone)
+    protected
+
+    def sub_records(tag_node)
+      @record[tag_node.type] || [@record]
     end
 
-    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)
+    private
+
+    def prepare_sub_records(tag_node, data_loader)
+      inner_labels = tag_node.inner_labels
+      return data_loader.sub_records(tag_node) unless inner_labels
+      data_loader.sub_records(tag_node).map do |record|
+        merge_inner_iteration_records(record, inner_labels, data_loader)
       end
     end
 
-    def prepare_inner_iteration_records(record, inner_labels)
+    def merge_inner_iteration_records(record, inner_labels, data_loader)
       new_record = nil
       inner_labels.each do |label|
-        if inner_data = @record[label.full_label(record)]
+        inner_data = data_loader.record[label.full_label(record)]
+        if inner_data
           new_record ||= record.dup
           new_record[label.inner_label] = inner_data
         end
@@ -112,27 +95,26 @@ module AdHocTemplate
       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
+    def format_sub_nodes(tag_node, record, data_loader, memo)
+      if tag_node.contains_any_value_assigned_tag_node?(record)
+        tag_node.format_sub_nodes(data_loader.new_with_record(record), memo)
+      elsif tag_node.contains_any_fallback_tag?
+        format_fallback_tags(tag_node.select_fallback_nodes,
+                             data_loader.new_with_record(record), memo)
+      else
+        ''
+      end
     end
 
-    def format_fallback_tags(fallback_nodes, record, memo)
-      data_loader = AdHocTemplate::DataLoader.new(record, @tag_formatter)
+    def format_fallback_tags(fallback_nodes, data_loader, memo)
       fallback_nodes.map do |fallback_node|
-        node = cast(fallback_node, Parser::IterationNode)
-        node.contains_any_value_tag? ? node.accept(data_loader, memo) : node.join
+        fallback_node.format_sub_nodes(data_loader, memo)
       end
     end
   end
 
-  def self.render(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

@@ -1,4 +1,4 @@
-#!/usr/bin/env ruby
+# frozen_string_literal: true
 
 require 'ad_hoc_template'
 require 'optparse_plus'
@@ -11,7 +11,8 @@ AdHocTemplate::ConfigManager.require_local_settings
 module AdHocTemplate
   class CommandLineInterface
     include Utils
-    attr_accessor :output_filename, :template_data, :record_data, :tag_type, :data_format
+    attr_accessor :output_filename, :tag_type, :data_format,
+                  :template_data, :record_data
     attr_writer :output_empty_entry
 
     TAG_RE_TO_TYPE = {
@@ -21,15 +22,15 @@ module AdHocTemplate
       /\Axml_like1/i => :xml_like1,
       /\Axml_like2/i => :xml_like2,
       /\Axml_comment_like/i => :xml_comment_like,
-    }
+    }.freeze
 
-    FORMAT_RE_TO_FORMAT = {
+    RE_TO_FORMAT = {
       /\Ad(efault)?/i => :default,
       /\Ay(a?ml)?/i => :yaml,
       /\Aj(son)?/i => :json,
       /\Ac(sv)?/i => :csv,
       /\At(sv)?/i => :tsv,
-    }
+    }.freeze
 
     def initialize
       @tag_formatter = AdHocTemplate::DefaultTagFormatter.new
@@ -37,6 +38,7 @@ module AdHocTemplate
       @tag_type = :default
       @data_format = nil
       @force_update = false
+      @init_local_settings = false
     end
 
     def parse_command_line_options
@@ -45,11 +47,11 @@ module AdHocTemplate
         opt.version = AdHocTemplate::VERSION
 
         opt.inherit_ruby_options('E') # -E, --encoding
-        opt.on(:output_file) {|output_file| @output_filename = File.expand_path(output_file) }
+        opt.on(:output_file) {|file| @output_filename = File.expand_path(file) }
         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.on(:tag_config) {|yaml| register_user_defined_tag_type(yaml) }
+        opt.on(: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 }
@@ -60,7 +62,7 @@ module AdHocTemplate
 
       unless @data_format
         guessed_format = ARGV.length < 2 ? :default : guess_file_format(ARGV[1])
-        @data_format =  guessed_format || :default
+        @data_format = guessed_format || :default
       end
     end
 
@@ -69,7 +71,7 @@ module AdHocTemplate
       if template
         @template_data = File.read(template)
       else
-        STDERR.puts "No template file is given."
+        STDERR.puts 'No template file is given.'
       end
 
       @record_data = record ? File.read(record) : ARGF.read
@@ -77,7 +79,7 @@ module AdHocTemplate
 
     def render
       AdHocTemplate.render(@record_data, @template_data, @tag_type,
-                            @data_format, @tag_formatter)
+                           @data_format, @tag_formatter)
     end
 
     def generate_entry_format
@@ -87,28 +89,25 @@ module AdHocTemplate
 
     def init_local_settings
       AdHocTemplate::ConfigManager.init_local_settings
-      config_dir = File.expand_path(AdHocTemplate::ConfigManager::LOCAL_SETTINGS_DIR)
+      config_dir = ConfigManager.expand_path('')
       puts "Please edit configuration files created in #{config_dir}"
-      exit
+      @init_local_settings = true
     end
 
     def generate_recipe_template(templates)
       encoding = Encoding.default_external.names[0]
-      AdHocTemplate::EntryFormatGenerator.
-        extract_recipes_from_template_files(templates,
-                                            @tag_type)
+      AdHocTemplate::EntryFormatGenerator
+        .extract_recipes_from_template_files(templates, @tag_type, encoding)
     end
 
     def update_output_files_in_recipe(recipe)
-      AdHocTemplate::RecipeManager.update_output_files_in_recipe(recipe,
-                                                                 @force_update)
+      AdHocTemplate::RecipeManager
+        .update_output_files_in_recipe(recipe, @force_update)
     end
 
     def open_output
       if @output_filename
-        open(@output_filename, "wb") do |out|
-          yield out
-        end
+        File.open(@output_filename, 'wb') {|out| yield out }
       else
         yield STDOUT
       end
@@ -116,34 +115,35 @@ module AdHocTemplate
 
     def execute
       parse_command_line_options
+      exit if @init_local_settings
       return update_output_files_in_recipe(@recipe_yaml) if @recipe_yaml
       read_input_files
-      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 }
+      open_output {|out| out.print generate_output }
     end
 
     private
 
+    def generate_output
+      return generate_entry_format if @output_empty_entry
+      return generate_recipe_template(ARGV) if @output_recipe_template
+      render
+    end
+
     def choose_tag_type(given_type)
-      err_msg = "The given type is not found. The default tag is chosen."
+      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|
+      if_any_regex_match(TAG_RE_TO_TYPE, given_type, err_msg) do |_, tag_type|
         @tag_type = tag_type
       end
     end
 
     def choose_data_format(data_format)
-      err_msg = "The given format is not found. The default format is chosen."
+      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
+      if_any_regex_match(RE_TO_FORMAT, format_part, err_msg) do |_, format|
+        csv_with_label = value_assigned?(label_part) && csv_or_tsv?(format)
+        @data_format = csv_with_label ? { format => label_part } : format
       end
     end
 
@@ -152,9 +152,8 @@ module AdHocTemplate
       @tag_type = Parser.register_user_defined_tag_type(config)
     end
 
-    def make_csv_option(iteration_label, format)
-      return format if iteration_label.nil? or iteration_label.empty?
-      { format => iteration_label }
+    def value_assigned?(iteration_label)
+      !(iteration_label.nil? || iteration_label.empty?)
     end
   end
 end

data/lib/ad_hoc_template/config_manager.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env ruby
+# frozen_string_literal: true
 
 require 'fileutils'
 
@@ -12,9 +12,7 @@ module AdHocTemplate
 
     def self.require_local_settings
       settings_file = File.expand_path(LOCAL_SETTINGS_FILE)
-      if File.exist? settings_file
-        require settings_file
-      end
+      require settings_file if File.exist? settings_file
     end
 
     def self.configure(&config_block)
@@ -44,18 +42,15 @@ module AdHocTemplate
     end
 
     def self.expand_path(path)
-      unless /\A[\.\/]/ =~ path
-        path = File.join(LOCAL_SETTINGS_DIR, path)
-      end
+      path = File.join(LOCAL_SETTINGS_DIR, path) unless %r{\A[\./]} =~ path
       File.expand_path(path)
     end
 
     def self.create_unless_exist(path, content)
       return if File.exist? path
-      open(path, "w") {|file| file.print content }
+      File.open(path, 'wb') {|file| file.print content }
     end
 
-    private_class_method :expand_path
     private_class_method :create_unless_exist
 
     @local_settings_template = <<SETTING_TEMPLATE
@@ -117,7 +112,7 @@ AdHocTemplate.local_settings do
 end
 SETTING_TEMPLATE
 
-    @custom_tag_template =<<TAG_TEMPLATE
+    @custom_tag_template = <<TAG_TEMPLATE
 ---
 tag_name: :default
 tag: ["<%", "%>"]