squib 0.18.0 → 0.19.0a

data/lib/squib/import/data_frame.rb

@@ -1,108 +1,108 @@
-# encoding: UTF-8
-
-require 'json'
-require 'forwardable'
-
-module Squib
-  class DataFrame
-    include Enumerable
-
-    def initialize(hash = {}, def_columns = true)
-      @hash = hash
-      columns.each { |col| def_column(col) } if def_columns
-    end
-
-    def each(&block)
-      @hash.each(&block)
-    end
-
-    def [](i)
-      @hash[i]
-    end
-
-    def []=(col, v)
-      @hash[col] = v
-      def_column(col)
-      return v
-    end
-
-    def columns
-      @hash.keys
-    end
-
-    def ncolumns
-      @hash.keys.size
-    end
-
-    def col?(col)
-      @hash.key? col
-    end
-
-    def row(i)
-      @hash.inject(Hash.new) { |ret, (name, arr)| ret[name] = arr[i]; ret }
-    end
-
-    def nrows
-      @hash.inject(0) { |max, (_n, col)| col.size > max ? col.size : max }
-    end
-
-    def to_json
-      @hash.to_json
-    end
-
-    def to_pretty_json
-      JSON.pretty_generate(@hash)
-    end
-
-    def to_h
-      @hash
-    end
-
-    def to_pretty_text
-      max_col = columns.inject(0) { |max, c | c.length > max ? c.length : max }
-      top    = " ╭#{'-' * 36}╮\n"
-      bottom = " ╰#{'-' * 36}╯\n"
-      str =  ''
-      0.upto(nrows - 1) do | i |
-        str += (' ' * max_col) + top
-        row(i).each do |col, data|
-          str += "#{col.rjust(max_col)} #{wrap_n_pad(data, max_col)}"
-        end
-        str += (' ' * max_col) + bottom
-      end
-      return str
-    end
-
-    private
-
-    def snake_case(str)
-      str.to_s.
-          strip.
-          gsub(/\s+/,'_').
-          gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
-          gsub(/([a-z]+)([A-Z])/,'\1_\2').
-          downcase.
-          to_sym
-    end
-
-    def wrap_n_pad(str, max_col)
-      new_str = str.to_s + ' ' # handle nil & empty strings
-      new_str = new_str.
-                  scan(/.{1,34}/). # break down
-                  map { |s| (' ' * max_col) + " | " + s.ljust(34) }.
-                  join(" |\n").
-                  lstrip      # initially no whitespace next to key
-      return new_str + " |\n"
-    end
-
-    def def_column(col)
-      raise "Column #{col} - does not exist" unless @hash.key? col
-      method_name = snake_case(col)
-      return if self.class.method_defined?(method_name) #warn people? or skip?
-      define_singleton_method method_name do
-        @hash[col]
-      end
-    end
-
-  end
-end
+# encoding: UTF-8
+
+require 'json'
+require 'forwardable'
+
+module Squib
+  class DataFrame
+    include Enumerable
+
+    def initialize(hash = {}, def_columns = true)
+      @hash = hash
+      columns.each { |col| def_column(col) } if def_columns
+    end
+
+    def each(&block)
+      @hash.each(&block)
+    end
+
+    def [](i)
+      @hash[i]
+    end
+
+    def []=(col, v)
+      @hash[col] = v
+      def_column(col)
+      return v
+    end
+
+    def columns
+      @hash.keys
+    end
+
+    def ncolumns
+      @hash.keys.size
+    end
+
+    def col?(col)
+      @hash.key? col
+    end
+
+    def row(i)
+      @hash.inject(Hash.new) { |ret, (name, arr)| ret[name] = arr[i]; ret }
+    end
+
+    def nrows
+      @hash.inject(0) { |max, (_n, col)| col.size > max ? col.size : max }
+    end
+
+    def to_json
+      @hash.to_json
+    end
+
+    def to_pretty_json
+      JSON.pretty_generate(@hash)
+    end
+
+    def to_h
+      @hash
+    end
+
+    def to_pretty_text
+      max_col = columns.inject(0) { |max, c | c.length > max ? c.length : max }
+      top    = " ╭#{'-' * 36}╮\n"
+      bottom = " ╰#{'-' * 36}╯\n"
+      str =  ''
+      0.upto(nrows - 1) do | i |
+        str += (' ' * max_col) + top
+        row(i).each do |col, data|
+          str += "#{col.rjust(max_col)} #{wrap_n_pad(data, max_col)}"
+        end
+        str += (' ' * max_col) + bottom
+      end
+      return str
+    end
+
+    private
+
+    def snake_case(str)
+      str.to_s.
+          strip.
+          gsub(/\s+/,'_').
+          gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+          gsub(/([a-z]+)([A-Z])/,'\1_\2').
+          downcase.
+          to_sym
+    end
+
+    def wrap_n_pad(str, max_col)
+      new_str = str.to_s + ' ' # handle nil & empty strings
+      new_str = new_str.
+                  scan(/.{1,34}/). # break down
+                  map { |s| (' ' * max_col) + " | " + s.ljust(34) }.
+                  join(" |\n").
+                  lstrip      # initially no whitespace next to key
+      return new_str + " |\n"
+    end
+
+    def def_column(col)
+      raise "Column #{col} - does not exist" unless @hash.key? col
+      method_name = snake_case(col)
+      return if self.class.method_defined?(method_name) #warn people? or skip?
+      define_singleton_method method_name do
+        @hash[col]
+      end
+    end
+
+  end
+end

data/lib/squib/import/quantity_exploder.rb

@@ -1,18 +1,18 @@
-module Squib
-  module Import
-    module QuantityExploder
-      def explode_quantities(data, qty)
-        return data unless data.col? qty.to_s.strip
-        qtys = data[qty]
-        new_data = Squib::DataFrame.new
-        data.each do |col, arr|
-          new_data[col] = []
-          qtys.each_with_index do |qty, index|
-            qty.to_i.times { new_data[col] << arr[index] }
-          end
-        end
-        return new_data
-      end
-    end
-  end
+module Squib
+  module Import
+    module QuantityExploder
+      def explode_quantities(data, qty)
+        return data unless data.col? qty.to_s.strip
+        qtys = data[qty]
+        new_data = Squib::DataFrame.new
+        data.each do |col, arr|
+          new_data[col] = []
+          qtys.each_with_index do |qty, index|
+            qty.to_i.times { new_data[col] << arr[index] }
+          end
+        end
+        return new_data
+      end
+    end
+  end
 end

data/lib/squib/import/xlsx_importer.rb

@@ -1,28 +1,28 @@
-autoload :Roo, 'roo'
-require_relative 'quantity_exploder'
-
-module Squib::Import
-  class XlsxImporter
-    include Squib::Import::QuantityExploder
-    def import_to_dataframe(import, &block)
-      s = Roo::Excelx.new(import.file)
-      s.default_sheet = s.sheets[import.sheet]
-      data = Squib::DataFrame.new
-      s.first_column.upto(s.last_column) do |col|
-        header = s.cell(s.first_row, col).to_s
-        header = header.strip if import.strip?
-        data[header] = []
-        (s.first_row + 1).upto(s.last_row) do |row|
-          cell = s.cell(row, col)
-          # Roo hack for avoiding unnecessary .0's on whole integers (https://github.com/roo-rb/roo/issues/139)
-          cell = s.excelx_value(row, col) if s.excelx_type(row, col) == [:numeric_or_formula, 'General']
-          cell = cell.strip if cell.respond_to?(:strip) && import.strip?
-          cell = block.yield(header, cell) unless block.nil?
-          data[header] << cell
-        end# row
-      end# col
-      explode_quantities(data, import.explode)
-    end
-  end
-end
-
+autoload :Roo, 'roo'
+require_relative 'quantity_exploder'
+
+module Squib::Import
+  class XlsxImporter
+    include Squib::Import::QuantityExploder
+    def import_to_dataframe(import, &block)
+      s = Roo::Excelx.new(import.file)
+      s.default_sheet = s.sheets[import.sheet]
+      data = Squib::DataFrame.new
+      s.first_column.upto(s.last_column) do |col|
+        header = s.cell(s.first_row, col).to_s
+        header = header.strip if import.strip?
+        data[header] = []
+        (s.first_row + 1).upto(s.last_row) do |row|
+          cell = s.cell(row, col)
+          # Roo hack for avoiding unnecessary .0's on whole integers (https://github.com/roo-rb/roo/issues/139)
+          cell = s.excelx_value(row, col) if s.excelx_type(row, col) == [:numeric_or_formula, 'General']
+          cell = cell.strip if cell.respond_to?(:strip) && import.strip?
+          cell = block.yield(header, cell) unless block.nil?
+          data[header] << cell
+        end# row
+      end# col
+      explode_quantities(data, import.explode)
+    end
+  end
+end
+

data/lib/squib/import/yaml_importer.rb

@@ -1,30 +1,30 @@
-require 'yaml'
-require_relative 'data_frame'
-require_relative 'quantity_exploder'
-
-module Squib::Import
-  class YamlImporter
-    include Squib::Import::QuantityExploder
-    def import_to_dataframe(import, &block)
-      data = import.data.nil? ? File.read(import.file) : import.data
-      yml = YAML.load(data)
-      data = Squib::DataFrame.new
-      # Get a universal list of keys to ensure everything is covered.
-      keys = yml.map { |c| c.keys}.flatten.uniq
-      keys.each { |k| data[k] = [] } #init arrays
-      yml.each do |card|
-      # nil value if key isn't set.
-      keys.each { |k| data[k] << card[k] }
-      end
-      unless block.nil?
-        data.each do |header, col|
-          col.map! do |val|
-          block.yield(header, val)
-          end
-        end
-      end
-      explode_quantities(data, import.explode)
-    end
-  end
-end
-
+require 'yaml'
+require_relative 'data_frame'
+require_relative 'quantity_exploder'
+
+module Squib::Import
+  class YamlImporter
+    include Squib::Import::QuantityExploder
+    def import_to_dataframe(import, &block)
+      data = import.data.nil? ? File.read(import.file) : import.data
+      yml = YAML.load(data)
+      data = Squib::DataFrame.new
+      # Get a universal list of keys to ensure everything is covered.
+      keys = yml.map { |c| c.keys}.flatten.uniq
+      keys.each { |k| data[k] = [] } #init arrays
+      yml.each do |card|
+      # nil value if key isn't set.
+      keys.each { |k| data[k] << card[k] }
+      end
+      unless block.nil?
+        data.each do |header, col|
+          col.map! do |val|
+          block.yield(header, val)
+          end
+        end
+      end
+      explode_quantities(data, import.explode)
+    end
+  end
+end
+