hash_map 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 09a2c86f0de008f859fd4002f7cd84531714d62b
-  data.tar.gz: 5efd346e6d557652d39622bfe7283d6a0ffcf52d
+  metadata.gz: 94701f9bddaba8235a48d0340f4c900c0d73cf1a
+  data.tar.gz: 827a696b1b3194e1b83857795772cc4e78c4d7b0
 SHA512:
-  metadata.gz: b041e1a7e7da905df2a8ceff08bcf5de7de7e6d2ec5f8aa5e6c2fbfc2e1af4dd9c924c75ddf211b1dbf6fc7daf84009851a10354bc39aca2259b4df99cf9fd91
-  data.tar.gz: 56b443c5b44598d5e442e00f831928873a26ce77534aea20a9a1f3adf74ca335d4693840aa3f5eac9f85a626bf89aa9695408d93e4aab666bd4d04ef12bdc3ce
+  metadata.gz: 6507b7366edc76cb9f072c6eecab282a8abaf8e18759dbb77d54766f4546946eafee13491ba7b6137a74f54c289900ce7f1bb36ed38123b905a94a282926b216
+  data.tar.gz: 8897e48ef5d0272feb79db75fee7390bda74ed9287139c226022a802b3b81757d33178349669e05b2b009db333bb77985a4eecb4af396be1f258d23fd02ebad4

data/README.md

@@ -46,17 +46,21 @@ Your beautiful Mapper:
 ```ruby
 class ProfileMapper < HashMap::Base
   property :first_name, from: :name
-  property(:last_name) { |input| "#{input[:first_surname]} #{input[:second_surname]}" }
+
+  property :last_name do |input|
+    "#{input[:first_surname]} #{input[:second_surname]}"
+  end
+
   property :language, from: [:address, :country, :language]
 
-  from_children :address do
+  from_child :address do
     property :code, from: :postal_code
-    from_children :country do
-      property :country_name
+    from_child :country do
+      property :country_name, from: :name
     end
   end
 
-  to_children :email do
+  to_child :email do
     property :address, from: :email
     property :type, default: :work
   end
@@ -68,13 +72,13 @@ end
 Your wanted hash:
 
 ```ruby
-ProfileMapper.new(original).to_h
+ProfileMapper.map(original)
 => {
   first_name: "Artur",
   last_name: "hello world",
   language: "ES",
   code: 12345,
-  country_name: nil,
+  country_name: "Spain",
   email: {
     address: "asdf@sdfs.com",
     type: :work
@@ -82,9 +86,100 @@ ProfileMapper.new(original).to_h
   telephone: nil
 }
 ```
+**IMPORTANT:**
+- The **output** is a **HashWithIndifferentAccess** you can access the values with strings or symbols.
+- The input is transformed as well, that's why you do not need to use strings.
 
 Enjoy!
 
+### Examples:
+**no from needed**
+```ruby
+class Clever < HashMap::Base
+  property :name # will get value from the key 'name'
+  property :address
+end
+```
+
+**properties**
+```ruby
+class Properties < HashMap::Base
+  properties :name, :address, :house
+end
+```
+
+**blocks:**
+
+If in **fron_child** block when you want to get the value with a block
+the value of the child and original will be yielded in this order: child, original
+
+```ruby
+class Blocks < HashMap::Base
+  from_child :address do
+    property :street do |address|
+      address[:street].upcase
+    end
+    property :owner do |address, original|
+      original[:name]
+    end
+    from_child :country do
+      property :country do |country|
+        country[:code].upcase
+      end
+    end
+  end
+  property :name do |original|
+    original[:name]
+  end
+end
+
+hash = {
+  name: 'name',
+  address:{
+    street: 'street',
+    country:{
+      code: 'es'
+    }
+  }
+}
+
+Blocks.map(hash)
+# => {"street"=>"STREET", "owner"=>"name", "country"=>"ES", "name"=>"name"}
+
+```
+
+### Motivation
+I got bored of doing this:
+```ruby
+# this is a hash from an API
+hash = JSON.parse(response, :symbolize_names => true)
+# hash = {
+#   user: {
+#     name: 'John',
+#     last_name: 'Doe',
+#     telephone: '989898',
+#     country: {
+#       code: 'es'
+#     }
+#   }
+# }
+
+user_hash = hash[:user]
+user = User.new
+user.name = user_hash[:name]
+user.lastname = user_hash[:last_name]
+user.phone = Phone.parse(user_hash[:telephone])
+user.country = Country.find_by(code: user_hash[:country][:code])
+
+# boring!!!
+# and that's a tiny response
+```
+
+solution:
+```ruby
+user = User.new(MyMapper.map(hash)) # done
+```
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake rspec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/lib/hash_map/base.rb

@@ -3,13 +3,18 @@ module HashMap
     include ToDSL
     delegate :[], to: :output
 
+    def self.map(input)
+      new(input).output
+    end
+
     def mapper
       @mapper ||= Mapper.new(original, self.class.attributes)
     end
 
     def output
-      mapper.output
+      @output ||= mapper.output
     end
     alias_method :to_h, :output
+    alias_method :to_hash, :output
   end
 end

data/lib/hash_map/dsl.rb

@@ -32,20 +32,39 @@ module HashMap
     end
 
     def property(key, opts = {}, &block)
-      new = {}.tap{ |h| h[:key] =  single_to_ary(key) }
-      new[:proc] = block if block
-      new[:from] = generate_from(new, opts)
-      attributes << new.merge!(opts.except(:from))
-      new
+      new_hash = {}.tap{ |h| h[:key] =  single_to_ary(key) }
+      new_hash[:proc] = block if block
+      new_hash[:from] = generate_from(new_hash, opts)
+      attributes << new_hash.merge!(opts.except(:from))
+      new_hash
+    end
+
+    def properties(*args)
+      args.each do |arg|
+        property(*arg)
+      end
     end
 
     def from_children(key, opts = {}, &block)
+      puts "[Depercation Warning] using: #{__callee__} use from_child instead"
+      from_child(key, opts, &block)
+    end
+
+    def from_child(key, opts = {}, &block)
       flat = _nested(key, opts, &block)
-      flat.each { |attr| attr[:from].unshift(key) }
+      flat.each do |attr|
+        attr[:from].unshift(key)
+        attr[:from_child] ? attr[:from_child].unshift(key) : attr[:from_child] = [key]
+      end
       @attributes += flat
     end
 
     def to_children(key, opts = {}, &block)
+      puts "[Depercation Warning] using: #{__callee__} use to_child instead"
+      to_child(key, opts, &block)
+    end
+
+    def to_child(key, opts = {}, &block)
       flat = _nested(key, opts, &block)
       flat.each { |attr| attr[:key].unshift(key) }
       @attributes += flat
@@ -65,8 +84,7 @@ module HashMap
     end
 
     def single_to_ary(elem)
-      return if elem.nil?
-      elem.is_a?(Array) ? elem : [elem]
+      Array.wrap(elem)
     end
   end
 end

data/lib/hash_map/mapper.rb

@@ -18,21 +18,31 @@ module HashMap
     private
 
     def get_value(struct)
-      value = if block = struct[:proc]
-        block.call(original)
+      value = if struct[:proc]
+        execute_block(struct)
       elsif struct[:from]
         get_value_from_key(struct)
       end
       nil_to_default(value, struct)
     end
 
-    def get_value_from_key(struct)
-      struct[:from].inject(original) do |output, k|
+    def get_value_from_key(struct, from = :from)
+      struct[from].inject(original) do |output, k|
         break unless output.respond_to?(:[])
         output.send(:[], k)
       end
     end
 
+    def execute_block(struct)
+      block = struct[:proc]
+      if struct[:from_child]
+        nested = get_value_from_key(struct, :from_child)
+        block.call(nested, original)
+      else
+        block.call(original, original)
+      end
+    end
+
     def build_keys(ary, value)
       ary.reverse.inject(value) do |a, n|
         HashWithIndifferentAccess.new({ n => a })

data/lib/hash_map/version.rb

@@ -1,3 +1,3 @@
 module HashMap
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hash_map
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Artur Pañach
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-10-20 00:00:00.000000000 Z
+date: 2015-11-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler