aduki 0.1.3 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 79dc256c2fd9daa39c568a3a85d1f30a3104a70b
-  data.tar.gz: 46d3a666d1711db748a7d8657c7eca5000dd1739
+  metadata.gz: b7074743cb0761525eaa92e7b9c6e3c942b2b27d
+  data.tar.gz: 757b6d2914b0d256e9b2404f959f85a0bd42662d
 SHA512:
-  metadata.gz: 0cf02afb1c9e116f720ade13f302d67fe54d7f1c29195a03211be5d5f7bdddcd804633889cb32da08dc446fced8f4d529aac230138f64308ef41897534daeb62
-  data.tar.gz: b97ea592dd63f5bb6cd986ccae8ed1f13dfbb03e7885894829df5668aaf078a973d9e3f006af7c1e3eb3dea08ebc932e475306fbeb4ee6464ca68fd2271c9dc7
+  metadata.gz: 23d19d50ef586a3dd4a2c29061a2fe8fca8837d235182a97bd9f0dedd1274019761e7b93ca14ef6d9aff0b504fcba8a49d1c6bfa17bb9eadb864b2d209df783a
+  data.tar.gz: 32443cdd6d8b1ef2008e1f33b4658f6097d6c17e7c2053937fb6bb47368a5fe4f518809b19913da6e266584750e4270ce47848bb34a3b4469aebdfafb8ca3a86

data/lib/aduki.rb

@@ -1,6 +1,8 @@
 require "date"
 require "time"
 require "aduki/version"
+require "aduki/recursive_hash"
+require "aduki/attr_finder"
 
 module Aduki
   def self.to_aduki obj, collector={ }, key="", join=""
@@ -108,7 +110,7 @@ module Aduki
       existing_value = object.send setter if object.respond_to?(setter)
       if existing_value
         if existing_value.is_a? Hash
-          existing_value.merge! value
+          value.each { |k, v| existing_value[k] = v }
         else
           Aduki.apply_attributes existing_value, value
         end
@@ -169,6 +171,14 @@ module Aduki
     def get_aduki_initializers
       @@initializers[self] || []
     end
+
+    def attr_finder finder, id, *args
+      class_eval Aduki::AttrFinder.attr_finders_text(finder, id, *args)
+    end
+
+    def attr_many_finder finder, id, name, options={ }
+      class_eval Aduki::AttrFinder.one2many_attr_finder_text(finder, id, name, options={ })
+    end
   end
 
   module Initializer

data/lib/aduki/attr_finder.rb

