ad_hoc_template 0.4.0 → 0.4.1

data/lib/ad_hoc_template/pseudohiki_formatter.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env ruby
+# frozen_string_literal: true
 
 require 'pseudohikiparser'
 
@@ -20,6 +20,8 @@ module AdHocTemplate
       private_class_method :choose_parser
     end
 
-    assign_format("ph") {|var, record| PseudoHikiFormatter.to_xhtml(var, record) }
+    assign_format('ph') do |var, record|
+      PseudoHikiFormatter.to_xhtml(var, record)
+    end
   end
 end

data/lib/ad_hoc_template/recipe_manager.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env ruby
+# frozen_string_literal: true
 
 require 'ad_hoc_template'
 require 'ad_hoc_template/utils'
@@ -10,12 +10,12 @@ module AdHocTemplate
     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 }
+    def self.update_output_files_in_recipe(recipe_file, force_update=false)
+      recipe_source = File.open(File.expand_path(recipe_file), &:read)
       recipes = YAML.load_stream(recipe_source)
       recipes.each do |recipe|
         manager = new(recipe)
-        if manager.modified_after_last_output? or force_update
+        if manager.modified_after_last_output? || force_update
           manager.update_output_file
         end
       end
@@ -60,10 +60,8 @@ module AdHocTemplate
 
     def parse_template
       template_path = File.expand_path(@recipe['template'])
-      template_source = open(template_path,
-                             open_mode(@template_encoding)) do |file|
-        file.read
-      end
+      template_source = File.open(template_path,
+                                  open_mode(@template_encoding), &:read)
       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)
@@ -75,7 +73,8 @@ module AdHocTemplate
       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 }
+        File.open(File.expand_path(@output_file),
+                  mode) {|file| file.print content }
       else
         STDOUT.print content
       end
@@ -117,15 +116,14 @@ module AdHocTemplate
     end
 
     def setup_main_label
-      if data_format = @default['data_format'] and
-          [:csv, :tsv].include? data_format
+      if (data_format = @default['data_format']) && csv_or_tsv?(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']
+      if !data_format && block['data']
         data_format = guess_file_format(block['data'])
       end
 
@@ -133,31 +131,25 @@ module AdHocTemplate
     end
 
     def read_file(file_name, encoding)
-      open(File.expand_path(file_name),
-           open_mode(encoding)) do |file|
-        file.read
-      end
+      File.open(File.expand_path(file_name),
+                open_mode(encoding), &:read)
     end
 
     def open_mode(encoding)
       encoding ||= Encoding.default_external.names[0]
-      mode = "rb"
-      return mode unless encoding and not encoding.empty?
+      mode = 'rb'
+      return mode unless encoding && !encoding.empty?
       bom = /\AUTF/i =~ encoding ? 'BOM|' : ''
-      mode += ":#{bom}#{encoding}"
+      "#{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 = :default if !data_format || data_format.empty?
       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
+      return data_format unless csv_or_tsv? data_format
+      label = block['label']
+      return { data_format => label.sub(/\A#/, '') } if label
       data_format
     end
 

data/lib/ad_hoc_template/record_reader.rb

@@ -1,14 +1,17 @@
-#!/usr/bin/env ruby
+# frozen_string_literal: true
 
 require 'yaml'
 require 'json'
 require 'csv'
 
+require 'ad_hoc_template/shim'
+
 module AdHocTemplate
   module RecordReader
     module YAMLReader
       def self.read_record(yaml_data)
-        RecordReader.convert_values_to_string(YAML.load(yaml_data))
+        RecordReader.convert_values_to_string(YAML.safe_load(yaml_data,
+                                                             [Symbol]))
       end
 
       def self.dump(config_data)
@@ -29,10 +32,12 @@ module AdHocTemplate
     end
 
     module CSVReader
+      using Shim unless ''.respond_to?(:+@)
+
       COL_SEP = {
         csv: CSV::DEFAULT_OPTIONS[:col_sep],
-        tsv: "\t"
-      }
+        tsv: "\t",
+      }.freeze
 
       module HEADER_POSITION
         TOP = '__header_top__'
@@ -42,10 +47,10 @@ module AdHocTemplate
       class NotSupportedError < StandardError; end
 
       def self.read_record(csv_data, config={ csv: nil })
-        label, sep  = parse_config(config)
+        label, sep = parse_config(config)
         header, *data = csv_to_array(csv_data, sep, label)
         csv_records = data.map {|row| convert_to_hash(header, row) }
-        if label and label.index('|')
+        if label && label.index('|')
           return compose_inner_iteration_records(csv_records, label)
         end
         compose_record(csv_records, label)
@@ -55,20 +60,15 @@ module AdHocTemplate
         data = RecordReader.parse_if_necessary(config_data)
         raise NotSupportedError unless csv_compatible_format?(data)
 
-        if kv_pairs = find_sub_records(data)
-          records = hashes_to_arrays(kv_pairs)
-        else
-          records = data.to_a.transpose
-        end
+        kv_pairs = find_sub_records(data)
+        records = kv_pairs ? hashes_to_arrays(kv_pairs) : data.to_a.transpose
 
         array_to_csv(records, col_sep)
       end
 
       def self.convert_to_hash(header, row_array)
         {}.tap do |record|
-          header.zip(row_array).each do |key, value|
-            record[key] = value
-          end
+          header.zip(row_array).each {|key, value| record[key] = value }
         end
         # if RUBY_VERSION >= 2.1.0: header.zip(row_array).to_h
       end
@@ -82,15 +82,13 @@ module AdHocTemplate
         when Hash
           format, label = config.to_a[0]
         end
-        col_sep = COL_SEP[format||:csv]
-        return label, col_sep
+        col_sep = COL_SEP[format || :csv]
+        [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 = array.transpose if !label || label == HEADER_POSITION::LEFT
         array
       end
 
@@ -123,15 +121,15 @@ module AdHocTemplate
       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
+        keys.each_with_object({}) do |key, labels|
+          labels[key] = [outer_label, inner_label, key].join('|')
         end
       end
 
       def self.csv_compatible_format?(data)
         iteration_blocks_count = data.values.count {|v| v.kind_of? Array }
-        iteration_blocks_count == 0 or (iteration_blocks_count == 1 && data.size == 1)
+        iteration_blocks_count.zero? ||
+          (iteration_blocks_count == 1 && data.size == 1)
       end
 
       def self.hashes_to_arrays(data)
@@ -147,10 +145,11 @@ module AdHocTemplate
       def self.array_to_csv(records, col_sep)
         # I do not adopt "records.map {|rec| rec.to_csv }.join",
         # because I'm not sure if it is sufficient for certain data or not.
-        # For example, a field value may contain carriage returns or line feeds,
-        # and in that case, improper handling of the end of record would be damaging.
+        # For example, a field value may contain carriage returns or line
+        # feeds, and in that case, improper handling of the end of record
+        # would be damaging.
 
-        CSV.generate('', col_sep: col_sep) do |csv|
+        CSV.generate(+'', col_sep: col_sep) do |csv|
           records.each {|record| csv << record }
         end
       end
@@ -179,17 +178,17 @@ module AdHocTemplate
 
     module DefaultFormReader
       SEPARATOR = /:\s*/o
-      BLOCK_HEAD = /\A\/\/\/@/o
-      ITERATION_HEAD = /\A\/\/\/@#/o
+      BLOCK_HEAD = %r{\A///@}
+      ITERATION_HEAD = %r{\A///@#}
       EMPTY_LINE = /\A#{LINE_END_STR}\Z/o
       ITERATION_MARK = /\A#/o
-      COMMENT_HEAD = /\A\/\/\/\//
+      COMMENT_HEAD = %r{\A////}
       READERS_RE = {
         key_value: SEPARATOR,
         iteration: ITERATION_HEAD,
         block: BLOCK_HEAD,
         empty_line: EMPTY_LINE,
-      }
+      }.freeze
 
       class ReaderState
         attr_accessor :current_block_label
@@ -266,6 +265,8 @@ module AdHocTemplate
       end
 
       class Reader
+        using Shim unless //.respond_to? :match?
+
         def self.setup_reader(stack)
           readers = {}
           {
@@ -273,9 +274,7 @@ module AdHocTemplate
             key_value: KeyValueReader,
             block: BlockReader,
             iteration: IterationReader,
-          }.each do |k, v|
-            readers[k] = v.new(stack, readers)
-          end
+          }.each {|k, v| readers[k] = v.new(stack, readers) }
           stack.push readers[:base]
           readers
         end
@@ -289,28 +288,28 @@ module AdHocTemplate
           @stack.pop
         end
 
-        def read(line)
-        end
+        def read(line); end
 
         private
 
         def push_reader_if_match(line, readers)
           readers.each do |reader|
-            return @stack.push(@readers[reader]) if READERS_RE[reader] === line
+            if READERS_RE[reader].match?(line)
+              return @stack.push(@readers[reader])
+            end
           end
         end
 
         def setup_new_block(line, initial_value)
-          label = line.sub(BLOCK_HEAD, "").chomp
+          label = line.sub(BLOCK_HEAD, '').chomp
           @stack.current_record[label] ||= initial_value
           @stack.current_block_label = label
         end
       end
 
-
       class BaseReader < Reader
         def setup_stack(line)
-          push_reader_if_match(line, [:iteration, :block, :key_value])
+          push_reader_if_match(line, %i[iteration block key_value])
         end
       end
 
@@ -320,7 +319,7 @@ module AdHocTemplate
           when EMPTY_LINE, ITERATION_HEAD, BLOCK_HEAD
             pop_stack
           end
-          push_reader_if_match(line, [:iteration, :block])
+          push_reader_if_match(line, %i[iteration block])
         end
 
         def read(line)
@@ -331,20 +330,22 @@ module AdHocTemplate
       end
 
       class BlockReader < Reader
+        using Shim unless ''.respond_to?(:+@)
+
         def setup_stack(line)
           case line
           when ITERATION_HEAD, BLOCK_HEAD
             @stack.remove_trailing_empty_lines_from_last_block!
             pop_stack
           end
-          push_reader_if_match(line, [:iteration, :block])
+          push_reader_if_match(line, %i[iteration block])
         end
 
         def read(line)
           block_value = @stack.last_block_value
           case line
           when BLOCK_HEAD
-            setup_new_block(line, String.new)
+            setup_new_block(line, +'')
           when EMPTY_LINE, COMMENT_HEAD
             block_value << line unless block_value.empty?
           else
@@ -389,7 +390,12 @@ module AdHocTemplate
         iteration_part = format_iteration_block(iteration_keys, labels)
         block_part = format_key_value_block(block_keys, labels)
 
-        [key_value_part, iteration_part, block_part].join($/).sub(/(#{$/}+)\Z/, $/)
+        all_parts = [key_value_part, iteration_part, block_part].join($/)
+        remove_redundant_newlines(all_parts)
+      end
+
+      def self.remove_redundant_newlines(str)
+        str.sub(/(#{$/}+)\Z/, $/)
       end
 
       def self.format_key_value_pairs(key_names, labels={})
@@ -399,33 +405,32 @@ module AdHocTemplate
       def self.format_key_value_block(key_names, labels)
         [].tap do |blocks|
           key_names.each do |key|
-            blocks.push "///@#{key}#{$/*2}#{labels[key]}"
+            blocks.push "///@#{key}#{$/ * 2}#{labels[key]}"
           end
         end.join($/)
       end
 
       def self.format_iteration_block(key_names, labels)
         key_names.map do |iteration_label|
-          iteration_block = ["///@#{iteration_label}#{$/}"]
-          labels[iteration_label].each do |sub_record|
-             iteration_block.push format_key_value_pairs(sub_record.keys, sub_record)
+          iteration_block = labels[iteration_label].map do |sub_record|
+            format_key_value_pairs(sub_record.keys, sub_record)
           end
-          iteration_block.join($/)
+          iteration_block.unshift("///@#{iteration_label}#{$/}")
         end.join($/)
       end
 
       def self.categorize_keys(labels)
-        iteration_part, rest = labels.partition do |e|
-          e[1].kind_of? Array
-        end.map {|e| e.map(&:first) }
+        iteration_part, rest = labels.partition {|e| e[1].kind_of? Array }
+                                 .map {|e| e.map(&:first) }
 
         block_part, key_value_part = rest.partition do |e|
           LINE_END_RE =~ labels[e]
         end
 
-        return iteration_part, key_value_part, block_part
+        [iteration_part, key_value_part, block_part]
       end
 
+      private_class_method :remove_redundant_newlines
       private_class_method :format_key_value_pairs
       private_class_method :format_key_value_block
       private_class_method :format_iteration_block
@@ -438,9 +443,7 @@ module AdHocTemplate
       csv: CSVReader,
       tsv: TSVReader,
       default: DefaultFormReader,
-    }
-
-    FORMAT_NAME_TO_READER.default = DefaultFormReader
+    }.tap {|h| h.default = DefaultFormReader }.freeze
 
     def self.dump(data_source, target_format=:default)
       FORMAT_NAME_TO_READER[target_format].dump(data_source)
@@ -463,7 +466,7 @@ module AdHocTemplate
       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
+        elsif v && !v.kind_of?(String)
           data[k] = v.to_s
         end
       end

data/lib/ad_hoc_template/shim.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module AdHocTemplate
+  ##
+  # Provide methods that are not availabe in older versions of Ruby.
+
+  module Shim
+    refine Regexp do
+      ##
+      # Regexp.match?() is available for Ruby >= 2.4,
+      # and the following implementation does not satisfy
+      # the full specification of the original method.
+
+      alias_method(:match?, :===)
+    end
+
+    refine String do
+      ##
+      # Regexp.match?() is available for Ruby >= 2.3,
+      # and the following implementation does not satisfy
+      # the full specification of the original method.
+
+      alias_method(:+@, :dup)
+    end
+  end
+end

data/lib/ad_hoc_template/utils.rb

@@ -1,16 +1,16 @@
-#!/usr/bin/env ruby
+# frozen_string_literal: true
 
 module AdHocTemplate
   module Utils
-        FILE_EXTENTIONS = {
+    FILE_EXTENTIONS = {
       /\.ya?ml\Z/i => :yaml,
       /\.json\Z/i => :json,
       /\.csv\Z/i => :csv,
       /\.tsv\Z/i => :tsv,
-    }
+    }.freeze
 
     def guess_file_format(filename)
-      if_any_regex_match(FILE_EXTENTIONS, filename) do |ext_re, format|
+      if_any_regex_match(FILE_EXTENTIONS, filename) do |_, format|
         return format
       end
     end
@@ -19,11 +19,17 @@ module AdHocTemplate
       regex_table.each do |re, paired_value|
         if re =~ target
           yield re, paired_value
-          return
+          return nil
         end
       end
       STDERR.puts failure_message if failure_message
       nil
     end
+
+    private
+
+    def csv_or_tsv?(format)
+      %i[csv tsv].include? format
+    end
   end
 end