ad_hoc_template 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ac72ef7ef92a4a6aa9be31762b2cc29177cecd44
+  data.tar.gz: 6fd32a26232fbb869f73632610c301e470e3178b
+SHA512:
+  metadata.gz: e6935f638dd7c1cb8979c86bbfbd653ec75a7a4aca0d7579391026b47e60840b55a4444696cef0f2203bf6a5460b95822324b7322754cd9a215fb92e357a76a7
+  data.tar.gz: 42d8b17110f59b24fe529029da629fa4150ce4c531b15721d47e7783da12edee4acf56086a6f3ec86b03d84197bdcf71967a9c989d4a0a784972682e6c27fe13

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 1.9.3

data/Gemfile

@@ -0,0 +1,11 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in ad_hoc_template.gemspec
+
+gem 'pseudohikiparser', :git => 'https://github.com/nico-hn/PseudoHikiParser.git', :tag => '0.0.2'
+
+group :development do
+  gem "bundler", "~> 1.3"
+  gem "rake"
+  gem "rspec"
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 HASHIMOTO, Naoki
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,94 @@
+# AdHocTemplate
+
+AdHocTemplate is a template processor with simple but sufficent rules for some ad hoc tasks.
+
+I conceived this template as a workaroud for some tasks in a working environment completely left behind the times (maybe 10-15 years or so?), where they don't seem to know what a database is.
+
+And I hope this tool saves you from meaningless tasks when you have to face such a situation.
+
+## Installation (not published to RubyGems.org yet)
+
+Add this line to your application's Gemfile:
+
+    gem 'ad_hoc_template'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install ad_hoc_template
+
+## Usage
+
+The following is an example of template format:
+
+```
+a test string with tags (<%= key1 %> and <%= key2 %>) in it
+
+<%#iteration_block
+the value of sub_key1 is <%= sub_key1 %>
+the value of sub_key2 is <%= sub_key2 %>
+
+#%>
+<%= block %>
+```
+
+And suppose you want to fill the template with sample data below:
+
+```
+key1: value1
+key2: value2
+key3: value3
+
+//@#iteration_block
+
+sub_key1: value1-1
+sub_key2: value1-2
+
+sub_key1: value2-1
+sub_key2: value2-2
+
+//@block
+
+the first line of block
+the second line of block
+
+the second paragraph in block
+
+```
+
+1. Save the template and sample data above as 'template.txt' and 'sample\_data.txt' respectively.
+2. Execute the following at the command line:
+
+```
+ad_hoc_template template.txt sample_data.txt
+```
+
+Then you will get the following result:
+
+```
+a test string with tags (value1 and value2) in it
+
+the value of sub_key1 is value1-1
+the value of sub_key2 is value1-2
+
+the value of sub_key1 is value2-1
+the value of sub_key2 is value2-2
+
+
+the first line of block
+the second line of block
+
+the second paragraph in block
+
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/ad_hoc_template.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ad_hoc_template/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "ad_hoc_template"
+  spec.version       = AdHocTemplate::VERSION
+  spec.authors       = ["HASHIMOTO, Naoki"]
+  spec.email         = ["hashimoto.naoki@gmail.com"]
+  spec.description   = %q{AdHocTemplate is a template processor with simple but sufficient rules for some ad hoc tasks.}
+  spec.summary       = %q{A tiny template processor}
+  spec.homepage      = "https://github.com/nico-hn/AdHocTemplate"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  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.2"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake", "~> 10.1"
+  spec.add_development_dependency "rspec", "~> 3.2"
+end

data/bin/ad_hoc_template

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require 'ad_hoc_template'
+require 'ad_hoc_template/command_line_interface'
+
+AdHocTemplate::CommandLineInterface.new.execute

data/lib/ad_hoc_template/command_line_interface.rb

@@ -0,0 +1,70 @@
+#!/usr/bin/env ruby
+
+require 'ad_hoc_template'
+require 'optparse'
+
+module AdHocTemplate
+  class CommandLineInterface
+    attr_accessor :output_filename, :template_data, :record_data
+
+    def initialize
+      @formatter = AdHocTemplate::DefaultTagFormatter.new
+      @output_filename = nil
+    end
+
+    def set_encoding(given_opt)
+      external, internal = given_opt.split(/:/o, 2)
+      Encoding.default_external = external if external and not external.empty?
+      Encoding.default_internal = internal if internal and not internal.empty?
+    end
+
+    def parse_command_line_options
+      OptionParser.new do |opt|
+        opt.on("-E [ex[:in]]", "--encoding [=ex[:in]]",
+               "Specify the default external and internal character encodings (same as the option of MRI") do |given_opt|
+          self.set_encoding(given_opt)
+        end
+
+        opt.on("-o [output_file]", "--output [=output_file]",
+               "Save the result into the specified file.") do |output_file|
+          @output_filename = File.expand_path(output_file)
+        end
+
+       opt.parse!
+      end
+    end
+
+    def read_input_files
+      template, record = ARGV.map {|arg| File.expand_path(arg) if arg }
+      if template
+        @template_data = File.read(template)
+      else
+        STDERR.puts "No template file is given."
+      end
+
+      @record_data = record ? File.read(record) : ARGF.read
+    end
+
+    def convert
+      AdHocTemplate::Converter.convert(@record_data, @template_data, @formatter)
+    end
+
+    def open_output
+      if @output_filename
+        open(@output_filename, "wb") do |out|
+          yield out
+        end
+      else
+        yield STDOUT
+      end
+    end
+
+    def execute
+      parse_command_line_options
+      read_input_files
+      open_output do |out|
+        out.print convert
+      end
+    end
+  end
+end

data/lib/ad_hoc_template/version.rb

@@ -0,0 +1,3 @@
+module AdHocTemplate
+  VERSION = "0.0.1"
+end

data/lib/ad_hoc_template.rb

@@ -0,0 +1,239 @@
+require "ad_hoc_template/version"
+require "pseudohiki/inlineparser"
+require "htmlelement"
+
+module AdHocTemplate
+  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?
+        super
+      end
+
+      def assign_type(first_leaf)
+        return first_leaf unless first_leaf.kind_of? String and /^\S/o.match(first_leaf)
+        @type, first_leaf_content = first_leaf.split(/\s+/o, 2)
+        first_leaf_content||""
+      end
+      private :assign_type
+
+      def contains_any_value_assigned_tag_node?(record)
+        self.select {|n| n.kind_of?(TagNode) }.each do |node|
+          val = record[node.join.strip]
+          return true if val and not val.empty?
+        end
+        false
+      end
+    end
+
+    class IterationTagNode < TagNode; end
+    class Leaf < Parser::Leaf; end
+
+    HEAD, TAIL = {}, {}
+
+    [[TagNode, "<%", "%>"],
+     [IterationTagNode, "<%#", "#%>"]].each do |type, head, tail|
+      HEAD[head] = type
+      TAIL[tail] = type
+    end
+
+    TOKEN_PAT = PseudoHiki.compile_token_pat(HEAD.keys, TAIL.keys)
+
+    def self.split_into_tokens(str)
+      tokens = []
+
+      while m = TOKEN_PAT.match(str)
+        tokens.push m.pre_match unless m.pre_match.empty?
+        tokens.push m[0]
+        str = m.post_match
+      end
+
+      tokens.push str unless str.empty?
+      tokens
+    end
+
+    def self.parse(str)
+      new(str).parse.tree
+    end
+
+    def initialize(str)
+      @tokens = Parser.split_into_tokens(str)
+      super()
+    end
+
+    def parse
+      while token = @tokens.shift
+        next if TAIL[token] == current_node.class and self.pop
+        next if HEAD[token] and self.push HEAD[token].new
+        self.push Leaf.create(token)
+      end
+
+      self
+    end
+  end
+
+  module RecordReader
+    SEPARATOR = /:\s*/o
+    BLOCK_HEAD = /\A\/\/@/o
+    EMPTY_LINE = /\A\r?\n\Z/o
+    ITERATION_MARK = /\A#/o
+
+    def self.remove_leading_empty_lines(lines)
+      until lines.empty? or /\S/o.match(lines.first)
+        lines.shift
+      end
+    end
+
+    def self.strip_blank_lines(block)
+      remove_leading_empty_lines(block)
+      block.pop while not block.empty? and EMPTY_LINE.match(block.last)
+    end
+
+    def self.read_key_value_list(lines, record)
+      while line = lines.shift and not EMPTY_LINE.match(line)
+        key, val = line.chomp.split(SEPARATOR, 2)
+        record[key] = val
+      end
+
+      record
+    end
+
+    def self.read_block(lines, record, block_head)
+      block = []
+
+      while line = lines.shift
+        if m = BLOCK_HEAD.match(line)
+          strip_blank_lines(block)
+          record[block_head] = block.join
+          return m.post_match.chomp
+        end
+
+        block.push(line)
+      end
+
+      strip_blank_lines(block)
+      record[block_head] = block.join
+    end
+
+    def self.read_block_part(lines, record, block_head)
+      until lines.empty? or not block_head
+        block_head = read_block(lines, record, block_head)
+      end
+    end
+
+    def self.read_iteration_block(lines, record, block_head)
+      records = []
+
+      while line = lines.shift
+        if m = BLOCK_HEAD.match(line)
+          record[block_head] = records
+          return m.post_match.chomp
+        elsif EMPTY_LINE.match(line)
+          next
+        else
+          lines.unshift line
+          records.push read_key_value_list(lines, {})
+        end
+      end
+
+      record[block_head] = records
+      nil
+    end
+
+    def self.read_iteration_block_part(lines, record, block_head)
+      while not lines.empty? and block_head and ITERATION_MARK.match(block_head)
+        block_head = read_iteration_block(lines, record, block_head)
+      end
+
+      block_head
+    end
+
+    def self.read_record(input)
+      lines = input.each_line.to_a
+      record = read_key_value_list(lines, {})
+      remove_leading_empty_lines(lines)
+
+      unless lines.empty?
+        m = BLOCK_HEAD.match(lines.shift)
+        block_head = read_iteration_block_part(lines, record, m.post_match.chomp)
+        read_block_part(lines, record, block_head) if block_head
+      end
+
+      record
+    end
+  end
+
+  class DefaultTagFormatter
+    def find_function(tag_type)
+      FUNCTION_TABLE[tag_type]||:default
+    end
+
+    def format(tag_type, var, record)
+      self.send(find_function(tag_type), var, record)
+    end
+
+    def default(var, record)
+      record[var]||"[#{var}]"
+    end
+
+    def html_encode(var ,record)
+      HtmlElement.escape(record[var]||var)
+    end
+
+    FUNCTION_TABLE = {
+      "=" => :default,
+      "h" => :html_encode
+    }
+  end
+
+  class Converter
+    def self.convert(record_data, template, formatter=DefaultTagFormatter.new)
+      tree = AdHocTemplate::Parser.parse(template)
+      record = AdHocTemplate::RecordReader.read_record(record_data)
+      AdHocTemplate::Converter.new(record, formatter).format(tree)
+    end
+
+    def initialize(record, formatter=DefaultTagFormatter.new)
+      @record = record
+      @formatter = formatter
+    end
+
+    def visit(tree)
+      case tree
+      when Parser::IterationTagNode
+        format_iteration_tag(tree)
+      when Parser::TagNode
+        format_tag(tree)
+      when Parser::Leaf
+        tree.join
+      else
+        tree.map {|node| node.accept(self) }
+      end
+    end
+
+    def format_iteration_tag(tag_node)
+      sub_records = @record["#"+(tag_node.type||"".freeze)]||[@record]
+      tag_node = Parser::TagNode.new.concat(tag_node.clone)
+
+      sub_records.map do |record|
+        if tag_node.contains_any_value_assigned_tag_node?(record)
+          converter = AdHocTemplate::Converter.new(record, @formatter)
+          tag_node.map {|leaf| leaf.accept(converter) }.join
+        else
+          "".freeze
+        end
+      end
+    end
+
+    def format_tag(tag_node)
+      leafs = tag_node.map {|leaf| leaf.accept(self) }
+      @formatter.format(tag_node.type, leafs.join.strip, @record)
+    end
+
+    def format(tree)
+      tree.accept(self).join
+    end
+  end
+end

data/spec/ad_hoc_template_spec.rb

@@ -0,0 +1,249 @@
+require 'spec_helper'
+require 'ad_hoc_template'
+
+describe AdHocTemplate do
+  it 'should have a version number' do
+    expect(AdHocTemplate::VERSION).to_not be_nil
+  end
+
+  describe AdHocTemplate::Parser do
+    it "returns a tree of TagNode and Leaf" do
+      expect(AdHocTemplate::Parser.parse("a test string with tags (<% the first tag %> and <% the second tag %>) in it")).to eq([["a test string with tags ("],
+                                                                                                                                 [[" the first tag "]],
+                                                                                                                                 [" and "],
+                                                                                                                                 [[" the second tag "]],
+                                                                                                                                 [") in it"]])
+    end
+
+    it "allows to have a nested tag" do
+      expect(AdHocTemplate::Parser.parse("a test string with a nested tag; <% an outer tag and <% an inner tag %> %>")).to eq([["a test string with a nested tag; "],
+                                                                                                                                [[" an outer tag and "],
+                                                                                                                                 [[" an inner tag "]],
+                                                                                                                                 [" "]]])
+    end
+
+    it "may have iteration tags." do
+      tree = AdHocTemplate::Parser.parse("a test string with a nested tag: <%# an iteration tag and <% an inner tag %> #%> and <% another tag %>")
+      expect(tree).to eq([["a test string with a nested tag: "],
+                          [[" an iteration tag and "],
+                           [[" an inner tag "]],
+                           [" "]],
+                          [" and "],
+                         [[" another tag "]]])
+      expect(tree[1]).to be_a_kind_of(AdHocTemplate::Parser::IterationTagNode)
+    end
+  end
+
+  describe AdHocTemplate::RecordReader do
+    it "can read several header type configurations at once." do
+      data = <<CONFIGS
+
+key1-1: value1-1
+key1-2: value1-2
+
+key2-1: value2-1
+key2-2: value2-2
+
+key3-1: value3-1
+key3-2: value3-2
+
+CONFIGS
+
+config = {}
+AdHocTemplate::RecordReader.read_iteration_block(data.each_line.to_a, config, "#configs")
+      expect(config).to eq({"#configs"=>[{"key1-1"=>"value1-1", "key1-2"=>"value1-2"},
+                                         {"key2-1"=>"value2-1", "key2-2"=>"value2-2"},
+                                         {"key3-1"=>"value3-1", "key3-2"=>"value3-2"}]})
+    end
+
+    it "reads configuration data and turns them into a hash object" do
+      data = <<CONFIG
+key1: value1
+key2: value2
+key3: value3
+
+//@block1
+
+the first line of block1
+the second line of block1
+
+the second paragraph in block1
+
+//@block2
+the first line of block2
+the second line of block2
+
+the second paragraph of block2
+CONFIG
+
+expected_config = {
+        "key1" => "value1",
+        "key2" => "value2",
+        "key3" => "value3",
+        "block1" => "the first line of block1\nthe second line of block1\n\nthe second paragraph in block1\n",
+        "block2" => "the first line of block2\nthe second line of block2\n\nthe second paragraph of block2\n"
+      }
+      expect(AdHocTemplate::RecordReader.read_record(data)).to eq(expected_config)
+    end
+
+    it "can read configuration data with 3 different kind of sections" do
+      data = <<CONFIG
+key1: value1
+key2: value2
+key3: value3
+
+//@#subconfigs
+
+key1-1: value1-1
+key1-2: value1-2
+
+key2-1: value2-1
+key2-2: value2-2
+
+//@block
+
+the first line of block
+the second line of block
+
+the second paragraph in block
+
+CONFIG
+
+expected_config = {
+        "key1" => "value1",
+        "key2" => "value2",
+        "key3" => "value3",
+        "#subconfigs" => [{"key1-1"=>"value1-1", "key1-2"=>"value1-2"}, {"key2-1"=>"value2-1", "key2-2"=>"value2-2"}],
+        "block" => "the first line of block\nthe second line of block\n\nthe second paragraph in block\n"
+      }
+      expect(AdHocTemplate::RecordReader.read_record(data)).to eq(expected_config)
+    end
+  end
+
+  describe AdHocTemplate::Converter do
+    it "returns the result of conversion." do
+      template = "a test string with tags (<%= key1 %> and <%= key2 %>) in it"
+      config_data = <<CONFIG
+key1: value1
+key2: value2
+CONFIG
+
+      tree = AdHocTemplate::Parser.parse(template)
+      config = AdHocTemplate::RecordReader.read_record(config_data)
+      expect(AdHocTemplate::Converter.new(config).format(tree)).to eq("a test string with tags (value1 and value2) in it")
+    end
+
+    it "accepts a template with an iteration block and evaluate repeatedly the block" do
+      template = <<TEMPLATE
+a test string with tags (<%= key1 %> and <%= key2 %>) in it
+
+<%#iteration_block
+the value of sub_key1 is <%= sub_key1 %>
+the value of sub_key2 is <%= sub_key2 %>
+
+#%>
+<%= block %>
+TEMPLATE
+
+      config_data = <<CONFIG
+key1: value1
+key2: value2
+key3: value3
+
+//@#iteration_block
+
+sub_key1: value1-1
+sub_key2: value1-2
+
+sub_key1: value2-1
+sub_key2: value2-2
+
+//@block
+
+the first line of block
+the second line of block
+
+the second paragraph in block
+
+CONFIG
+
+expected_result = <<RESULT
+a test string with tags (value1 and value2) in it
+
+the value of sub_key1 is value1-1
+the value of sub_key2 is value1-2
+
+the value of sub_key1 is value2-1
+the value of sub_key2 is value2-2
+
+
+the first line of block
+the second line of block
+
+the second paragraph in block
+
+RESULT
+      tree = AdHocTemplate::Parser.parse(template)
+      config = AdHocTemplate::RecordReader.read_record(config_data)
+      expect(AdHocTemplate::Converter.new(config).format(tree)).to eq(expected_result)
+    end
+
+    it "may contains iteration blocks without key label." do
+      template = <<TEMPLATE
+a test string with tags (<%= key1 %> and <%= key2 %>) in it
+
+<%#
+the value of key1 is <%= key1 %>
+the value of key2 is <%= key2 %>
+
+#%>
+<%#
+the value of key2 is <%= non-existent-key %>
+the value of key2 is <%= key-without-value %>
+#%>
+<%# the value of key2 is <%= non-existent-key %> #%>
+<%= block %>
+TEMPLATE
+
+      config_data = <<CONFIG
+key1: value1
+key2: value2
+key3: value3
+key-without-value: 
+
+//@block
+
+the first line of block
+the second line of block
+
+the second paragraph in block
+
+CONFIG
+
+expected_result = <<RESULT
+a test string with tags (value1 and value2) in it
+
+the value of key1 is value1
+the value of key2 is value2
+
+
+
+
+the first line of block
+the second line of block
+
+the second paragraph in block
+
+RESULT
+      tree = AdHocTemplate::Parser.parse(template)
+      config = AdHocTemplate::RecordReader.read_record(config_data)
+      expect(AdHocTemplate::Converter.new(config).format(tree)).to eq(expected_result)
+    end
+
+    it 'can convert &"<> into character entities' do
+      result = AdHocTemplate::Converter.convert('characters: &, ", < and >',
+                                       'a string with characters (<%h characters %>) that should be represented as character entities.')
+      expect(result).to eq('a string with characters (&amp;, &quot;, &lt; and &gt;) that should be represented as character entities.')
+    end
+  end
+end

data/spec/command_line_interface_spec.rb

@@ -0,0 +1,130 @@
+#!/usr/bin/env ruby
+
+require 'shellwords'
+require 'stringio'
+require 'spec_helper'
+require 'ad_hoc_template'
+require 'ad_hoc_template/command_line_interface'
+
+describe AdHocTemplate do
+  describe AdHocTemplate::CommandLineInterface do
+    it "can set the input/output encoding" do
+      command_line_interface = AdHocTemplate::CommandLineInterface.new
+      command_line_interface.set_encoding("UTF-8:Shift_JIS")
+      expect(command_line_interface.class::Encoding.default_external.names).to include("UTF-8")
+      expect(command_line_interface.class::Encoding.default_internal.names).to include("Shift_JIS")
+    end
+
+    it "accepts an internal only argument" do
+      command_line_interface = AdHocTemplate::CommandLineInterface.new
+      command_line_interface.set_encoding(":UTF-8")
+      expect(command_line_interface.class::Encoding.default_internal.names).to include("UTF-8")
+    end
+
+    it "accepts also an external only argument" do
+      command_line_interface = AdHocTemplate::CommandLineInterface.new
+      command_line_interface.set_encoding("Shift_JIS")
+      expect(command_line_interface.class::Encoding.default_external.names).to include("Shift_JIS")
+      command_line_interface.set_encoding("UTF-8:")
+      expect(command_line_interface.class::Encoding.default_external.names).to include("UTF-8")
+    end
+
+    it "can set the internal/external encoding from the command line" do
+      command_line_interface = AdHocTemplate::CommandLineInterface.new
+      set_argv("-E UTF-8:Shift_JIS")
+      command_line_interface.parse_command_line_options
+      expect(command_line_interface.class::Encoding.default_external.names).to include("UTF-8")
+      expect(command_line_interface.class::Encoding.default_internal.names).to include("Shift_JIS")
+    end
+
+    it "can specify the output file from command line" do
+      pwd = File.expand_path(".")
+      output_filename = "file_for_saving_result.txt"
+      command_line_interface = AdHocTemplate::CommandLineInterface.new
+      set_argv("-o #{output_filename}")
+      command_line_interface.parse_command_line_options
+      expect(command_line_interface.output_filename).to eq(File.join(pwd, output_filename))
+    end
+
+    it "reads input data from command line" do
+      template_filename = "template.txt"
+      record_filename = "record.txt"
+      template = "a dummy content of template file"
+      record = "a dummy content of record file"
+
+      allow(File).to receive(:read).with(File.expand_path(template_filename)).and_return(template)
+      allow(File).to receive(:read).with(File.expand_path(record_filename)).and_return(record)
+
+      set_argv("#{template_filename} #{record_filename}")
+      command_line_interface = AdHocTemplate::CommandLineInterface.new
+      command_line_interface.read_input_files
+
+      expect(command_line_interface.template_data).to eq(template)
+      expect(command_line_interface.record_data).to eq(record)
+    end
+
+    it "returns the result to the standard output unless an output file is specified." do
+      template_filename = "template.txt"
+      record_filename = "record.txt"
+
+      template = <<TEMPLATE
+a test string with tags (<%= key1 %> and <%= key2 %>) in it
+
+<%#iteration_block
+the value of sub_key1 is <%= sub_key1 %>
+the value of sub_key2 is <%= sub_key2 %>
+
+#%>
+<%= block %>
+TEMPLATE
+
+      record = <<CONFIG
+key1: value1
+key2: value2
+key3: value3
+
+//@#iteration_block
+
+sub_key1: value1-1
+sub_key2: value1-2
+
+sub_key1: value2-1
+sub_key2: value2-2
+
+//@block
+
+the first line of block
+the second line of block
+
+the second paragraph in block
+
+CONFIG
+
+      expected_result = <<RESULT
+a test string with tags (value1 and value2) in it
+
+the value of sub_key1 is value1-1
+the value of sub_key2 is value1-2
+
+the value of sub_key1 is value2-1
+the value of sub_key2 is value2-2
+
+
+the first line of block
+the second line of block
+
+the second paragraph in block
+
+RESULT
+
+
+      allow(File).to receive(:read).with(File.expand_path(template_filename)).and_return(template)
+      allow(File).to receive(:read).with(File.expand_path(record_filename)).and_return(record)
+      allow(STDOUT).to receive(:print).with(expected_result)
+
+      set_argv("#{template_filename} #{record_filename}")
+      command_line_interface = AdHocTemplate::CommandLineInterface.new
+      command_line_interface.execute
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'shellwords'
+require 'ad_hoc_template'
+
+module Helpers
+  def set_argv(command_line_str)
+    ARGV.replace Shellwords.split(command_line_str)
+  end
+end
+
+RSpec.configure do |c|
+  c.include Helpers
+end

metadata

@@ -0,0 +1,121 @@
+--- !ruby/object:Gem::Specification
+name: ad_hoc_template
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- HASHIMOTO, Naoki
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-03-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pseudohikiparser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.0.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.0.2
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.1'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+description: AdHocTemplate is a template processor with simple but sufficient rules
+  for some ad hoc tasks.
+email:
+- hashimoto.naoki@gmail.com
+executables:
+- ad_hoc_template
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- ad_hoc_template.gemspec
+- bin/ad_hoc_template
+- lib/ad_hoc_template.rb
+- lib/ad_hoc_template/command_line_interface.rb
+- lib/ad_hoc_template/version.rb
+- spec/ad_hoc_template_spec.rb
+- spec/command_line_interface_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/nico-hn/AdHocTemplate
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: A tiny template processor
+test_files:
+- spec/ad_hoc_template_spec.rb
+- spec/command_line_interface_spec.rb
+- spec/spec_helper.rb
+has_rdoc: