yahm 0.0.13 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2268a85f2c3678373c5876d84572eef2c5c42d1d
-  data.tar.gz: c83ef4d99b06fe6cb44e2adae92c926867279abe
+  metadata.gz: 2f91884e21f0dc68a1777f51cda708d53f053608
+  data.tar.gz: c3ad59e14872e528f9a19d3b203645dbc9f9d36e
 SHA512:
-  metadata.gz: 6468ee781b3d6a486e432478773037c461d2409156c54c78e0f7dd4ee1297b1a3ceec42d6489cfa3b7aa8a2af93f788e9a319fbaac1e4f9d0217d3117baada10
-  data.tar.gz: 96bf352b68b0731ce51fee14490fb7c1a3898812c9d5ff5e48ee07246b9bfe62a824eb7d8c11557a883a032feadf0709a9f983a39ac9cea3935cfa24a9f94995
+  metadata.gz: 9d57cb78535fd2ef77a611088ed6311d0932b406e27b366de9f9ddc7477837ca14c7bbfb3814f3ce7f36a430e808186fb088528addbc979e151bcd6e0c0933ae
+  data.tar.gz: a59e91fd750bd9640cee0e3d71bb989fa7a6b8fafdf0748f927f725373344ff7e03649b18e92d5133edac055992c379bc314d592b890d8b8dddaba9cc1afce54

data/CHANGELOG.md

@@ -0,0 +1,85 @@
+## 0.0.x => 0.1.x
+
+### `Yahm::Mapping`
+
+#### Constructor now takes a block directly
+```ruby
+
+require "yahm"
+
+mapping = Yahm::Mapping.new do
+  map "/foo", to: "/bar"
+end
+```
+
+#### Constructor takes a new option ```:context```, which is used for lambda/proc method resolution
+```ruby
+some_class = Class.new do
+  require "yahm"
+
+  def some_method(value)
+    value.to_s + "bar"
+  end
+
+  def mapping
+    @mapping ||= Yahm::Mapping.new(context: self) do
+      map "/foo", to: "/bar", processed_by: lambda { |v| some_method(v) }
+    end
+  end
+
+  def apply_mapping_to(hash)
+    mapping.apply_to(hash)
+  end
+end
+
+some_class.new.apply_mapping_to({foo: "foo"})) # => {:bar=>"foobar"}
+```
+
+#### Renamed `translate_hash` to `apply_to`
+
+```ruby
+
+require "yahm"
+
+mapping = Yahm::Mapping.new do
+  map "/foo", to: "/bar"
+end
+
+# before
+# mapping.translate_hash({foo:1})
+
+# now
+mapping.apply_to({foo:1})
+```
+
+#### Lambdas/Procs as to: option now take two parameters ```|value, result|```
+
+```ruby
+require "yahm"
+
+Yahm::Mapping.new do
+  map "/source", to: lambda { |v, result| result.merge!(target: true) }
+end
+```
+
+### Removed `Yahm::HashMapper`
+
+The modul was removed, because mappings can be stored and executed with plain ruby class/instance methods without the need for a seperate modul to extend classes with.
+
+```ruby
+require "yahm"
+
+class Foo
+  def initialize(hash)
+    @hash = hash
+  end
+
+  @mapping = Yahm::Mapping.new do
+    map "/foo", to: "/bar"
+  end
+  
+  def apply_mapping_to(hash = @hash)
+    @mapping.apply_to(hash)
+  end
+end
+```

data/Gemfile

@@ -2,3 +2,8 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in yahm.gemspec
 gemspec
+
+gem "pry",                "~> 0.9.12.4"
+gem "pry-nav",            "~> 0.2.3"
+gem "pry-stack_explorer", "~> 0.4.9.1"
+gem "pry-syntax-hacks",   "~> 0.0.6"

data/README.md

@@ -18,7 +18,7 @@ Or install it yourself as:
 
 ## Dependencies
 
