data_list_converter 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 90b751c23abda8fff5e4f880e1e1d475e1378550
-  data.tar.gz: e92c028832903d36fbf59a4e5a748b1f2fade8de
+  metadata.gz: f30ac8c96cff1ef18fbc8a4b77b9fbdd6b4692f8
+  data.tar.gz: 352ac88d1dc9e7788f6c43fa8d088dad0b1379a1
 SHA512:
-  metadata.gz: 78a0e7592e01534a87c3fc699e47bc02ab42f4a025b87bcfac9a20d1681b14b6728f3924ef7f3bf856d67abc0064966148c01536871428a7eeb118a2fce3c54a
-  data.tar.gz: 96242eb4b09180865882dc30df9a8add9b5379bb6c6696b59a682ab2162099f3b43e141d34c978f8642c8ff153c5c87d5ea12a984bac1945181fde99dc243a51
+  metadata.gz: a4448d7a014634430dad667bbb06b84f9d6a85396bd7c0027b9e632a6e142e5f101451c5e0aada043912dc99588b595ae9c8ac92a785262cda9455a53d925edd
+  data.tar.gz: d8df5278d2c4ff143bd13d6e1dfe151d52cba4a1df60c1704c241a2992977b9ac950b854e28a05507e492acbacb70f557778d17bc959977aa8b7601c93885d31

data/Rakefile

@@ -12,7 +12,15 @@ task :console do
 end
 
 task :test do
-  load 'test/data_list_converter_test.rb'
+  require 'minitest/pride'
+  require 'minitest/autorun'
+  require 'data_list_converter'
+
+  load 'test/testdata.rb'
+
+  Dir['test/*_test.rb'].each do |file|
+    load file
+  end
 end
 
 task :build do

data/data_list_converter.gemspec

@@ -2,7 +2,7 @@ $:.push File.expand_path("../lib", __FILE__)
 
 Gem::Specification.new do |s|
   s.name        = "data_list_converter"
-  s.version     = "0.2.1"
+  s.version     = "0.3.0"
   s.platform    = Gem::Platform::RUBY
   s.authors     = ["linjunhalida"]
   s.email       = ["linjunhalida@gmail.com"]

data/lib/data_list_converter.rb

@@ -3,6 +3,7 @@ require 'data_list_converter/base'
 require 'data_list_converter/types/basic'
 require 'data_list_converter/types/csv_file'
 require 'data_list_converter/types/records'
+require 'data_list_converter/types/multi_sheet'
 require 'data_list_converter/types/xls_file' rescue LoadError
 require 'data_list_converter/types/xlsx_file' rescue LoadError
 

data/lib/data_list_converter/base.rb

@@ -25,14 +25,14 @@ class DataListConverter
       CONVERTERS.keys.flatten.uniq.sort
     end
 
-    def register_converter(from_type, to_type, method)
+    def register_converter(from_type, to_type, &block)
       @route_map = nil # clear cache
-      CONVERTERS[[from_type, to_type]] = method
+      CONVERTERS[[from_type, to_type]] = block
     end
 
-    def register_filter(type, name, method)
+    def register_filter(type, name, &block)
       FILTERS[type] ||= {}
-      FILTERS[type][name] = method
+      FILTERS[type][name] = block
     end
 
     # Example:

data/lib/data_list_converter/filters/count.rb

@@ -1,27 +1,26 @@
 class DataListConverter
-  self.register_filter(
-    :item_iterator, :count, lambda{ |proc, options|
-      count = 0
-      size = options[:size] || 100
-      msg_format = options[:msg] || "on %{count}"
-      total_format = options[:total] || "total: %{total}"
-      out = options[:out] || STDOUT
-      total = 1
-      lambda { |&block|
-        proc.call do |item|
-          if item.keys == [:total]
-            total = item[:total]
-            out.write(total_format % {total: total})
-            out.write("\n")
-          else
-            block.call(item)
-            count += 1
-            msg = msg_format % {count: count, percent: (count / total.to_f * 100).round(2)}
-            out.write(msg + "\n") if count % size == 0
-          end
+  self.register_filter(:item_iterator, :count) do |proc, options|
+    count = 0
+    size = options[:size] || 100
+    msg_format = options[:msg] || "on %{count}"
+    total_format = options[:total] || "total: %{total}"
+    out = options[:out] || STDOUT
+    total = 1
+    lambda { |&block|
+      proc.call do |item|
+        if item.keys == [:total]
+          total = item[:total]
+          out.write(total_format % {total: total})
+          out.write("\n")
+        else
+          block.call(item)
+          count += 1
+          msg = msg_format % {count: count, percent: (count / total.to_f * 100).round(2)}
+          out.write(msg + "\n") if count % size == 0
         end
-      }
-    })
+      end
+    }
+  end
 end
 
 

data/lib/data_list_converter/filters/limit.rb

@@ -10,8 +10,7 @@ class DataListConverter
       end
     }
   end
-  self.register_filter(
-    :item_iterator, :limit, self.method(:iterator_limit))
-  self.register_filter(
-    :table_iterator, :limit, self.method(:iterator_limit))
+
+  self.register_filter(:item_iterator, :limit, &self.method(:iterator_limit))
+  self.register_filter(:table_iterator, :limit, &self.method(:iterator_limit))
 end

data/lib/data_list_converter/filters/remove_debug.rb

@@ -1,16 +1,15 @@
 class DataListConverter
-  self.register_filter(
-    :table_iterator, :remove_debug, lambda{ |proc, options|
-      lambda { |&block|
-        columns = nil
-        debug_index = nil
-        proc.call do |row|
-          unless columns
-            columns = row
-            debug_index = columns.index('debug')
-          end
-          block.call(row[0..(debug_index-1)])
+  self.register_filter(:table_iterator, :remove_debug) do |proc, options|
+    lambda { |&block|
+      columns = nil
+      debug_index = nil
+      proc.call do |row|
+        unless columns
+          columns = row
+          debug_index = columns.index('debug')
         end
-      }
-    })
+        block.call(row[0..(debug_index-1)])
+      end
+    }
+  end
 end

data/lib/data_list_converter/types/basic.rb

@@ -2,43 +2,40 @@
 # table_data: [['name', 'value'], ['xx', '12'], ..]
 # item_iterator and table_iterator are iterators which yield each row
 class DataListConverter
-  self.register_converter(
-    :item_iterator, :table_iterator, lambda{ |proc, options|
-      lambda { |&block|
-        columns = nil
-        proc.call do |item|
-          unless columns
-            columns = item.keys.map(&:to_sym)
-            block.call(columns.map(&:to_s))
-          end
-          # item_iterator key can be symbol or string
-          block.call(columns.map{ |c| item[c] || item[c.to_s] })
+  self.register_converter(:item_iterator, :table_iterator) do |proc, options|
+    lambda { |&block|
+      columns = nil
+      proc.call do |item|
+        unless columns
+          columns = item.keys.map(&:to_sym)
+          block.call(columns.map(&:to_s))
         end
-      }
-    })
-  self.register_converter(
-    :table_iterator, :item_iterator, lambda{ |proc, options|
-      lambda {|&block|
-        columns = nil
-        proc.call do |row|
-          unless columns
-            columns = row.map{|c| (c || "").to_sym}
-          else
-            block.call(columns.zip(row).to_h)
-          end
+        # item_iterator key can be symbol or string
+        block.call(columns.map{ |c| item[c] || item[c.to_s] })
+      end
+    }
+  end
+
+  self.register_converter(:table_iterator, :item_iterator) do |proc, options|
+    lambda {|&block|
+      columns = nil
+      proc.call do |row|
+        unless columns
+          columns = row.map{|c| (c || "").to_sym}
+        else
+          block.call(columns.zip(row).to_h)
         end
-      }
-    })
+      end
+    }
+  end
 
   def self.iterator_to_data(proc, options={})
     out = []
     proc.call { |d| out << d }
     out
   end
-  self.register_converter(
-    :item_iterator, :item_data, self.method(:iterator_to_data))
-  self.register_converter(
-    :table_iterator, :table_data, self.method(:iterator_to_data))
+  self.register_converter(:item_iterator, :item_data, &self.method(:iterator_to_data))
+  self.register_converter(:table_iterator, :table_data, &self.method(:iterator_to_data))
 
   def self.data_to_iterator(data, options={})
     lambda { |&block|
@@ -47,8 +44,6 @@ class DataListConverter
       end
     }
   end
-  self.register_converter(
-    :item_data, :item_iterator, self.method(:data_to_iterator))
-  self.register_converter(
-    :table_data, :table_iterator, self.method(:data_to_iterator))
+  self.register_converter(:item_data, :item_iterator, &self.method(:data_to_iterator))
+  self.register_converter(:table_data, :table_iterator, &self.method(:data_to_iterator))
 end

data/lib/data_list_converter/types/csv_file.rb

@@ -1,23 +1,22 @@
 require 'csv'
 
-# csv_file
 class DataListConverter
-  self.register_converter(
-    :csv_file, :table_iterator, lambda { |input, options|
-      lambda { |&block|
-        CSV.open(input[:filename]) do |csv|
-          csv.each do |row|
-            block.call(row)
-          end
-        end
-      }
-    })
-  self.register_converter(
-    :table_iterator, :csv_file, lambda { |proc, options|
-      CSV.open(options[:filename], 'wb', force_quotes: true) do |csv|
-        proc.call do |row|
-          csv << row
+  self.register_converter(:csv_file, :table_iterator) do |input, options|
+    lambda { |&block|
+      CSV.open(input[:filename]) do |csv|
+        csv.each do |row|
+          block.call(row)
         end
       end
-    })
+    }
+  end
+
+  self.register_converter(:table_iterator, :csv_file) do |proc, options|
+    CSV.open(options[:filename], 'wb', force_quotes: true) do |csv|
+      proc.call do |row|
+        csv << row
+      end
+    end
+    options[:filename]
+  end
 end

data/lib/data_list_converter/types/multi_sheet.rb

@@ -0,0 +1,29 @@
+# multi_sheet_table_data = {
+#   'sheet1' => [columns, row, row, ...],
+#   'sheet2' => [columns, row, row, ...],
+# }
+# also:
+# multi_sheet_item_data
+# multi_sheet_table_iterator
+# multi_sheet_item_iterator
+
+class DataListConverter
+
+  MULT_SHEET_CONVERTS = [[:table_data, :table_iterator],
+                         [:item_data, :item_iterator],
+                         [:table_iterator, :item_iterator],
+                        ]
+  (MULT_SHEET_CONVERTS + MULT_SHEET_CONVERTS.map(&:reverse)).each do |i|
+    from_type, to_type = i
+    self.register_converter(
+      :"multi_sheet_#{from_type}",
+      :"multi_sheet_#{to_type}",
+    ) do |data, options|
+      data.map do |sheet, from_data|
+        to_data = self.convert(from_type, to_type, from_data)
+        [sheet, to_data]
+      end.to_h
+    end
+  end
+
+end

data/lib/data_list_converter/types/records.rb

@@ -1,15 +1,16 @@
-# records
+# ActiveRecords
 class DataListConverter
-  self.register_converter(
-    :records, :item_iterator, lambda { |records, options|
-      columns = options[:columns]
-      lambda { |&block|
-        records.find_each do |record|
-          item = columns.map do |column|
-            [column.first.to_sym, record.send(column[1])]
-          end.to_h
-          block.call(item)
-        end
-      }
-    })
+
+  self.register_converter(:records, :item_iterator) do |records, options|
+    columns = options[:columns]
+    lambda { |&block|
+      records.find_each do |record|
+        item = columns.map do |column|
+          [column.first.to_sym, record.send(column[1])]
+        end.to_h
+        block.call(item)
+      end
+    }
+  end
+
 end

data/lib/data_list_converter/types/xls_file.rb

@@ -1,73 +1,54 @@
 # xls_file only works when installed spreadsheet gem
-# multi_sheet_data = {
-#   'sheet1' => [columns, row, row, ...],
-#   'sheet2' => [columns, row, row, ...],
-# }
 require 'spreadsheet'
 
 class DataListConverter
-  self.register_converter(
-    :xls_file, :table_iterator, lambda { |input, options|
-      lambda { |&block|
-        book = Spreadsheet.open(input[:filename])
-        sheet = book.worksheet input[:sheet] || 0
-        sheet.each do |row|
-          block.call(row.to_a)
-        end
-      }
-    })
-  self.register_converter(
-    :table_iterator, :xls_file, lambda { |proc, options|
-      book = Spreadsheet::Workbook.new
-      sheet = book.create_worksheet(name: (options[:sheet] || "Sheet1"))
+
+  self.register_converter(:xls_file, :table_iterator) do |input, options|
+    lambda { |&block|
+      book = Spreadsheet.open(input[:filename])
+      sheet = book.worksheet input[:sheet] || 0
+      sheet.each do |row|
+        block.call(row.to_a)
+      end
+    }
+  end
+
+  self.register_converter(:table_iterator, :xls_file) do |proc, options|
+    book = Spreadsheet::Workbook.new
+    sheet = book.create_worksheet(name: (options[:sheet] || "Sheet1"))
+    i = 0
+    proc.call do |row|
+      sheet.row(i).push *row
+      i += 1
+    end
+    book.write(options[:filename])
+    options[:filename]
+  end
+
+  self.register_converter(:multi_sheet_table_iterator, :xls_file) do |data, options|
+    book = Spreadsheet::Workbook.new
+    data.each do |name, table_iterator|
+      sheet = book.create_worksheet(name: name)
       i = 0
-      proc.call do |row|
-        sheet.row(i).push *row
+      table_iterator.call do |row|
+        sheet.row(i).concat(row)
         i += 1
       end
-      book.write(options[:filename])
-      options[:filename]
-    })
+    end
+    filename = options[:filename]
+    book.write(filename)
+    filename
+  end
 
-  self.register_converter(
-    :multi_sheet_iterator, :multi_sheet_data, lambda { |data, options|
-      data.map do |k, iter|
-        data = self.convert(:table_iterator, :table_data, iter)
-        [k, data]
-      end.to_h
-    })
-  self.register_converter(
-    :multi_sheet_data, :multi_sheet_iterator, lambda { |data, options|
-      data.map do |k, v|
-        iter = self.convert(:table_data, :table_iterator, v)
-        [k, iter]
-      end.to_h
-    })
-  self.register_converter(
-    :multi_sheet_iterator, :xls_file, lambda { |data, options|
-      book = Spreadsheet::Workbook.new
-      data.each do |name, table_iterator|
-        sheet = book.create_worksheet(name: name)
-        i = 0
-        table_iterator.call do |row|
-          sheet.row(i).concat(row)
-          i += 1
+  self.register_converter(:xls_file, :multi_sheet_table_iterator) do |data, options|
+    book = Spreadsheet.open(data[:filename])
+    book.worksheets.map do |sheet|
+      iterator = lambda { |&block|
+        sheet.each do |row| 
+          block.call(row.to_a)
         end
-      end
-      filename = options[:filename]
-      book.write(filename)
-      filename
-    })
-  self.register_converter(
-    :xls_file, :multi_sheet_iterator, lambda { |data, options|
-      book = Spreadsheet.open(data[:filename])
-      book.worksheets.map do |sheet|
-        iterator = lambda { |&block|
-          sheet.each do |row| 
-            block.call(row.to_a)
-          end
-        }
-        [sheet.name, iterator]
-      end.to_h
-    })
+      }
+      [sheet.name, iterator]
+    end.to_h
+  end
 end

data/lib/data_list_converter/types/xlsx_file.rb

@@ -1,66 +1,61 @@
 # xlsx_file only works when installed rubyXL gem
-# multi_sheet_data = {
-#   'sheet1' => [columns, row, row, ...],
-#   'sheet2' => [columns, row, row, ...],
-# }
 require 'rubyXL'
 
 class DataListConverter
