bumblebee 2.1.0 → 3.0.0

data/lib/bumblebee/mutator.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2018-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+module Bumblebee
+  # A Mutator is a composition of a converter with hash value setting.  It can be a straight
+  # converter, or it can be new types which are not directly defined as 'converters.'
+  class Mutator
+    module Types
+      IGNORE = :ignore
+    end
+    include ::Bumblebee::Mutator::Types
+
+    attr_reader :converter, :type
+
+    def initialize(arg)
+      if arg.nil?
+        @type = nil
+        @converter = ::Bumblebee::NullConverter.new
+      elsif mutator?(arg)
+        @type = ::Bumblebee::Mutator::Types.const_get(arg.to_s.upcase.to_sym)
+        @converter = ::Bumblebee::NullConverter.new
+      else
+        @type = nil
+        @converter = ::Bumblebee::SimpleConverter.new(arg)
+      end
+
+      freeze
+    end
+
+    def set(object, key, val)
+      return object if ignore?
+
+      ::Bumblebee::ObjectInterface.set(object, key, converter.convert(val))
+    end
+
+    private
+
+    def ignore?
+      type == IGNORE
+    end
+
+    def mutator?(arg)
+      return false unless arg.is_a?(String) || arg.is_a?(Symbol)
+
+      ::Bumblebee::Mutator::Types.constants.include?(arg.to_s.upcase.to_sym)
+    end
+  end
+end

data/lib/bumblebee/null_converter.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2018-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+module Bumblebee
+  # Base converter using the Null Object Pattern.  Use this when a custom converter is not needed.
+  class NullConverter
+    def convert(val)
+      val
+    end
+  end
+end

data/lib/bumblebee/object_interface.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2018-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+module Bumblebee
+  # Provides methods for interacting with custom objects.
+  class ObjectInterface
+    class << self
+      def traverse(object, through)
+        pointer = object
+
+        through.each do |t|
+          next unless pointer
+
+          pointer = get(pointer, t)
+        end
+
+        pointer
+      end
+
+      def build(object, through)
+        pointer = object
+
+        through.each do |t|
+          pointer = get(pointer, t) || get(set(pointer, t, pointer.class.new), t)
+        end
+
+        pointer
+      end
+
+      def set(object, key, val)
+        object.tap do |o|
+          setter_method = "#{key}="
+          if o.respond_to?(setter_method)
+            o.send(setter_method, val)
+          elsif o.respond_to?(:[])
+            o[key] = val
+          end
+        end
+      end
+
+      def get(object, key)
+        if object.is_a?(Hash)
+          indifferent_hash_get(object, key)
+        elsif object.respond_to?(key)
+          object.send(key)
+        end
+      end
+
+      private
+
+      def indifferent_hash_get(hash, key)
+        if hash.key?(key.to_s)
+          hash[key.to_s]
+        elsif hash.key?(key.to_s.to_sym)
+          hash[key.to_s.to_sym]
+        end
+      end
+    end
+  end
+end

data/lib/bumblebee/simple_converter.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2018-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+module Bumblebee
+  # Subclass of Converter that provides a simple implementation for each Type.
+  class SimpleConverter < ::Bumblebee::Converter
+    DEFAULT_DATE = '1900-01-01'
+    DEFAULT_BIG_DECIMAL = 0
+
+    private
+
+    def process_pluck_join(val)
+      raise ArgumentError, 'sub_property is required for a pluck_join' unless sub_property
+
+      Array(val).map { |h| per.convert(h.is_a?(Hash) ? h[sub_property] : nil) }
+                .join(separator)
+    end
+
+    def process_pluck_split(val)
+      raise ArgumentError, 'sub_property is required for a pluck_split' unless sub_property
+
+      process_split(val).map do |v|
+        object_class.new.tap { |h| ::Bumblebee::ObjectInterface.set(h, sub_property, v) }
+      end
+    end
+
+    def process_ignore(_val)
+      nil
+    end
+
+    def process_join(val)
+      Array(val).map { |v| per.convert(v) }.join(separator)
+    end
+
+    def process_split(val)
+      val.to_s.split(separator).map { |v| per.convert(v) }
+    end
+
+    def process_function(val)
+      raise ArgumentError, 'function is required for function type' unless function
+
+      function.call(val)
+    end
+
+    def process_date(val)
+      return nil if nullable? && null_or_empty?(val)
+
+      Date.strptime(null_or_empty_default(val, DEFAULT_DATE).to_s, date_format)
+    end
+
+    def process_string(val)
+      return nil if nullable? && null_or_empty?(val)
+
+      val.to_s
+    end
+
+    def process_integer(val)
+      return nil if nullable? && null_or_empty?(val)
+
+      val.to_i
+    end
+
+    def process_float(val)
+      return nil if nullable? && null_or_empty?(val)
+
+      val.to_f
+    end
+
+    def process_bigdecimal(val)
+      return nil if nullable? && null_or_empty?(val)
+
+      BigDecimal(null_or_empty_default(val, DEFAULT_BIG_DECIMAL).to_s)
+    end
+
+    def process_boolean(val)
+      if nullable? && nully?(val)
+        nil
+      elsif truthy?(val)
+        true
+      else
+        false
+      end
+    end
+
+    def null_or_empty_default(val, default)
+      null_or_empty?(val) ? default : val
+    end
+
+    def null_or_empty?(val)
+      val.nil? || val.to_s.empty?
+    end
+
+    # rubocop:disable Style/DoubleNegation
+    def nully?(val)
+      null_or_empty?(val) || !!(val.to_s =~ /(nil|null)$/i)
+    end
+
+    def truthy?(val)
+      !!(val.to_s =~ /(true|t|yes|y|1)$/i)
+    end
+    # rubocop:enable Style/DoubleNegation
+  end
+end

data/lib/bumblebee/template.rb

@@ -10,30 +10,20 @@
 module Bumblebee
   # Wraps up columns and provides to main methods:
   # generate_csv: take in an array of objects and return a string (CSV contents)
-  # parse_csv: take in a string and return an array of OpenStruct objects
+  # parse_csv: take in a string and return an array of hashes
   class Template
-    class << self
-      def columns
-        @columns ||= []
-      end
+    extend Forwardable
+    extend ::Bumblebee::ColumnDsl
 
-      def column(field, opts = {})
-        columns << ::Bumblebee::Column.make(opts.merge(field: field))
+    def_delegators :column_set, :headers, :columns
 
-        self
-      end
+    attr_reader :object_class
 
-      def all_columns
-        ancestors.reverse_each.inject([]) do |arr, ancestor|
-          ancestor < ::Bumblebee::Template ? arr + ancestor.columns : arr
-        end
-      end
-    end
-
-    attr_reader :columns
+    def initialize(columns: nil, object_class: Hash, &block)
+      @column_set   = ::Bumblebee::ColumnSet.new(self.class.all_columns)
+      @object_class = object_class
 
-    def initialize(columns = [], &block)
-      @columns = self.class.all_columns + ::Bumblebee::Column.array(columns)
+      column_set.add(columns)
 
       return unless block_given?
 
@@ -44,43 +34,39 @@ module Bumblebee
       end
     end
 
-    # New DSL method to use for adding columns
-    def column(field, opts = {})
-      @columns << ::Bumblebee::Column.make(opts.merge(field: field))
-      self
-    end
+    def column(header, opts = {})
+      column_set.column(header, opts)
 
-    # Return array of strings (headers)
-    def headers
-      columns.map(&:header)
+      self
     end
 
-    def generate_csv(objects, options = {})
+    def generate(objects, options = {})
       objects = objects.is_a?(Hash) ? [objects] : Array(objects)
 
       write_options = options.merge(headers: headers, write_headers: true)
 
       CSV.generate(write_options) do |csv|
         objects.each do |object|
-          row = columns.map { |column| column.object_to_csv(object) }
-
-          csv << row
+          csv << columns.each_with_object({}) do |column, hash|
+            column.csv_set(object, hash)
+          end
         end
       end
     end
 
-    def parse_csv(string, options = {})
+    def parse(string, options = {})
       csv = CSV.new(string, options.merge(headers: true))
 
-      # Drop the first record, it is the header record
       csv.to_a.map do |row|
         # Build up a hash using the column one at a time
-        extracted_hash = columns.inject({}) do |hash, column|
-          hash.merge(column.csv_to_object(row))
+        columns.each_with_object(object_class.new) do |column, object|
+          column.object_set(row, object)
         end
-
-        extracted_hash
       end
     end
+
+    private
+
+    attr_reader :column_set
   end
 end

data/lib/bumblebee/version.rb

@@ -8,5 +8,5 @@
 #
 
 module Bumblebee
-  VERSION = '2.1.0'
+  VERSION = '3.0.0'
 end

data/spec/bumblebee/simple_converter_spec.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2018-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+require 'spec_helper'
+require './spec/examples/converter_test_case'
+
+describe ::Bumblebee::SimpleConverter do
+  describe '#convert' do
+    ConverterTestCase.all.each do |test_case|
+      it "should convert: #{test_case.arg}" do
+        converter = ::Bumblebee::SimpleConverter.new(test_case.arg)
+
+        test_case.convert_cases.each do |convert_case|
+          input = convert_case.first
+          output = convert_case.last
+
+          expect(converter.convert(input)).to eq(output)
+          expect(converter.convert(input).class).to eq(output.class)
+        end
+      end
+    end
+  end
+end

data/spec/bumblebee/template_spec.rb

@@ -8,65 +8,180 @@
 #
 
 require 'spec_helper'
+require 'examples/person_template'
+require 'examples/simple_object'
 
 describe ::Bumblebee::Template do
-  let(:field) { :id }
-  let(:opts) { { header: 'ID #' } }
+  describe 'array/string-based columns and symbol based object keys' do
+    let(:data_objects) { yaml_fixture('simple', 'data.yml').map(&:symbolize_keys) }
 
-  context 'with a blank template' do
-    let(:template) { ::Bumblebee::Template.new }
+    let(:csv_file) { fixture('simple', 'data.csv') }
 
-    subject { template }
+    let(:columns) { yaml_fixture('simple', 'columns.yml') }
 
-    it '#column should add a column' do
-      subject.column(field, opts)
+    subject { ::Bumblebee::Template.new(columns: columns) }
 
-      expect(subject.columns.length).to eq(1)
-      expect(subject.columns.first.field).to eq(field)
-      expect(subject.columns.first.header).to eq(opts[:header])
+    specify '#generate_csv properly builds a CSV-formatted string' do
+      actual = subject.generate(data_objects)
+
+      expect(actual).to eq(csv_file)
+    end
+
+    specify '#parse_csv properly builds objects' do
+      actual = subject.parse(csv_file)
+
+      actual = actual.map(&:symbolize_keys)
+
+      expect(actual).to eq(data_objects)
     end
   end
 
-  describe '#initialize' do
-    specify 'that initialization accepts a block (with arity) for column creation' do
-      template = ::Bumblebee::Template.new do |t|
-        t.column field, opts
-      end
+  describe 'array/string-based columns and OpenStruct objects' do
+    let(:data_objects) do
+      yaml_fixture('simple', 'data.yml').map { |h| OpenStruct.new(h.symbolize_keys) }
+    end
+
+    let(:csv_file) { fixture('simple', 'data.csv') }
 
-      expect(template.columns.length).to eq(1)
-      expect(template.columns.first.field).to eq(field)
-      expect(template.columns.first.header).to eq(opts[:header])
+    let(:columns) { yaml_fixture('simple', 'columns.yml') }
+
+    subject { ::Bumblebee::Template.new(columns: columns, object_class: OpenStruct) }
+
+    specify '#generate_csv properly builds a CSV-formatted string' do
+      actual = subject.generate(data_objects)
+
+      expect(actual).to eq(csv_file)
+    end
+
+    specify '#parse_csv properly builds objects' do
+      actual = subject.parse(csv_file)
+
+      expect(actual).to eq(data_objects)
     end
