data_list_converter 0.2.1 → 0.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA1:
3
- metadata.gz: 90b751c23abda8fff5e4f880e1e1d475e1378550
4
- data.tar.gz: e92c028832903d36fbf59a4e5a748b1f2fade8de
3
+ metadata.gz: f30ac8c96cff1ef18fbc8a4b77b9fbdd6b4692f8
4
+ data.tar.gz: 352ac88d1dc9e7788f6c43fa8d088dad0b1379a1
5
5
  SHA512:
6
- metadata.gz: 78a0e7592e01534a87c3fc699e47bc02ab42f4a025b87bcfac9a20d1681b14b6728f3924ef7f3bf856d67abc0064966148c01536871428a7eeb118a2fce3c54a
7
- data.tar.gz: 96242eb4b09180865882dc30df9a8add9b5379bb6c6696b59a682ab2162099f3b43e141d34c978f8642c8ff153c5c87d5ea12a984bac1945181fde99dc243a51
6
+ metadata.gz: a4448d7a014634430dad667bbb06b84f9d6a85396bd7c0027b9e632a6e142e5f101451c5e0aada043912dc99588b595ae9c8ac92a785262cda9455a53d925edd
7
+ data.tar.gz: d8df5278d2c4ff143bd13d6e1dfe151d52cba4a1df60c1704c241a2992977b9ac950b854e28a05507e492acbacb70f557778d17bc959977aa8b7601c93885d31
data/Rakefile CHANGED
@@ -12,7 +12,15 @@ task :console do
12
12
  end
13
13
 
14
14
  task :test do
15
- load 'test/data_list_converter_test.rb'
15
+ require 'minitest/pride'
16
+ require 'minitest/autorun'
17
+ require 'data_list_converter'
18
+
19
+ load 'test/testdata.rb'
20
+
21
+ Dir['test/*_test.rb'].each do |file|
22
+ load file
23
+ end
16
24
  end
17
25
 
18
26
  task :build do
@@ -2,7 +2,7 @@ $:.push File.expand_path("../lib", __FILE__)
2
2
 
3
3
  Gem::Specification.new do |s|
4
4
  s.name = "data_list_converter"
5
- s.version = "0.2.1"
5
+ s.version = "0.3.0"
6
6
  s.platform = Gem::Platform::RUBY
7
7
  s.authors = ["linjunhalida"]
8
8
  s.email = ["linjunhalida@gmail.com"]
@@ -3,6 +3,7 @@ require 'data_list_converter/base'
3
3
  require 'data_list_converter/types/basic'
4
4
  require 'data_list_converter/types/csv_file'
5
5
  require 'data_list_converter/types/records'
6
+ require 'data_list_converter/types/multi_sheet'
6
7
  require 'data_list_converter/types/xls_file' rescue LoadError
7
8
  require 'data_list_converter/types/xlsx_file' rescue LoadError
8
9
 
@@ -25,14 +25,14 @@ class DataListConverter
25
25
  CONVERTERS.keys.flatten.uniq.sort
26
26
  end
27
27
 
28
- def register_converter(from_type, to_type, method)
28
+ def register_converter(from_type, to_type, &block)
29
29
  @route_map = nil # clear cache
30
- CONVERTERS[[from_type, to_type]] = method
30
+ CONVERTERS[[from_type, to_type]] = block
31
31
  end
32
32
 
33
- def register_filter(type, name, method)
33
+ def register_filter(type, name, &block)
34
34
  FILTERS[type] ||= {}
35
- FILTERS[type][name] = method
35
+ FILTERS[type][name] = block
36
36
  end
37
37
 
38
38
  # Example:
@@ -1,27 +1,26 @@
1
1
  class DataListConverter
2
- self.register_filter(
3
- :item_iterator, :count, lambda{ |proc, options|
4
- count = 0
5
- size = options[:size] || 100
6
- msg_format = options[:msg] || "on %{count}"
7
- total_format = options[:total] || "total: %{total}"
8
- out = options[:out] || STDOUT
9
- total = 1
10
- lambda { |&block|
11
- proc.call do |item|
12
- if item.keys == [:total]
13
- total = item[:total]
14
- out.write(total_format % {total: total})
15
- out.write("\n")
16
- else
17
- block.call(item)
18
- count += 1
19
- msg = msg_format % {count: count, percent: (count / total.to_f * 100).round(2)}
20
- out.write(msg + "\n") if count % size == 0
21
- end
2
+ self.register_filter(:item_iterator, :count) do |proc, options|
3
+ count = 0
4
+ size = options[:size] || 100
5
+ msg_format = options[:msg] || "on %{count}"
6
+ total_format = options[:total] || "total: %{total}"
7
+ out = options[:out] || STDOUT
8
+ total = 1
9
+ lambda { |&block|
10
+ proc.call do |item|
11
+ if item.keys == [:total]
12
+ total = item[:total]
13
+ out.write(total_format % {total: total})
14
+ out.write("\n")
15
+ else
16
+ block.call(item)
17
+ count += 1
18
+ msg = msg_format % {count: count, percent: (count / total.to_f * 100).round(2)}
19
+ out.write(msg + "\n") if count % size == 0
22
20
  end
23
- }
24
- })
21
+ end
22
+ }
23
+ end
25
24
  end