-  self.register_converter(
-    :xlsx_file, :table_iterator, lambda { |input, options|
-      lambda { |&block|
-        book = RubyXL::Parser.parse(input[:filename])
-        sheet = book.worksheets[input[:sheet] || 0]
-        sheet.each do |row|
-          block.call(row.cells.map(&:value))
-        end
-      }
-    })
-  self.register_converter(
-    :table_iterator, :xlsx_file, lambda { |proc, options|
-      book = RubyXL::Workbook.new
-      sheet = book.worksheets[0]
-      sheet.sheet_name = options[:sheet] if options[:sheet]
+
+  self.register_converter(:xlsx_file, :table_iterator) do |input, options|
+    lambda { |&block|
+      book = RubyXL::Parser.parse(input[:filename])
+      sheet = book.worksheets[input[:sheet] || 0]
+      sheet.each do |row|
+        block.call(row.cells.map(&:value))
+      end
+    }
+  end
+
+  self.register_converter(:table_iterator, :xlsx_file) do |proc, options|
+    book = RubyXL::Workbook.new
+    sheet = book.worksheets[0]
+    sheet.sheet_name = options[:sheet] if options[:sheet]
+    i = 0
+    proc.call do |row|
+      row.each_with_index do |v, j|
+        sheet.add_cell(i, j, v)
+      end
+      i += 1
+    end
+    filename = options[:filename]
+    book.write(filename)
+    filename
+  end
+
+  self.register_converter(:multi_sheet_table_iterator, :xlsx_file) do |data, options|
+    book = RubyXL::Workbook.new
+    book.worksheets.pop
+    data.each do |name, table_iterator|
+      sheet = book.add_worksheet(name)
       i = 0
-      proc.call do |row|
+      table_iterator.call do |row|
         row.each_with_index do |v, j|
           sheet.add_cell(i, j, v)
         end
         i += 1
       end
-      filename = options[:filename]
-      book.write(filename)
-      filename
-    })
+    end
+    filename = options[:filename]
+    book.write(filename)
+    filename
+  end
 
-  self.register_converter(
-    :multi_sheet_iterator, :xlsx_file, lambda { |data, options|
-      book = RubyXL::Workbook.new
-      book.worksheets.pop
-      data.each do |name, table_iterator|
-        sheet = book.add_worksheet(name)
-        i = 0
-        table_iterator.call do |row|
-          row.each_with_index do |v, j|
-            sheet.add_cell(i, j, v)
-          end
-          i += 1
+  self.register_converter(:xlsx_file, :multi_sheet_table_iterator) do |data, options|
+    book = RubyXL::Parser.parse(data[:filename])
+    book.worksheets.map do |sheet|
+      iterator = lambda { |&block|
+        sheet.each do |row|
+          block.call(row.cells.map(&:value))
         end
-      end
-      filename = options[:filename]
-      book.write(filename)
-      filename
-    })
-  self.register_converter(
-    :xlsx_file, :multi_sheet_iterator, lambda { |data, options|
-      book = RubyXL::Parser.parse(data[:filename])
-      book.worksheets.map do |sheet|
-        iterator = lambda { |&block|
-          sheet.each do |row|
-            block.call(row.cells.map(&:value))
-          end
-        }
-        [sheet.sheet_name, iterator]
-      end.to_h
-    })
+      }
+      [sheet.sheet_name, iterator]
+    end.to_h
+  end
 end

data/test/base_test.rb

