hyogen 0.0.1 → 0.0.2

data/Manifest.txt

@@ -1,13 +1,16 @@
 History.txt
 Manifest.txt
 README.txt
+README
 Rakefile
+bin/hyogen
 lib/hyogen.rb
+lib/hyogen/reader.rb
+lib/hyogen/table_elements.rb
+lib/hyogen/template.rb
 lib/hyogen/version.rb
 scripts/txt2html
 setup.rb
-test/test_helper.rb
-test/test_hyogen.rb
 website/index.html
 website/index.txt
 website/javascripts/rounded_corners_lite.inc.js

data/README

@@ -0,0 +1,47 @@
+= Overview
+Hyogen converts CSV or Excel data to Ruby objects or any text.
+This package is like Java's XLSBeans library.
+
+= Here is how do you it
+
+Start with a very simple example.
+
+=== Input
+
+Input data is CSV or Excel format data. The data have to include table tag.
+Hyogen converts input data to array of Table class object.
+Table class is set of Record class. Record class is a row of table.
+
+  {VTABLE}User List
+  {L}id, name, gender
+  1, Taro, male
+  2, Hanko, female
+  3, Ichiro, male
+
+=== Template
+
+Template format is erb.
+
+  <%- table = tables.first -%>
+  <%- for record in table.records -%>
+  My name is <%= record["name"] %>. I'm <%= record["gender"] %>.
+  <%- end -%>
+
+=== Output
+
+  My name is Taro. I'm male.
+  My name is Hanko. I'm female.
+  My name is Ichiro. I'm male.
+
+= Table tag
+
+<b>{VTABLE}</b>:: This tag means start of table and the line of records is vertical.
+<b>{HTABLE}</b>:: This tag means start of table and the line of records is horizontal.
+<b>{L}</b>:: This tag means start of label.
+
+<b>{N}</b>:: This tag means 
+<b><></b>:: This tag means 
+
+= Install
+require ParseExcel
+

data/Rakefile

@@ -45,8 +45,8 @@ hoe = Hoe.new(GEM_NAME, VERS) do |p|
   p.url = HOMEPATH
   p.rubyforge_name = RUBYFORGE_PROJECT if RUBYFORGE_PROJECT
 #  p.test_globs = ["test/**/test_*.rb"]
-#  p.test_globs = ["spec/**/spec_*.rb"]
-  p.test_globs = ["spec/**/*"]
+#  p.test_globs = ["spec/**/spec_*.rb", "spec/**/*.csv", "spec/**/*.xls"]
+  p.test_globs = ["spec/**/*[^~]"]
   p.clean_globs = CLEAN  #An array of file patterns to delete on clean.
 #  p.package_files.include("spec/**/*")
   
@@ -96,3 +96,21 @@ task :check_version do
     exit
   end
 end
+
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'html'
+  rdoc.options += RDOC_OPTS
+  rdoc.template = "#{ENV['template']}.rb" if ENV['template']
+  if ENV['DOC_FILES']
+    rdoc.rdoc_files.include(ENV['DOC_FILES'].split(/,\s*/))
+  else
+#    rdoc.rdoc_files.include('README', 'CHANGELOG')
+    rdoc.rdoc_files.include('README')
+    rdoc.rdoc_files.include('lib/**/*.rb')
+  end
+end
+
+desc "Publish to RubyForge"
+task :rubyforge => [:rdoc, :package] do
+  Rake::RubyForgePublisher.new(RUBYFORGE_PROJECT, 'yyagi').upload
+end

data/bin/hyogen

@@ -0,0 +1,26 @@
+#!/bin/ruby
+
+require 'lib/hyogen'
+require 'optparse'
+
+opts = OptionParser.new do |opt|
+  opt.on("-s source") {|val| $sourcefile = val}
+  opt.on("-o outputdir") {|val| $outputdir = val}
+end
+opts.parse! ARGV
+$templatefiles = ARGV
+$outputdir ||= '.'
+
+if ([$sourcefile, $templatefiles].any? {|e| e == nil})
+  puts <<USAGE
+Usage: #{$0} -s sourcefile [-o outputdir] templatefiles
+  sourcefile: csv or xls file
+  templatefiles: The extention of file name is '.template'.
+USAGE
+  exit
+end
+
+tables = Hyogen.parse_tables($sourcefile)
+for template in $templatefiles do
+  Hyogen::Template.generate(tables, template, $outputdir)
+end

data/lib/hyogen/reader.rb

@@ -0,0 +1,288 @@
+require  'forwardable'
+require 'csv'
+require 'parseexcel'
+
+module Hyogen
+  class Reader
+    module Tag
+      VTABLE = /\{VTABLE\}/
+      HTABLE = /\{HTABLE\}/
+      LABELS = /\{L\}/
+      LABEL_NOTE = /\{N\}/
+      ALIAS = /<(.+)>/
+      
+      def self.aliased(str)
+        result = remove_space( (str =~ Tag::ALIAS) ? $1 : str )
+        (result || "").sub(LABEL_NOTE,"")
+      end
+
+      def self.lookup_tag(obj, tag)
+        return nil  if obj == nil
+        list = (obj.kind_of?(Array) ? obj : [obj])
+        data = nil
+        position = nil
+        matched_value = nil
+        list.each_with_index do |value, i|
+          if tag =~ value
+            matched_value = value
+            position = i
+            m = Regexp.last_match
+            data = remove_space(m.pre_match)
+            data = remove_space(m.post_match)  if data == ""
+            break
+          end
+        end
+        return nil  unless matched_value
+        {:value => matched_value, :tag => tag, :data => data, :position => position}
+      end
+
+      def self.lookup_table_tag(obj)
+        lookup_tag(obj, Tag::VTABLE)  or lookup_tag(obj, Tag::HTABLE)
+      end
+      
+      private
+      def self.remove_space(str)
+        return nil  unless str
+        str.sub(/^\s*/,"").sub(/\s*$/,"")
+      end
+    end
+    
+    class Matrix
+      extend Forwardable
+      def initialize data
+        @data = data #�񎟌��z��
+      end
+      def_delegator :@data, :each, :each_row
+      def_delegator :@data, :each_with_index, :each_row_with_index
+      def_delegator :@data, :[], :row
+      def_delegator :@data, :size, :row_size
+      def_delegators :@data, :first
+      def value(row, column) @data[row][column] end
+      def column_size(n=0)  (@data == []) ? 0 : @data[n].size end
+      def column(n) @data.collect {|line| line[n]} end
+      def subset(row_range)  self.class.new(row(row_range)) end
+      def to_a()  row(0..-1)  end
+    end
+    
+    class Scheme
+      private
+      class PositionedLabel
+        def initialize(aNames, aPosition)
+          @names = aNames #String[]
+          @position = aPosition
+          @note = {}
+        end
+        attr_reader :names, :position
+        attr_accessor :note
+      end
+      public
+      def initialize
+        @body_position = nil
+        @record_direction = nil
+        @record_position = nil
+        @record_size = nil
+        @positioned_labels = []
+      end
+      attr_reader :positioned_labels
+      attr_accessor :body_position, :record_direction, :record_position, :record_size
+      def add_label(label_name, position)
+        before_label = @positioned_labels.find{|l| l.position == position}
+        if before_label
+          before_label.names << label_name
+        else
+          @positioned_labels << PositionedLabel.new([label_name], position)
+        end
+      end
+      def positioned_labels_to_labels
+        @positioned_labels.collect {|pos_label| Label.new(pos_label.names, pos_label.note)}
+      end
+    end
+    
+    def initialize matrix
+      @source = matrix
+      @table = nil
+      @scheme = nil
+    end
+    
+    def read_table
+      return nil  unless Tag::lookup_table_tag(@source.first)
+      
+      @scheme = Scheme.new
+      title = read_table_header
+      @table = Table.new(title)
+      read_labels
+      @table.records = read_records
+      @table.labels = @scheme.positioned_labels_to_labels
+      @table
+    end
+    
+    private
+    def read_table_header
+      table_tag = Tag::lookup_table_tag(@source.first)
+      raise "is not table"  unless table_tag
+      title = table_tag[:data]
+      @scheme.record_direction =  (table_tag[:tag] == Tag::HTABLE ? :horizontal : :vertical)
+      @scheme.body_position = 1
+      title
+    end
+    
+    def read_labels
+      @source.each_row_with_index do |values, row|
+        next  if row < @scheme.body_position
+        values.each_with_index do |value, column|
+          read_labels_from value, row, column
+        end
+#        break  unless @record_position[:row] == row
+      end
+    end
+    
+    def read_labels_from(value, row, column)
+      tagdata = Tag::lookup_tag(value, Tag::LABELS)
+      return  unless tagdata
+      
+      case @scheme.record_direction
+      when :vertical
+        @scheme.record_position = row + 1
+        @scheme.record_size = @source.column(column).size - @scheme.record_position
+        label_names = [tagdata[:data]] + @source.row(row)[column+1 .. -1]
+        label_start_position = column
+        
+      when :horizontal
+        @scheme.record_position = column + 1
+        @scheme.record_size = @source.row(row).size - @scheme.record_position
+        label_names = [tagdata[:data]] + @source.column(column)[row+1 .. -1]
+        label_start_position = row
+      else
+        raise
+      end
+      add_label label_names, label_start_position
+    end
+    
+    def add_label label_names, label_start_position
+      @previous_label_name = nil
+      label_names.each_with_index do |label_name, i|
+        if label_name
+          label_name = Tag.aliased(label_name)
+        else
+          raise "���x����������܂���"  unless @previous_label_name
+          label_name = @previous_label_name
+        end
+        @scheme.add_label label_name, label_start_position+i
+        @previous_label_name = label_name
+      end
+    end
+    
+#    def directed_values(position, start_pos, end_pos)
+#    end
+    
+    def key_position_of_label
+      @scheme.positioned_labels.first.position
+    end
+    
+    def read_records
+      return []  if [@source, @scheme, @scheme.record_position].any? {|e| e == nil}
+      record_last_position = @scheme.record_position + @scheme.record_size
+      (@scheme.record_position ... record_last_position).collect do |pos|
+        unless read_label_note_from pos
+          read_record_from pos
+        end
+      end.compact
+    rescue ArgumentError
+      return []
+    end
+    
+    def read_label_note_from pos
+      note_tag = Tag::lookup_tag(read_value(key_position_of_label, pos), Tag::LABEL_NOTE)
+      return nil  unless note_tag
+      note_name = Tag.aliased(note_tag[:data])
+      for pos_label in @scheme.positioned_labels do
+        value = Tag.aliased read_value(pos_label.position, pos)
+        pos_label.note[note_name] = value
+      end
+      true
+    end
+    
+    def read_record_from pos
+      record = Record.new
+      for pos_label in @scheme.positioned_labels do
+        value = Tag.aliased read_value(pos_label.position, pos)
+        record.set pos_label.names, value
+      end
+      record
+    end
+    
+    def read_value label_position, pos
+      (@scheme.record_direction == :vertical) ? @source.value(pos, label_position) : @source.value(label_position,pos)
+    end
+    
+    private
+    def self.read_tables(any_format)
+      matrix_list = any_format_to_matrixies any_format
+      matrix_list.collect do |matrix|
+        Reader.devide_into_table(matrix).collect do |table_lines|
+          Reader.new(table_lines).read_table
+        end
+      end.flatten
+    end
+    
+    def self.any_format_to_matrixies any_format
+      case any_format
+      when Array  #Array of Array of Value
+        [ Matrix.new(any_format) ]
+      when String
+        case File.extname(any_format)
+        when '.csv'
+          [ Matrix.new(CSV.read(any_format)) ]
+        when '.xls'
+          matrixes_from_excel_file(any_format)
+        else #String of CSV
+          [ Matrix.new(CSV.parse(any_format)) ]
+        end
+      end
+    end
+  
+    CHAR_CODE = 'sjis'
+    def self.worksheet_to_matrix worksheet
+      data = []
+      worksheet.num_rows.times do |r|
+        data << worksheet.row(r).collect {|cell| cell.to_s(CHAR_CODE)}
+      end
+      Matrix.new(data)
+    end
+  
+    def self.matrixes_from_excel_file(file_path)
+      result = []
+      workbook = Spreadsheet::ParseExcel.parse(file_path)
+      workbook.sheet_count.times do |sheet_num|
+        result << worksheet_to_matrix(workbook.worksheet(sheet_num))
+      end
+      result
+    end
+    
+    def self.start_of_table(line)
+      Tag::lookup_table_tag(line) != nil
+    end
+    
+    def self.end_of_table(line)
+      (line.all? {|v| v == nil  or  v =~ /^\s*$/}) or start_of_table(line)
+    end
+    
+    public
+    def self.devide_into_table matrix
+      result = []
+      count = 0
+      until (count >= matrix.row_size) do
+        unless start_of_table( matrix.row(count) )
+          count += 1
+          next
+        end
+        start_of_table = count
+        
+        begin count += 1 end until (count >= matrix.row_size  or  Tag::lookup_tag(matrix.row(count),Tag::LABELS))
+        count += 1  until  (count >= matrix.row_size  or end_of_table(matrix.row(count)) )
+        result << matrix.subset(start_of_table...count)
+      end
+      result
+    end
+  end
+end

data/lib/hyogen/table_elements.rb

@@ -0,0 +1,38 @@
+module Hyogen
+  #�\����ǂݎ�������R�[�h
+  #�\�̃��x�����������ƂȂ�A�\�̒l�������̒l�ƂȂ�B
+  class Record < Hash
+    def initialize
+    end
+    
+    def set(label_names, value)
+      target = self
+      label_names.each_with_index do |name, i|
+        if (i+1) == label_names.size
+          target[name] = value
+        else
+          target[name] ||= {}
+          target = target[name]
+        end
+      end
+    end
+  end
+  
+  class Label
+    def initialize names, note
+      @names = names  # Array of String
+      @note = note  # (String, String)
+    end
+    attr_reader :names, :note
+  end
+
+  class Table
+    def initialize(title)
+      @title = title
+      @labels = nil
+      @records = nil
+    end
+    attr_reader :title
+    attr_accessor :labels, :records
+  end
+end

data/lib/hyogen/template.rb

@@ -0,0 +1,17 @@
+require 'erb'
+
+module Hyogen
+  class Template
+    def self.generate(tables, source_path, output_dir='.')
+      @tables = tables
+      erb = File.open(source_path) {|f| ERB.new(f.read, nil, "-")}
+      result = erb.result(binding)
+      File.open(generate_file_name(output_dir,source_path), "w") {|f| f.write result}
+    end
+    
+    def self.generate_file_name(output_dir, source_path)
+      filename = File.basename(source_path, File.extname(source_path))
+      output_dir + '/' + filename
+    end
+  end
+end

data/lib/hyogen/version.rb

@@ -2,7 +2,7 @@ module Hyogen #:nodoc:
   module VERSION #:nodoc:
     MAJOR = 0
     MINOR = 0
-    TINY  = 1
+    TINY  = 2
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/spec/spec_hyogen.rb

@@ -5,29 +5,29 @@ context "deviding csvlines into tables:" do
   specify "empty" do
     csvdata = CSV.parse("")
     table_list = Hyogen::Reader.devide_into_table(Hyogen::Reader::Matrix.new(csvdata))
-    table_list.should_eql []
+    table_list.should == []
   end
   
   specify "the smallest table" do
     csvdata = CSV.parse("{VTABLE}")
     table_list = Hyogen::Reader.devide_into_table(Hyogen::Reader::Matrix.new(csvdata))
-    table_list.size.should_eql 1
-    table_list.first.to_a.should_eql [["{VTABLE}"]]
+    table_list.size.should == 1
+    table_list.first.to_a.should == [["{VTABLE}"]]
   end
   
   specify "the single table" do
     csvdata = CSV.parse("{HTABLE}\na,b\n1,2")
     table_list = Hyogen::Reader.devide_into_table(Hyogen::Reader::Matrix.new(csvdata))
-    table_list.size.should_eql 1
-    table_list.first.to_a.should_eql [["{HTABLE}"],["a","b"],["1","2"]]
+    table_list.size.should == 1
+    table_list.first.to_a.should == [["{HTABLE}"],["a","b"],["1","2"]]
   end
   
   specify "the multiple table" do
     csvdata = CSV.parse("{VTABLE}\n{L}\na,b\n{HTABLE}\n{L}\n1,2")
     table_list = Hyogen::Reader.devide_into_table(Hyogen::Reader::Matrix.new(csvdata))
-    table_list.size.should_eql 2
-    table_list[0].to_a.should_eql [["{VTABLE}"],["{L}"],["a","b"]]
-    table_list[1].to_a.should_eql [["{HTABLE}"],["{L}"],["1","2"]]
+    table_list.size.should == 2
+    table_list[0].to_a.should == [["{VTABLE}"],["{L}"],["a","b"]]
+    table_list[1].to_a.should == [["{HTABLE}"],["{L}"],["1","2"]]
   end
 end
 
@@ -35,13 +35,13 @@ context "parse tables:" do
   specify "empty" do
     csvdata = CSV.parse("")
     tables = Hyogen.parse_tables(csvdata)
-    tables.should_eql []
+    tables.should == []
   end
   
   specify "single table" do
     csvdata = CSV.parse("{VTABLE}\n")
     tables = Hyogen.parse_tables(csvdata)
-    tables.size.should_equal 1
+    tables.size.should == 1
     tables.first.title.should == ""
   end
   
@@ -49,13 +49,13 @@ context "parse tables:" do
     csvdata = CSV.parse("test table{VTABLE}\n")
     tables = Hyogen.parse_tables(csvdata)
     tables.size.should == 1
-    tables.first.title.should_eql "test table"
+    tables.first.title.should == "test table"
   end
 
   specify "multiple tables" do
     csvdata = CSV.parse("{VTABLE}\n{L}\n{HTABLE}\n{L}")
     tables = Hyogen.parse_tables(csvdata)
-    tables.size.should_equal 2
+    tables.size.should == 2
   end
 end
 
@@ -64,7 +64,7 @@ context "parse label:" do
   specify "hlabel" do
     csvdata = CSV.parse("test data{VTABLE}\n{L}l1,l2\n,A\n,B")
     tables = Hyogen.parse_tables(csvdata)
-    tables.size.should_equal 1
+    tables.size.should == 1
     table = tables.first
     table.labels.size.should == 2
     table.labels[0].names.should == ["l1"]
@@ -74,7 +74,7 @@ context "parse label:" do
   specify "vlabel" do
     csvdata = CSV.parse("test data{HTABLE}\n{L}l1,A\nl2,B")
     tables = Hyogen.parse_tables(csvdata)
-    tables.size.should_equal 1
+    tables.size.should == 1
     table = tables.first
     table.labels.size.should == 2
     table.labels[0].names.should == ["l1"]
@@ -89,14 +89,14 @@ context "Table has single label:" do
   specify "vtable label" do
     csvdata = CSV.parse("test data{VTABLE}\n{L}l\nA\nB")
     tables = Hyogen.parse_tables(csvdata)
-    tables.size.should_equal 1
+    tables.size.should == 1
     tables.first.records.should == expect
   end
   
   specify "htable label" do
     csvdata = CSV.parse("test data{HTABLE},,\nl{L},A,B")
     tables = Hyogen.parse_tables(csvdata)
-    tables.size.should_equal 1
+    tables.size.should == 1
     table = tables.first
     table.records.should == expect
   end
@@ -107,16 +107,16 @@ context "redudancy:" do
   specify "table" do
     csvdata = CSV.parse("{VTABLE}\n\n{L}a,b\n\n{HTABLE}\n{L}1,2\n\nhoge")
     table_list = Hyogen::Reader.devide_into_table(Hyogen::Reader::Matrix.new(csvdata))
-    table_list.size.should_eql 2
-    table_list[0].to_a.should_eql [["{VTABLE}"],[nil],["{L}a","b"]]
-    table_list[1].to_a.should_eql [["{HTABLE}"],["{L}1","2"]]
+    table_list.size.should == 2
+    table_list[0].to_a.should == [["{VTABLE}"],[nil],["{L}a","b"]]
+    table_list[1].to_a.should == [["{HTABLE}"],["{L}1","2"]]
   end
   
   specify "data" do
     expect = [{"l"=>"A"}, {"l"=>"B"}]
     csvdata = CSV.parse("test data  {VTABLE}  \n\n  {L}  l  \n  A  \nB  \n")
     tables = Hyogen.parse_tables(csvdata)
-    tables.size.should_equal 1
+    tables.size.should == 1
     tables.first.title.should == "test data"
     tables.first.records.should == expect
   end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: hyogen
 version: !ruby/object:Gem::Version 
-  version: 0.0.1
-date: 2007-05-02 00:00:00 +09:00
+  version: 0.0.2
+date: 2007-05-14 00:00:00 +09:00
 summary: This package allows you to mapping CSV or Excel to Ruby objects and generating some data.
 require_paths: 
 - lib
@@ -32,13 +32,16 @@ files:
 - History.txt
 - Manifest.txt
 - README.txt
+- README
 - Rakefile
+- bin/hyogen
 - lib/hyogen.rb
+- lib/hyogen/reader.rb
+- lib/hyogen/table_elements.rb
+- lib/hyogen/template.rb
 - lib/hyogen/version.rb
 - scripts/txt2html
 - setup.rb
-- test/test_helper.rb
-- test/test_hyogen.rb
 - website/index.html
 - website/index.txt
 - website/javascripts/rounded_corners_lite.inc.js
@@ -50,13 +53,12 @@ test_files:
 - spec/sample1.txt.template
 - spec/sample1.xls
 - spec/spec_hyogen.rb
-- spec/spec_hyogen.rb.1~
 rdoc_options: []
 
 extra_rdoc_files: []
 
-executables: []
-
+executables: 
+- hyogen
 extensions: []
 
 requirements: []

data/spec/spec_hyogen.rb.1~

@@ -1,294 +0,0 @@
-require 'lib/hyogen'
-require 'spec'
-
-
-context "deviding csvlines into tables:" do
-  specify "empty" do
-    csvdata = CSV.parse("")
-    table_list = Hyogen::Reader.devide_into_table(Hyogen::Reader::Matrix.new(csvdata))
-    table_list.should_eql []
-  end
-  
-  specify "the smallest table" do
-    csvdata = CSV.parse("{VTABLE}")
-    table_list = Hyogen::Reader.devide_into_table(Hyogen::Reader::Matrix.new(csvdata))
-    table_list.size.should_eql 1
-    table_list.first.to_a.should_eql [["{VTABLE}"]]
-  end
-  
-  specify "the single table" do
-    csvdata = CSV.parse("{HTABLE}\na,b\n1,2")
-    table_list = Hyogen::Reader.devide_into_table(Hyogen::Reader::Matrix.new(csvdata))
-    table_list.size.should_eql 1
-    table_list.first.to_a.should_eql [["{HTABLE}"],["a","b"],["1","2"]]
-  end
-  
-  specify "the multiple table" do
-    csvdata = CSV.parse("{VTABLE}\n{L}\na,b\n{HTABLE}\n{L}\n1,2")
-    table_list = Hyogen::Reader.devide_into_table(Hyogen::Reader::Matrix.new(csvdata))
-    table_list.size.should_eql 2
-    table_list[0].to_a.should_eql [["{VTABLE}"],["{L}"],["a","b"]]
-    table_list[1].to_a.should_eql [["{HTABLE}"],["{L}"],["1","2"]]
-  end
-end
-
-context "parse tables:" do
-  specify "empty" do
-    csvdata = CSV.parse("")
-    tables = Hyogen.parse_tables(csvdata)
-    tables.should_eql []
-  end
-  
-  specify "single table" do
-    csvdata = CSV.parse("{VTABLE}\n")
-    tables = Hyogen.parse_tables(csvdata)
-    tables.size.should_equal 1
-    tables.first.title.should == ""
-  end
-  
-  specify "labeled table" do
-    csvdata = CSV.parse("test table{VTABLE}\n")
-    tables = Hyogen.parse_tables(csvdata)
-    tables.size.should == 1
-    tables.first.title.should_eql "test table"
-  end
-
-  specify "multiple tables" do
-    csvdata = CSV.parse("{VTABLE}\n{L}\n{HTABLE}\n{L}")
-    tables = Hyogen.parse_tables(csvdata)
-    tables.size.should_equal 2
-  end
-end
-
-context "parse label:" do
-  expect = [{"l1"=>"A"}, {"l2"=>"B"}]
-  specify "hlabel" do
-    csvdata = CSV.parse("test data{VTABLE}\n{L}l1,l2\n,A\n,B")
-    tables = Hyogen.parse_tables(csvdata)
-    tables.size.should_equal 1
-    table = tables.first
-    table.labels.size.should == 2
-    table.labels[0].names.should == ["l1"]
-    table.labels[1].names.should == ["l2"]
-  end
-  
-  specify "vlabel" do
-    csvdata = CSV.parse("test data{HTABLE}\n{L}l1,A\nl2,B")
-    tables = Hyogen.parse_tables(csvdata)
-    tables.size.should_equal 1
-    table = tables.first
-    table.labels.size.should == 2
-    table.labels[0].names.should == ["l1"]
-    table.labels[1].names.should == ["l2"]
-  end
-end
-
-    
-#�P����(���x����=1)�\
-context "Table has single label:" do
-  expect = [{"l"=>"A"}, {"l"=>"B"}]
-  specify "vtable label" do
-    csvdata = CSV.parse("test data{VTABLE}\n{L}l\nA\nB")
-    tables = Hyogen.parse_tables(csvdata)
-    tables.size.should_equal 1
-    tables.first.records.should == expect
-  end
-  
-  specify "htable label" do
-    csvdata = CSV.parse("test data{HTABLE},,\nl{L},A,B")
-    tables = Hyogen.parse_tables(csvdata)
-    tables.size.should_equal 1
-    table = tables.first
-    table.records.should == expect
-  end
-end
-
-#�璷�ȃf�[�^���܂ޕ\
-context "redudancy:" do
-  specify "table" do
-    csvdata = CSV.parse("{VTABLE}\n\n{L}a,b\n\n{HTABLE}\n{L}1,2\n\nhoge")
-    table_list = Hyogen::Reader.devide_into_table(Hyogen::Reader::Matrix.new(csvdata))
-    table_list.size.should_eql 2
-    table_list[0].to_a.should_eql [["{VTABLE}"],[nil],["{L}a","b"]]
-    table_list[1].to_a.should_eql [["{HTABLE}"],["{L}1","2"]]
-  end
-  
-  specify "data" do
-    expect = [{"l"=>"A"}, {"l"=>"B"}]
-    csvdata = CSV.parse("test data  {VTABLE}  \n\n  {L}  l  \n  A  \nB  \n")
-    tables = Hyogen.parse_tables(csvdata)
-    tables.size.should_equal 1
-    tables.first.title.should == "test data"
-    tables.first.records.should == expect
-  end
-end
-
-#�����̃��R�[�h�ƕ����̃��x�������•\
-context "Table has multiple records and multiple labels:" do
-  expect = [{"name"=>"A", "age"=>"10"}, {"name"=>"B", "age"=>"20"}]
-  specify "vertical" do
-    csvdata = CSV.parse("{VTABLE}\n{L}name,age\nA,10\nB,20")
-    table = Hyogen.parse_tables(csvdata).first
-    table.records.should == expect
-  end
-  
-  specify "horizontal" do
-    csvdata = CSV.parse("{HTABLE},,\n{L}name,A,B\nage,10,20")
-    table = Hyogen.parse_tables(csvdata).first
-    table.records.should == expect
-  end
-end
-
-#�K�w�̂���\
-context "Table is structured" do
-  expect = [{"category"=> {"type" => "C"}}]
-  specify "vtable" do
-    csvdata = CSV.parse("{VTABLE}\n{L}category\n{L}type\nC")
-    table = Hyogen.parse_tables(csvdata).first
-    table.records.should == expect
-  end
-  specify "htable" do
-    csvdata = CSV.parse("{HTABLE},,o\n{L}category,{L}type,C")
-    table = Hyogen.parse_tables(csvdata).first
-    table.records.should == expect
-  end
-end
-
-#�⑫�^�O
-context "Note Tag" do
-  expect_records = [
-  {""=>"id1", "name"=> "alice", "age" => "10"},
-  {""=>"id2", "name"=> "bob", "age" => "20"},
-  ]
-  specify "" do
-    csvdata = CSV.parse("{HTABLE}\n{L},id1,id2,{N}�⑫\nname,alice,bob,���O\nage,10,20,��")
-    table = Hyogen.parse_tables(csvdata).first
-    table.records.should == expect_records
-    
-    table.labels[0].note.should == {"�⑫" => "�⑫"}
-    table.labels[1].note.should == {"�⑫" => "���O"}
-    table.labels[2].note.should == {"�⑫" => "��"}
-  end
-end
-
-
-context "Matrix of Excel Worksheet:" do
-  specify "" do
-    file = "./spec/sample1.xls"
-    workbook = Spreadsheet::ParseExcel.parse(file)
-    ws = workbook.worksheet(0)
-    matrix = Hyogen::Reader::worksheet_to_matrix(ws)
-    matrix.row_size.should == 4
-    matrix.column_size(0).should == 1
-    matrix.column_size(1).should == 4
-    
-    matrix.value(0,0).should == "{HTABLE}"
-    matrix.row(1).should == ["{L}", "id1", "id2", "{N}�⑫"]
-    matrix.to_a.should == [
-    ["{HTABLE}"],
-    ["{L}", "id1", "id2", "{N}�⑫"],
-    ["name", "Alice", "Bob", "���O"],
-    ["age", "10.0", "20.0", "��"]
-    ]
-  end
-end
-
-#�e��t�@�C���t�H�[�}�b�g
-context "File formats" do
-  def check table
-    expect_records = [
-    {""=>"id1", "name"=> "Alice", "age" => "10.0"},
-    {""=>"id2", "name"=> "Bob", "age" => "20.0"},
-    ]
-    table.records.should == expect_records
-    table.labels[0].note.should == {"�⑫" => "�⑫"}
-    table.labels[1].note.should == {"�⑫" => "���O"}
-    table.labels[2].note.should == {"�⑫" => "��"}
-  end
-  specify "csv string" do
-    input = "{HTABLE}\n{L},id1,id2,{N}�⑫\nname,Alice,Bob,���O\nage,10.0,20.0,��"
-    check Hyogen.parse_tables(input).first
-  end
-  specify "csv array" do
-    input = CSV.parse("{HTABLE}\n{L},id1,id2,{N}�⑫\nname,Alice,Bob,���O\nage,10.0,20.0,��")
-    check Hyogen.parse_tables(input).first
-  end
-  specify "csv file" do
-    input = "./spec/sample1.csv"
-    check Hyogen.parse_tables(input).first
-  end
-  specify "xls file" do
-    input = "./spec/sample1.xls"
-    check Hyogen.parse_tables(input).first
-  end
-end
-
-
-#�ȗ�
-context "label syoryaku" do
-  specify "vtable" do
-    csvdata = CSV.parse("{VTABLE},\n{L}a,\n{L}t1,t2\n1,2")
-    expect = [{"a"=> {"t1" => "1", "t2" => "2"}}]
-    table = Hyogen.parse_tables(csvdata).first
-    table.records.should == expect
-  end
-  
-  specify "overwrite" do
-    csvdata = CSV.parse("{VTABLE},\n{L}a,\n{L}t,\n1,2")
-    expect = [{"a"=> {"t" => "2"}}]
-    table = Hyogen.parse_tables(csvdata).first
-    table.records.should == expect
-  end
-end
-
-#�u��
-context "alias" do
-  specify "label" do
-    csvdata = CSV.parse("{VTABLE},\n{L}a,\n{L}t1,t2<abc>\n1,2")
-    expect = [{"a"=> {"t1" => "1", "abc" => "2"}}]
-    table = Hyogen.parse_tables(csvdata).first
-    table.records.should == expect
-  end
-  
-  specify "value" do
-    csvdata = CSV.parse("{VTABLE},\n{L}a,\n{L}t1,t2\n1,2  <2.00>")
-    expect = [{"a"=> {"t1" => "1", "t2" => "2.00"}}]
-    table = Hyogen.parse_tables(csvdata).first
-    table.records.should == expect
-  end
-end
-
-#����
-context "generate:" do
-  def check table
-    expect_records = [
-    {""=>"id1", "name"=> "alice", "age" => "10.0"},
-    {""=>"id2", "name"=> "bob", "age" => "20.0"},
-    ]
-    table.records.should == expect_records
-    table.labels[0].note.should == {"�⑫" => "�⑫"}
-    table.labels[1].note.should == {"�⑫" => "���O"}
-    table.labels[2].note.should == {"�⑫" => "��"}
-  end
-  specify "from script" do
-    input = "{HTABLE}\n{L},id1,id2,{N}�⑫\nname,Alice,Bob,���O\nage,10.0,20.0,��"
-    tables = Hyogen.parse_tables(input)
-    begin
-      File.delete('./spec/sample1.txt')
-    rescue Errno::ENOENT
-    end
-    Hyogen::Template.generate(tables, './spec/sample1.txt.template', './spec')
-    result = File.open('./spec/sample1.txt') {|f| f.read}
-    result.should == "My name is Alice. I'm 10 years old.\nMy name is Bob. I'm 20 years old.\n"
-  end
-  specify "from shell" do
-    begin
-      File.delete('./spec/sample1.txt')
-    rescue Errno::ENOENT
-    end
-    result = system 'ruby', 'hyogen', '-s', './spec/sample1.xls', './spec/sample1.txt.template', '-o', './spec'
-    result.should == true
-    result = File.open('./spec/sample1.txt') {|f| f.read}
-    result.should == "My name is Alice. I'm 10 years old.\nMy name is Bob. I'm 20 years old.\n"
-  end
-end

data/test/test_helper.rb

@@ -1,2 +0,0 @@
-require 'test/unit'
-require File.dirname(__FILE__) + '/../lib/hyogen'

data/test/test_hyogen.rb

@@ -1,11 +0,0 @@
-require File.dirname(__FILE__) + '/test_helper.rb'
-
-class TestHyogen < Test::Unit::TestCase
-
-  def setup
-  end
-  
-  def test_truth
-    assert true
-  end
-end