active_report 5.2.1 → 5.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fc6291c1487bae4301fdd9c40d2e45a8d2499318f976df9697c02ca30ea5359f
-  data.tar.gz: bea6b9dffd09487c4167b1ce3e9d1895b128cf6e182042bfa77e21bef454cbb0
+  metadata.gz: f93cb814920fb21c597c30929a0aeaa42b12e8d55bf8d6cd279fc19feeb70d5a
+  data.tar.gz: cfaf4b8f1766e6d0d3e29322758f45228c60593acce062197b56e4aa5e15b456
 SHA512:
-  metadata.gz: e9e8217015fb690d39687511238c14aa3d17abfa95cc6a29d0e4f0de087bec2cebe39137b00d9a9d09ef4b18fe70b1674646217f396d97a6e7614e5cbf0bcce3
-  data.tar.gz: 9730503da7cbb66022758b6d47676dbb71ab0a194aa2c9c874d33cd04f43d12aea8921ff2e3a45436c5130e5b7fc9bfc3d0afc6bc502fe83546b1bea99d5bc2a
+  metadata.gz: 7d084d1a9d69806666acb79ce1346f6136684da0bb70bf23e2cf092dc3fe354acf78736073fbfcc009aabed24696a23ed597849b7f4e7443195a67f0c56b19fb
+  data.tar.gz: e99b0c98944ec3d34aa2c040483e943306b1ef9b227ed5c73773c6cfd3d3f6617ca0366e82cd067df5ee0c96926292f76c190fda39cef9dc6420247a6a1b1c07

data/.reek

@@ -33,5 +33,8 @@ TooManyStatements:
 UncommunicativeMethodName:
   exclude:
     - 'ActiveReport::Base#encode_to_utf8'
+UncommunicativeVariableName:
+  exclude:
+    - 'ActiveReport::Hash#import'
 UtilityFunction:
   enabled: false

data/.rubocop.yml

@@ -14,6 +14,8 @@ Lint/ScriptPermission:
   Enabled: false
 Metrics/AbcSize:
   Enabled: false
+Metrics/ClassLength:
+  Enabled: false
 Metrics/MethodLength:
   Enabled: false
 Metrics/ParameterLists:

data/lib/active_report/array.rb

@@ -2,43 +2,17 @@
 
 class ActiveReport::Array < ActiveReport::Base
 
-  def initialize(datum, headers: nil, options: {}, stream: false)
-    @datum = datum
-    @headers = headers
-    @options = csv_options.merge(options)
-    @stream = stream
-  end
-
-  def self.export(datum, headers: nil, options: {}, stream: false)
-    klass = new(datum, headers: headers, options: options, stream: stream)
-    klass.export
-  end
-
-  def self.import(datum, headers: nil, options: {})
-    klass = new(datum, headers: headers, options: options)
-    klass.import
-  end
-
   def export
-    @datum = munge_first(@datum)
-
-    if @stream == true
-      Enumerator.new do |csv|
-        csv << CSV.generate_line(@headers) unless @headers.nil?
-        @datum.each { |row| csv << CSV.generate_line(row) }
-      end
-    else
-      CSV.generate(@options) do |csv|
-        csv << @headers unless @headers.nil?
-        @datum.each { |row| csv << row }
-      end
-    end
+    @data = munge_first(@data)
+    @data = @data.unshift(@opts[:headers]) unless @opts[:headers].nil?
+
+    @opts[:stream] ? export_stream : export_csv
   end
 
   def import
-    array = merge(@headers)
+    array = merge(@opts[:headers])
 
-    CSV.foreach(@datum, @options) do |row|
+    CSV.foreach(@data, @opts[:options]) do |row|
       row = encode_to_utf8(row) if csv_force_encoding?
       array.push(row)
     end
@@ -47,4 +21,18 @@ class ActiveReport::Array < ActiveReport::Base
     metatransform(array)
   end
 
+  private
+
+  def export_csv
+    CSV.generate(@opts[:options]) do |csv|
+      @data.each { |row| csv << row }
+    end
+  end
+
+  def export_stream
+    Enumerator.new do |csv|
+      @data.each { |row| csv << CSV.generate_line(row) }
+    end
+  end
+
 end

data/lib/active_report/base.rb

@@ -4,6 +4,14 @@ class ActiveReport::Base
 
   @@evaluate = false
 
+  def initialize(data, opts = {})
+    @data = data
+    @opts = opts
+
+    %i[except only].each { |key| @opts[key] = munge(@opts[key]) }
+    @opts[:options] ||= csv_options
+  end
+
   def csv_options
     ActiveReport.configuration.csv_options
   end
@@ -25,6 +33,16 @@ class ActiveReport::Base
     self
   end
 
+  def self.export(data, opts = {})
+    klass = new(data, opts)
+    klass.export
+  end
+
+  def self.import(data, opts = {})
+    klass = new(data, opts)
+    klass.import
+  end
+
   private
 
   def encode_to_utf8(line)
@@ -43,11 +61,12 @@ class ActiveReport::Base
   end
 
   def filter(object)
-    if @only.empty?
-      return if @except.empty?
-      object.delete_if { |key, _| @except.include?(key) }
+    if @opts[:only].empty?
+      return object if @opts[:except].empty?
+
+      object.delete_if { |key, _| @opts[:except].include?(key) }
     else
-      object.keep_if { |key, _| @only.include?(key) }
+      object.keep_if { |key, _| @opts[:only].include?(key) }
     end
   end
 
@@ -55,6 +74,10 @@ class ActiveReport::Base
     object.to_s.tr('_', ' ').capitalize
   end
 
+  def humanize_values(data)
+    data.map { |col| humanize(col) }
+  end
+
   def merge(object)
     [object].compact
   end
@@ -67,53 +90,49 @@ class ActiveReport::Base
   end
   # rubocop:enable Security/Eval, Lint/RescueException
 
-  def metaform_array(datum)
-    datum.map { |val| metaform(val) }
+  def metaform_array(data)
+    data.map { |val| metaform(val) }
   end
 
-  def metaform_hash(datum)
-    datum.each { |key, val| datum[key] = metaform(val) }
+  def metaform_hash(data)
+    data.each { |key, val| data[key] = metaform(val) }
   end
 
-  def metamorph_array(datum)
-    case datum.first.class.name
-    when 'Array' then datum.map { |arr| metaform_array(arr) }
-    when 'Hash' then datum.map { |hsh| metaform_hash(hsh) }
-    else metaform_array(datum)
+  def metamorph_array(data)
+    case data.first.class.name
+    when 'Array' then data.map { |arr| metaform_array(arr) }
+    when 'Hash' then data.map { |hsh| metaform_hash(hsh) }
+    else metaform_array(data)
     end
   end
 
-  def metamorph(datum)
-    case datum.class.name
-    when 'Array' then metamorph_array(datum)
-    when 'Hash' then metaform_hash(datum)
-    else metaform(datum)
+  def metamorph(data)
+    case data.class.name
+    when 'Array' then metamorph_array(data)
+    when 'Hash' then metaform_hash(data)
+    else metaform(data)
     end
   end
 
-  def metatransform(datum)
-    return if datum.empty?
-    evaluate? ? metamorph(datum) : datum
+  def metatransform(data)
+    return if data.empty?
+    evaluate? ? metamorph(data) : data
   end
 
-  def munge(datum)
-    datum.is_a?(Array) ? datum : merge(datum)
+  def munge(data)
+    data.is_a?(Array) ? data : merge(data)
   end
 
-  def munge_first(datum)
-    datum.first.is_a?(Array) ? datum : merge(datum)
+  def munge_first(data)
+    data.first.is_a?(Array) ? data : merge(data)
   end
 
-  def filter_values(datum)
-    array = []
-    (filter(datum) || datum).each_value { |val| array << val }
-    array
+  def filter_values(data)
+    filter(data).values
   end
 
-  def filter_humanize_keys(datum)
-    array = []
-    (filter(datum.first) || datum.first).each_key { |key| array << humanize(key) }
-    array
+  def filter_humanize_keys(data)
+    filter(data.first).collect { |key, _| humanize(key) }
   end
 
 end

data/lib/active_report/configuration.rb

@@ -8,7 +8,7 @@ module ActiveReport
     def initialize
       @csv_force_encoding = true
       @csv_options = { encoding: 'UTF-8' }
-      @import_adapter = 'mysql2_adapter'
+      @import_adapter = 'sqlite3_adapter'
       @import_options = { validate: false, on_duplicate_key_ignore: true }
     end
 

data/lib/active_report/hash.rb

@@ -2,65 +2,49 @@
 
 class ActiveReport::Hash < ActiveReport::Base
 
-  def initialize(datum, only: nil, except: nil, headers: nil, options: {}, stream: false)
-    @datum = datum
-    @only = munge(only)
-    @except = munge(except)
-    @headers = headers
-    @options = csv_options.merge(options)
-    @stream = stream
-  end
-
-  # rubocop:disable Metrics/LineLength
-  def self.export(datum, only: nil, except: nil, headers: nil, options: {}, stream: false)
-    klass = new(datum, only: only, except: except, headers: headers, options: options, stream: stream)
-    klass.export
-  end
-  # rubocop:enable Metrics/LineLength
-
-  def self.import(datum, only: nil, except: nil, headers: nil, options: {})
-    klass = new(datum, only: only, except: except, headers: headers, options: options)
-    klass.import
-  end
-
   def export
-    @datum = munge(@datum)
-    @headers = (@headers || filter_humanize_keys(@datum))
+    @data = munge(@data)
+    @opts[:headers] = (@opts[:headers] || filter_humanize_keys(@data))
 
-    if @stream == true
-      Enumerator.new do |csv|
-        csv << CSV.generate_line(@headers)
-        @data.each { |row| csv << CSV.generate_line(filter_values(row)) }
-      end
-    else
-      CSV.generate(@options) do |csv|
-        csv << @headers
-        @datum.each { |row| csv << filter_values(row) }
-      end
-    end
+    @opts[:stream] ? export_stream : export_csv
   end
 
   def import
     array = []
-    line = 0
 
-    CSV.foreach(@datum, @options) do |data|
+    CSV.foreach(@data, @opts[:options]).with_index do |data, i|
       data = encode_to_utf8(data) if csv_force_encoding?
 
-      if @headers.nil? && line.zero?
-        @headers = data
+      if @opts[:headers].nil? && i.zero?
+        @opts[:headers] = data
       else
         subdata = {}
-        @headers.each_with_index { |header, idx| subdata[header.to_s] = data[idx] }
+        @opts[:headers].each_with_index { |header, idx| subdata[header.to_s] = data[idx] }
         filter(subdata)
         array.push(subdata)
       end
-
-      line += 1
     end
 
     array = array.first if array.size == 1
     metatransform(array)
   end
 
+  private
+
+  def export_csv
+    CSV.generate(@opts[:options]) do |csv|
+      csv << @opts[:headers]
+
+      @data.each { |row| csv << filter_values(row) }
+    end
+  end
+
+  def export_stream
+    Enumerator.new do |csv|
+      csv << CSV.generate_line(@opts[:headers])
+
+      @data.each { |row| csv << CSV.generate_line(filter_values(row)) }
+    end
+  end
+
 end

data/lib/active_report/record.rb

@@ -7,65 +7,37 @@ require 'json'
 
 class ActiveReport::Record < ActiveReport::Base
 
-  attr_accessor :datum, :model, :only, :except, :headers, :options
-
-  # rubocop:disable Metrics/LineLength
-  def initialize(datum, model: nil, only: nil, except: nil, headers: nil, options: {}, stream: false)
-    @datum = datum
-    @model = model
-    @only = munge(only)
-    @except = munge(except)
-    @headers = headers
-    @options = csv_options.merge(options)
-    @stream = stream
-  end
-
-  def self.export(datum, only: nil, except: nil, headers: nil, options: {}, stream: false)
-    klass = new(datum, only: only, except: except, headers: headers, options: options, stream: stream)
-    klass.export
-  end
-  # rubocop:enable Metrics/LineLength
+  # rubocop:disable Metrics/PerceivedComplexity
+  def export
+    %i[except only].each { |key| @opts[key] = @opts[key].map(&:to_s) }
 
-  def self.import(datum, only: nil, except: nil, headers: nil, options: {}, model: nil)
-    klass = new(datum, only: only, except: except, headers: headers, options: options, model: model)
-    klass.import
-  end
+    if !@data.is_a?(ActiveRecord::Relation) && @data.try(:superclass) == ActiveRecord::Base
+      @opts[:headers] = (@opts[:headers] || humanize_values(@data.column_names))
 
-  def export
-    @datum = if @datum.is_a?(ActiveRecord::Relation)
-               JSON.parse(@datum.to_json).flatten
-             else
-               merge(@datum.attributes)
-             end
-
-    @only.map!(&:to_s)
-    @except.map!(&:to_s)
-    @headers = (@headers || filter_humanize_keys(@datum))
-
-    if @stream == true
-      Enumerator.new do |csv|
-        csv << CSV.generate_line(@headers)
-        @data.each { |row| csv << CSV.generate_line(filter_values(row)) }
-      end
+      @opts[:stream] ? export_stream : export_csv
     else
-      CSV.generate(@options) do |csv|
-        csv << @headers
-        @datum.each { |row| csv << filter_values(row) }
-      end
+      @data = if @data.is_a?(ActiveRecord::Relation)
+                JSON.parse(@data.to_json).flatten
+              else
+                merge(@data.attributes)
+              end
+
+      ActiveReport::Hash.export(@data, @opts)
     end
   end
+  # rubocop:enable Metrics/PerceivedComplexity
 
   def import
-    if @model.nil? || (@model.superclass != ActiveRecord::Base)
+    if @opts[:model].nil? || (@opts[:model].superclass != ActiveRecord::Base)
       raise ArgumentError,
             'Model must be an ActiveRecord::Base object.'
     end
 
-    @datum = ActiveReport::Hash.import(@datum, headers: @headers, options: @options)
-    @datum = munge(@datum)
+    @data = ActiveReport::Hash.import(@data, headers: @opts[:headers], options: @opts[:options])
+    @data = munge(@data)
 
     records = []
-    @datum.each do |data|
+    @data.each do |data|
       params = {}
 
       data.each do |key, value|
@@ -78,7 +50,29 @@ class ActiveReport::Record < ActiveReport::Base
       records << params
     end
 
-    @model.import(records, import_options)
+    @opts[:model].import(records, import_options)
+  end
+
+  private
+
+  def export_csv
+    CSV.generate(@opts[:options]) do |csv|
+      csv << @opts[:headers]
+
+      @data.find_each do |row|
+        csv << filter_values(row.attributes)
+      end
+    end
+  end
+
+  def export_stream
+    Enumerator.new do |csv|
+      csv << CSV.generate_line(@opts[:headers])
+
+      @data.find_each do |row|
+        csv << CSV.generate_line(filter_values(row.attributes))
+      end
+    end
   end
 
 end

data/lib/active_report/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActiveReport
-  VERSION ||= '5.2.1'
+  VERSION ||= '5.2.2'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active_report
 version: !ruby/object:Gem::Version
-  version: 5.2.1
+  version: 5.2.2
 platform: ruby
 authors:
 - Juan Gomez