@@ -0,0 +1,45 @@
+describe DataListConverter do
+  before :all do
+    @c = DataListConverter
+  end
+
+  describe :convert do
+    specify do
+      @c.convert(:item_data, :table_data, ITEM_DATA).must_equal TABLE_DATA
+    end
+
+    it 'has parameters' do
+      begin
+        @c.convert(:item_data, :csv_file, ITEM_DATA, csv_file: {filename: "test.csv"})
+        File.read("test.csv").strip.must_equal CSV_DATA
+        @c.convert(:csv_file, :item_data, {filename: "test.csv"}).must_equal(ITEM_DATA)
+      ensure
+        FileUtils.rm_f("test.csv")
+      end
+    end
+
+    it 'has filters' do
+      filter = :limit
+      item_data = [{name: "james"}] * 20
+      result = @c.convert(:item_data, :table_data, item_data,
+                          item_iterator: {filter: filter})
+      result.must_equal([["name"]] + [["james"]]*10)
+      
+      filter = {limit: {size: 2}}
+      item_data = [{name: "james"}] * 10
+      result = @c.convert(:item_data, :table_data, item_data,
+                          item_iterator: {filter: filter})
+      result.must_equal [["name"], ["james"], ["james"]]
+
+      string = StringIO.new
+      filter = [{limit: {size: 12}}, {count: {size: 4, out: string, msg: ".%{count}"}}]
+      item_data = [{name: "james"}] * 20
+      result = @c.convert(:item_data, :table_data, item_data,
+                          item_iterator: {filter: filter})
+      result.must_equal([["name"]] + [["james"]]*12)
+      string.string.must_equal ".4\n.8\n.12\n"
+    end
+
+  end
+
+end

data/test/filters_test.rb

@@ -0,0 +1,37 @@
+describe DataListConverter do
+  before :all do
+    @c = DataListConverter
+  end
+
+  describe :limit do
+    specify do
+      filter = {limit: {size: 2}}
+      item_data = [{name: "james"}] * 10
+      result = DataListConverter.convert(
+        :item_data, :table_data, item_data,
+        item_iterator: {filter: filter})
+      result.must_equal [["name"], ["james"], ["james"]]
+    end
+  end
+
+  describe :count do
+    specify do
+      iter = lambda { |&block|
+        total = 10000
+        block.call(total: total)
+        (1..total-1).each do |i|
+          block.call(id: i, value: i*i)
+        end
+      }
+      string = StringIO.new
+      filter = {count: {size: 4000,
+                        out: string,
+                        msg: "%{percent}%"}}
+      result = DataListConverter.convert(
+        :item_iterator, :table_data, iter,
+        item_iterator: {filter: filter})
+      string.string.split("\n").must_equal ['total: 10000', '40.0%', '80.0%']
+    end
+  end
+  
+end

data/test/testdata.rb

@@ -0,0 +1,27 @@
+ITEM_DATA = [
+  {name: "James", score: '12'},
+  {name: "Bob", score: '33'},
+]
+
+TABLE_DATA = [
+  ['name', 'score'],
+  ['James', '12'],
+  ['Bob', '33']
+]
+
+CSV_DATA = %{
+"name","score"
+"James","12"
+"Bob","33"
+}.strip
+
+
+MULTI_SHEET_TABLE_DATA = {
+  "sheet1" => [['name'], ['james'], ['bob']],
+  "sheet2" => [['value'], ['21'], ['12']],
+}
+
+MULTI_SHEET_ITEM_DATA = {
+  "sheet1" => [{name: "james"}, {name: "bob"}],
+  "sheet2" => [{value: "21"}, {value: "12"}],
+}

data/test/types_test.rb