@@ -0,0 +1,90 @@
+class Aduki::AttrFinder
+  if defined? ActiveSupport
+    def self.camelize    str ; str.to_s.camelize    ; end
+    def self.singularize str ; str.to_s.singularize ; end
+    def self.pluralize   str ; str.to_s.pluralize   ; end
+  else
+    def self.camelize str
+      str.split(/\//).map { |s| s.gsub(/(^|_)([a-z])/) { |m| $2.upcase } }.join("::")
+    end
+    def self.singularize str
+      str.to_s.gsub(/ies$/, "y").gsub(/s$/, '')
+    end
+    def self.pluralize str
+      str.to_s.gsub(/y$/, "ies").gsub(/([^s])$/, '\1s')
+    end
+  end
+
+  def self.hashify_args a
+    return a.first if a.first.is_a? Hash
+    a.inject({ }) { |hash, arg|
+      if arg.is_a?(Hash)
+        hash.merge arg
+      else
+        hash[arg] = camelize arg.to_s
+        hash
+      end
+    }
+  end
+
+  def self.attr_finders_text finder, id, *args
+    hashify_args(args).map { |name, klass|
+      attr_finder_text finder, id, name, klass
+    }.join("\n")
+  end
+
+  def self.attr_finder_text finder, id, name, klass
+    id_method = "#{name}_#{id}"
+    <<EVAL
+remove_method :#{id_method}  if method_defined?(:#{id_method})
+remove_method :#{id_method}= if method_defined?(:#{id_method}=)
+remove_method :#{name}       if method_defined?(:#{name})
+remove_method :#{name}=      if method_defined?(:#{name}=)
+
+attr_reader :#{id_method}
+
+def #{id_method}= x
+  @#{id_method}= x
+  @#{name} = nil
+end
+
+def #{name}
+  @#{name} ||= #{klass}.#{finder}(@#{id_method}) unless @#{id_method}.nil? || @#{id_method} == ''
+end
+
+def #{name}= x
+  @#{name} = x
+  @#{id_method} = x ? x.#{id} : nil
+end
+EVAL
+  end
+
+  def self.one2many_attr_finder_text finder, id, name, options={ }
+    singular = singularize name.to_s
+    klass    = options[:class_name] || camelize(singular)
+    id_method = "#{singular}_#{pluralize id}"
+    <<EVAL
+remove_method :#{id_method}  if method_defined?(:#{id_method})
+remove_method :#{id_method}= if method_defined?(:#{id_method}=)
+remove_method :#{name}       if method_defined?(:#{name})
+remove_method :#{name}=      if method_defined?(:#{name}=)
+
+attr_reader :#{id_method}
+
+def #{id_method}= x
+  @#{id_method} = x
+  @#{name}      = nil
+end
+
+def #{name}
+  @#{name} ||= #{klass}.#{finder} @#{id_method} unless @#{id_method}.nil?
+end
+
+def #{name}= x
+  @#{id_method} = x ? x.map(&:#{id}) : nil
+  @#{name}      = x
+end
+EVAL
+  end
+
+end

data/lib/aduki/recursive_hash.rb

@@ -0,0 +1,33 @@
+require 'aduki'
+
+class Aduki::RecursiveHash < Hash
+  def []= key, value
+    return super(key, value) unless key.is_a? String
+
+    k0, k1 = key.split(/\./, 2)
+
+    if k0.match(/\[\d+\]$/)
+      getter = k0.gsub(/\[\d+\]$/, '')
+      index  = k0.gsub(/.*\[(\d+)\]$/, '\1').to_i
+      subarray = self[getter] || []
+      if k1
+        subarray[index] ||= Aduki::RecursiveHash.new
+        subarray[index][k1] = value
+      else
+        subarray[index] = value
+      end
+      super getter, subarray
+    else
+      return super(key, value) if k1.nil?
+      existing = self[k0]
+      subhash = (existing.is_a? Hash) ? existing : Aduki::RecursiveHash.new
+      subhash[k1] = value
+      super k0, subhash
+    end
+  end
+
+  def copy other
+    other.each { |k, v| self[k]= v }
+    self
+  end
+end

data/lib/aduki/version.rb

@@ -1,3 +1,3 @@
 module Aduki
-  VERSION = "0.1.3"
+  VERSION = "0.2.0"
 end

data/spec/attr_finder_spec.rb

@@ -0,0 +1,21 @@
+require "aduki"
+require "spec_helper"
+
+describe Aduki::AttrFinder do
+  it "should assign a value using attr_finder" do
+    props = {
+      "name"           => "Eamonn de Valera",
+      "city_name"      => "dublin",
+      "gift_names[0]"  => "dinner",
+      "gift_names[1]"  => "whiskey",
+      "gift_names[2]"  => "cigars",
+    }
+
+    politician = Politician.new props
+
+    expect(politician.name).to eq "Eamonn de Valera"
+    expect(politician.city).to eq City::CITIES["dublin"]
+    expect(politician.city.name).to eq "dublin"
+    expect(politician.gifts).to eq [Gift.lookup("dinner"), Gift.lookup("whiskey"), Gift.lookup("cigars")]
+  end
+end

data/spec/custom_builder_spec.rb

@@ -12,7 +12,7 @@ describe Aduki::Initializer do
     contraption = MachineBuilder.new props
 
     expect(contraption.name).to eq "Anna Livia"
-    expect(contraption.city).to eq CITIES["dublin"]
-    expect(contraption.city.name).to eq "Dublin"
+    expect(contraption.city).to eq City::CITIES["dublin"]
+    expect(contraption.city.name).to eq "dublin"
   end
 end

data/spec/finder_spec.rb

@@ -0,0 +1,136 @@
+require "aduki"
+require "aduki/attr_finder"
+require "spec_helper"
+
+describe Aduki::AttrFinder do
+  it "generates code for a single attribute" do
+    txt = Aduki::AttrFinder.attr_finder_text :find, :id, "widget_holder", "WidgetHolder"
+    expected = <<EXPECTED
+remove_method :widget_holder_id  if method_defined?(:widget_holder_id)
+remove_method :widget_holder_id= if method_defined?(:widget_holder_id=)
+remove_method :widget_holder       if method_defined?(:widget_holder)
+remove_method :widget_holder=      if method_defined?(:widget_holder=)
+
+attr_reader :widget_holder_id
+
+def widget_holder_id= x
+  @widget_holder_id= x
+  @widget_holder = nil
+end
+
+def widget_holder
+  @widget_holder ||= WidgetHolder.find(@widget_holder_id) unless @widget_holder_id.nil? || @widget_holder_id == ''
+end
+
+def widget_holder= x
+  @widget_holder = x
+  @widget_holder_id = x ? x.id : nil
+end
+EXPECTED
+
+    expect(txt).to eq expected
+  end
+
+  it "generates code for multiple attributes" do
+    txt = Aduki::AttrFinder.attr_finders_text :open, :time, :happy_hour, widget: "WidgetHolder::Base"
+    expected = <<EXPECTED
+remove_method :happy_hour_time  if method_defined?(:happy_hour_time)
+remove_method :happy_hour_time= if method_defined?(:happy_hour_time=)
+remove_method :happy_hour       if method_defined?(:happy_hour)
+remove_method :happy_hour=      if method_defined?(:happy_hour=)
+
+attr_reader :happy_hour_time
+
+def happy_hour_time= x
+  @happy_hour_time= x
+  @happy_hour = nil
+end
+
+def happy_hour
+  @happy_hour ||= HappyHour.open(@happy_hour_time) unless @happy_hour_time.nil? || @happy_hour_time == ''
+end
+
+def happy_hour= x
+  @happy_hour = x
+  @happy_hour_time = x ? x.time : nil
+end
+
+remove_method :widget_time  if method_defined?(:widget_time)
+remove_method :widget_time= if method_defined?(:widget_time=)
+remove_method :widget       if method_defined?(:widget)
+remove_method :widget=      if method_defined?(:widget=)
+
+attr_reader :widget_time
+
+def widget_time= x
+  @widget_time= x
+  @widget = nil
+end
+
+def widget
+  @widget ||= WidgetHolder::Base.open(@widget_time) unless @widget_time.nil? || @widget_time == ''
+end
+
+def widget= x
+  @widget = x
+  @widget_time = x ? x.time : nil
+end
+EXPECTED
+
+    expect(txt).to eq expected
+  end
+
+  it "generates a one-to-many finder" do
+    txt = Aduki::AttrFinder.one2many_attr_finder_text :purchase, :price, :birthday_gifts
+    expected = <<EXPECTED
+remove_method :birthday_gift_prices  if method_defined?(:birthday_gift_prices)
+remove_method :birthday_gift_prices= if method_defined?(:birthday_gift_prices=)
+remove_method :birthday_gifts       if method_defined?(:birthday_gifts)
+remove_method :birthday_gifts=      if method_defined?(:birthday_gifts=)
+
+attr_reader :birthday_gift_prices
+
+def birthday_gift_prices= x
+  @birthday_gift_prices = x
+  @birthday_gifts      = nil
+end
+
+def birthday_gifts
+  @birthday_gifts ||= BirthdayGift.purchase @birthday_gift_prices unless @birthday_gift_prices.nil?
+end
+
+def birthday_gifts= x
+  @birthday_gift_prices = x ? x.map(&:price) : nil
+  @birthday_gifts      = x
+end
+EXPECTED
+    expect(txt).to eq expected
+  end
+
+  it "generates a one-to-many finder with alternative class name" do
+    txt = Aduki::AttrFinder.one2many_attr_finder_text :purchase, :price, :birthday_gifts, class_name: "ToyShop"
+    expected = <<EXPECTED
+remove_method :birthday_gift_prices  if method_defined?(:birthday_gift_prices)
+remove_method :birthday_gift_prices= if method_defined?(:birthday_gift_prices=)
+remove_method :birthday_gifts       if method_defined?(:birthday_gifts)
+remove_method :birthday_gifts=      if method_defined?(:birthday_gifts=)
+
+attr_reader :birthday_gift_prices
+
+def birthday_gift_prices= x
+  @birthday_gift_prices = x
+  @birthday_gifts      = nil
+end
+
+def birthday_gifts
+  @birthday_gifts ||= ToyShop.purchase @birthday_gift_prices unless @birthday_gift_prices.nil?
+end
+
+def birthday_gifts= x
+  @birthday_gift_prices = x ? x.map(&:price) : nil
+  @birthday_gifts      = x
+end
+EXPECTED
+    expect(txt).to eq expected
+  end
+end

data/spec/initializer_spec.rb

@@ -252,7 +252,7 @@ describe Aduki::Initializer do
     expect(model.gadget.speaker.threads).to eq [ 12.4, 8.16, 21.42 ]
   end
 
-  it "should handle pre-initialized hashes with a previously-set array type" do
+  it "should handle pre-initialized hashes" do
     props = {
       "name"                => "Brackish Water",
       "gadget.name"         => "The Loud Gadget",
@@ -265,4 +265,105 @@ describe Aduki::Initializer do
 
     expect(model.gadget.variables).to eq({ "x"=> "29", "y" => "12.4", "z" => "8.16"})
   end
+
+  it "should handle pre-initialized hashes with more complex subkeys" do
+    props = {
+      "name"                => "Brackish Water",
+      "gadget.name"         => "The Loud Gadget",
+      "gadget.variables.x[4]" => "24",
+      "gadget.variables.x[7]" => "27",
+      "gadget.variables.x[3].length" => "3",
+      "gadget.variables.x[3].width"  => "13",
+      "gadget.variables.x[3].depth[0]"       => "23",
+      "gadget.variables.x[3].depth[1].high"  => "23+10",
+      "gadget.variables.x[3].depth[1].low"   => "23-10",
+      "gadget.variables.x[3].depth[2]"       => "33",
+      "gadget.variables.y.fortune"   => "flavours",
+      "gadget.variables.y.help"      => "F1",
+      "gadget.variables.y.pandora"   => "boxy",
+      "gadget.variables.z" => "8.16",
+    }
+
+    model = Model.new props
+
+    expected = {
+      "x"=> [
+             nil,
+             nil,
+             nil,
+             {
+               "length" => "3",
+               "width" => "13",
+               "depth" => [
+                           "23",
+                           { "high" => "23+10", "low" => "23-10"},
+                           "33"
+                          ],
+             },
+             "24",
+             nil,
+             nil,
+             "27"
+            ],
+      "y" => {
+        "fortune" => "flavours",
+        "help" => "F1",
+        "pandora" => "boxy"},
+      "z" => "8.16"
+    }
+    expect(model.gadget.variables).to eq expected
+  end
+
+  it "creates a new hash by recursively splitting string keys on separator-character" do
+    props = {
+      "name"                => "Brackish Water",
+      "gadget.name"         => "The Loud Gadget",
+      "gadget.variables.x[4]" => "24",
+      "gadget.variables.x[7]" => "27",
+      "gadget.variables.x[3].length" => "3",
+      "gadget.variables.x[3].width"  => "13",
+      "gadget.variables.x[3].depth[0]"       => "23",
+      "gadget.variables.x[3].depth[1].high"  => "23+10",
+      "gadget.variables.x[3].depth[1].low"   => "23-10",
+      "gadget.variables.x[3].depth[2]"       => "33",
+      "gadget.variables.y.fortune"   => "flavours",
+      "gadget.variables.y.help"      => "F1",
+      "gadget.variables.y.pandora"   => "boxy",
+      "gadget.variables.z" => "8.16",
+    }
+
+    hash = Aduki::RecursiveHash.new.copy props
+    expected = {
+      "name" => "Brackish Water",
+      "gadget" => {
+        "name" => "The Loud Gadget",
+        "variables" => {
+          "x"=> [
+                 nil,
+                 nil,
+                 nil,
+                 {
+                   "length" => "3",
+                   "width" => "13",
+                   "depth" => [
+                               "23",
+                               { "high" => "23+10", "low" => "23-10"},
+                               "33"
+                              ],
+                 },
+                 "24",
+                 nil,
+                 nil,
+                 "27"
+                ],
+          "y" => {
+            "fortune" => "flavours",
+            "help" => "F1",
+            "pandora" => "boxy"},
+          "z" => "8.16"
+        }
+      }
+    }
+    expect(hash).to eq expected
+  end
 end

data/spec/merge_attributes_spec.rb

@@ -83,4 +83,43 @@ describe Aduki::Initializer do
     expect(model.gadget.speaker.ohms).    to eq "29"
     expect(model.gadget.speaker.diameter).to eq "large"
   end
+
+
+  it "merges a hash attribute" do
+    props = {
+      "name"                => "Brackish Water",
+      "gadget.name"         => "The Loud Gadget",
+      "gadget.variables.x" => "29",
+      "gadget.variables.y" => "12.4",
+      "gadget.variables.z" => "8.16",
+    }
+
+    model = Model.new props
+
+    more_props = {
+      "gadget.variables.x.left"     => "strong",
+      "gadget.variables.x.right"    => "central",
+      "gadget.variables.y.left"     => "weak",
+      "gadget.variables.y.right"    => "mirror",
+      "gadget.variables.other"      => "central",
+    }
+
+    Aduki.apply_attributes model, more_props
+
+    expected = {
+      "x"=> {
+        "left"  => "strong",
+        "right" => "central",
+      },
+      "y" => {
+        "left"  => "weak",
+        "right" => "mirror",
+      },
+      "z" => "8.16",
+      "other" => "central"
+    }
+
+    expect(model.gadget.variables).to eq expected
+  end
+
 end

data/spec/spec_helper.rb

@@ -6,18 +6,46 @@ RSpec.configure do |config|
 end
 
 
-CITIES = { }
-
 class City < Struct.new(:name)
+  CITIES = { }
   def self.aduki_find value
     CITIES[value]
   end
+
+  def register
+    CITIES[name] = self
+  end
+end
+
+City.new("paris"    ).register
+City.new("madrid"   ).register
+City.new("stockholm").register
+City.new("dublin"   ).register
+
+class Gift
+  GIFTS = { }
+  include Aduki::Initializer
+  attr_accessor :name, :price
+  def self.lookup name
+    name.is_a?(String) ? GIFTS[name] : name.map { |n| GIFTS[n] }
+  end
+  def register
+    GIFTS[name] = self
+  end
 end
 
-CITIES["paris"]     = City.new "Paris"
-CITIES["madrid"]    = City.new "Madrid"
-CITIES["stockholm"] = City.new "Stockholm"
-CITIES["dublin"]    = City.new "Dublin"
+Gift.new(name: "dinner"    , price: :cheap    ).register
+Gift.new(name: "massage"   , price: :cheap    ).register
+Gift.new(name: "med_cruise", price: :expensive).register
+Gift.new(name: "whiskey"   , price: :medium   ).register
+Gift.new(name: "cigars"    , price: :medium   ).register
+
+class Politician
+  include Aduki::Initializer
+  attr_accessor :name
+  attr_finder :aduki_find, :name, :city
+  attr_many_finder :lookup, :name, :gifts
+end
 
 class Contraption
   include Aduki::Initializer
@@ -52,7 +80,7 @@ class Gadget
   attr_accessor :name, :price, :supplier, :variables
   attr_writer :wattage
   aduki_initialize :speaker, Speaker
-  aduki_initialize :variables, Hash, nil
+  aduki_initialize :variables, Aduki::RecursiveHash, nil
 
   def watts
     @wattage

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: aduki
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.0
 platform: ruby
 authors:
 - Conan Dalton
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-03 00:00:00.000000000 Z
+date: 2016-04-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -53,9 +53,13 @@ files:
 - Rakefile
 - aduki.gemspec
 - lib/aduki.rb
+- lib/aduki/attr_finder.rb
+- lib/aduki/recursive_hash.rb
 - lib/aduki/version.rb
 - spec/array_attribute_spec.rb
+- spec/attr_finder_spec.rb
 - spec/custom_builder_spec.rb
+- spec/finder_spec.rb
 - spec/initializer_spec.rb
 - spec/merge_attributes_spec.rb
 - spec/model.rb
@@ -90,7 +94,9 @@ specification_version: 4
 summary: set object attributes recursively from an attributes hash
 test_files:
 - spec/array_attribute_spec.rb
+- spec/attr_finder_spec.rb
 - spec/custom_builder_spec.rb
+- spec/finder_spec.rb
 - spec/initializer_spec.rb
 - spec/merge_attributes_spec.rb
 - spec/model.rb