26
25
 
27
26
 
@@ -10,8 +10,7 @@ class DataListConverter
10
10
  end
11
11
  }
12
12
  end
13
- self.register_filter(
14
- :item_iterator, :limit, self.method(:iterator_limit))
15
- self.register_filter(
16
- :table_iterator, :limit, self.method(:iterator_limit))
13
+
14
+ self.register_filter(:item_iterator, :limit, &self.method(:iterator_limit))
15
+ self.register_filter(:table_iterator, :limit, &self.method(:iterator_limit))
17
16
  end
@@ -1,16 +1,15 @@
1
1
  class DataListConverter
2
- self.register_filter(
3
- :table_iterator, :remove_debug, lambda{ |proc, options|
4
- lambda { |&block|
5
- columns = nil
6
- debug_index = nil
7
- proc.call do |row|
8
- unless columns
9
- columns = row
10
- debug_index = columns.index('debug')
11
- end
12
- block.call(row[0..(debug_index-1)])
2
+ self.register_filter(:table_iterator, :remove_debug) do |proc, options|
3
+ lambda { |&block|
4
+ columns = nil
5
+ debug_index = nil
6
+ proc.call do |row|
7
+ unless columns
8
+ columns = row
9
+ debug_index = columns.index('debug')
13
10
  end
14
- }
15
- })
11
+ block.call(row[0..(debug_index-1)])
12
+ end
13
+ }
14
+ end
16
15
  end
@@ -2,43 +2,40 @@
2
2
  # table_data: [['name', 'value'], ['xx', '12'], ..]
3
3
  # item_iterator and table_iterator are iterators which yield each row
4
4
  class DataListConverter
5
- self.register_converter(
6
- :item_iterator, :table_iterator, lambda{ |proc, options|
7
- lambda { |&block|
8
- columns = nil
9
- proc.call do |item|
10
- unless columns
11
- columns = item.keys.map(&:to_sym)
12
- block.call(columns.map(&:to_s))
13
- end
14
- # item_iterator key can be symbol or string
15
- block.call(columns.map{ |c| item[c] || item[c.to_s] })
5
+ self.register_converter(:item_iterator, :table_iterator) do |proc, options|
6
+ lambda { |&block|
7
+ columns = nil
8
+ proc.call do |item|
9
+ unless columns
10
+ columns = item.keys.map(&:to_sym)
11
+ block.call(columns.map(&:to_s))
16
12
  end
17
- }
18
- })
19
- self.register_converter(
20
- :table_iterator, :item_iterator, lambda{ |proc, options|
21
- lambda {|&block|
22
- columns = nil
23
- proc.call do |row|
24
- unless columns
25
- columns = row.map{|c| (c || "").to_sym}
26
- else
27
- block.call(columns.zip(row).to_h)
28
- end
13
+ # item_iterator key can be symbol or string
14
+ block.call(columns.map{ |c| item[c] || item[c.to_s] })
15
+ end
16
+ }
17
+ end
18
+
19
+ self.register_converter(:table_iterator, :item_iterator) do |proc, options|
20
+ lambda {|&block|
21
+ columns = nil
22
+ proc.call do |row|
23
+ unless columns
24
+ columns = row.map{|c| (c || "").to_sym}
25
+ else
26
+ block.call(columns.zip(row).to_h)
29
27
  end
30
- }
31
- })
28
+ end
29
+ }
30
+ end
32
31
 
33
32
  def self.iterator_to_data(proc, options={})
34
33
  out = []
35
34
  proc.call { |d| out << d }
36
35
  out
37
36
  end
38
- self.register_converter(
39
- :item_iterator, :item_data, self.method(:iterator_to_data))
40
- self.register_converter(
41
- :table_iterator, :table_data, self.method(:iterator_to_data))
37
+ self.register_converter(:item_iterator, :item_data, &self.method(:iterator_to_data))
38
+ self.register_converter(:table_iterator, :table_data, &self.method(:iterator_to_data))
42
39
 
43
40
  def self.data_to_iterator(data, options={})
44
41
  lambda { |&block|
@@ -47,8 +44,6 @@ class DataListConverter
47
44
  end
48
45
  }
49
46
  end
50
- self.register_converter(
51
- :item_data, :item_iterator, self.method(:data_to_iterator))
52
- self.register_converter(
53
- :table_data, :table_iterator, self.method(:data_to_iterator))
47
+ self.register_converter(:item_data, :item_iterator, &self.method(:data_to_iterator))
48
+ self.register_converter(:table_data, :table_iterator, &self.method(:data_to_iterator))
54
49
  end
@@ -1,23 +1,22 @@
1
1
  require 'csv'
2
2
 
3
- # csv_file
4
3
  class DataListConverter
5
- self.register_converter(
6
- :csv_file, :table_iterator, lambda { |input, options|
7
- lambda { |&block|
8
- CSV.open(input[:filename]) do |csv|
9
- csv.each do |row|
10
- block.call(row)
11
- end
12
- end
13
- }
14
- })
15
- self.register_converter(
16
- :table_iterator, :csv_file, lambda { |proc, options|
17
- CSV.open(options[:filename], 'wb', force_quotes: true) do |csv|
18
- proc.call do |row|
19
- csv << row
4
+ self.register_converter(:csv_file, :table_iterator) do |input, options|
5
+ lambda { |&block|
6
+ CSV.open(input[:filename]) do |csv|
7
+ csv.each do |row|
8
+ block.call(row)
20
9
  end
21
10
  end
22
- })
11
+ }
12
+ end
13
+
14
+ self.register_converter(:table_iterator, :csv_file) do |proc, options|
15
+ CSV.open(options[:filename], 'wb', force_quotes: true) do |csv|
16
+ proc.call do |row|
17
+ csv << row
18
+ end
19
+ end
20
+ options[:filename]
21
+ end
23
22
  end
@@ -0,0 +1,29 @@
1
+ # multi_sheet_table_data = {
2
+ # 'sheet1' => [columns, row, row, ...],
3
+ # 'sheet2' => [columns, row, row, ...],
4
+ # }
5
+ # also:
6
+ # multi_sheet_item_data
7
+ # multi_sheet_table_iterator
8
+ # multi_sheet_item_iterator
9
+
10
+ class DataListConverter
11
+
12
+ MULT_SHEET_CONVERTS = [[:table_data, :table_iterator],
13
+ [:item_data, :item_iterator],
14
+ [:table_iterator, :item_iterator],
15
+ ]
16
+ (MULT_SHEET_CONVERTS + MULT_SHEET_CONVERTS.map(&:reverse)).each do |i|
17
+ from_type, to_type = i
18
+ self.register_converter(
19
+ :"multi_sheet_#{from_type}",
20
+ :"multi_sheet_#{to_type}",
21
+ ) do |data, options|
22
+ data.map do |sheet, from_data|
23
+ to_data = self.convert(from_type, to_type, from_data)
24
+ [sheet, to_data]
25
+ end.to_h
26
+ end
27
+ end
28
+
29
+ end
@@ -1,15 +1,16 @@
1
- # records
1
+ # ActiveRecords
2
2
  class DataListConverter
3
- self.register_converter(
4
- :records, :item_iterator, lambda { |records, options|
5
- columns = options[:columns]
6
- lambda { |&block|
7
- records.find_each do |record|
8
- item = columns.map do |column|
9
- [column.first.to_sym, record.send(column[1])]
10
- end.to_h
11
- block.call(item)
12
- end
13
- }
14
- })
3
+
4
+ self.register_converter(:records, :item_iterator) do |records, options|
5
+ columns = options[:columns]
6
+ lambda { |&block|
7
+ records.find_each do |record|
8
+ item = columns.map do |column|
9
+ [column.first.to_sym, record.send(column[1])]
10
+ end.to_h
11
+ block.call(item)
12
+ end
13
+ }
14
+ end
15
+
15
16
  end
@@ -1,73 +1,54 @@
1
1
  # xls_file only works when installed spreadsheet gem
2
- # multi_sheet_data = {
3
- # 'sheet1' => [columns, row, row, ...],
4
- # 'sheet2' => [columns, row, row, ...],
5
- # }
6
2
  require 'spreadsheet'
7
3
 
8
4
  class DataListConverter