@@ -0,0 +1,74 @@
+describe DataListConverter do
+  before :all do
+    @c = DataListConverter
+  end
+
+  describe :type do
+    specify do
+      DataListConverter.types.must_equal(
+        [:item_data, :item_iterator,
+         :table_data, :table_iterator,
+         :multi_sheet_item_data,
+         :multi_sheet_table_data,
+         :multi_sheet_item_iterator,
+         :multi_sheet_table_iterator,
+         :csv_file, :xls_file, :xlsx_file,
+         :records,
+        ].sort
+      )
+    end
+  end
+
+  describe :multi_sheet do
+    specify do
+      @c.convert(:multi_sheet_item_data, :multi_sheet_table_data, MULTI_SHEET_ITEM_DATA).must_equal(MULTI_SHEET_TABLE_DATA)
+      @c.convert(:multi_sheet_table_data, :multi_sheet_item_data, MULTI_SHEET_TABLE_DATA).must_equal(MULTI_SHEET_ITEM_DATA)
+    end
+  end
+
+  describe :csv_file do
+    specify do
+      begin
+        @c.convert(:item_data, :csv_file, ITEM_DATA, csv_file: {filename: "test.csv"})
+        @c.convert(:csv_file, :item_data, {filename: "test.csv"}).must_equal ITEM_DATA
+      ensure
+        FileUtils.rm_f("test.csv")
+      end
+    end
+  end
+
+  describe :xls_file do
+    specify do
+      begin
+        @c.convert(:item_data, :xls_file, ITEM_DATA, xls_file: {filename: "test.xls"})
+        @c.convert(:xls_file, :item_data, {filename: "test.xls"}).must_equal ITEM_DATA
+
+        @c.convert(:multi_sheet_table_data, :xls_file, MULTI_SHEET_TABLE_DATA,
+                   xls_file: {filename: 'test.xls'})
+        @c.convert(:xls_file, :multi_sheet_table_data,
+                   {filename: 'test.xls'},
+                  ).must_equal(MULTI_SHEET_TABLE_DATA)
+      ensure
+        FileUtils.rm_f("test.xls")
+      end
+    end
+  end
+
+  describe :xlsx_file do
+    specify do
+      begin
+        @c.convert(:item_data, :xlsx_file, ITEM_DATA, xlsx_file: {filename: "test.xlsx"})
+        @c.convert(:xlsx_file, :item_data, {filename: "test.xlsx"}).must_equal ITEM_DATA
+
+        @c.convert(:multi_sheet_table_data, :xlsx_file, MULTI_SHEET_TABLE_DATA,
+                   xlsx_file: {filename: 'test.xlsx'})
+        @c.convert(:xlsx_file, :multi_sheet_table_data,
+                   {filename: 'test.xlsx'},
+                  ).must_equal(MULTI_SHEET_TABLE_DATA)
+      ensure
+        FileUtils.rm_f("test.xlsx")
+      end
+    end
+
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: data_list_converter
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - linjunhalida
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-12-30 00:00:00.000000000 Z
+date: 2016-01-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -101,10 +101,14 @@ files:
 - lib/data_list_converter/filters/remove_debug.rb
 - lib/data_list_converter/types/basic.rb
 - lib/data_list_converter/types/csv_file.rb
+- lib/data_list_converter/types/multi_sheet.rb
 - lib/data_list_converter/types/records.rb
 - lib/data_list_converter/types/xls_file.rb
 - lib/data_list_converter/types/xlsx_file.rb
-- test/data_list_converter_test.rb
+- test/base_test.rb
+- test/filters_test.rb
+- test/testdata.rb
+- test/types_test.rb
 homepage: http://github.com/halida/data_list_converter
 licenses:
 - MIT
@@ -130,4 +134,7 @@ signing_key:
 specification_version: 4
 summary: convert data between different formats
 test_files:
-- test/data_list_converter_test.rb
+- test/base_test.rb
+- test/filters_test.rb
+- test/testdata.rb
+- test/types_test.rb

data/test/data_list_converter_test.rb

@@ -1,134 +0,0 @@
-require 'minitest/pride'
-require 'minitest/autorun'
-
-require 'data_list_converter'
-
-ITEM_DATA = [
-  {name: "James", score: '12'},
-  {name: "Bob", score: '33'},
-]
-
-TABLE_DATA = [
-  ['name', 'score'],
-  ['James', '12'],
-  ['Bob', '33']
-]
-
-CSV_DATA = %{
-"name","score"
-"James","12"
-"Bob","33"
-}.strip
-
-describe DataListConverter do
-  describe :type do
-    it 'works' do
-      DataListConverter.types.must_equal(
-        [:csv_file, :item_data, :item_iterator, :multi_sheet_data, :multi_sheet_iterator,
-         :records, :table_data, :table_iterator, :xls_file, :xlsx_file])
-    end
-  end
-
-  describe :convert do
-    before :all do
-      @c = DataListConverter
-    end
-    
-    it 'works' do
-      @c.convert(:item_data, :table_data, ITEM_DATA).must_equal TABLE_DATA
-    end
-
-    it 'has parameters' do
-      begin
-        @c.convert(:item_data, :csv_file, ITEM_DATA, csv_file: {filename: "test.csv"})
-        File.read("test.csv").strip.must_equal CSV_DATA
-        @c.convert(:csv_file, :item_data, {filename: "test.csv"}).must_equal(ITEM_DATA)
-      ensure
-        FileUtils.rm_f("test.csv")
-      end
-    end
-
-    it 'has filters' do
-      filter = :limit
-      item_data = [{name: "james"}] * 20
-      result = @c.convert(:item_data, :table_data, item_data,
-                          item_iterator: {filter: filter})
-      result.must_equal([["name"]] + [["james"]]*10)
-      
-      filter = {limit: {size: 2}}
-      item_data = [{name: "james"}] * 10
-      result = @c.convert(:item_data, :table_data, item_data,
-                          item_iterator: {filter: filter})
-      result.must_equal [["name"], ["james"], ["james"]]
-
-      string = StringIO.new
-      filter = [{limit: {size: 12}}, {count: {size: 4, out: string, msg: ".%{count}"}}]
-      item_data = [{name: "james"}] * 20
-      result = @c.convert(:item_data, :table_data, item_data,
-                          item_iterator: {filter: filter})
-      result.must_equal([["name"]] + [["james"]]*12)
-      string.string.must_equal ".4\n.8\n.12\n"
-    end
-
-    it 'has type xls_file' do
-      begin
-        @c.convert(:item_data, :xls_file, ITEM_DATA, xls_file: {filename: "test.xls"})
-        @c.convert(:xls_file, :item_data, {filename: "test.xls"}).must_equal ITEM_DATA
-
-        multi_sheet = {
-          "sheet1" => [['name'], ['james'], ['bob']],
-          "sheet2" => [['value'], ['21'], ['12']],
-        }
-        @c.convert(:multi_sheet_data, :xls_file, multi_sheet, xls_file: {filename: 'test.xls'})
-        @c.convert(:xls_file, :multi_sheet_data, {filename: 'test.xls'}).must_equal multi_sheet
-      ensure
-        FileUtils.rm_f("test.xls")
-      end
-    end
-
-    it 'has type xlsx_file' do
-      begin
-        @c.convert(:item_data, :xlsx_file, ITEM_DATA, xlsx_file: {filename: "test.xlsx"})
-        @c.convert(:xlsx_file, :item_data, {filename: "test.xlsx"}).must_equal ITEM_DATA
-
-        multi_sheet = {
-          "sheet1" => [['name'], ['james'], ['bob']],
-          "sheet2" => [['value'], ['21'], ['12']],
-        }
-        @c.convert(:multi_sheet_data, :xlsx_file, multi_sheet, xlsx_file: {filename: 'test.xlsx'})
-        @c.convert(:xlsx_file, :multi_sheet_data, {filename: 'test.xlsx'}).must_equal multi_sheet
-      ensure
-        FileUtils.rm_f("test.xlsx")
-      end
-    end
-  end
-
-  describe :filters do
-    it 'limit iterator' do
-      filter = {limit: {size: 2}}
-      item_data = [{name: "james"}] * 10
-      result = DataListConverter.convert(
-        :item_data, :table_data, item_data,
-        item_iterator: {filter: filter})
-      result.must_equal [["name"], ["james"], ["james"]]
-    end
-
-    it 'count item_iterator' do
-      iter = lambda { |&block|
-        total = 10000
-        block.call(total: total)
-        (1..total-1).each do |i|
-          block.call(id: i, value: i*i)
-        end
-      }
-      string = StringIO.new
-      filter = {count: {size: 4000,
-                        out: string,
-                        msg: "%{percent}%"}}
-      result = DataListConverter.convert(
-        :item_iterator, :table_data, iter,
-        item_iterator: {filter: filter})
-      string.string.split("\n").must_equal ['total: 10000', '40.0%', '80.0%']
-    end
-  end
-end