morfo 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3500e5ec94def95ffed72498a8dcfee478e10e80
-  data.tar.gz: b543a2e81a8032f6bc5736b42761dbb08b822ab7
+  metadata.gz: 87b740fa3940052dc425842ec2f8a8c1b39a8955
+  data.tar.gz: ce6d9032e4b76325233bcad0e4ed2a29dba17c15
 SHA512:
-  metadata.gz: 7a373305e8dfd3add0b3070c66e1d357dde9b453746942f3b03afaa3c68b99e5124dac54147e499cf08c05c8489e79f8cbfa3538c5f36164213cb592f077f8e1
-  data.tar.gz: 5cde3c3dd8d6082817b1976c070e673045d9b1ff496b45c36330311888747910dc62de4ef1bb92a77d27154d99e4658b77cd04dbda9e1289ac04fae72057ae63
+  metadata.gz: f0baa0e37cf6809e502bed94eb4da771d3572b51970918d9666d1ea4bdcc2c9872b046f78df3f2035727da35a33affbe3daa3c51c9d050864c61cd6361580aa8
+  data.tar.gz: e1e50f08391db40f95d7ecb81908c19e9e3774d996ca0fa0da757e1f7cd4a1f3c582bbc34cdb0b86ca2ab3dcc840f9b715f24aafb37c05a7bc3f6dd4a395196e

data/CONTRIBUTING.md

@@ -2,6 +2,6 @@
 
 1. Fork it
 2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Add some feature'`)
+3. Commit your changes (`git commit -am "Add some feature"`)
 4. Push to the branch (`git push origin my-new-feature`)
 5. Create new Pull Request

data/Gemfile

@@ -1,19 +1,19 @@
-source 'https://rubygems.org'
+source "https://rubygems.org"
 
 # Specify your gem's dependencies in morfo.gemspec
 gemspec
 
 group :test, :development do
-  gem 'coveralls', require: false
-  gem 'guard'
-  gem 'guard-rspec'
-  gem 'simplecov'
-  gem 'pry'
-  gem 'rubinius-coverage', platform: :rbx
+  gem "coveralls", require: false
+  gem "guard"
+  gem "guard-rspec"
+  gem "simplecov"
+  gem "pry"
+  gem "rubinius-coverage", platform: :rbx
 
-  gem 'rb-inotify', require: false
-  gem 'rb-fsevent', require: false
-  gem 'rb-fchange', require: false
+  gem "rb-inotify", require: false
+  gem "rb-fsevent", require: false
+  gem "rb-fchange", require: false
 end
 
-gem 'json'
+gem "json"

data/Guardfile

@@ -1,8 +1,8 @@
 # A sample Guardfile
 # More info at https://github.com/guard/guard#readme
 
-guard :rspec, cmd: 'bundle exec rspec', all_on_start: true do
+guard :rspec, cmd: "bundle exec rspec", all_on_start: true do
   watch(%r{^spec/.+_spec\.rb$})
   watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
-  watch('spec/spec_helper.rb')  { 'spec' }
+  watch("spec/spec_helper.rb")  { "spec" }
 end

data/README.md

@@ -12,7 +12,7 @@ This gem is currently only tested on Ruby 2.0 (including 2.0 mode of JRuby and R
 
 Add this line to your application's Gemfile:
 
-    gem 'morfo'
+    gem "morfo"
 
 And then execute:
 
@@ -32,83 +32,199 @@ Use the `field` method to specify what fields exist and where they will get thei
 
 The most basic form is copying the value from another field.
 
-    class Title < Morfo::Base
-      field(:tv_show_title)from(:title)
-    end
+```ruby
+class Title < Morfo::Base
+  field(:tv_show_title)from(:title)
+end
+```
 
 Afterwards use the `morf` method to morf all hashes in one array to the end result:
 
-    Title.morf([
-              {title: 'The Walking Dead'} ,
-              {title: 'Breaking Bad'},
-            ])
+```ruby
+Title.morf([
+          { title: "The Walking Dead" },
+          { title: "Breaking Bad" },
+        ])
 
-    # [
-    #   {tv_show_title: 'The Walking Dead'},
-    #   {tv_show_title: 'Breaking Bad'},
-    # ]
+# [
+#   { tv_show_title: "The Walking Dead" },
+#   { tv_show_title: "Breaking Bad" },
+# ]
+```
 
 If you want to have access to nested values, just provide the path to that field comma separated.
 
-
-    class Name < Morfo::Base
-      field(:first_name).from(:name, :first)
-      field(:last_name).from(:name, :last)
-    end
-
-    Name.morf([
-          {
-            name: {
-              first: 'Clark',
-              last: 'Kent',
-            },
-          },
-          {
-            name: {
-              first: 'Bruce',
-              last: 'Wayne',
-            },
-          },
-        ])
-
-    # [
-    #     {first_name: 'Clark',last_name: 'Kent'},
-    #     {first_name: 'Bruce',last_name: 'Wayne'},
-    # ]
-
-## Transformations
+```ruby
+class Name < Morfo::Base
+  field(:first_name).from(:name, :first)
+  field(:last_name).from(:name, :last)
+end
+
+Name.morf([
+      {
+        name: {
+          first: "Clark",
+          last: "Kent",
+        },
+      },
+      {
+        name: {
+          first: "Bruce",
+          last: "Wayne",
+        },
+      },
+    ])
+
+# [
+#   { first_name: "Clark", last_name: "Kent" },
+#   { first_name: "Bruce", last_name: "Wayne" },
+# ]
+```
+
+### Transformations
 
 It's also possible to transform the value in any way ruby lets you transform a value. just provide a block in the `transformed` method.
 
-    class AndZombies < Morfo::Base
-      field(:title).from(title).transformed {|title| "#{title} and Zombies"}
-    end
+```ruby
+class AndZombies < Morfo::Base
+  field(:title).from(title).transformed {|title| "#{title} and Zombies"}
+end
 
-    AndZombies.morf([
-          {title: 'Pride and Prejudice'},
-          {title: 'Fifty Shades of Grey'},
-        ])
+AndZombies.morf([
+      { title: "Pride and Prejudice" },
+      { title: "Fifty Shades of Grey" },
+    ])
 
-    # [
-    #     {title: 'Pride and Prejudice and Zombies'},
-    #     {title: 'Fifty Shades of Grey and Zombies'},
-    # ]
+# [
+#   { title: "Pride and Prejudice and Zombies" },
+#   { title: "Fifty Shades of Grey and Zombies" },
+# ]
+```
 
-## Calculations
+### Calculations
 
 If the value of your field should be based on multiple fields of the input row, yoy can specify a calculation block via the `calculated` method. As an argument the whole input row is passed in.
 
-    class NameConcatenator < Morfo::Base
-      field(:name).calculated {|row| "#{row[:first_name]} #{row[:last_name]}"}
-      field(:status).calculated {'Best Friend'}
-    end
-
-    NameConcatenator.morf([
-          {first_name: 'Robin', last_name: 'Hood'},
-          {first_name: 'Sherlock', last_name: 'Holmes'},
-        ])
+```ruby
+class NameConcatenator < Morfo::Base
+  field(:name).calculated {|row| "#{row[:first_name]} #{row[:last_name]}"}
+  field(:status).calculated {"Best Friend"}
+end
+
+NameConcatenator.morf([
+      { first_name: "Robin", last_name: "Hood" },
+      { first_name: "Sherlock", last_name: "Holmes" },
+    ])
+
+# [
+#   { name: "Robin Hood", status: "Best Friend" },
+#   { name: "Sherlock Holmes", status: "Best Friend" }
+# ]
+```
+
+### Builder
+
+On top of creating transformers with Ruby classes, it is also possible to build transformers with a hash syntax (which could then be serialized as json and stored somewhere else).
+
+```ruby
+morfer = Morfo::Builder.new([
+  { field: :first_name, from: [:name, :first] },
+  { field: :last_name, from: [:name, :last] },
+])
+
+morfer.morf([
+      {
+        name: {
+          first: "Clark",
+          last: "Kent",
+        },
+      },
+      {
+        name: {
+          first: "Bruce",
+          last: "Wayne",
+        },
+      },
+    ])
+
+# [
+#   { first_name: "Clark", last_name: "Kent" },
+#   { first_name: "Bruce", last_name: "Wayne" },
+# ]
+```
+
+The builder includes all other features such as calculation and transformation
+
+#### Builder Transformations
+
+To transform a value, use the placeholder %{value}
+
+```ruby
+class AndZombies < Morfo::Base
+  field(:title).from(title).transformed {|title| "#{title} and Zombies"}
+end
+
+morfer = Morfo::Builder.new([
+  { field: :title, from: :title, transformed: "%{title} and Zombies" },
+])
+
+morfer.morf([
+      { title: "Pride and Prejudice" },
+      { title: "Fifty Shades of Grey" },
+    ])
+
+# [
+#   { title: "Pride and Prejudice and Zombies" },
+#   { title: "Fifty Shades of Grey and Zombies" },
+# ]
+```
+
+#### Builder Calculations
+
+To get access to the other fields use the [ruby string format syntax](http://ruby-doc.org/core-2.2.0/String.html#method-i-25).
+
+```ruby
+morfer = Morfo::Builder.new([
+  { field: :name, calculated: "%{first_name} %{last_name}" },
+  { field: :status, calculated: "Best Friend" },
+])
+
+morfer.morf([
+  { first_name: "Robin", last_name: "Hood" },
+  { first_name: "Sherlock", last_name: "Holmes" },
+])
+
+# [
+#   { name: "Robin Hood", status: "Best Friend" },
+#   { name: "Sherlock Holmes", status: "Best Friend" }
+# ]
+```
+
+It's even possible to get access to nested keys, using a dot as separator:
+
+```ruby
+morfer = Morfo::Builder.new([
+  { field: :name, calculated: "%{name.first} %{name.last}" },
+])
+
+morfer.morf([
+      {
+        name: {
+          first: "Clark",
+          last: "Kent",
+        },
+      },
+      {
+        name: {
+          first: "Bruce",
+          last: "Wayne",
+        },
+      },
+])
+
+# [
+#   { name: "Clark Kent" },
+#   { name: "Bruce Wayne" },
+# ]
+```
 
-    # [
-    #   {:name=>"Robin Hood", :status=>"Best Friend"},
-    #   {:name=>"Sherlock Holmes", :status=>'Best Friend'}
-    # ]

data/Rakefile

@@ -1,4 +1,4 @@
-require 'bundler/gem_tasks'
-require 'rspec/core/rake_task'
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
 
 RSpec::Core::RakeTask.new(:spec)

data/benchmarks/data.rb

@@ -7,16 +7,16 @@ module BenchmarkData
 
   def row
     {
-      first_name: 'Jazmyn',
-      last_name: 'Willms',
-      gender: 'female',
-      phone_number: '485-675-9228',
-      cell_phone: '1-172-435-9402 x4907',
-      street_name: 'Becker Inlet',
-      street_number: '15a',
-      city: 'Carolynchester',
-      zip: '38189',
-      country: 'USA',
+      first_name: "Jazmyn",
+      last_name: "Willms",
+      gender: "female",
+      phone_number: "485-675-9228",
+      cell_phone: "1-172-435-9402 x4907",
+      street_name: "Becker Inlet",
+      street_number: "15a",
+      city: "Carolynchester",
+      zip: "38189",
+      country: "USA",
     }
   end
 

data/benchmarks/run.rb

@@ -1,28 +1,28 @@
-require 'morfo'
-require 'benchmark'
-require './benchmarks/data'
+require "morfo"
+require "benchmark"
+require "./benchmarks/data"
 
 iterations = 100
 batch_size = 10000
 
 definitions = [
   {
-    label: 'Simple (strings)',
+    label: "Simple (strings)",
     row: BenchmarkData.row_string_keys,
     morf_class: BenchmarkData::SimpleMorferString
   },
   {
-    label: 'Simple (symbols)',
+    label: "Simple (symbols)",
     row: BenchmarkData.row,
     morf_class: BenchmarkData::SimpleMorferSymbol
   },
   {
-    label: 'Nested (strings)',
+    label: "Nested (strings)",
     row: BenchmarkData.row_nested_string_keys,
     morf_class: BenchmarkData::NestedMorferString
   },
   {
-    label: 'Nested (symbols)',
+    label: "Nested (symbols)",
     row: BenchmarkData.row_nested,
     morf_class: BenchmarkData::NestedMorferSymbol
   },

data/lib/morfo.rb

@@ -1,5 +1,8 @@
-require 'morfo/version'
-require 'morfo/actions'
+require "active_support/core_ext/hash"
+require "morfo/version"
+require "morfo/tools"
+require "morfo/actions"
+require "morfo/builder"
 
 module Morfo
   class Base
@@ -16,7 +19,7 @@ module Morfo
     def self.morf_single input
       output = {}
       mapping_actions.each do |field_path, action|
-        deep_merge!(output, store_value(action.execute(input), field_path))
+        output.deep_merge!(store_value(action.execute(input), field_path))
       end
       output
     end
@@ -37,17 +40,5 @@ module Morfo
         end
       end
     end
-
-    def self.deep_merge! hash, other_hash, &block
-      other_hash.each_pair do |k,v|
-        tv = hash[k]
-        if tv.is_a?(Hash) && v.is_a?(Hash)
-          hash[k] = deep_merge!(tv, v, &block)
-        else
-          hash[k] = block && tv ? block.call(k, tv, v) : v
-        end
-      end
-      hash
-    end
   end
 end

data/lib/morfo/builder.rb

@@ -0,0 +1,34 @@
+module Morfo
+  class Builder
+    def initialize(definitions)
+      @definitions = definitions
+    end
+
+    def build
+      # WTF??? `definitions` is not accessible inside class
+      # so this javascript technique is necesseray
+      tmp_definitions = definitions.map { |h| h.symbolize_keys }
+      Class.new(Morfo::Base) do
+        tmp_definitions.each do |definition|
+          f = field(*definition[:field])
+
+          if definition[:from]
+            f = f.from(*definition[:from])
+          end
+
+          if definition[:calculated]
+            f = f.calculated { |r| definition[:calculated] % Morfo::Tools::FlattenHashKeys.new(r).flatten }
+          end
+
+          if definition[:transformed]
+            f = f.transformed { |v| definition[:transformed] % {value: v} }
+          end
+        end
+      end
+    end
+
+    private
+
+    attr_reader :definitions
+  end
+end