+  end
+
+  describe 'array/string-based columns and custom objects' do
+    let(:data_objects) do
+      yaml_fixture('simple', 'data.yml').map { |h| SimpleObject.new(h.symbolize_keys) }
+    end
+
+    let(:csv_file) { fixture('simple', 'data.csv') }
+
+    let(:columns) { yaml_fixture('simple', 'columns.yml') }
+
+    subject { ::Bumblebee::Template.new(columns: columns, object_class: SimpleObject) }
+
+    specify '#generate_csv properly builds a CSV-formatted string' do
+      actual = subject.generate(data_objects)
+
+      expect(actual).to eq(csv_file)
+    end
+
+    specify '#parse_csv properly builds objects' do
+      actual = subject.parse(csv_file)
+
+      expect(actual).to eq(data_objects)
+    end
+  end
+
+  describe 'config-based columns' do
+    let(:data_objects) { yaml_fixture('registrations', 'data.yml') }
+
+    let(:csv_file) { fixture('registrations', 'data.csv') }
+
+    let(:columns) { yaml_fixture('registrations', 'columns.yml') }
+
+    subject { ::Bumblebee::Template.new(columns: columns) }
 
-    specify 'that initialization accepts a block (without arity) for column creation' do
-      template = ::Bumblebee::Template.new do
-        column :id, header: 'ID #'
+    specify '#generate_csv properly builds a CSV-formatted string' do
+      actual = subject.generate(data_objects)
+
+      expect(actual).to eq(csv_file)
+    end
+
+    specify '#parse_csv properly builds objects' do
+      actual = subject.parse(csv_file)
+
+      expect(actual).to eq(data_objects)
+    end
+  end
+
+  describe 'block-based (with local context) columns' do
+    let(:data_objects) { yaml_fixture('registrations', 'data.yml') }
+
+    let(:csv_file) { fixture('registrations', 'data.csv') }
+
+    let(:columns) { yaml_fixture('registrations', 'columns.yml') }
+
+    subject do
+      ::Bumblebee::Template.new do |t|
+        columns.each do |header, opts|
+          t.column(header, opts)
+        end
       end
+    end
+
+    specify '#generate_csv properly builds a CSV-formatted string' do
+      actual = subject.generate(data_objects)
+
+      expect(actual).to eq(csv_file)
+    end
+
+    specify '#parse_csv properly builds objects' do
+      actual = subject.parse(csv_file)
 
-      expect(template.columns.length).to eq(1)
-      expect(template.columns.first.field).to eq(field)
-      expect(template.columns.first.header).to eq(opts[:header])
+      expect(actual).to eq(data_objects)
     end
   end
 
-  describe 'subclassing' do
-    class PersonTemplate < ::Bumblebee::Template
-      column :id, header: 'ID #'
+  describe 'block-based (without local context) columns' do
+    let(:data_objects) { yaml_fixture('registrations', 'data.yml') }
+
+    let(:csv_file) { fixture('registrations', 'data.csv') }
+
+    subject do
+      ::Bumblebee::Template.new do
+        columns = yaml_fixture('registrations', 'columns.yml')
+        columns.each do |header, opts|
+          column(header, opts)
+        end
+      end
+    end
+
+    specify '#generate_csv properly builds a CSV-formatted string' do
+      actual = subject.generate(data_objects)
+
+      expect(actual).to eq(csv_file)
     end
 
-    class CompletePersonTemplate < PersonTemplate
-      column :first, header: 'First Name'
+    specify '#parse_csv properly builds objects' do
+      actual = subject.parse(csv_file)
+
+      expect(actual).to eq(data_objects)
+    end
+  end
+
+  describe 'class-based columns' do
+    let(:data_objects) { yaml_fixture('people', 'data.yml') }
+
+    let(:csv_file) { fixture('people', 'data.csv') }
+
+    subject { PersonTemplate.new }
+
+    specify '#generate_csv properly builds a CSV-formatted string' do
+      template = PersonTemplate.new
+
+      actual = template.generate(data_objects)
+
+      expect(actual).to eq(csv_file)
     end
 
-    it 'should use class-level declared columns in the correct parenting hierarchical order' do
-      template = CompletePersonTemplate.new
+    specify '#parse_csv properly builds objects' do
+      template = PersonTemplate.new
 
-      expect(template.columns.length).to eq(2)
-      expect(template.columns.first.field).to eq(:id)
-      expect(template.columns.first.header).to eq('ID #')
+      actual = template.parse(csv_file)
 
-      expect(template.columns.last.field).to eq(:first)
-      expect(template.columns.last.header).to eq('First Name')
+      expect(actual).to eq(data_objects)
     end
   end
 end