morfo 0.3.0 → 0.4.0

data/lib/morfo/tools.rb

@@ -0,0 +1,34 @@
+module Morfo
+  module Tools
+    class FlattenHashKeys
+      attr_reader :input_hash
+
+      def initialize(input_hash)
+        @input_hash = input_hash.dup.freeze
+      end
+
+      def flatten
+        input_hash.inject({}) do |result_hash, (key, value)|
+          inner_hash = false
+          if value.is_a?(Hash)
+            inner_hash = true
+            value.each do |inner_key, inner_value|
+              if inner_value.is_a?(Hash)
+                inner_hash = true
+              end
+              result_hash.merge!("#{key}.#{inner_key}".to_sym => inner_value)
+            end
+          else
+            result_hash.merge!(key.to_sym => value)
+          end
+
+          if inner_hash
+            FlattenHashKeys.new(result_hash).flatten
+          else
+            result_hash
+          end
+        end
+      end
+    end
+  end
+end

data/lib/morfo/version.rb

@@ -1,3 +1,3 @@
 module Morfo
-  VERSION = '0.3.0'
+  VERSION = "0.4.0"
 end

data/morfo.gemspec

@@ -1,27 +1,28 @@
 # coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
+lib = File.expand_path("../lib", __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'morfo/version'
+require "morfo/version"
 
 Gem::Specification.new do |spec|
-  spec.name          = 'morfo'
+  spec.name          = "morfo"
   spec.version       = Morfo::VERSION
-  spec.authors       = ['Leif Gensert']
-  spec.email         = ['leif@propertybase.com']
+  spec.authors       = ["Leif Gensert"]
+  spec.email         = ["leif@propertybase.com"]
   spec.description   = %q{This gem provides a DSL for converting one hash into another}
   spec.summary       = %q{Inspired by ActiveImporter, this gem generically converts an array of hashes}
-  spec.homepage      = ''
-  spec.license       = 'MIT'
+  spec.homepage      = ""
+  spec.license       = "MIT"
 
   spec.files         = `git ls-files`.split($/)
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = ['lib']
+  spec.require_paths = ["lib"]
 
-  spec.add_dependency 'rake'
-  spec.add_dependency 'json'
-  spec.add_dependency 'rubysl' if RUBY_ENGINE == 'rbx'
+  spec.add_dependency "rake"
+  spec.add_dependency "json"
+  spec.add_dependency "activesupport", ">= 3.2"
+  spec.add_dependency "rubysl" if RUBY_ENGINE == "rbx"
 
-  spec.add_development_dependency 'bundler', '~> 1.3'
-  spec.add_development_dependency 'rspec', '>= 2.14', '< 4.0'
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rspec", ">= 2.14", "< 4.0"
 end

data/spec/lib/morfo/builder_spec.rb

@@ -0,0 +1,114 @@
+require "spec_helper"
+
+describe Morfo::Builder do
+  describe "#build" do
+    subject { described_class.new(definitions) }
+
+    let(:definitions) do
+      [
+        {
+          field: :tv_show_title,
+          from: :title,
+        }
+      ]
+    end
+
+    let(:morfer) { subject.build }
+
+    it "has a morf method" do
+      expect(morfer).to respond_to(:morf)
+    end
+
+    it "has a morf_single method" do
+      expect(morfer).to respond_to(:morf_single)
+    end
+  end
+
+  context "on the fly morfers" do
+    subject { described_class.new(definitions).build }
+
+    it_behaves_like "a 1 to 1 morfer" do
+      let(:definitions) do
+        [
+          { field: :tv_show_title, from: :title }
+        ]
+      end
+    end
+
+    it_behaves_like "a 1 to many morfer" do
+      let(:definitions) do
+        [
+          { field: :title, from: :title },
+          { field: :also_title, from: :title },
+        ]
+      end
+    end
+
+    it_behaves_like "a static morfer" do
+      let(:definitions) do
+        [
+          { field: :new_title, calculated: "Static Title" },
+        ]
+      end
+    end
+
+    it_behaves_like "a calculating morfer" do
+      let(:definitions) do
+        [
+          { field: :title_with_channel, calculated: "%{title}, (%{channel})" },
+        ]
+      end
+    end
+
+    it_behaves_like "a 1 to 1 morfer with transformation" do
+      let(:definitions) do
+        [
+          { field: :title, from: :title, transformed: "%{value} and Zombies" }
+        ]
+      end
+    end
+
+    it_behaves_like "a morfer with nested source" do
+      subject(:valid_path) do
+        described_class.new(
+          [
+            { field: :rating, from: [:ratings, :imdb] }
+          ]
+        ).build
+      end
+
+      subject(:valid_path_with_transformation) do
+        described_class.new(
+          [
+            { field: :rating, from: [:ratings, :imdb], transformed: "Rating: %{value}" }
+          ]
+        ).build
+      end
+
+      subject(:valid_path_with_calculation) do
+        described_class.new(
+          [
+            { field: :ratings, calculated: "IMDB: %{ratings.imdb}, Trakt: %{ratings.trakt}, Rotten Tommatoes: %{ratings.rotten_tomatoes}" }
+          ]
+        ).build
+      end
+
+      subject(:invalid_path) do
+        described_class.new(
+          [
+            { field: :rating, from: [:very, :long, :path, :that, :might, :not, :exist] }
+          ]
+        ).build
+      end
+    end
+
+    it_behaves_like "a morfer with nested destination" do
+      let(:definitions) do
+        [
+          { field: [:tv_show, :title], from: :title },
+          { field: [:tv_show, :channel], from: :channel, transformed: "Channel: %{value}" },
+        ]
+      end
+    end
+  end
+end

data/spec/lib/morfo/tools_spec.rb

@@ -0,0 +1,91 @@
+require "spec_helper"
+
+module Morfo
+  module Tools
+    describe FlattenHashKeys do
+      subject { described_class.new(input_hash) }
+
+      context "symbol keys" do
+        context "flat hash" do
+          let(:input_hash) { { simple: :hash } }
+          let(:expected_output) { { simple: :hash } }
+
+          it "returns a new hash" do
+            expect(subject.flatten).not_to be(input_hash)
+          end
+
+          it "returns the correct hash" do
+            expect(subject.flatten).to eq(expected_output)
+          end
+        end
+
+        context "single nested hash" do
+          let(:input_hash) { { a: { nested: :hash } } }
+          let(:expected_output) { { :"a.nested" => :hash } }
+
+          it "returns a new hash" do
+            expect(subject.flatten).not_to be(input_hash)
+          end
+
+          it "returns the correct hash" do
+            expect(subject.flatten).to eq(expected_output)
+          end
+        end
+
+        context "multiple nested hash" do
+          let(:input_hash) { { a: { deeper: { nested: :hash } } } }
+          let(:expected_output) { { :"a.deeper.nested" => :hash } }
+
+          it "returns a new hash" do
+            expect(subject.flatten).not_to be(input_hash)
+          end
+
+          it "returns the correct hash" do
+            expect(subject.flatten).to eq(expected_output)
+          end
+        end
+      end
+
+      context "string keys" do
+        context "flat hash" do
+          let(:input_hash) { { "simple" => :hash } }
+          let(:expected_output) { { simple: :hash } }
+
+          it "returns a new hash" do
+            expect(subject.flatten).not_to be(input_hash)
+          end
+
+          it "returns the correct hash" do
+            expect(subject.flatten).to eq(expected_output)
+          end
+        end
+
+        context "single nested hash" do
+          let(:input_hash) { { "a" => { "nested" => :hash } } }
+          let(:expected_output) { { :"a.nested" => :hash } }
+
+          it "returns a new hash" do
+            expect(subject.flatten).not_to be(input_hash)
+          end
+
+          it "returns the correct hash" do
+            expect(subject.flatten).to eq(expected_output)
+          end
+        end
+
+        context "multiple nested hash" do
+          let(:input_hash) { { "a" => { "deeper" => { "nested" => :hash } } } }
+          let(:expected_output) { { :"a.deeper.nested" => :hash } }
+
+          it "returns a new hash" do
+            expect(subject.flatten).not_to be(input_hash)
+          end
+
+          it "returns the correct hash" do
+            expect(subject.flatten).to eq(expected_output)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/morfo_spec.rb

@@ -1,287 +1,108 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe Morfo::Base do
-  let(:input) do
-    [
-      {
-        title: 'The Walking Dead',
-        channel: 'AMC',
-        watchers: 1337,
-        status: 'running',
-        cast: ['Lincoln, Andrew', 'McBride, Melissa'],
-        ratings: {
-          imdb: 8.7,
-          trakt: 89,
-          rotten_tomatoes: 93,
-        },
-      },
-      {
-        title: 'Breaking Bad',
-        channel: 'AMC',
-        watchers: 72891,
-        status: 'ended',
-        cast: ['Cranston, Bryan', 'Gunn, Anna'],
-        ratings: {
-          imdb: 9.5,
-          trakt: 95,
-          rotten_tomatoes: 100,
-        },
-      }
-    ]
-  end
-
-  let(:single_input) do
-    input.first
-  end
-
-  context 'errors' do
+  it_behaves_like "an error throwing morfer" do
     subject(:no_from) do
       class NilMorfer < Morfo::Base
         field(:my_field)
       end
       NilMorfer
     end
-
-    describe '#morf' do
-      it 'raises error for nil field' do
-        expect{no_from.morf([{my_field: :something}])}.to raise_error(ArgumentError)
-      end
-    end
-
-    describe '#morf_single' do
-      it 'raises error for nil field' do
-        expect{no_from.morf_single({my_field: :something})}.to raise_error(ArgumentError)
-      end
-    end
   end
 
-  context '1 to 1 conversion' do
+  it_behaves_like "a 1 to 1 morfer" do
     subject do
       class TitleMorfer < Morfo::Base
         field(:tv_show_title).from(:title)
       end
       TitleMorfer
     end
-
-    describe '#morf' do
-      it 'maps title correctly' do
-        expected_output = input.map{|v| {tv_show_title: v[:title]} }
-        expect(subject.morf(input)).to eq(expected_output)
-      end
-
-      it 'leaves out nil values in result' do
-        expected_output = [{},{}]
-        modified_input = input.map{|h| h.reject{|k, v| k == :title}}
-        expect(subject.morf(modified_input)).to eq(expected_output)
-      end
-    end
-
-    describe '#morf_single' do
-      it 'maps title correctly' do
-        expected_output = { tv_show_title: single_input[:title] }
-        expect(subject.morf_single(single_input)).to eq(expected_output)
-      end
-
-      it 'leaves out nil values in result' do
-        expected_output = {}
-        modified_input = single_input.reject { |k, v| k == :title }
-        expect(subject.morf_single(modified_input)).to eq(expected_output)
-      end
-    end
   end
 
-  context '1 to 1 conversion with transformation' do
+  it_behaves_like "a 1 to 1 morfer with transformation" do
     subject do
-      class NumCastMorfer < Morfo::Base
-        field(:cast_num).from(:cast).transformed{|v| v.size}
-      end
-      NumCastMorfer
-    end
-
-    describe '#morf' do
-      it 'calls transformation correctly' do
-        expected_output = input.map{|v| {cast_num: v[:cast].size} }
-        expect(subject.morf(input)).to eq(expected_output)
-      end
-    end
-
-    describe '#morf_single' do
-      it 'calls transformation correctly' do
-        expected_output = { cast_num: single_input[:cast].size }
-        expect(subject.morf_single(single_input)).to eq(expected_output)
+      class AndZombies < Morfo::Base
+        field(:title).from(:title).transformed{|v| "#{v} and Zombies"}
       end
+      AndZombies
     end
   end
 
-  context '1 to many conversion' do
+  it_behaves_like "a 1 to many morfer" do
     subject do
-      class MutliTitleMorfer < Morfo::Base
+      class MultiTitleMorfer < Morfo::Base
         field(:title).from(:title)
         field(:also_title).from(:title)
       end
-      MutliTitleMorfer
-    end
-
-    describe '#morf' do
-      it 'maps title to multiple fields' do
-        expected_output = input.map{|v| {title: v[:title], also_title: v[:title]} }
-        expect(subject.morf(input)).to eq(expected_output)
-      end
+      MultiTitleMorfer
     end
+  end
 
-    describe '#morf_single' do
-      it 'maps title to multiple fields' do
-        expected_output = {title: single_input[:title], also_title: single_input[:title]}
-        expect(subject.morf_single(single_input)).to eq(expected_output)
+  it_behaves_like "a calculating morfer" do
+    subject do
+      class TitlePrefixMorfer < Morfo::Base
+        field(:title_with_channel).calculated{|r| "#{r[:title]}, (#{r[:channel]})"}
       end
+      TitlePrefixMorfer
     end
   end
 
-  context 'nested conversion' do
-    context 'nested source' do
-      subject(:valid_path) do
-        class ImdbRatingMorfer < Morfo::Base
-          field(:rating).from(:ratings, :imdb)
-        end
-        ImdbRatingMorfer
-      end
-
-      subject(:valid_path_with_transformation) do
-        class ImdbRatingMorferWithTransformation < Morfo::Base
-          field(:rating).from(:ratings, :imdb).transformed {|v| "Rating: #{v}"}
-        end
-        ImdbRatingMorferWithTransformation
-      end
-
-      subject(:invalid_path) do
-        class InvalidImdbRatingMorfer < Morfo::Base
-          field(:rating).from(:very, :long, :path, :that, :might, :not, :exist)
-        end
-        InvalidImdbRatingMorfer
-      end
-
-      describe '#morf' do
-        it 'maps nested attributes' do
-          expected_output = input.map{|v| {rating: v[:ratings][:imdb]} }
-          expect(valid_path.morf(input)).to eq(expected_output)
-        end
-
-        it 'maps nested attributes with transformation' do
-          expected_output = input.map{|v| {rating: "Rating: #{v[:ratings][:imdb]}"} }
-          expect(valid_path_with_transformation.morf(input)).to eq(expected_output)
-        end
-
-        it 'doesn\'t raise error for invalid path' do
-          expected_output = [{},{}]
-          expect(invalid_path.morf(input)).to eq(expected_output)
-        end
-      end
-
-      describe '#morf_single' do
-        it 'maps nested attributes' do
-          expected_output = {rating: single_input[:ratings][:imdb]}
-          expect(valid_path.morf_single(single_input)).to eq(expected_output)
-        end
-
-        it 'maps nested attributes with transformation' do
-          expected_output = {rating: "Rating: #{single_input[:ratings][:imdb]}"}
-          expect(valid_path_with_transformation.morf_single(single_input)).to eq(expected_output)
-        end
-
-        it 'doesn\'t raise error for invalid path' do
-          expected_output = { }
-          expect(invalid_path.morf_single(single_input)).to eq(expected_output)
-        end
+  it_behaves_like "a static morfer" do
+    subject do
+      class StaticTitleMorfer < Morfo::Base
+        field(:new_title).calculated{ "Static Title" }
       end
+      StaticTitleMorfer
     end
+  end
 
-    context 'nested destination' do
-      subject do
-        class WrapperMorfer < Morfo::Base
-          field(:tv_show, :title).from(:title)
-          field(:tv_show, :channel).from(:channel).transformed {|v| "Channel: #{v}"}
-        end
-        WrapperMorfer
-      end
-
-      describe '#morf' do
-        it 'maps to nested destination' do
-          expected_output = input.map{|v|
-            {
-              tv_show: {
-                title: v[:title],
-                channel: "Channel: #{v[:channel]}",
-              }
-            }
-          }
-          expect(subject.morf(input)).to eq(expected_output)
-        end
-      end
-
-      describe '#morf_single' do
-        it 'maps to nested destination' do
-          expected_output = {
-            tv_show: {
-              title: single_input[:title],
-              channel: "Channel: #{single_input[:channel]}",
-            }
-          }
-          expect(subject.morf_single(single_input)).to eq(expected_output)
-        end
+  it_behaves_like "a morfer with nested source" do
+    subject(:valid_path) do
+      class ImdbRatingMorfer < Morfo::Base
+        field(:rating).from(:ratings, :imdb)
       end
+      ImdbRatingMorfer
     end
-  end
 
-  context 'calculations' do
-    subject do
-      class TitlePrefixMorfer < Morfo::Base
-        field(:title_with_channel).calculated{|r| "#{r[:title]}, (#{r[:channel]})"}
+    subject(:valid_path_with_transformation) do
+      class ImdbRatingMorferWithTransformation < Morfo::Base
+        field(:rating).from(:ratings, :imdb).transformed {|v| "Rating: #{v}"}
       end
-      TitlePrefixMorfer
+      ImdbRatingMorferWithTransformation
     end
 
-    describe '#morf' do
-      it 'maps calculation correctly' do
-        expected_output = input.map{|r|
-          {
-            title_with_channel: "#{r[:title]}, (#{r[:channel]})"
-          }
-        }
-        expect(subject.morf(input)).to eq(expected_output)
+    subject(:valid_path_with_calculation) do
+      class ImdbRatingMorferWithCalculation < Morfo::Base
+        field(:ratings).calculated {|r| "IMDB: #{r[:ratings][:imdb]}, Trakt: #{r[:ratings][:trakt]}, Rotten Tommatoes: #{r[:ratings][:rotten_tomatoes]}" }
       end
+      ImdbRatingMorferWithCalculation
     end
 
-    describe '#morf_single' do
-      it 'maps calculation correctly' do
-        expected_output = {
-          title_with_channel: "#{single_input[:title]}, (#{single_input[:channel]})"
-        }
-
-        expect(subject.morf_single(single_input)).to eq(expected_output)
+    subject(:invalid_path) do
+      class InvalidImdbRatingMorfer < Morfo::Base
+        field(:rating).from(:very, :long, :path, :that, :might, :not, :exist)
       end
+      InvalidImdbRatingMorfer
     end
   end
 
-  context 'static values' do
+  it_behaves_like "a morfer with nested destination" do
     subject do
-      class StaticTitleMorfer < Morfo::Base
-        field(:new_title).calculated{ 'Static Title' }
-      end
-      StaticTitleMorfer
-    end
-
-    describe '#morf' do
-      it 'maps static value correctly' do
-        expected_output = input.map{|r| {new_title: 'Static Title'} }
-        expect(subject.morf(input)).to eq(expected_output)
+      class WrapperMorfer < Morfo::Base
+        field(:tv_show, :title).from(:title)
+        field(:tv_show, :channel).from(:channel).transformed {|v| "Channel: #{v}"}
       end
+      WrapperMorfer
     end
+  end
 
-    describe '#morf_single' do
-      it 'maps static value correctly' do
-        expected_output = { new_title: 'Static Title' }
-        expect(subject.morf_single(single_input)).to eq(expected_output)
+  it_behaves_like "a morfer with nested destination" do
+    subject do
+      class WrapperMorfer < Morfo::Base
+        field(:tv_show, :title).from(:title)
+        field(:tv_show, :channel).from(:channel).transformed {|v| "Channel: #{v}"}
       end
+      WrapperMorfer
     end
   end
 end