yahm 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2f91884e21f0dc68a1777f51cda708d53f053608
-  data.tar.gz: c3ad59e14872e528f9a19d3b203645dbc9f9d36e
+  metadata.gz: 9fe26e652bc9220089279697888c2caa5b3469b4
+  data.tar.gz: 49fcff2c3a44c6e2fcd3a870eb3db4521bdc47be
 SHA512:
-  metadata.gz: 9d57cb78535fd2ef77a611088ed6311d0932b406e27b366de9f9ddc7477837ca14c7bbfb3814f3ce7f36a430e808186fb088528addbc979e151bcd6e0c0933ae
-  data.tar.gz: a59e91fd750bd9640cee0e3d71bb989fa7a6b8fafdf0748f927f725373344ff7e03649b18e92d5133edac055992c379bc314d592b890d8b8dddaba9cc1afce54
+  metadata.gz: 20b69251b456cb660f337f03eb9e18357a8f6d3f3d8a20db461b49021dd1566a0ddaa33828efbc9750448f58a4508459a8f25815d9c6387995b2554076882021
+  data.tar.gz: 0062463e2cf0ac9bbea45c04deb07cffe4302eb83cb059d2126a8e618b601aee08ddaf135594884a2b11230b3b91d7633be23fbef05cad819f2e443914f265b9

data/README.md

@@ -69,7 +69,21 @@ end
 Record.new({ ... })
 => { :id => "...", :count => ..., :subjects => { :most_important_subject => "..."}, ... }
 ```
-### Options
+### Mapping options
+
+#### `context:`
+
+Something that responds to a method call, e.g. a class. Is used the resolve undefined methods of lambdas/procs.
+
+#### `use_threads: [true|false]` [experimental]
+
+Use a thread pool to execute to rules of a mapping. The current implementation is very naiv. No locking of shared data etc. Use this *only* if *you know* what you are doing and if your rules a complex enough to compensate the overhead introduced by threading.
+
+#### `thread_pool_size: [number]` [experimental]
+
+The number of threads used to execute rules if `use_threads: true`.
+
+### Per rule options
 
 #### `to: [string|lambda|proc]`
 
@@ -91,14 +105,6 @@ You can pass a lambda/proc as `processed_by` option. Inside of lambdas or procs,
 
 If a value is a string and `split_by` is supplied, the string is splitted by the given character and an array would be returned.
 
-#### `use_threads: [true|false]` [experimental]
-
-Use a thread pool to execute to rules of a mapping. The current implementation is very naiv. No locking of shared data etc. Use this *only* if *you know* what you are doing and if your rules a complex enough to compensate the overhead introduced by threading.
-
-#### `thread_pool_size: [number]` [experimental]
-
-The number of threads used to execute rules if `use_threads: true`.
-
 ## Related work
 
 * hash_mapper (https://github.com/ismasan/hash_mapper)

data/lib/yahm.rb

@@ -1,137 +1,6 @@
-require "yahm/version"
+require "hpath"
 
 class Yahm
   require "yahm/mapping"
-
-  def self.get(object, path)
-    current_path_element, remaining_path = split_path(path)
-
-    if hash_path?(current_path_element) && object.is_a?(Hash)
-      key = current_path_element[1..-1]
-
-      # handle cases where one forces symbol/string keys
-      value =
-      if key.start_with?(":")
-        object[key[1..-1].to_sym]
-      elsif key.start_with?('"') && key.end_with?('"')
-        object[key[1..-2]]
-      else
-        object[key.to_sym] || object[key.to_s]
-      end
-
-      unless value.nil?
-        remaining_path ? self.get(value, remaining_path) : value
-      else
-        value
-      end
-    elsif array_path?(current_path_element) && object.is_a?(Array)
-      index_parameter = current_path_element.slice(1..-2)
-
-      index =
-      if index_parameter == ""
-        0..object.length
-      else
-        index_parameter.to_i
-      end
-
-      if remaining_path
-        unless object[index].nil?
-          map_result = object[index.is_a?(Range) ? index : index..index].map do |array_element|
-            self.get(array_element, remaining_path)
-          end.compact
-
-          map_result == [] ? nil : map_result.flatten(array_depth(map_result) - 1)
-        else
-          nil
-        end
-      else
-        object[index]
-      end
-    end
-  end
-
-  def self.set(object, path, value)
-    current_path_element, remaining_path = split_path(path)
-    next_path_element = split_path(remaining_path)[0]
-
-    if hash_path?(current_path_element) && object.is_a?(Hash)
-      key = current_path_element[1..-1]
-
-      # handle cases where one forces symbol/string keys
-      key =
-      if key.start_with?(":")
-        key[1..-1].to_sym
-      elsif key.start_with?('"') && key.end_with?('"')
-        key[1..-2]
-      else
-        key.to_sym # keys should be symbols per default
-      end
-
-      if next_path_element.nil?
-        object[key] = value
-      elsif hash_path?(next_path_element)
-        self.set(object[key] || object[key] = {}, remaining_path, value)
-      elsif array_path?(next_path_element)
-        self.set(object[key] || object[key] = [], remaining_path, value)
-      end
-    elsif array_path?(current_path_element) && object.is_a?(Array)
-      if hash_path?(next_path_element)
-        object.push(_object = {})
-        self.set(_object, remaining_path, value)
-      end
-    end
-  end
-
-  #
-  private
-  #
-  def self.array_depth(array)
-    depth = 1
-    until array == (flattend_array = array.flatten(1))
-      depth += 1
-      array = flattend_array
-    end
-
-    depth
-  end
-  
-  def self.array_path?(path)
-    path[0] == "["
-  end
-
-  def decode_string_or_symbol_from(string)
-    if string.start_with?(":")
-      string[1..-1].to_sym
-    elsif string.start_with?('"') && string.end_with?('"')
-      string[1..-2]
-    else
-      string.to_sym # defaults to symbols
-    end
-  end
-
-  def self.hash_path?(path)
-    path[0] == "/"
-  end
-
-  def self.split_path(path)
-    unless path.nil?
-      path_elements = path
-      .gsub(/(\/)|(\[)/,
-        "/" => " /",
-        "["  => " [",
-      )
-      .split(" ")
-
-      remaining_path =
-      if path_elements.length > 1
-        path_elements.slice(1..-1).join
-      else
-        nil
-      end
-
-      [path_elements.first, remaining_path]
-    else
-      [nil, nil]
-    end
-  end
+  require "yahm/version"
 end

data/lib/yahm/mapping.rb

@@ -60,7 +60,16 @@ class Yahm::Mapping
   end
 
   def apply_rule(rule, input_hash, output_hash)
-    value = Yahm.get(input_hash, rule[:path])
+    value =
+    if rule[:path].is_a?(Array)
+      rule[:path].inject({}) do |memo, _path|
+        memo[_path] = Hpath.get(input_hash, _path)
+        memo
+      end
+    else
+      Hpath.get(input_hash, rule[:path])
+    end
+
     value = rule[:default] && value.nil? ? rule[:default] : value
     value = rule[:force_array] ? (value.nil? ? [] : [value].flatten(1)) : value
     value = rule[:split_by] && value.is_a?(String) ? value.split(rule[:split_by]).map!(&:strip) : value
@@ -69,7 +78,7 @@ class Yahm::Mapping
     if rule[:to].is_a?(Proc)
       instance_exec(value, output_hash, &rule[:to])
     else
-      Yahm.set(output_hash, rule[:to], value)
+      Hpath.set(output_hash, rule[:to], value)
     end
   end
 end

data/lib/yahm/version.rb

@@ -1,3 +1,3 @@
 class Yahm
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/spec/yahm/mapping_spec.rb

@@ -131,5 +131,18 @@ describe Yahm::Mapping do
         :array_length => 2
       })
     end
+
+    it "can map multiple input fields to one output field" do
+      mapping = Yahm::Mapping.new do
+        map ["/hello", "/world", "/foo"], to: "/combined", processed_by: lambda { |v| v.values.compact.join(" ") }
+      end
+
+      expect(mapping.apply_to({
+        hello: "hello",
+        world: "world"
+      })).to eq({
+        combined: "hello world"
+      })
+    end
   end
 end

data/spec/yahm_spec.rb

@@ -5,89 +5,4 @@ describe Yahm do
     expect(Yahm.const_defined? :Mapping).to be_true
     expect(Yahm::Mapping.class.is_a? Class)
   end
-
-  describe "#get" do
-    let(:object) do
-      {
-        hello: "world",
-        empty_array: [],
-        empty_hash: [],
-        "string_key" => "foobar",
-        some: {
-          really: [
-            {
-              nested: [
-                {
-                  structure: "hello"
-                },
-                {
-                  structure: "world"
-                }
-              ]
-            }
-          ]
-        },
-        foo: [
-          {
-            bar: 1
-          },
-          {
-            bar: 2
-          }
-        ],
-        arr_of_arrs: [
-          [ [1,2] , [3,4,5] ],
-          [ 6,7 ],
-          8
-        ]
-      }
-    end
-
-    it "returns elements which match the given path" do
-      expect(Yahm.get(object, "/hello")).to eq("world")
-      expect(Yahm.get(object, "/empty_array")).to eq([])
-      expect(Yahm.get(object, "/empty_hash")).to eq([])
-      expect(Yahm.get(object, "/foo")).to eq([{:bar=>1}, {:bar=>2}])
-      expect(Yahm.get(object, "/foo[0]")).to eq({:bar=>1})
-      expect(Yahm.get(object, "/foo[1]")).to eq({:bar=>2})
-      expect(Yahm.get(object, "/foo[]/bar")).to eq([1,2])
-      expect(Yahm.get(object, "/arr_of_arrs[0][1][2]")).to eq([5])
-      expect(Yahm.get(object, "/some/really[]/nested[]/structure")).to eq(["hello", "world"])
-      expect(Yahm.get(object, "/arr_of_arrs[0]")).to eq([[1, 2], [3, 4, 5]])
-    end
-
-    it "returns nil if the path is invalid" do
-      expect(Yahm.get(object, "/hello_world")).to eq(nil)
-      expect(Yahm.get(object, "/foo[3]")).to eq(nil)
-      expect(Yahm.get(object, "/foo[]/bar/muff")).to eq(nil)
-      expect(Yahm.get(object, "/foo[]/bar[0]")).to eq(nil)
-    end
-
-    it "allows specification of the key type using : or \"\"" do
-      expect(Yahm.get(object, '/"string_key"')).to eq("foobar")
-      expect(Yahm.get(object, '/:string_key"')).to eq(nil)
-      expect(Yahm.get(object, "/string_key")).to eq("foobar")
-    end
-  end
-
-  describe "#set" do
-    it "sets the objects value according to path and value" do
-      Yahm.set(object = {}, "/foo[]/bar", [1,2,3])
-      expect(object).to eq({:foo=>[{:bar=>[1, 2, 3]}]})
-    end
-
-    it "allows specification of the key type using : or \"\"" do
-      Yahm.set(object = {}, "/:foo/\"bar\"", "foobar")
-      expect(object).to eq({:foo=>{"bar"=>"foobar"}})
-    end
-
-    it "extends existing arrays/hashes if present" do
-      Yahm.set(object = { foo: [{bar: [1,2,3]}] }, "/foo[]/bar", [4,5,6])
-      expect(object).to eq({:foo=>[{:bar=>[1, 2, 3]}, {:bar=>[4, 5, 6]}]})
-
-      Yahm.set(object = { foo: "bar" }, "/muff", "muffmuff")
-      expect(object).to eq({:foo=>"bar", :muff=>"muffmuff"})
-    end
-
-  end
 end

data/yahm.gemspec

@@ -7,7 +7,6 @@ Gem::Specification.new do |spec|
   spec.name          = "yahm"
   spec.version       = Yahm::VERSION
   spec.authors       = ["Michael Sievers"]
-  spec.email         = ["m.sievers@ub.uni-paderborn.de"]
   spec.summary       = %q{Yet another ruby hash mapper}
   spec.homepage      = "https://github.com/ubpb/yahm"
   spec.license       = "MIT"
@@ -17,6 +16,7 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
+  spec.add_dependency "hpath",  ">= 0.0.5"
   spec.add_dependency "thread", ">= 0.1.4"
 
   spec.add_development_dependency "bundler",               "~> 1.5"

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: yahm
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Michael Sievers
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-03 00:00:00.000000000 Z
+date: 2014-06-10 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: hpath
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.5
 - !ruby/object:Gem::Dependency
   name: thread
   requirement: !ruby/object:Gem::Requirement
@@ -67,8 +81,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 description: 
-email:
-- m.sievers@ub.uni-paderborn.de
+email: 
 executables: []
 extensions: []
 extra_rdoc_files: []