data_list_converter 0.1 → 0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f397cef319fe34bff9143714c69003b6e9f2cb2f
-  data.tar.gz: 96708c56c0bfd2a4e48ebff454ec004c3becda34
+  metadata.gz: 3d8949f31a68b057f6914e873ec2ebe6e38b5dc4
+  data.tar.gz: a3d47489bc2874afde23b3281e3d792a6d05cc0b
 SHA512:
-  metadata.gz: 20f9d84f520b6039d6c4a2b7bb1c7e9367a16a18b30818170a98637742bccf9524d5a2fefaa919730eb4b736e66571f13ab9acea08ade8c29200d996b9a7f80a
-  data.tar.gz: 957d4cc8c98c9dc7cad99814ee4acaaa18cf222481c043926649b86241d4e5deb4db74d31e9631f97a428e10952a46ac152759a9ee24acaeda54a774cac11c62
+  metadata.gz: 9679c6942102474e5100153518b93b91352881a980ad8da94417b6a7adbe052a26500ac41ce4e5937521c9e3fdec0902de0776cb9d01e5caf28d05f8b0876e6c
+  data.tar.gz: 9e93b4ed6e0459f410378196a9e2486c0d6ee07b9339a5383a39641577e1eba1cb7ad7359d6aef8539693e38fde49ea0e1c20ea34646554580fa9ba0b3850d4c

data/Rakefile

@@ -5,6 +5,12 @@ Bundler::GemHelper.install_tasks
 
 task :default => :test
 
+task :console do
+  require 'pry'
+  require 'data_list_converter'
+  Pry.start
+end
+
 task :test do
   load 'test/data_list_converter_test.rb'
 end

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.1"
+  s.version     = "0.2"
   s.platform    = Gem::Platform::RUBY
   s.authors     = ["linjunhalida"]
   s.email       = ["linjunhalida@gmail.com"]
@@ -14,6 +14,8 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'rake', '~> 10.4'
   s.add_development_dependency 'minitest', '~> 5.7'
   s.add_development_dependency 'spreadsheet', '~> 1.0'
+  s.add_development_dependency 'rubyXL', '~> 3.3'
+  s.add_development_dependency 'pry'
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")

data/lib/data_list_converter.rb

