bumblebee 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 981b25ba3c2fc7438e3c0207297a6e084ae70f30
+  data.tar.gz: f96a80682fdd1533f8ea017f72696bb8f47750b6
+SHA512:
+  metadata.gz: 92fdf21e7dbaadc2e9836e07de7cfa9e9113ff94ecb74756ecd0ce97b99bde0eb599764df2306f2e36813e0706acec923441ec4491ce19e43fc69c95040c083c
+  data.tar.gz: 27e2f192458decd10ca7834245bbcf9f913fc850d9ac9161c4346d78deb671ae6e5cff377a832758de9e26520fc4ccaad149470f3eb9624725541ee79c236496

data/.editorconfig

@@ -0,0 +1,8 @@
+# See http://editorconfig.org/
+
+[*]
+trim_trailing_whitespace = true
+indent_style = space
+indent_size = 2
+insert_final_newline = true
+end_of_line = lf

data/.gitignore

@@ -0,0 +1,3 @@
+.DS_Store
+*.gem
+/tmp

data/.rubocop.yml

@@ -0,0 +1,8 @@
+Metrics/LineLength:
+  Max: 100
+
+Metrics/BlockLength:
+  ExcludedMethods: ['it', 'describe', 'context']
+
+Metrics/MethodLength:
+  Max: 12

data/.ruby-version

@@ -0,0 +1 @@
+2.3.7

data/.travis.yml

@@ -0,0 +1,12 @@
+language: ruby
+rvm:
+- 2.3.1
+- 2.3.7
+cache: bundler
+script:
+- bundle exec rubocop
+- bundle exec rspec
+notifications:
+  hipchat:
+    rooms:
+      secure: i6oRaPbul9by4YkFdGOROctO6Clgsn1Q5eTrHGn9SJeKtOtBm79ezCS3w0UBLKGcE1Cso3gMNUjzMmi/i2je9rUUIZFXUaT3COyh1LLHlPU4y6j3ZQReWb/m43AEKL0akW6eiAUnmddc96WyTL6x5zplqHKweZs/kHutAor36x+sPTNumHm5yM795HVFlmUqpLnJu3OAIEC+1EhIHxX6xG5lOveAQ7/8KnyIRJWFQI2sHwZUPyD2YM6o+kYzGTfiXixpuG7sbyN17+u3YuQc8kPWgXkk/5+VF7B0OIuEymm9rnnisGxIU0B3nrDESumdNnhbSMGrItgsmhssICZ1Dr1pa3uBr2CFT3ZbQszuQvPfq1Pavytw5+jTjAqqhq2DQCXQRZT16Mnu1eFvHyu9yWeqFECJGQ8ligDcsckvQe2GU432dAt6Dj6zEnL4CsOi/NhaGkfW+b1hnD2L9LjCV3TGoT1YHuBxP2gxd2mN7ihCaPtaXMwojhzmPClqbdxmu/v8aZv7nF9SiYzXOMG/Hj5/wtQA6dE64LufQIkn2XYxDWeh7pnjye1u0np9LHp0Qw0R8KT8uGm7kL6BRUaN2xynl6O13r8juRk2xDHGry6tse8+/zooOZkB84akZZunKGki9jh1APjza0tylTr0C139N1/VAyeB4cA+GFFRWxY=

data/Gemfile

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,89 @@
+PATH
+  remote: .
+  specs:
+    bumblebee (1.0.0)
+      acts_as_hashable (~> 1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    acts_as_hashable (1.0.3)
+    ast (2.4.0)
+    coderay (1.1.2)
+    diff-lcs (1.3)
+    ffi (1.9.25)
+    formatador (0.2.5)
+    guard (2.15.0)
+      formatador (>= 0.2.4)
+      listen (>= 2.7, < 4.0)
+      lumberjack (>= 1.0.12, < 2.0)
+      nenv (~> 0.1)
+      notiffany (~> 0.0)
+      pry (>= 0.9.12)
+      shellany (~> 0.0)
+      thor (>= 0.18.1)
+    guard-compat (1.2.1)
+    guard-rspec (4.7.3)
+      guard (~> 2.1)
+      guard-compat (~> 1.1)
+      rspec (>= 2.99.0, < 4.0)
+    jaro_winkler (1.5.1)
+    listen (3.1.5)
+      rb-fsevent (~> 0.9, >= 0.9.4)
+      rb-inotify (~> 0.9, >= 0.9.7)
+      ruby_dep (~> 1.2)
+    lumberjack (1.0.13)
+    method_source (0.9.2)
+    nenv (0.3.0)
+    notiffany (0.1.1)
+      nenv (~> 0.1)
+      shellany (~> 0.0)
+    parallel (1.12.1)
+    parser (2.5.3.0)
+      ast (~> 2.4.0)
+    powerpack (0.1.2)
+    pry (0.12.2)
+      coderay (~> 1.1.0)
+      method_source (~> 0.9.0)
+    rainbow (3.0.0)
+    rb-fsevent (0.10.3)
+    rb-inotify (0.9.10)
+      ffi (>= 0.5.0, < 2)
+    rspec (3.8.0)
+      rspec-core (~> 3.8.0)
+      rspec-expectations (~> 3.8.0)
+      rspec-mocks (~> 3.8.0)
+    rspec-core (3.8.0)
+      rspec-support (~> 3.8.0)
+    rspec-expectations (3.8.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-mocks (3.8.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-support (3.8.0)
+    rubocop (0.59.2)
+      jaro_winkler (~> 1.5.1)
+      parallel (~> 1.10)
+      parser (>= 2.5, != 2.5.1.1)
+      powerpack (~> 0.1)
+      rainbow (>= 2.2.2, < 4.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (~> 1.0, >= 1.0.1)
+    ruby-progressbar (1.10.0)
+    ruby_dep (1.5.0)
+    shellany (0.0.1)
+    thor (0.20.3)
+    unicode-display_width (1.4.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bumblebee!
+  guard-rspec (~> 4.7)
+  rspec (~> 3.8)
+  rubocop (~> 0.59)
+
+BUNDLED WITH
+   1.17.1

data/Guardfile

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+guard :rspec, cmd: 'bundle exec rspec' do
+  require 'guard/rspec/dsl'
+  dsl = Guard::RSpec::Dsl.new(self)
+
+  # RSpec files
+  rspec = dsl.rspec
+  watch(rspec.spec_helper) { rspec.spec_dir }
+  watch(rspec.spec_support) { rspec.spec_dir }
+  watch(rspec.spec_files)
+
+  # Ruby files
+  ruby = dsl.ruby
+  dsl.watch_spec_files_for(ruby.lib_files)
+end

data/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2018 Blue Marble Payroll, LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,220 @@
+# Bumblebee
+
+[![Build Status](https://travis-ci.org/bluemarblepayroll/bumblebee.svg?branch=master)](https://travis-ci.org/bluemarblepayroll/bumblebee)
+
+Higher level languages, such as Ruby, make interacting with CSVs trivial. Even so, this library provides a very simple object/csv mapper that allows you to fully interact with CSVs in a declarative way.  Locking in common patterns, even in higher level languages, is important in large codebases.  Using a library such as this will help ensure standardization around CSV interaction.
+
+There are situations where this may not be appropriate.  This library is not meant to be extremely performant given large files and/or datasets.  This library shines with CSV and/or data-sets of less than 100,000 records (approx.)
+
+## Installation
+
+To install through Rubygems:
+
+````
+gem install install bumblebee
+````
+
+You can also add this to your Gemfile:
+
+````
+bundle add bumblebee
+````
+
+## Examples
+
+### A Simple 1:1 Example
+
+Imagine the following CSV:
+
+id | name | dob        | phone
+-- | ---- | ---------- | ------------
+1  | Matt | 1901-02-03 | 555-555-5555
+2  | Nick | 1921-09-03 | 444-444-4444
+3  | Sam  | 1932-12-12 | 333-333-3333
+
+Using the following column configuration:
+
+````
+columns = [
+  { field: :id },
+  { field: :name },
+  { field: :dob },
+  { field: :phone }
+]
+````
+
+We could parse this data and turn it into hashes:
+
+````
+objects = ::Bumblebee.parse_csv(columns, data)
+````
+
+*Note: Data, in this case, would be the read CSV file contents in string format.*
+
+The variable `objects` would now be an array of hash objects.
+
+### Custom Headers
+
+If our headers are not a perfect 1:1 match to our object, such as:
+
+ID # | First Name | Date of Birth | Phone #
+---- | ---------- | ------------- | ------------
+1    | Matt       | 1901-02-03    | 555-555-5555
+2    | Nick       | 1921-09-03    | 444-444-4444
+3    | Sam        | 1932-12-12    | 333-333-3333
+
+Then we can explicitly map those as:
+
+````
+columns = [
+  { field: :id,     header: 'ID #' },
+  { field: :name,   header: 'First Name' },
+  { field: :dob,    header: 'Date of Birth' },
+  { field: :phone,  header: 'Phone #' }
+]
+````
+
+### Nested Objects
+
+Let's say we have the following data which we want to create a CSV from:
+
+````
+objects = [
+  {
+    id: 1,
+    name:     { first: 'Matt' },
+    demo:     { dob: '1901-02-03' },
+    contact:  { phone: '555-555-5555' }
+  },
+  {
+    id: 2,
+    name:     { first: 'Nick' },
+    demo:     { dob: '1921-09-03' },
+    contact:  { phone: '444-444-4444' }
+  },
+  {
+    id: 3,
+    name:     { first: 'Sam' },   
+    demo:     { dob: '1932-12-12' },
+    contact:  { phone: '333-333-3333' }
+  }
+]
+````
+
+We could create a flat-file CSV:
+
+ID # | First Name | Date of Birth | Phone #
+---- | ---------- | ------------- | ------------
+1    | Matt       | 1901-02-03    | 555-555-5555
+2    | Nick       | 1921-09-03    | 444-444-4444
+3    | Sam        | 1932-12-12    | 333-333-3333
+
+Using the following column config:
+
+````
+columns = [
+  { field: :id,                 header: 'ID #' },
+  { field: [:name, :first],     header: 'First Name' },
+  { field: [:demo, :dob],       header: 'Date of Birth' },
+  { field: [:contact, :phone],  header: 'Phone #' }
+]
+````
+
+And executing the following:
+
+````
+csv = ::Bumblebee.generate_csv(columns, objects)
+````
+
+The above columns config would work both ways, so if we received the CSV, we could parse it to an array of nested hashes.  Unfortunately, for now, we cannot do better than an array of nested hashes.
+
+### Custom Formatting
+
+You can also pass in functions that can do the value formatting.  For example:
+
+````
+columns = [
+  {
+    field: :id,
+    header: 'ID #'
+  },
+  {
+    field: :name,   
+    header: 'First Name',     
+    to_csv: [:name, :first, ->(o) { o.to_s.upcase }]
+  },
+  {
+    field: :dob,    
+    header: 'Date of Birth',  
+    to_csv: [:demo, :dob]
+  },
+  {
+    field: :phone,  
+    header: 'Phone #',        
+    to_csv: [:contact, :phone]
+  }
+]
+````
+
+would ensure the CSV has only upper-case `First Name` values.
+
+#### Further CSV Customization
+
+The two main methods:
+
+* generate_csv
+* parse_csv
+
+also accept custom options that [Ruby's CSV::new](https://ruby-doc.org/stdlib-2.6/libdoc/csv/rdoc/CSV.html#method-c-new) accepts.  The only caveat is that Bumblebee needs headers for its mapping, so it overrides the header options.
+
+## Contributing
+
+### Development Environment Configuration
+
+Basic steps to take to get this repository compiling:
+
+1. Install [Ruby](https://www.ruby-lang.org/en/documentation/installation/) (check bumblebee.gemspec for versions supported)
+2. Install bundler (gem install bundler)
+3. Clone the repository (git clone git@github.com:bluemarblepayroll/bumblebee.git)
+4. Navigate to the root folder (cd bumblebee)
+5. Install dependencies (bundle)
+
+### Running Tests
+
+To execute the test suite run:
+
+````
+bundle exec rspec spec --format documentation
+````
+
+Alternatively, you can have Guard watch for changes:
+
+````
+bundle exec guard
+````
+
+Also, do not forget to run Rubocop:
+
+````
+bundle exec rubocop
+````
+
+### Publishing
+
+Note: ensure you have proper authorization before trying to publish new versions.
+
+After code changes have successfully gone through the Pull Request review process then the following steps should be followed for publishing new versions:
+
+1. Merge Pull Request into master
+2. Update [lib/bumblebee/version.rb](https://github.com/bluemarblepayroll/bumblebee/blob/master/lib/bumblebee/version.rb) [version number](https://semver.org/)
+3. Bundle
+4. Update CHANGELOG.md
+5. Commit & Push master to remote and ensure CI builds master successfully
+6. Build the project locally: `gem build bumblebee`
+7. Publish package to NPM: `gem push bumblebee-X.gem` where X is the version to push
+8. Tag master with new version: `git tag <version>`
+9. Push tags remotely: `git push origin --tags`
+
+## License
+
+This project is MIT Licensed.

data/bumblebee.gemspec

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require './lib/bumblebee/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'bumblebee'
+  s.version     = Bumblebee::VERSION
+  s.summary     = 'Object/CSV Mapper'
+
+  s.description = <<-DESCRIPTION
+    Higher level languages, such as Ruby, make interacting with CSVs trivial.
+    Even so, this library provides a very simple object/csv mapper that allows you to fully interact with CSVs in a declarative way.
+  DESCRIPTION
+
+  s.authors     = ['Matthew Ruggio']
+  s.email       = ['mruggio@bluemarblepayroll.com']
+  s.files       = `git ls-files`.split("\n")
+  s.test_files  = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
+  s.homepage    = 'https://github.com/bluemarblepayroll/bumblebee'
+  s.license     = 'MIT'
+
+  s.required_ruby_version = '>= 2.3.1'
+
+  s.add_dependency('acts_as_hashable', '~>1.0')
+
+  s.add_development_dependency('guard-rspec', '~>4.7')
+  s.add_development_dependency('rspec', '~> 3.8')
+  s.add_development_dependency('rubocop', '~> 0.59')
+end

data/lib/bumblebee/bumblebee.rb

@@ -0,0 +1,30 @@
+# 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 'csv'
+require 'acts_as_hashable'
+require 'ostruct'
+
+require_relative 'column'
+require_relative 'template'
+
+# The top-level module provides the two main methods for convenience.
+# You can also consume these in a more OOP way using the Template class or a more
+# procedural way using these.
+module Bumblebee
+  class << self
+    def generate_csv(columns, objects, options = {})
+      ::Bumblebee::Template.new(columns).generate_csv(objects, options)
+    end
+
+    def parse_csv(columns, string, options = {})
+      ::Bumblebee::Template.new(columns).parse_csv(string, options)
+    end
+  end
+end

data/lib/bumblebee/column.rb

@@ -0,0 +1,96 @@
+# 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
+  # This is main piece of logic that defines a column which can go from objects to csv cell values
+  # and csv rows to objects.
+  class Column
+    acts_as_hashable
+
+    attr_reader :field,
+                :to_object,
+                :header,
+                :to_csv
+
+    def initialize(field:, header: nil, to_csv: nil, to_object: nil)
+      raise ArgumentError, 'field is required' unless field
+
+      @field      = field
+      @header     = make_header(header || field)
+      @to_csv     = Array(to_csv || field)
+      @to_object  = Array(to_object || field)
+    end
+
+    # Take a object and convert to a value.
+    def object_to_csv(object)
+      val = object
+
+      # Iterate over keys until we reach a nil or the end of keys.
+      to_csv.each do |f|
+        # short-circuit out of the extract method
+        return nil unless val
+
+        val = single_extract(val, f)
+      end
+
+      val
+    end
+
+    def csv_to_object(csv_hash)
+      return nil unless csv_hash
+
+      value   = csv_hash[header]
+      pointer = hash = {}
+
+      to_object[0..-2].each do |f|
+        if f.is_a?(Proc)
+          value = f.call(value)
+        else
+          pointer = pointer[f] = {}
+        end
+      end
+
+      pointer[to_object[-1]] = value
+
+      hash
+    end
+
+    private
+
+    # Loop through all values, contcatenating their string equivalent with an underscore.
+    # Since we allow procs, but we want deterministic headers, we will simply transform
+    # theem to _proc_.  This is not perfect and could create naming clashes, but it really
+    # should not be.  You should really leave proc's out of header and field.
+    def make_header(value)
+      Array(value).map do |v|
+        if v.is_a?(Proc)
+          'proc'
+        else
+          v.to_s
+        end
+      end.join('_')
+    end
+
+    # Take an object and attempt to extract a value from it.
+    # First, see if the key is a proc, if so, then delegate to the proc.
+    # Next, see if the object responds to the key, if so, then call it.
+    # Lastly, see if it responds to brackets, if so, then call the brackets method sending
+    # in the key.
+    # Finally if all else fails, return nil.
+    def single_extract(object, key)
+      if key.is_a?(Proc)
+        key.call(object)
+      elsif object.respond_to?(key)
+        object.send(key)
+      elsif object.respond_to?(:[])
+        object[key]
+      end
+    end
+  end
+end

data/lib/bumblebee/template.rb

@@ -0,0 +1,58 @@
+# 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
+  # 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
+  class Template
+    attr_reader :columns
+
+    def initialize(columns = [])
+      @columns = ::Bumblebee::Column.array(columns)
+    end
+
+    # Return array of strings (headers)
+    def headers
+      columns.map(&:header)
+    end
+
+    def generate_csv(objects, options = {})
+      objects = objects.is_a?(Hash) ? [objects] : Array(objects)
+
+      CSV.generate(make_options(options)) do |csv|
+        objects.each do |object|
+          row = columns.map { |column| column.object_to_csv(object) }
+
+          csv << row
+        end
+      end
+    end
+
+    def parse_csv(string, options = {})
+      csv = CSV.new(string, make_options(options))
+
+      # Drop the first record, it is the header record
+      csv.to_a[1..-1].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))
+        end
+
+        extracted_hash
+      end
+    end
+
+    private
+
+    def make_options(options = {})
+      options.merge(headers: headers, write_headers: true)
+    end
+  end
+end

data/lib/bumblebee/version.rb

@@ -0,0 +1,12 @@
+# 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
+  VERSION = '1.0.0'
+end

data/lib/bumblebee.rb

@@ -0,0 +1,10 @@
+# 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_relative 'bumblebee/bumblebee'

data/spec/bumblebee/bumblebee_spec.rb

@@ -0,0 +1,52 @@
+# 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/spec_helper'
+
+describe ::Bumblebee do
+  let(:columns) do
+    [
+      { field: :name },
+      { field: :dob }
+    ]
+  end
+
+  let(:people) do
+    [
+      { name: 'Matt', dob: '1901-01-03' },
+      { name: 'Nathan', dob: '1931-09-03' }
+    ]
+  end
+
+  let(:csv) { "name,dob\nMatt,1901-01-03\nNathan,1931-09-03\n" }
+
+  let(:quoted_csv) { "\"name\",\"dob\"\n\"Matt\",\"1901-01-03\"\n\"Nathan\",\"1931-09-03\"\n" }
+
+  it 'should generate a csv' do
+    actual = ::Bumblebee.generate_csv(columns, people)
+
+    expect(actual).to eq(csv)
+  end
+
+  it 'should generate a csv and accept options' do
+    options = {
+      force_quotes: true
+    }
+
+    actual = ::Bumblebee.generate_csv(columns, people, options)
+
+    expect(actual).to eq(quoted_csv)
+  end
+
+  it 'should parse a csv' do
+    objects = ::Bumblebee.parse_csv(columns, csv)
+
+    expect(objects).to eq(people)
+  end
+end

data/spec/bumblebee/column_spec.rb

@@ -0,0 +1,187 @@
+# 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'
+
+describe ::Bumblebee::Column do
+  let(:object) do
+    OpenStruct.new(
+      name: 'Mattycakes',
+      dob: '1921-01-02',
+      pizza: 'Pepperoni',
+      license: OpenStruct.new(id: '123456')
+    )
+  end
+
+  let(:hash) do
+    {
+      name: 'Mattycakes',
+      dob: '1921-01-02',
+      pizza: 'Pepperoni',
+      license:  { id: '123456' }
+    }
+  end
+
+  describe 'initialization' do
+    it 'should error if field is nil' do
+      expect { ::Bumblebee::Column.new(field: nil) }.to raise_error(ArgumentError)
+    end
+
+    it 'should initialize with just a field' do
+      field = :name
+
+      column = ::Bumblebee::Column.new(field: field)
+
+      expect(column.field).to     eq(field)
+      expect(column.header).to    eq(field.to_s)
+      expect(column.to_csv).to    eq([field])
+      expect(column.to_object).to  eq([field])
+    end
+
+    describe 'header computation' do
+      it 'should compute from single field' do
+        field = :name
+
+        column = ::Bumblebee::Column.new(field: field)
+
+        expect(column.header).to eq(field.to_s)
+      end
+
+      it 'should compute from multiple fields' do
+        field = [:name, 'is', :too, 22.4]
+
+        column = ::Bumblebee::Column.new(field: field)
+
+        expect(column.header).to eq(field.map(&:to_s).join('_'))
+      end
+
+      it 'should compute from a lambda literal' do
+        column = ::Bumblebee::Column.new(field: ->(o) {})
+        expect(column.header).to eq('proc')
+      end
+
+      it 'should compute from a proc' do
+        column = ::Bumblebee::Column.new(field: proc {})
+        expect(column.header).to eq('proc')
+      end
+    end
+  end
+
+  describe '#csv_to_object' do
+    it 'should correctly extract the value using field' do
+      record = {
+        'name' => 'Nathan'
+      }
+
+      column = ::Bumblebee::Column.new(field: 'name')
+
+      expect(column.csv_to_object(record)).to eq(record)
+    end
+
+    it 'should correctly extract the value using header' do
+      csv_row = {
+        'First Name' => 'Nathan'
+      }
+
+      record = {
+        'name' => 'Nathan'
+      }
+
+      column = ::Bumblebee::Column.new(field: 'name', header: 'First Name')
+
+      expect(column.csv_to_object(csv_row)).to eq(record)
+    end
+
+    it 'should correctly extract the value using custom from_csv value' do
+      csv_row = {
+        'First Name' => 'Nathan'
+      }
+
+      record = {
+        'First' => 'Nathan'
+      }
+
+      column = ::Bumblebee::Column.new(
+        field:      'name',
+        header:     'First Name',
+        to_object:  'First'
+      )
+
+      expect(column.csv_to_object(csv_row)).to eq(record)
+    end
+  end
+
+  describe '#object_to_csv' do
+    context 'using field' do
+      context 'for single values' do
+        it 'should get csv value correctly' do
+          column = ::Bumblebee::Column.new(field: :name)
+
+          expect(column.object_to_csv(object)).to eq(object.name)
+          expect(column.object_to_csv(hash)).to   eq(hash[:name])
+        end
+
+        it 'should return nil when does not exist' do
+          column = ::Bumblebee::Column.new(field: :doesnt_exist)
+
+          expect(column.object_to_csv(object)).to eq(nil)
+          expect(column.object_to_csv(hash)).to   eq(nil)
+        end
+      end
+
+      context 'for arrays' do
+        it 'should get csv value correctly' do
+          column = ::Bumblebee::Column.new(field: %i[license id])
+
+          expect(column.object_to_csv(object)).to eq(object.license.id)
+          expect(column.object_to_csv(hash)).to   eq(hash[:license][:id])
+        end
+
+        it 'should return nil when it hits dead end at beginning' do
+          column = ::Bumblebee::Column.new(field: %i[something that does not exist])
+
+          expect(column.object_to_csv(object)).to eq(nil)
+          expect(column.object_to_csv(hash)).to   eq(nil)
+        end
+
+        it 'should return nil when it hits dead end in middle' do
+          column = ::Bumblebee::Column.new(field: %i[license doesnt_exist here])
+
+          expect(column.object_to_csv(object)).to eq(nil)
+          expect(column.object_to_csv(hash)).to   eq(nil)
+        end
+      end
+
+      context 'when mixing in procs' do
+        it 'should get csv value correctly when proc runs against end value' do
+          column = ::Bumblebee::Column.new(field: [:license, :id, ->(o) { "# #{o}" }])
+
+          expect(column.object_to_csv(object)).to eq("# #{object.license.id}")
+          expect(column.object_to_csv(hash)).to   eq("# #{hash[:license][:id]}")
+        end
+
+        it 'should get csv value correctly when proc runs against object-based value' do
+          column = ::Bumblebee::Column.new(field: [:license, ->(o) { "# #{o.id}" }])
+          expect(column.object_to_csv(object)).to eq("# #{object.license.id}")
+
+          column = ::Bumblebee::Column.new(field: [:license, ->(o) { "# #{o[:id]}" }])
+          expect(column.object_to_csv(hash)).to   eq("# #{hash[:license][:id]}")
+        end
+
+        it 'should not hit proc if ran against nil' do
+          column = ::Bumblebee::Column.new(field: [:doesnt_exist, ->(o) { "# #{o.id}" }])
+          expect(column.object_to_csv(object)).to eq(nil)
+
+          column = ::Bumblebee::Column.new(field: [:doesnt_exist, ->(o) { "# #{o[:id]}" }])
+          expect(column.object_to_csv(hash)).to eq(nil)
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+# 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 './lib/bumblebee'

metadata

@@ -0,0 +1,125 @@
+--- !ruby/object:Gem::Specification
+name: bumblebee
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Matthew Ruggio
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-12-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: acts_as_hashable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.7'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.8'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.59'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.59'
+description: |2
+      Higher level languages, such as Ruby, make interacting with CSVs trivial.
+      Even so, this library provides a very simple object/csv mapper that allows you to fully interact with CSVs in a declarative way.
+email:
+- mruggio@bluemarblepayroll.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".editorconfig"
+- ".gitignore"
+- ".rubocop.yml"
+- ".ruby-version"
+- ".travis.yml"
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- Guardfile
+- LICENSE
+- README.md
+- bumblebee.gemspec
+- lib/bumblebee.rb
+- lib/bumblebee/bumblebee.rb
+- lib/bumblebee/column.rb
+- lib/bumblebee/template.rb
+- lib/bumblebee/version.rb
+- spec/bumblebee/bumblebee_spec.rb
+- spec/bumblebee/column_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/bluemarblepayroll/bumblebee
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.1
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.2.3
+signing_key: 
+specification_version: 4
+summary: Object/CSV Mapper
+test_files:
+- spec/bumblebee/bumblebee_spec.rb
+- spec/bumblebee/column_spec.rb
+- spec/spec_helper.rb