-None
+* thread (https://github.com/meh/ruby-thread) for threading support
 
 ## Usage
 
@@ -28,16 +28,12 @@ None
 ```ruby
 require "yahm"
 
-class Record
-  extend Yahm::HashMapper
-  
-  define_mapper :from_other_record do
-    map "/record/id", to: "/id"
-  end
+mapping = Yahm::Mapping.new do
+  map "/foo", to: "/bar"
 end
 
-Record.new.from_other_record({ ... })
-=> { :id => "..." }
+mapping.apply_to({foo: 1})
+# => {:bar=>1}
 ```
 
 ### More advanced examples
@@ -46,90 +42,62 @@ Record.new.from_other_record({ ... })
 require "yahm"
 
 class Record
-  extend Yahm::HashMapper
-  attr_accessor :translated_hash
+
+  def initialize(hash)
+    @record = mapping.apply_to(hash)
+  end
   
-  define_mapper :from_other_record, call_setter: :translated_hash= do
-    map "/record/id",         to: "/id"
-    map "/record/count",      to: "/count", processed_by: :to_i
-    map "/record/subject[0]", to: "/subjects/most_important_subject"
-    map "/record/languages",  to: "/languages", force_array: true
-    map "/record/authors",    to: "/authors", split_by: ";"
-    map "/record/version",    to: "/version", default: 1
+  private
+  
+  def lookup_id(id)
+    # ...
+  end
+  
+  def mapping
+    @mapping ||= Yahm::Mapping.new(context: self) do
+      map "/record/id",          to: "/id", processed_by: lambda { |id| lookup_id(id) }
+      map "/record/count",       to: "/count", processed_by: proc { |count| count.to_i }
+      map "/record/subject[0]",  to: "/subjects/most_important_subject"
+      map "/record/languages[]", to: "/languages", force_array: true
+      map "/record/authors",     to: "/authors", split_by: ";"
+      map "/record/version",     to: "/version", default: 1
+      map "/record/label",       to: lambda { |label, result| result[:label] = label }
+    end
   end
 end
 
-Record.new.from_other_record({ ... })
-=> { :id => "...", :count => ..., :subjects => { :most_important_subject => "..."}, ... }
-
-Record.translated_hash
+Record.new({ ... })
 => { :id => "...", :count => ..., :subjects => { :most_important_subject => "..."}, ... }
 ```
+### Options
 
-#### Examples for using `to`
+#### `to: [string|lambda|proc]`
 
-The `to` option of a mapping rule can either be a string, naming the path in the resultung hash or a proc, which is executed in the context of the created mapper. The result hash can be accessed by `@result`.
+The `to` option of a mapping rule can either be a string, naming the path in the resultung hash or a lambda/proc, which is executed within the created mapper. When a `context` option was supplied to `#new` or `apply_to` methods are also resolved against this scope.
 
-```ruby
-require "yahm"
+#### `default: [value]`
 
-class Record
-  extend Yahm::HashMapper
-  
-  define_mapper :from_other_record do
-    def funky_method(value)
-      @result[:is_funky] = true if funky?(value)
-    end
-  
-    map "/record/count",        to: "count"
-    map "/record/name",         to: lambda { |v| funky_method(v) }
-  end
-end
-```
+If a value would be `nil` and `default` is given, the `default` value is used instead of `nil`.
 
-#### Examples for using `processed_by`
+#### `force_array: [true|false]`
 
-You can pass symbols, lambdas or procs as `processed_by` option. Inside of lambdas or procs, `self` corresponds to the context of the defined mapper. To access the context of to extended object, use `_self`.
+This ensures, that the value written in the result ist always a hash. Even when the result would be `nil`, an empty array is created.
 
+#### `processed_by: [lambda|proc]`
 
-```ruby
-require "yahm"
+You can pass a lambda/proc as `processed_by` option. Inside of lambdas or procs, `self` corresponds to the context of the defined mapper. When a `context` option was supplied to `#new` or `apply_to` methods are also resolved against this scope.
 
-class Record
-  extend Yahm::HashMapper
-  
-  def process_bool_string(string)
-    string == "true" ? true : (string == "false" ? false : nil)
-  end
-  
-  define_mapper :from_other_record do
-    def cheap?(price)
-      price.to_i < 20
-    end
-  
-    map "/record/id",           to: "id",        processed_by: :to_i
-    map "/record/count",        to: "count",     processed_by: proc { |v| v.to_i }
-    map "/record/subject",      to: "subjects",  processed_by: :downcase
-    map "/record/price",        to: "is_cheap",  processed_by: lambda { |v| cheap?(v) }
-    map "/record/is_available", to: "available", processed_by: lambda { |v| _self.process_bool_string(v) }
-  end
-end
-```
+#### `split_by: [string]`
 
-#### Private mappers
+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.
 
-You can control, wether a mapper is defined as a private method or not by passing the `private:[true|false]` option to `define_mapper`.
+#### `use_threads: [true|false]` [experimental]
 
-```ruby
+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.
 
-class Record
-  extend Yahm::HashMapper
- 
-  define_mapper :my_private_mapper, private: true do
-    map "/some/internals", to: "internals"
-  end
-end
-```
+#### `thread_pool_size: [number]` [experimental]
+
+The number of threads used to execute rules if `use_threads: true`.
 
 ## Related work
 

data/lib/yahm.rb

@@ -1,6 +1,137 @@
 require "yahm/version"
 
 class Yahm
-  require "yahm/hash_mapper"
   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
 end

data/lib/yahm/mapping.rb

@@ -1,76 +1,75 @@
+require "thread/pool"
+
 class Yahm::Mapping
 
-  attr_reader :_self
+  attr_accessor :thread_pool_size
+  attr_accessor :use_threads
 
   def initialize(options = {}, &block)
+    @context = options[:context]
     @rules = []
     @result = nil
-    self.instance_eval(&block) if block
-  end
+    @use_threads = options[:use_threads] || false
+    @thread_pool_size = options[:thread_pool_size] || 2
 
-  def map(str, options = {})
-    @rules.push [str, options]
-    self
+    self.instance_eval(&block) if block
   end
 
-  def translate_hash(input_hash, options = {})
-    @_self = options[:_self]
+  def apply_to(input_hash, options = {})
     @result = {}
 
-    @rules.each do |rule|
-      process_rule(input_hash, rule)
+    if @use_threads
+      thread_pool = Thread.pool(@thread_pool_size) if @use_threads
+
+      @rules.each do |rule|
+        thread_pool.process do
+          apply_rule(rule, input_hash, @result)
+        end
+      end
+    
+      thread_pool.shutdown
+    else
+      @rules.each do |rule|
+        apply_rule(rule, input_hash, @result)
+      end
     end
 
     @result
   end
 
-  alias_method :apply_to, :translate_hash # some syntactic sugar
-
-  private
-
-  def process_rule(input_hash, rule)
-    sanitized_source_path = rule.first
-    .sub(/^\//, "")
-    .gsub(/\[(\d+)\]/, "/\\1")
-    .split("/")
-    .map do |element|
-      if element[/\A\d+\Z/]
-        element.to_i
-      else
-        element.to_sym
-      end
-    end
-
-    if (to_option = rule.last[:to]).is_a?(String)
-      sanitized_target_path = rule.last[:to].sub(/^\//, "").split("/").map(&:to_sym)
-      target_parent_path = sanitized_target_path.slice(0, sanitized_target_path.length - 1)
+  #
+  # dynamic context method resolutuon
+  #
+  def method_missing(sym, *args, &block)
+    if @context.respond_to?(sym)
+      @context.send(sym, *args, &block)
+    else
+      super
     end
+  end
 
-    source_value = sanitized_source_path.inject(input_hash) { |hash, key| hash.nil? ? nil : hash[key]}
+  def respond_to_missing?(sym, *)
+    @context.respond_to?(sym) || super
+  end
 
-    unless (symbol_or_callable = rule.last[:processed_by]).nil?
-      source_value = if symbol_or_callable.is_a?(Symbol)
-        source_value.send(symbol_or_callable)
-      else
-        symbol_or_callable.call(source_value)
-      end
-    end
+  private
 
-    unless (split_by_character = rule.last[:split_by]).nil?
-      source_value = source_value.split(split_by_character).map(&:strip) unless source_value.nil? || source_value.is_a?(Array)
-    end
+  def map(path, options = {})
+    @rules.push({ path: path }.merge(options))
+    self
+  end
 
-    unless rule.last[:force_array].nil?
-      source_value = (source_value.is_a?(Array) ? source_value : [source_value]).compact
-    end
+  def apply_rule(rule, input_hash, output_hash)
+    value = Yahm.get(input_hash, rule[:path])
+    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
+    value = rule[:processed_by] ? rule[:processed_by].call(value) : value
 
-    if to_option.is_a?(String)
-      target_hash_parent_element = target_parent_path.inject(@result) { |hash, key| hash[key.to_sym] ||= {} }
-      target_hash_parent_element.merge!({
-        sanitized_target_path.last => ((source_value.nil? && !(default_value = rule.last[:default]).nil?) ? default_value : source_value)
-      })
-    elsif to_option.is_a?(Proc)
-      instance_exec(source_value, &to_option)
+    if rule[:to].is_a?(Proc)
+      instance_exec(value, output_hash, &rule[:to])
+    else
+      Yahm.set(output_hash, rule[:to], value)
     end
   end
 end

data/lib/yahm/version.rb

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

data/spec/spec_helper.rb

@@ -1,5 +1,8 @@
 require "yahm"
-require "pry"
+begin
+  require "pry"
+rescue LoadError
+end
 
 # See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
 RSpec.configure do |config|

data/spec/yahm/mapping_spec.rb

@@ -1,32 +1,54 @@
 require_relative "../spec_helper"
 
 describe Yahm::Mapping do
-  it "is a class used internally by Yahm::HashMapper#define_mapper" do
-  end
+  describe "#new" do
+    it "can be called with a block, containing the mapping described by the DSL" do
+      mapping = Yahm::Mapping.new do
+        map "/foo", to: "/bar"
+      end
+
+      expect(mapping.apply_to({foo:1})).to eq({:bar=>1})
+    end
+
+    context "when called with a \"context\" option" do
+      it "passes methods from withing the mapping (e.g. procs/lambdas) to the context" do
+        some_class = Class.new do
+          require "yahm"
 
-  describe ".map" do
-    let(:mapping) { Yahm::Mapping.new }
+          def some_method(value)
+            value.to_s + "bar"
+          end
 
-    it "adds a mapping rule to a mapping" do
-      mapping.map("/foo", to: "bar")
-      expect(mapping.instance_variable_get :@rules).not_to be_nil
+          def mapping
+            @mapping ||= Yahm::Mapping.new(context: self) do
+              map "/foo", to: "/bar", processed_by: lambda { |v| some_method(v) }
+            end
+          end
+
+          def apply_mapping_to(hash)
+            mapping.apply_to(hash)
+          end
+        end
+       
+        expect(some_class.new.apply_mapping_to({foo: "foo"})).to eq({:bar=>"foobar"})
+      end
     end
   end
-  
-  describe ".translate_hash" do
+
+  describe ".apply_to" do
     let(:mapping) do
-      _mapping = Yahm::Mapping.new
-      _mapping.map "/record_id",          to: "/id"
-      _mapping.map "/record/title",       to: "/tile"
-      _mapping.map "/record/isbns",       to: "/my_data/isbns"
-      _mapping.map "/record/isbns[1]",    to: "/main_isbn"                     # when an array, one can specifiy which element to choose
-      _mapping.map "/record/count",       to: "/count", :processed_by => :to_i # processed_by specifies a method which post_processes to value
-      _mapping.map "/record/languages",   to: "/languages", force_array: true
-      _mapping.map "/record/authors",     to: "/authors", split_by: ";"
-      _mapping.map "/record/version",     to: "/version", default: 1
-      _mapping.map "/record/creators",    to: "/creators", force_array: true   # when source value is nil, there should be an empty array in the target hash
-      _mapping.map "/record/publishers",  to: "/publishers", split_by: ";"     # if there are is no source value, this should result to nil in the target hash
-      _mapping
+      Yahm::Mapping.new do
+        map "/record_id",          to: "/id"
+        map "/record/title",       to: "/title"
+        map "/record/isbns",       to: "/my_data/isbns"
+        map "/record/isbns[1]",    to: "/main_isbn"                     # when an array, one can specifiy which element to choose
+        map "/record/count",       to: "/count", processed_by: lambda { |v| v.to_i }
+        map "/record/languages",   to: "/languages", force_array: true
+        map "/record/authors",     to: "/authors", split_by: ";"
+        map "/record/version",     to: "/version", default: 1
+        map "/record/creators",    to: "/creators", force_array: true   # when source value is nil, there should be an empty array in the target hash
+        map "/record/publishers",  to: "/publishers", split_by: ";"     # if there are is no source value, this should result to nil in the target hash
+      end
     end
 
     let(:input_hash) do
@@ -45,10 +67,10 @@ describe Yahm::Mapping do
       }
     end
 
-    it "translates a given hash according to @rules" do
-      expect(mapping.translate_hash(input_hash)).to eq({
+    let(:expected_result) do
+      {
         :id=>"some_id123",
-        :tile=>"some title",
+        :title=>"some title",
         :my_data=>{:isbns=>["3-86680-192-0", "3-680-08783-7"]},
         :main_isbn=>"3-680-08783-7",
         :count=>3,
@@ -57,48 +79,57 @@ describe Yahm::Mapping do
         :version=>1,
         :creators=>[],
         :publishers=>nil
-      })
+      }
+    end
+
+    it "translates a given hash according to @rules" do
+      expect(mapping.apply_to(input_hash)).to eq(expected_result)
     end
 
+    context "when threading is enabled" do
+      it "translates a given hash according to @rules" do
+        mapping.use_threads = true
+        expect(mapping.apply_to(input_hash)).to eq(expected_result)
+      end
+    end
+    
     it "does not apply \"split_by\" if source value is an array" do
-      expect(Yahm::Mapping.new.map("/source/value", to: "/target", split_by: ";").translate_hash(source: { value: ["foo", "foo;bar"] }))
+      expect(Yahm::Mapping.new { map "/source/value", to: "/target", split_by: ";" }.apply_to(source: { value: ["foo", "foo;bar"] }))
       .to eq({
         :target => ["foo", "foo;bar"]
       })
     end
 
     it "processes the source value by the lambda/proc given by \"processed_by\"" do
-      expect(Yahm::Mapping.new.map("/source/value", to: "/target", processed_by: lambda { |v| v.downcase }).translate_hash(source: { value: "A STRING" }))
+      expect(Yahm::Mapping.new { map "/source/value", to: "/target", processed_by: lambda { |v| v.downcase } }.apply_to(source: { value: "A STRING" }))
       .to eq({
         :target => "a string"
       })
 
-      expect(Yahm::Mapping.new.map("/source/value", to: "/target", processed_by: proc { |v| v.downcase }).translate_hash(source: { value: "A STRING" }))
+      expect(Yahm::Mapping.new { map "/source/value", to: "/target", processed_by: proc { |v| v.downcase } }.apply_to(source: { value: "A STRING" }))
       .to eq({
         :target => "a string"
       })
     end
 
     it "returns nil if the source path does not exist" do
-      expect(Yahm::Mapping.new.map("/source/value/min", to: "/target").translate_hash(foo: "bar"))
-      .to eq({
+      expect(Yahm::Mapping.new { map "/source/value/min", to: "/target" }.apply_to(foo: "bar")).to eq({
         :target => nil
       })
     end
 
     it "accepts a lambda/proc as :to option" do
-      expect(Yahm::Mapping.new.map("/source", to: proc { |v| @result = { target: true } }).translate_hash(foo: "bar"))
+      expect(Yahm::Mapping.new { map "/source", to: lambda { |v, result| result.merge!(target: true) } }.apply_to(foo: "bar"))
       .to eq({
         :target => true
       })
     end
 
     it "provides multiple values as an array of values to lambdas/procs" do
-      expect(Yahm::Mapping.new.map("/source", to: "/array_length",  processed_by: lambda { |v| v.length }).translate_hash(source: ["bar", "moep"]))
+      expect(Yahm::Mapping.new { map "/source", to: "/array_length",  processed_by: lambda { |v| v.length } }.apply_to(source: ["bar", "moep"]))
       .to eq({
         :array_length => 2
       })
     end
   end
-
 end

data/spec/yahm_spec.rb

@@ -1,8 +1,93 @@
 require_relative "./spec_helper"
 
 describe Yahm do
-  it "has a module called HashMapper" do
-    expect(Yahm.const_defined? :HashMapper).to be_true
-    expect(Yahm::HashMapper.class.is_a? Module)
+  it "has a class named Mapping" 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

@@ -17,11 +17,9 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
+  spec.add_dependency "thread", ">= 0.1.4"
+
   spec.add_development_dependency "bundler",               "~> 1.5"
-  spec.add_development_dependency "pry",                   "~> 0.9.12.4"
-  spec.add_development_dependency "pry-nav",               "~> 0.2.3"
-  spec.add_development_dependency "pry-stack_explorer",    "~> 0.4.9.1"
-  spec.add_development_dependency "pry-syntax-hacks",      "~> 0.0.6"
-  spec.add_development_dependency "rspec",                 "~> 2.14.1"
+  spec.add_development_dependency "rspec",                 ">= 2.14.1"
   spec.add_development_dependency "rake"
 end

metadata

@@ -1,97 +1,55 @@
 --- !ruby/object:Gem::Specification
 name: yahm
 version: !ruby/object:Gem::Version
-  version: 0.0.13
+  version: 0.1.0
 platform: ruby
 authors:
 - Michael Sievers
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-02 00:00:00.000000000 Z
+date: 2014-06-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.5'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.5'
-- !ruby/object:Gem::Dependency
-  name: pry
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.9.12.4
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.9.12.4
-- !ruby/object:Gem::Dependency
-  name: pry-nav
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.2.3
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.2.3
-- !ruby/object:Gem::Dependency
-  name: pry-stack_explorer
+  name: thread
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.4.9.1
-  type: :development
+        version: 0.1.4
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.4.9.1
+        version: 0.1.4
 - !ruby/object:Gem::Dependency
-  name: pry-syntax-hacks
+  name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.0.6
+        version: '1.5'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.0.6
+        version: '1.5'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: 2.14.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: 2.14.1
 - !ruby/object:Gem::Dependency
@@ -117,16 +75,15 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".rspec"
+- CHANGELOG.md
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - lib/yahm.rb
-- lib/yahm/hash_mapper.rb
 - lib/yahm/mapping.rb
 - lib/yahm/version.rb
 - spec/spec_helper.rb
-- spec/yahm/hash_mapper_spec.rb
 - spec/yahm/mapping_spec.rb
 - spec/yahm_spec.rb
 - yahm.gemspec
@@ -156,6 +113,5 @@ specification_version: 4
 summary: Yet another ruby hash mapper
 test_files:
 - spec/spec_helper.rb
-- spec/yahm/hash_mapper_spec.rb
 - spec/yahm/mapping_spec.rb
 - spec/yahm_spec.rb

data/lib/yahm/hash_mapper.rb

@@ -1,20 +0,0 @@
-module Yahm::HashMapper
-  def define_mapper(mapper_method_name, options = {}, &block)
-    mapping = Yahm::Mapping.new(&block)
-
-    define_method mapper_method_name do |hash|
-      translated_hash = mapping.translate_hash(hash, _self: self)
-      unless (setter_name = options[:call_setter]).nil?
-        self.send(setter_name, translated_hash)
-      end
-
-      translated_hash
-    end
-
-    if options[:private]
-      private mapper_method_name.to_sym
-    end
-
-    self
-  end
-end

data/spec/yahm/hash_mapper_spec.rb

@@ -1,88 +0,0 @@
-require_relative "../spec_helper"
-
-describe Yahm::HashMapper do
-  context "when extending a class" do
-    let(:class_extended_with_hash_mapper) do
-      class MyClass
-        extend Yahm::HashMapper
-      end
-    end
-
-    it "adds a class method called #define_mapper" do
-      expect(class_extended_with_hash_mapper.methods).to include(:define_mapper)
-    end
-  end
-
-  describe "#define_mapper" do
-    let(:class_extended_with_hash_mapper) do
-      Class.new do
-        extend Yahm::HashMapper
-
-        def method_of_extended_object(value)
-          true
-        end
-
-        define_mapper :my_mapper do
-          def mapper_local_method(value)
-            true
-          end
-
-          map "/source[0]", to: "target_1", processed_by: proc { |v| mapper_local_method(v) }
-          map "/source[1]", to: "target_2", processed_by: proc { |v| _self.method_of_extended_object(v) }
-          map "/source[2]", to: "target_3", processed_by: proc { |v| another_local_method(v) }
-
-          def another_local_method(value)
-            true
-          end
-        end
-
-        define_mapper :my_private_mapper, private: true do
-        end
-      end
-    end
-
-    it "adds a named mapper method to the instances of the extended class" do
-      expect(class_extended_with_hash_mapper.new).to respond_to(:my_mapper)
-    end
-
-    it "provides the context of the defined mapper as \"self\" for \"processed_by\" callables" do
-      expect(class_extended_with_hash_mapper.new.my_mapper({source: ["foo", "bar"]})).to eq({
-        target_1: true,
-        target_2: true,
-        target_3: true
-      })      
-    end
-
-    it "provides the context of the extended object as \"_self\" for \"processed_by\" callables" do
-      expect(class_extended_with_hash_mapper.new.my_mapper({source: ["foo", "bar"]})).to eq({
-        target_1: true,
-        target_2: true,
-        target_3: true
-      })
-    end
-
-    context "when called with an option called 'call_setter'" do
-      let(:class_extended_with_hash_mapper) do
-        Class.new do
-          extend Yahm::HashMapper
-
-          attr_accessor :my_result
-
-          define_mapper :my_mapper, call_setter: :my_result= do
-          end
-        end
-      end
-
-      it "calls a method with the given name with the result of the mapping" do
-        (instance = class_extended_with_hash_mapper.new).my_mapper({})
-        expect(instance.my_result).not_to be_nil
-      end
-    end
-
-    context "when called with private: true" do
-      it "adds a private named mapper method to the instances of the extended class" do
-        expect(class_extended_with_hash_mapper.new.private_methods).to include(:my_private_mapper)
-      end
-    end
-  end
-end