@@ -1,353 +1,11 @@
-require 'csv'
-
-# this class is used for convert data between types,
-# so we can use it to easily export and import data.
-# 
-class DataListConverter
-  CONVERTERS = {}
-  FILTERS = {}
-
-  class << self
-
-    def types
-      CONVERTERS.keys.flatten.uniq.sort
-    end
-
-    def register_converter(from_type, to_type, method)
-      @route_map = nil # clear cache
-      CONVERTERS[[from_type, to_type]] = method
-    end
-
-    def register_filter(type, name, method)
-      FILTERS[type] ||= {}
-      FILTERS[type][name] = method
-    end
-
-    # Example:
-    # convert(:item_iterator, :item_data, iter)
-    # convert(:item_iterator, :csv_file, iter, csv_file: {filename: 'result.csv'})
-    # convert(:csv_file, :item_data, {filename: 'result.csv'})
-    #
-    # can add filter:
-    # filter = :limit
-    # filter = {limit: {size: 2}}
-    # filter = [{limit: {size: 12}}, {count: {size: 4}}]
-    # convert(:item_iterator, :table_data, iter, table_iterator: {filter: filter})
-    def convert(from_type, to_type, from_value, options={})
-      methods = []
-      add_filter = lambda { |type|
-        filters = (options[type] || {}).delete(:filter)
-        return unless filters
-        methods += normalize_filters(type, filters)
-      }
-
-      route = find_route(from_type, to_type)
-      add_filter.call(route[0])
-
-      (0..(route.length-2)).map do |i|
-        from_type, to_type = route[i], route[i+1]
-        method = CONVERTERS[[from_type, to_type]]
-        raise "cannot find converter #{from_type} -> #{to_type}" unless method
-        methods.push([method, options[to_type] || {}])
-        add_filter.call(to_type)
-      end
-
-      methods.inject(from_value) do |v, method|
-        method, args = method
-        method.call(v, args)
-      end
-    end
-
-    def normalize_filters(type, filters)
-      # filter list as array
-      filters = [filters] unless filters.kind_of?(Array)
-      filters.map do |v|
-        # fix filter arguments
-        case v
-        # {:limit, {count: 12}} => [:limit, {count: 12}]
-        when Hash; v.first
-        # :debug => [:debug, {}]
-        when Symbol, String; [v, {}]
-        else; v
-        end
-      end.map do |name, args|
-        method = FILTERS[type][name] rescue raise("cannot find method for type #{type} filter #{name}")
-        [method, args]
-      end
-    end
-
-    # One type of data can be converted into any other types,
-    # we have a list of convert methods: CONVERTERS
-    # If we want to convert between types, like: convert item_data into csv_file,
-    # we need find all the intermidate data type, like: [:item_data, :item_iterator, :table_iterator, :csv_file]
-    def find_route(from_type, to_type)
-      raise Exception, "from_type should not equal to to_type: #{from_type}" if from_type == to_type
-      out = find_next_node([], [from_type], route_map, to_type)
-      raise Exception, "Route not found: #{from_type} -> #{to_type}" unless out
-      out
-    end
-
-    # iterate through the type convert graph, and find the route
-    def find_next_node (out, nodes, map, end_node)
-      nodes.each do |node|
-        return out + [node] if node == end_node
-        next unless next_nodes = map[node]
-
-        new_map = map.dup
-        new_map.delete(node)
-        result = find_next_node(out + [node], next_nodes, new_map, end_node)
-        return result if result
-      end
-      nil
-    end
-    private :find_next_node
-
-    # convert adjacency list into quick lookup hash
-    def route_map
-      @route_map ||= \
-      begin
-        CONVERTERS.keys.
-          inject({}) do |map, item|
-          map[item.first] ||= []
-          map[item.first] += [item[1]]
-          map
-        end
-      end
-    end
-
-  end
-end
-
-# register types
-
-# item_data: [{name: 'xx', value: 12}, ...]
-# 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] })
-        end
-      }
-    })
-  self.register_converter(
-    :table_iterator, :item_iterator, lambda{ |proc, options|
-      lambda {|&block|
-        columns = nil
-        proc.call do |row|
-          unless columns
-            columns = row.map(&:to_sym)
-          else
-            block.call(columns.zip(row).to_h)
-          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))
-
-  def self.data_to_iterator(data, options={})
-    lambda { |&block|
-      data.each do |d|
-        block.call(d)
-      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))
-end
-
-# records
-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
-      }
-    })
-end
-
-# 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
-        end
-      end
-    })
-end
-
-# xls_file only works when installed spreadsheet gem
-# multi_sheet_data = {
-#   'sheet1' => [columns, row, row, ...],
-#   'sheet2' => [columns, row, row, ...],
-# }
-begin
-  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"))
-        i = 0
-        proc.call do |row|
-          sheet.row(i).push *row
-          i += 1
-        end
-        book.write(options[:filename])
-        options[:filename]
-      })
-
-    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
-          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
-      })
-  end
-rescue LoadError
-  nil
-end
-
-
-# filters
-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)])
-        end
-      }
-    })
-
-  def self.iterator_limit(proc, options)
-    limit_size = options[:size] || 10
-    lambda { |&block|
-      limit = 0
-      proc.call do |item|
-        block.call(item)
-        limit += 1
-        break if limit >= limit_size
-      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, :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
-        end
-      }
-    })
-end
+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/xls_file' rescue LoadError
+require 'data_list_converter/types/xlsx_file' rescue LoadError
 
+require 'data_list_converter/filters/count'
+require 'data_list_converter/filters/limit'
+require 'data_list_converter/filters/remove_debug'

data/lib/data_list_converter/base.rb

@@ -0,0 +1,148 @@
+# this class is used for convert data between types,
+# so we can use it to easily export and import data.
+# 
+class DataListConverter
+  CONVERTERS = {}
+  FILTERS = {}
+
+  class << self
+
+    attr_accessor :debug
+
+    def on_debug
+      self.debug = true
+      yield
+    ensure
+      self.debug = false
+    end
+
+    def log(msg)
+      return unless debug
+      puts "#{Time.now.strftime('%Y-%m-%d %H:%M:%S')}\t#{msg}"
+    end
+
+    def types
+      CONVERTERS.keys.flatten.uniq.sort
+    end
+
+    def register_converter(from_type, to_type, method)
+      @route_map = nil # clear cache
+      CONVERTERS[[from_type, to_type]] = method
+    end
+
+    def register_filter(type, name, method)
+      FILTERS[type] ||= {}
+      FILTERS[type][name] = method
+    end
+
+    # Example:
+    # convert(:item_iterator, :item_data, iter)
+    # convert(:item_iterator, :csv_file, iter, csv_file: {filename: 'result.csv'})
+    # convert(:csv_file, :item_data, {filename: 'result.csv'})
+    #
+    # can add filter:
+    # filter = :limit
+    # filter = {limit: {size: 2}}
+    # filter = [{limit: {size: 12}}, {count: {size: 4}}]
+    # convert(:item_iterator, :table_data, iter, table_iterator: {filter: filter})
+    def convert(from_type, to_type, from_value, options={})
+      methods = []
+      add_filter = lambda { |type|
+        filters = (options[type] || {}).delete(:filter)
+        return unless filters
+        methods += normalize_filters(type, filters)
+      }
+
+      route = find_route(from_type, to_type)
+      add_filter.call(route[0])
+
+      self.log("route: #{route}")
+      (0..(route.length-2)).map do |i|
+        from_type, to_type = route[i], route[i+1]
+        method = CONVERTERS[[from_type, to_type]]
+        raise "cannot find converter #{from_type} -> #{to_type}" unless method
+        methods.push([method, options[to_type] || {}])
+        add_filter.call(to_type)
+      end
+
+      self.log("methods: #{methods}")
+      methods.inject(from_value) do |v, method|
+        method, args = method
+        method.call(v, args)
+      end
+    end
+
+    def normalize_filters(type, filters)
+      # filter list as array
+      filters = [filters] unless filters.kind_of?(Array)
+      filters.map do |v|
+        # fix filter arguments
+        case v
+        # {:limit, {count: 12}} => [:limit, {count: 12}]
+        when Hash; v.first
+        # :debug => [:debug, {}]
+        when Symbol, String; [v, {}]
+        else; v
+        end
+      end.map do |name, args|
+        method = FILTERS[type][name] rescue raise("cannot find method for type #{type} filter #{name}")
+        [method, args]
+      end
+    end
+
+    # One type of data can be converted into any other types,
+    # we have a list of convert methods: CONVERTERS
+    # If we want to convert between types, like: convert item_data into csv_file,
+    # we need find all the intermidate data type, like: [:item_data, :item_iterator, :table_iterator, :csv_file]
+    def find_route(from_type, to_type)
+      raise Exception, "from_type should not equal to to_type: #{from_type}" if from_type == to_type
+      # map wide search
+      checked = Set.new
+      checking = Set.new([from_type])
+      directions = {}
+
+      while not checking.empty?
+        current_node = checking.first
+
+        next_nodes = route_map[current_node]
+        # mark direction from from_type
+        next_nodes.each do |node|
+          # first marked is the shortest
+          directions[node] ||= current_node
+        end
+
+        if next_nodes.include?(to_type)
+          # get route
+          start = to_type
+          route = [start]
+          while start != from_type
+            previous = directions[start]
+            raise "cannot find previous for #{start} in #{directions}" if not previous
+            route.push(previous)
+            start = previous
+          end
+          return route.reverse
+        else
+          checking.delete(current_node)
+          checked.add(current_node)
+          checking += Set.new(next_nodes) - checked
+        end
+      end
+      raise Exception, "Route not found: #{from_type} -> #{to_type}"
+    end
+
+    # convert adjacency list into quick lookup hash
+    def route_map
+      @route_map ||= \
+      begin
+        CONVERTERS.keys.
+          inject({}) do |map, item|
+          map[item.first] ||= []
+          map[item.first] += [item[1]]
+          map
+        end
+      end
+    end
+
+  end
+end

