data_maps 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1ff13a28428388b271443275bd30d17178780d23
-  data.tar.gz: 1e501af25f3bed2e788332d01374440ce2a45286
+  metadata.gz: 0db231594073294046bbb5835c640cf80e9104a2
+  data.tar.gz: 061514db19e260ce0d6920d08c00bfbaaa3b676a
 SHA512:
-  metadata.gz: 83fbf366ee2287b51444a37253b285854d669b4e47279fbc45c16a26593c0533d90bb3f899961c0e26774e0b0d15255dd3ea0ac1fc92ef4ca57c8d56edef3c12
-  data.tar.gz: 621c5f21a176a058321f76eb758e8d55f71ccfd5851e96bc5d77a71848b652d8d503c7d7e2a42fba5fb32704787d02725da9ff0d77cf34b52726763abaa04842
+  metadata.gz: d164afd5020057a201912e236cda59b9262d02df41872bed00dfbc56c932aabcdbbcd7c517f777eddc63f9d73ac63f3cb0e07634c8077c09c31445103674d45d
+  data.tar.gz: cf4b01f7a57cc76b881ef7ae7ff9fd69f279d35b7b813f02ab8b3196a7e1219b7f41492131921448ee1f3dd489b8cb9f76686518824ac87540f357e2beeadfed

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    data_maps (0.1.0)
+    data_maps (0.2.0)
       activesupport (~> 3.2.21)
 
 GEM

data/README.md

@@ -3,10 +3,10 @@ DataMaps
 [![Build Status](https://travis-ci.org/dino115/data_maps.svg?branch=master)](https://travis-ci.org/dino115/data_maps)
 [![Code Climate](https://codeclimate.com/github/dino115/data_maps/badges/gpa.svg)](https://codeclimate.com/github/dino115/data_maps)
 [![Test Coverage](https://codeclimate.com/github/dino115/data_maps/badges/coverage.svg)](https://codeclimate.com/github/dino115/data_maps)
+[![Gem Version](https://badge.fury.io/rb/data_maps.svg)](http://badge.fury.io/rb/data_maps)
 
-Create great mappings to convert structured data into your own format!
-
-**Attention:** This gem is currently under development and can't be used yet!
+Create mappings to convert structured data into another format!
+This is useful for dynamic generated or serializable (e.g. to save) mappings.
 
 ## Installation
 
@@ -27,7 +27,7 @@ Or install it yourself as:
 ## Usage
 
 ### Mapper
-The DataMaps::Mapper converts data from a ruby hash to another.
+The DataMaps::Mapper converts data only from a ruby hash. So you have to import your data and create a ruby hash of it.
 
 ```ruby
 mapper = DataMaps::Mapper.new(mapping)
@@ -40,7 +40,9 @@ end
 ### Mapping
 Create mappings.
 
-#### Simple field mapping
+#### Field mapping
+You can map a single field, a nested field or multiple fields.
+
 ```ruby
 mapping = DataMaps::Mapping.new({
   'field' => {
@@ -48,6 +50,82 @@ mapping = DataMaps::Mapping.new({
   }
   # or simple: 'field' => 'source'
 })
+
+# Example:
+#
+# source_data = {
+#   'familyname' => 'Smith'
+# }
+#
+# mapping = {
+#   'last_name' => {
+#     from: 'familyname'
+#   }
+# }
+#
+# destination_data = {
+#   'last_name' => 'Smith'
+# }
+```
+
+For nested fields you can specify the field chain as `Array`.
+```ruby
+mapping = DataMaps::Mapping.new({
+  'field' => {
+    from: ['level1', 'level2']
+  }
+})
+
+# Example:
+#
+# source_data = {
+#   company_relation: {
+#     id: '123',
+#     name: 'My Company'
+#   }
+# }
+#
+# mapping = {
+#   'company' => {
+#     from: ['company_relation', 'name']
+#   }
+# }
+#
+# destination_data = {
+#   'company' => 'My Company'
+# }
+```
+
+You can select multiple fields from your data. By pass them as `Hash`. You can pass directly a new field name.
+```ruby
+mapping = DataMaps::Mapping.new({
+  'field' => {
+    from: { field: true, other_field: true } # or map them directly to a new field name by passing the new name instead of true
+  }
+})
+
+# Example:
+#
+# source_data = {
+#   customer_street: 'My street 5',
+#   customer_city: 'Cologne'
+# }
+#
+# mapping = {
+#   'address' => {
+#     from: {
+#       customer_street: 'street',
+#       customer_city: 'city'
+#     }
+#   }
+# }
+#
+# destination_data = {
+#   'address' => {
+#     'street' => 'My street 5',
+#     'city' => 'Cologne'
+#   }
+# }
 ```
 
 #### Conditions
@@ -55,13 +133,13 @@ Conditions must always have a when and then command. All condition statements ar
 The only exception is when using `then: { filter: true }`, then the execution breaks immediately and removes the whole field from result data.
 
 ```ruby
-  'field' => {
-    from: 'source' # or array of source fields
-    conditions: [
-      { when: { empty: true }, then: { set: 'something' },
-      { when: { regex: /[1-9]{5}/i }, then: { convert: { numeric: 'Integer' } } }
-    ]
-  }
+'field' => {
+  from: 'source'
+  conditions: [
+    { when: { empty: true }, then: { set: 'something' },
+    { when: { regex: /[1-9]{5}/i }, then: { convert: { numeric: 'Integer' } } }
+  ]
+}
 ```
 
 ##### Possible when's
@@ -71,42 +149,42 @@ The only exception is when using `then: { filter: true }`, then the execution br
   The condition is true when `data.empty? == result`
 
   ```ruby
-    empty: true # or false
+  empty: true # or false
   ```
 - **When: regex**
   Define a regular expression condition.
   The condition is true when `data.match regex`. Only works with strings.
 
   ```ruby
-    regex: /[a-z]/i
+  regex: /[a-z]/i
   ```
 - **When: gt, gte**
   Check if data is *greater* or *greater or equal* than the given value. Only works with comparable objects.
 
   ```ruby
-    gt: 5
-    gte 5
+  gt: 5
+  gte 5
   ```
 - **When: lt, lte**
   Check if data is *lower* or *lower or equal* than the given value. Only works with comparable objects.
 
   ```ruby
-    lt: 5
-    lte: 5
+  lt: 5
+  lte: 5
   ```
 - **When: eq, neq**
   Check if data is *equal* or *not equal* to the given value. Only works with comparable objects.
 
   ```ruby
-    eq: 10
-    neq: 'a-value'
+  eq: 10
+  neq: 'a-value'
   ```
 - **When: in, nin**
   Check if data is *in* or *not in* the set of given values. Doesn't work for a collection of values.
 
   ```ruby
-    in: ['a', 'b', 'c']
-    nin: ['x', 'y', 'z']
+  in: ['a', 'b', 'c']
+  nin: ['x', 'y', 'z']
   ```
 - **When: custom**
   Define your own condition class by defining them in the `DataMaps::When` module.
@@ -114,15 +192,15 @@ The only exception is when using `then: { filter: true }`, then the execution br
   You have to extend the `DataMaps::When::Base` class. Then all options are available via the `option` attribute reader.
 
   ```ruby
-    class DataMaps::When::IsZip < DataMaps::When::Base
-      def execute(data)
-        !!data.match(/\d{5}/)
-      end
+  class DataMaps::When::IsZip < DataMaps::When::Base
+    def execute(data)
+      !!data.match(/\d{5}/)
     end
+  end
   ```
 
   ```ruby
-    is_zip: true # option isn't used, you can pass anything, for example and readability true
+  is_zip: true # option isn't used, you can pass anything, for example and readability true
   ```
 
 ##### Possible then's
@@ -131,21 +209,21 @@ The only exception is when using `then: { filter: true }`, then the execution br
   Set the value to given value.
 
   ```ruby
-    set: 'to this value'
+  set: 'to this value'
   ```
 - **Then: convert**
   Apply the configured converter. See converter section for more information.
 
   ```ruby
-    convert: {
-      numeric: 'Integer'
-    }
+  convert: {
+    numeric: 'Integer'
+  }
   ```
 - **Then: filter**
   When this is set to true then the whole field will filtered.
 
   ```ruby
-    filter: true
+  filter: true
   ```
 - **Then: custom**
   Define your own *then* by defining them in the `DataMaps::Then` module.
@@ -153,31 +231,31 @@ The only exception is when using `then: { filter: true }`, then the execution br
   You have to extend the `DataMaps::Then::Base` class. Then all options are available via the `option` attribute reader.
 
   ```ruby
-    class DataMaps::Then::SendEmail < DataMaps::Then::Base
-      def execute(data)
-        MyFramework::Email.send(to: option)
-        data
-      end
+  class DataMaps::Then::SendEmail < DataMaps::Then::Base
+    def execute(data)
+      MyFramework::Email.send(to: option)
+      data
     end
+  end
   ```
 
   ```ruby
-    send_email: me@example.com
+  send_email: me@example.com
   ```
 
 #### Converter
 Apply one or many converters to the input data. Converters applied procedural.
 
 ```ruby
-  'field' => {
-    from: 'source',
-    convert: {
-      map: {
-        1: 'A',
-        2: 'B'
-      }
+'field' => {
+  from: 'source',
+  convert: {
+    map: {
+      1: 'A',
+      2: 'B'
     }
   }
+}
 ```
 
 ##### Possible converter
@@ -188,61 +266,61 @@ Apply one or many converters to the input data. Converters applied procedural.
   For arrays and hashes it returns nil if the value is not in the mapping. For flat values it returns the original data.
 
   ```ruby
-    map: {
-      from: to
-    }
+  map: {
+    from: to
+  }
   ```
 - **Converter: numeric**
   Cast data to a numeric value. Possible options are 'Integer', 'Float' or a number, then it is casted to float and rounded. Doesn't work with collections.
   Can raise an error if the value is not convertable.
 
   ```ruby
-    numeric: 'Integer'
-    numeric: 'Float'
-    numeric: 2
+  numeric: 'Integer'
+  numeric: 'Float'
+  numeric: 2
   ```
 - **Converter: String**
   Cast explicit to string. Doesn't work with collections.
   Can raise error if the value is not convertable.
 
   ```ruby
-    string: true
+  string: true
   ```
 - **Converter: Boolean**
   Cast explicit to bool (by double negotiation). Doesn't work with collections.
   Can return unexpected values, e.g. a double negotiated empty array is true! `!![] #=> true`
 
   ```ruby
-    bool: true
+  bool: true
   ```
 - **Converter: keys**
   This maps the hash keys when the input data is a hash or when you select multiple *from* fields. Only works with hashes.
   Return the original data when the data isn't a hash.
 
   ```ruby
-    keys: {
-      'address1' => 'street'
-    }
+  keys: {
+    'address1' => 'street'
+  }
   ```
 - **Converter: Prefix**
   This prefixes the data with a given value. Call `to_s` on data and always returns a string.
 
   ```ruby
-    prefix: '$'
+  prefix: '$'
   ```
 - **Converter: Postfix**
   This postfixes the data with a given value. Call `to_s` on data and always returns a string.
 
   ```ruby
-    postfix: '€'
+  postfix: '€'
   ```
 - **Converter: ruby**
   Apply any method on the current data object.
 
   ```ruby
-    ruby: :upcase
-    ruby: [:slice, 5]
-    ruby: [:join, ', ']
+  ruby: :upcase
+  ruby: [:slice, 5]
+  ruby: [:join, ', ']
   ```
 - **Converter: custom**
   Define your own *converter* by defining them in the `DataMaps::Converter` module.
@@ -250,15 +328,15 @@ Apply one or many converters to the input data. Converters applied procedural.
   You have to extend the `DataMaps::Converter::Base` class. Then all options are available via the `option` attribute reader.
 
   ```ruby
-    class DataMaps::Converter::ToPersonObject < DataMaps::Converter::Base
-      def execute(data)
-        Person.new(data, option)
-      end
+  class DataMaps::Converter::ToPersonObject < DataMaps::Converter::Base
+    def execute(data)
+      Person.new(data, option)
     end
+  end
   ```
 
   ```ruby
-    to_person_object: { as: :importer } # passed value are available with option
+  to_person_object: { as: :importer } # passed value are available with option
   ```
 
 Have fun using the `DataMaps` gem :)

data/data_maps.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |spec|
   spec.email         = ['axel.wahlen@mixxt.de']
   spec.summary       = %q{ Maps data to another structure through a mapping }
   spec.description   = %q{ Maps data to another structure through a mapping }
-  spec.homepage      = ''
+  spec.homepage      = 'https://github.com/dino115/data_maps'
   spec.license       = 'MIT'
 
   spec.files         = `git ls-files -z`.split("\x0")

data/lib/data_maps/statement.rb

@@ -45,7 +45,11 @@ module DataMaps
     # @param [mixed] data
     # @return [Array] key and value of the result
     def execute(data)
-      data = from.is_a?(Array) ? Hash[from.map{ |f| [f, data[f.to_s]] }] : data[from.to_s]
+      data = case from
+        when Array then from.reduce(data) { |val, f| val.fetch(f) if val.is_a?(Hash) }
+        when Hash then Hash[from.map { |k,v| [v.is_a?(TrueClass) ? k.to_s : v.to_s, data[k.to_s]] }]
+        else data[from.to_s]
+      end
 
       data = execute_conditions(data)
       data = execute_converter(data)

data/lib/data_maps/version.rb

@@ -1,3 +1,3 @@
 module DataMaps
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

data/spec/data_maps/statement_spec.rb

@@ -37,20 +37,34 @@ describe DataMaps::Statement do
   end
 
   describe '#execute' do
-    it 'slices source_data from a single field' do
+    it 'slices the source data from a single field' do
       statement = DataMaps::Statement.new('from', 'to', [], [])
       data = { 'from' => 'some value' }
 
       expect(statement.execute(data)).to eq ['to', 'some value']
     end
 
-    it 'slices source_data from an array of fields' do
+    it 'slices source data from a field chain (array of fields)' do
       statement = DataMaps::Statement.new(%w[ from1 from2 ], 'to', [], [])
+      data = { 'from1' => { 'from2' => 'my value', 'from3' => 'my second value' }, 'from4' => 'another value' }
+
+      expect(statement.execute(data)).to eq ['to', 'my value']
+    end
+
+    it 'slices source data from a collection of fields (hash of fields)' do
+      statement = DataMaps::Statement.new({ from1: true, from2: true }, 'to', [], [])
       data = { 'from1' => 'first value', 'from2' => 'second value', 'from3' => 'third value' }
 
       expect(statement.execute(data)).to eq ['to', { 'from1' => 'first value', 'from2' => 'second value' }]
     end
 
+    it 'slices source data from a collection of fields with mapping (hash of fields)' do
+      statement = DataMaps::Statement.new({ from1: 'field1', from2: 'field2' }, 'to', [], [])
+      data = { 'from1' => 'first value', 'from2' => 'second value', 'from3' => 'third value' }
+
+      expect(statement.execute(data)).to eq ['to', { 'field1' => 'first value', 'field2' => 'second value' }]
+    end
+
     it 'calls execute_conditions with data' do
       statement = DataMaps::Statement.new('from', 'to', [], [])
       data = { 'from' => 'some value' }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: data_maps
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Axel Wahlen
@@ -147,7 +147,7 @@ files:
 - spec/data_maps/when/empty_spec.rb
 - spec/data_maps/when/regex_spec.rb
 - spec/spec_helper.rb
-homepage: ''
+homepage: https://github.com/dino115/data_maps
 licenses:
 - MIT
 metadata: {}