9
- self.register_converter(
10
- :xls_file, :table_iterator, lambda { |input, options|
11
- lambda { |&block|
12
- book = Spreadsheet.open(input[:filename])
13
- sheet = book.worksheet input[:sheet] || 0
14
- sheet.each do |row|
15
- block.call(row.to_a)
16
- end
17
- }
18
- })
19
- self.register_converter(
20
- :table_iterator, :xls_file, lambda { |proc, options|
21
- book = Spreadsheet::Workbook.new
22
- sheet = book.create_worksheet(name: (options[:sheet] || "Sheet1"))
5
+
6
+ self.register_converter(:xls_file, :table_iterator) do |input, options|
7
+ lambda { |&block|
8
+ book = Spreadsheet.open(input[:filename])
9
+ sheet = book.worksheet input[:sheet] || 0
10
+ sheet.each do |row|
11
+ block.call(row.to_a)
12
+ end
13
+ }
14
+ end
15
+
16
+ self.register_converter(:table_iterator, :xls_file) do |proc, options|
17
+ book = Spreadsheet::Workbook.new
18
+ sheet = book.create_worksheet(name: (options[:sheet] || "Sheet1"))
19
+ i = 0
20
+ proc.call do |row|
21
+ sheet.row(i).push *row
22
+ i += 1
23
+ end
24
+ book.write(options[:filename])
25
+ options[:filename]
26
+ end
27
+
28
+ self.register_converter(:multi_sheet_table_iterator, :xls_file) do |data, options|
29
+ book = Spreadsheet::Workbook.new
30
+ data.each do |name, table_iterator|
31
+ sheet = book.create_worksheet(name: name)
23
32
  i = 0
24
- proc.call do |row|
25
- sheet.row(i).push *row
33
+ table_iterator.call do |row|
34
+ sheet.row(i).concat(row)
26
35
  i += 1
27
36
  end
28
- book.write(options[:filename])
29
- options[:filename]
30
- })
37
+ end
38
+ filename = options[:filename]
39
+ book.write(filename)
40
+ filename
41
+ end
31
42
 
32
- self.register_converter(
33
- :multi_sheet_iterator, :multi_sheet_data, lambda { |data, options|
34
- data.map do |k, iter|
35
- data = self.convert(:table_iterator, :table_data, iter)
36
- [k, data]
37
- end.to_h
38
- })
39
- self.register_converter(
40
- :multi_sheet_data, :multi_sheet_iterator, lambda { |data, options|
41
- data.map do |k, v|
42
- iter = self.convert(:table_data, :table_iterator, v)
43
- [k, iter]
44
- end.to_h
45
- })
46
- self.register_converter(
47
- :multi_sheet_iterator, :xls_file, lambda { |data, options|
48
- book = Spreadsheet::Workbook.new
49
- data.each do |name, table_iterator|
50
- sheet = book.create_worksheet(name: name)
51
- i = 0
52
- table_iterator.call do |row|
53
- sheet.row(i).concat(row)
54
- i += 1
43
+ self.register_converter(:xls_file, :multi_sheet_table_iterator) do |data, options|
44
+ book = Spreadsheet.open(data[:filename])
45
+ book.worksheets.map do |sheet|
46
+ iterator = lambda { |&block|
47
+ sheet.each do |row|
48
+ block.call(row.to_a)
55
49
  end
56
- end
57
- filename = options[:filename]
58
- book.write(filename)
59
- filename
60
- })
61
- self.register_converter(
62
- :xls_file, :multi_sheet_iterator, lambda { |data, options|
63
- book = Spreadsheet.open(data[:filename])
64
- book.worksheets.map do |sheet|
65
- iterator = lambda { |&block|
66
- sheet.each do |row|
67
- block.call(row.to_a)
68
- end
69
- }
70
- [sheet.name, iterator]
71
- end.to_h
72
- })
50
+ }
51
+ [sheet.name, iterator]
52
+ end.to_h
53
+ end
73
54
  end
@@ -1,66 +1,61 @@
1
1
  # xlsx_file only works when installed rubyXL gem
2
- # multi_sheet_data = {
3
- # 'sheet1' => [columns, row, row, ...],
4
- # 'sheet2' => [columns, row, row, ...],
5
- # }
6
2
  require 'rubyXL'
7
3
 
8
4
  class DataListConverter
9
- self.register_converter(
10
- :xlsx_file, :table_iterator, lambda { |input, options|
11
- lambda { |&block|
12
- book = RubyXL::Parser.parse(input[:filename])
13
- sheet = book.worksheets[input[:sheet] || 0]
14
- sheet.each do |row|
15
- block.call(row.cells.map(&:value))
16
- end
17
- }
18
- })
19
- self.register_converter(
20
- :table_iterator, :xlsx_file, lambda { |proc, options|
21
- book = RubyXL::Workbook.new
22
- sheet = book.worksheets[0]
23
- sheet.sheet_name = options[:sheet] if options[:sheet]
5
+
6
+ self.register_converter(:xlsx_file, :table_iterator) do |input, options|
7
+ lambda { |&block|
8
+ book = RubyXL::Parser.parse(input[:filename])
9
+ sheet = book.worksheets[input[:sheet] || 0]
10
+ sheet.each do |row|
11
+ block.call(row.cells.map(&:value))
12
+ end
13
+ }
14
+ end
15
+
16
+ self.register_converter(:table_iterator, :xlsx_file) do |proc, options|
17
+ book = RubyXL::Workbook.new
18
+ sheet = book.worksheets[0]
19
+ sheet.sheet_name = options[:sheet] if options[:sheet]
20
+ i = 0
21
+ proc.call do |row|
22
+ row.each_with_index do |v, j|
23
+ sheet.add_cell(i, j, v)
24
+ end
25
+ i += 1
26
+ end
27
+ filename = options[:filename]
28
+ book.write(filename)
29
+ filename
30
+ end
31
+
32
+ self.register_converter(:multi_sheet_table_iterator, :xlsx_file) do |data, options|
33
+ book = RubyXL::Workbook.new
34
+ book.worksheets.pop
35
+ data.each do |name, table_iterator|
36
+ sheet = book.add_worksheet(name)
24
37
  i = 0
25
- proc.call do |row|
38
+ table_iterator.call do |row|
26
39
  row.each_with_index do |v, j|
27
40
  sheet.add_cell(i, j, v)
28
41
  end
29
42
  i += 1
30
43
  end
31
- filename = options[:filename]
32
- book.write(filename)
33
- filename
34
- })
44
+ end
45
+ filename = options[:filename]
46
+ book.write(filename)
47
+ filename
48
+ end
35
49
 
36
- self.register_converter(
37
- :multi_sheet_iterator, :xlsx_file, lambda { |data, options|
38
- book = RubyXL::Workbook.new
39
- book.worksheets.pop
40
- data.each do |name, table_iterator|
41
- sheet = book.add_worksheet(name)
42
- i = 0
43
- table_iterator.call do |row|
44
- row.each_with_index do |v, j|
45
- sheet.add_cell(i, j, v)
46
- end
47
- i += 1
50
+ self.register_converter(:xlsx_file, :multi_sheet_table_iterator) do |data, options|
51
+ book = RubyXL::Parser.parse(data[:filename])
52
+ book.worksheets.map do |sheet|
53
+ iterator = lambda { |&block|
54
+ sheet.each do |row|
55
+ block.call(row.cells.map(&:value))
48
56
  end
49
- end
50
- filename = options[:filename]
51
- book.write(filename)
52
- filename
53
- })
54
- self.register_converter(
55
- :xlsx_file, :multi_sheet_iterator, lambda { |data, options|
56
- book = RubyXL::Parser.parse(data[:filename])
57
- book.worksheets.map do |sheet|
58
- iterator = lambda { |&block|
59
- sheet.each do |row|
60
- block.call(row.cells.map(&:value))
61
- end
62
- }
63
- [sheet.sheet_name, iterator]
64
- end.to_h
65
- })
57
+ }
58
+ [sheet.sheet_name, iterator]
59
+ end.to_h
60
+ end
66
61
  end
data/test/base_test.rb ADDED
@@ -0,0 +1,45 @@
1
+ describe DataListConverter do
2
+ before :all do
3
+ @c = DataListConverter
4
+ end
5
+
6
+ describe :convert do
7
+ specify do
8
+ @c.convert(:item_data, :table_data, ITEM_DATA).must_equal TABLE_DATA
9
+ end
10
+
11
+ it 'has parameters' do
12
+ begin
13
+ @c.convert(:item_data, :csv_file, ITEM_DATA, csv_file: {filename: "test.csv"})
14
+ File.read("test.csv").strip.must_equal CSV_DATA
15
+ @c.convert(:csv_file, :item_data, {filename: "test.csv"}).must_equal(ITEM_DATA)
16
+ ensure
17
+ FileUtils.rm_f("test.csv")
18
+ end
19
+ end
20
+
21
+ it 'has filters' do
22
+ filter = :limit
23
+ item_data = [{name: "james"}] * 20
24
+ result = @c.convert(:item_data, :table_data, item_data,
25
+ item_iterator: {filter: filter})
26
+ result.must_equal([["name"]] + [["james"]]*10)
27
+
28
+ filter = {limit: {size: 2}}
29
+ item_data = [{name: "james"}] * 10
30
+ result = @c.convert(:item_data, :table_data, item_data,
31
+ item_iterator: {filter: filter})
32
+ result.must_equal [["name"], ["james"], ["james"]]
33
+
34
+ string = StringIO.new
35
+ filter = [{limit: {size: 12}}, {count: {size: 4, out: string, msg: ".%{count}"}}]
36
+ item_data = [{name: "james"}] * 20
37
+ result = @c.convert(:item_data, :table_data, item_data,
38
+ item_iterator: {filter: filter})
39
+ result.must_equal([["name"]] + [["james"]]*12)
40
+ string.string.must_equal ".4\n.8\n.12\n"
41
+ end
42
+
43
+ end
44
+
45
+ end
@@ -0,0 +1,37 @@
1
+ describe DataListConverter do
2
+ before :all do
3
+ @c = DataListConverter
4
+ end
5
+
6
+ describe :limit do
7
+ specify do
8
+ filter = {limit: {size: 2}}
9
+ item_data = [{name: "james"}] * 10
10
+ result = DataListConverter.convert(
11
+ :item_data, :table_data, item_data,
12
+ item_iterator: {filter: filter})
13
+ result.must_equal [["name"], ["james"], ["james"]]
14
+ end
15
+ end
16
+
17
+ describe :count do
18
+ specify do
19
+ iter = lambda { |&block|
20
+ total = 10000
21
+ block.call(total: total)
22
+ (1..total-1).each do |i|
23
+ block.call(id: i, value: i*i)
24
+ end
25
+ }
26
+ string = StringIO.new
27
+ filter = {count: {size: 4000,
28
+ out: string,
29
+ msg: "%{percent}%"}}
30
+ result = DataListConverter.convert(
31
+ :item_iterator, :table_data, iter,
32
+ item_iterator: {filter: filter})
33
+ string.string.split("\n").must_equal ['total: 10000', '40.0%', '80.0%']
34
+ end
35
+ end
36
+
37
+ end
data/test/testdata.rb ADDED
@@ -0,0 +1,27 @@
1
+ ITEM_DATA = [
2
+ {name: "James", score: '12'},
3
+ {name: "Bob", score: '33'},
4
+ ]
5
+
6
+ TABLE_DATA = [
7
+ ['name', 'score'],
8
+ ['James', '12'],
9
+ ['Bob', '33']
10
+ ]
11
+
12
+ CSV_DATA = %{
13
+ "name","score"
14
+ "James","12"
15
+ "Bob","33"
16
+ }.strip
17
+
18
+
19
+ MULTI_SHEET_TABLE_DATA = {
20
+ "sheet1" => [['name'], ['james'], ['bob']],
21
+ "sheet2" => [['value'], ['21'], ['12']],
22
+ }
23
+
24
+ MULTI_SHEET_ITEM_DATA = {
25
+ "sheet1" => [{name: "james"}, {name: "bob"}],
26
+ "sheet2" => [{value: "21"}, {value: "12"}],
27
+ }
@@ -0,0 +1,74 @@
1
+ describe DataListConverter do
2
+ before :all do
3
+ @c = DataListConverter
4
+ end
5
+
6
+ describe :type do
7
+ specify do
8
+ DataListConverter.types.must_equal(
9
+ [:item_data, :item_iterator,
10
+ :table_data, :table_iterator,
11
+ :multi_sheet_item_data,
12
+ :multi_sheet_table_data,
13
+ :multi_sheet_item_iterator,
14
+ :multi_sheet_table_iterator,
15
+ :csv_file, :xls_file, :xlsx_file,
16
+ :records,
17
+ ].sort
18
+ )
19
+ end
20
+ end
21
+
22
+ describe :multi_sheet do
23
+ specify do
24
+ @c.convert(:multi_sheet_item_data, :multi_sheet_table_data, MULTI_SHEET_ITEM_DATA).must_equal(MULTI_SHEET_TABLE_DATA)
25
+ @c.convert(:multi_sheet_table_data, :multi_sheet_item_data, MULTI_SHEET_TABLE_DATA).must_equal(MULTI_SHEET_ITEM_DATA)
26
+ end
27
+ end
28
+
29
+ describe :csv_file do
30
+ specify do
31
+ begin
32
+ @c.convert(:item_data, :csv_file, ITEM_DATA, csv_file: {filename: "test.csv"})
33
+ @c.convert(:csv_file, :item_data, {filename: "test.csv"}).must_equal ITEM_DATA
34
+ ensure
35
+ FileUtils.rm_f("test.csv")
36
+ end
37
+ end
38
+ end
39
+
40
+ describe :xls_file do
41
+ specify do
42
+ begin
43
+ @c.convert(:item_data, :xls_file, ITEM_DATA, xls_file: {filename: "test.xls"})
44
+ @c.convert(:xls_file, :item_data, {filename: "test.xls"}).must_equal ITEM_DATA
45
+
46
+ @c.convert(:multi_sheet_table_data, :xls_file, MULTI_SHEET_TABLE_DATA,
47
+ xls_file: {filename: 'test.xls'})
48
+ @c.convert(:xls_file, :multi_sheet_table_data,
49
+ {filename: 'test.xls'},
50
+ ).must_equal(MULTI_SHEET_TABLE_DATA)
51
+ ensure
52
+ FileUtils.rm_f("test.xls")
53
+ end
54
+ end
55
+ end
56
+
57
+ describe :xlsx_file do
58
+ specify do
59
+ begin
60
+ @c.convert(:item_data, :xlsx_file, ITEM_DATA, xlsx_file: {filename: "test.xlsx"})
61
+ @c.convert(:xlsx_file, :item_data, {filename: "test.xlsx"}).must_equal ITEM_DATA
62
+
63
+ @c.convert(:multi_sheet_table_data, :xlsx_file, MULTI_SHEET_TABLE_DATA,
64
+ xlsx_file: {filename: 'test.xlsx'})
65
+ @c.convert(:xlsx_file, :multi_sheet_table_data,
66
+ {filename: 'test.xlsx'},
67
+ ).must_equal(MULTI_SHEET_TABLE_DATA)
68
+ ensure
69
+ FileUtils.rm_f("test.xlsx")
70
+ end
71
+ end
72
+
73
+ end
74
+ end
metadata CHANGED
@@ -1,14 +1,14 @@
1
1
  --- !ruby/object:Gem::Specification
2
2
  name: data_list_converter
3
3
  version: !ruby/object:Gem::Version
4
- version: 0.2.1
4
+ version: 0.3.0
5
5
  platform: ruby
6
6
  authors:
7
7
  - linjunhalida
8
8
  autorequire:
9
9
  bindir: bin
10
10
  cert_chain: []
11
- date: 2015-12-30 00:00:00.000000000 Z
11
+ date: 2016-01-05 00:00:00.000000000 Z
12
12
  dependencies:
13
13
  - !ruby/object:Gem::Dependency
14
14
  name: rake
@@ -101,10 +101,14 @@ files:
101
101
  - lib/data_list_converter/filters/remove_debug.rb
102
102
  - lib/data_list_converter/types/basic.rb
103
103
  - lib/data_list_converter/types/csv_file.rb
104
+ - lib/data_list_converter/types/multi_sheet.rb
104
105
  - lib/data_list_converter/types/records.rb
105
106
  - lib/data_list_converter/types/xls_file.rb
106
107
  - lib/data_list_converter/types/xlsx_file.rb
107
- - test/data_list_converter_test.rb
108
+ - test/base_test.rb
109
+ - test/filters_test.rb
110
+ - test/testdata.rb
111
+ - test/types_test.rb
108
112
  homepage: http://github.com/halida/data_list_converter
109
113
  licenses:
110
114
  - MIT
@@ -130,4 +134,7 @@ signing_key:
130
134
  specification_version: 4
131
135
  summary: convert data between different formats
132
136
  test_files:
133
- - test/data_list_converter_test.rb
137
+ - test/base_test.rb
138
+ - test/filters_test.rb
139
+ - test/testdata.rb
140
+ - test/types_test.rb
@@ -1,134 +0,0 @@
1
- require 'minitest/pride'
2
- require 'minitest/autorun'
3
-
4
- require 'data_list_converter'
5
-
6
- ITEM_DATA = [
7
- {name: "James", score: '12'},
8
- {name: "Bob", score: '33'},
9
- ]
10
-
11
- TABLE_DATA = [
12
- ['name', 'score'],
13
- ['James', '12'],
14
- ['Bob', '33']
15
- ]
16
-
17
- CSV_DATA = %{
18
- "name","score"
19
- "James","12"
20
- "Bob","33"
21
- }.strip
22
-
23
- describe DataListConverter do
24
- describe :type do
25
- it 'works' do
26
- DataListConverter.types.must_equal(
27
- [:csv_file, :item_data, :item_iterator, :multi_sheet_data, :multi_sheet_iterator,
28
- :records, :table_data, :table_iterator, :xls_file, :xlsx_file])
29
- end
30
- end
31
-
32
- describe :convert do
33
- before :all do
34
- @c = DataListConverter
35
- end
36
-
37
- it 'works' do
38
- @c.convert(:item_data, :table_data, ITEM_DATA).must_equal TABLE_DATA
39
- end
40
-
41
- it 'has parameters' do
42
- begin
43
- @c.convert(:item_data, :csv_file, ITEM_DATA, csv_file: {filename: "test.csv"})
44
- File.read("test.csv").strip.must_equal CSV_DATA
45
- @c.convert(:csv_file, :item_data, {filename: "test.csv"}).must_equal(ITEM_DATA)
46
- ensure
47
- FileUtils.rm_f("test.csv")
48
- end
49
- end
50
-
51
- it 'has filters' do
52
- filter = :limit
53
- item_data = [{name: "james"}] * 20
54
- result = @c.convert(:item_data, :table_data, item_data,
55
- item_iterator: {filter: filter})
56
- result.must_equal([["name"]] + [["james"]]*10)
57
-
58
- filter = {limit: {size: 2}}
59
- item_data = [{name: "james"}] * 10
60
- result = @c.convert(:item_data, :table_data, item_data,
61
- item_iterator: {filter: filter})
62
- result.must_equal [["name"], ["james"], ["james"]]
63
-
64
- string = StringIO.new
65
- filter = [{limit: {size: 12}}, {count: {size: 4, out: string, msg: ".%{count}"}}]
66
- item_data = [{name: "james"}] * 20
67
- result = @c.convert(:item_data, :table_data, item_data,
68
- item_iterator: {filter: filter})
69
- result.must_equal([["name"]] + [["james"]]*12)
70
- string.string.must_equal ".4\n.8\n.12\n"
71
- end
72
-
73
- it 'has type xls_file' do
74
- begin
75
- @c.convert(:item_data, :xls_file, ITEM_DATA, xls_file: {filename: "test.xls"})
76
- @c.convert(:xls_file, :item_data, {filename: "test.xls"}).must_equal ITEM_DATA
77
-
78
- multi_sheet = {
79
- "sheet1" => [['name'], ['james'], ['bob']],
80
- "sheet2" => [['value'], ['21'], ['12']],
81
- }
82
- @c.convert(:multi_sheet_data, :xls_file, multi_sheet, xls_file: {filename: 'test.xls'})
83
- @c.convert(:xls_file, :multi_sheet_data, {filename: 'test.xls'}).must_equal multi_sheet
84
- ensure
85
- FileUtils.rm_f("test.xls")
86
- end
87
- end
88
-
89
- it 'has type xlsx_file' do
90
- begin
91
- @c.convert(:item_data, :xlsx_file, ITEM_DATA, xlsx_file: {filename: "test.xlsx"})
92
- @c.convert(:xlsx_file, :item_data, {filename: "test.xlsx"}).must_equal ITEM_DATA
93
-
94
- multi_sheet = {
95
- "sheet1" => [['name'], ['james'], ['bob']],
96
- "sheet2" => [['value'], ['21'], ['12']],
97
- }
98
- @c.convert(:multi_sheet_data, :xlsx_file, multi_sheet, xlsx_file: {filename: 'test.xlsx'})
99
- @c.convert(:xlsx_file, :multi_sheet_data, {filename: 'test.xlsx'}).must_equal multi_sheet
100
- ensure
101
- FileUtils.rm_f("test.xlsx")
102
- end
103
- end
104
- end
105
-
106
- describe :filters do
107
- it 'limit iterator' do
108
- filter = {limit: {size: 2}}
109
- item_data = [{name: "james"}] * 10
110
- result = DataListConverter.convert(
111
- :item_data, :table_data, item_data,
112
- item_iterator: {filter: filter})
113
- result.must_equal [["name"], ["james"], ["james"]]
114
- end
115
-
116
- it 'count item_iterator' do
117
- iter = lambda { |&block|
118
- total = 10000
119
- block.call(total: total)
120
- (1..total-1).each do |i|
121
- block.call(id: i, value: i*i)
122
- end
123
- }
124
- string = StringIO.new
125
- filter = {count: {size: 4000,
126
- out: string,
127
- msg: "%{percent}%"}}
128
- result = DataListConverter.convert(
129
- :item_iterator, :table_data, iter,
130
- item_iterator: {filter: filter})
131
- string.string.split("\n").must_equal ['total: 10000', '40.0%', '80.0%']
132
- end
133
- end
134
- end