data/lib/data_list_converter/filters/count.rb

@@ -0,0 +1,27 @@
+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
+        end
+      }
+    })
+end
+
+

data/lib/data_list_converter/filters/limit.rb

@@ -0,0 +1,17 @@
+class DataListConverter
+  def self.iterator_limit(proc, options)
+    limit_size = options[:size] || 10
+    lambda { |&block|
+      limit = 0
+      proc.call do |item|
+        block.call(item)
+        limit += 1
+        break if limit >= limit_size
+      end
+    }
+  end
+  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

@@ -0,0 +1,16 @@
+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)])
+        end
+      }
+    })
+end

data/lib/data_list_converter/types/basic.rb

@@ -0,0 +1,54 @@
+# item_data: [{name: 'xx', value: 12}, ...]
+# 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] })
+        end
+      }
+    })
+  self.register_converter(
+    :table_iterator, :item_iterator, lambda{ |proc, options|
+      lambda {|&block|
+        columns = nil
+        proc.call do |row|
+          unless columns
+            columns = row.map(&:to_sym)
+          else
+            block.call(columns.zip(row).to_h)
+          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))
+
+  def self.data_to_iterator(data, options={})
+    lambda { |&block|
+      data.each do |d|
+        block.call(d)
+      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))
+end

data/lib/data_list_converter/types/csv_file.rb

@@ -0,0 +1,23 @@
+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
+        end
+      end
+    })
+end

data/lib/data_list_converter/types/records.rb

@@ -0,0 +1,15 @@
+# records
+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
+      }
+    })
+end

data/lib/data_list_converter/types/xls_file.rb

@@ -0,0 +1,73 @@
+# 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"))
+      i = 0
+      proc.call do |row|
+        sheet.row(i).push *row
+        i += 1
+      end
+      book.write(options[:filename])
+      options[:filename]
+    })
+
+  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
+        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
+    })
+end

data/lib/data_list_converter/types/xlsx_file.rb

@@ -0,0 +1,66 @@
+# 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]
+      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
+    })
+
+  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
+        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
+    })
+end

data/test/data_list_converter_test.rb

@@ -25,7 +25,7 @@ describe DataListConverter 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])
+         :records, :table_data, :table_iterator, :xls_file, :xlsx_file])
     end
   end
 
@@ -85,6 +85,22 @@ describe DataListConverter do
         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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: data_list_converter
 version: !ruby/object:Gem::Version
-  version: '0.1'
+  version: '0.2'
 platform: ruby
 authors:
 - linjunhalida
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-12-04 00:00:00.000000000 Z
+date: 2015-12-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -52,6 +52,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rubyXL
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Data List Converter is a tool to convert data between different formats.
 email:
 - linjunhalida@gmail.com
@@ -66,6 +94,15 @@ files:
 - Rakefile
 - data_list_converter.gemspec
 - lib/data_list_converter.rb
+- lib/data_list_converter/base.rb
+- lib/data_list_converter/filters/count.rb
+- lib/data_list_converter/filters/limit.rb
+- 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/records.rb
+- lib/data_list_converter/types/xls_file.rb
+- lib/data_list_converter/types/xlsx_file.rb
 - test/data_list_converter_test.rb
 homepage: http://github.com/halida/data_list_converter
 licenses: