attribute_cartographer 0.0.1 → 0.0.2

data/.rvmrc

@@ -1 +1 @@
-rvm 1.9.2-p136@attribute_cartography --create
+rvm 1.9.2-p136@attribute_cartographer --create

data/README

@@ -8,7 +8,7 @@ Attribute Cartographer allows you to map an attributes hash into similarly or di
 
 == INSTALL
 
-Add attribute-cartography to your Gemfile
+Add attribute-cartographer to your Gemfile
 
   gem 'attribute-cartographer'
 
@@ -20,14 +20,19 @@ Then run:
   class Mapper
     include AttributeCartographer
 
-    map :a, :b
-    map :c, :d, ->(v) { v.downcase }
+    map :a
+    map :b, ->(v) { v.downcase }
+
+    map :c, :d
+    map :e, :f, ->(v) { v.downcase }
+    map :g, :h, ->(v) { v.downcase }, ->(v) { v.upcase }
+
+    map [:i, :j, :k]
+    map [:l, :m, :n], ->(v) { v.upcase }
   end
 
-  account = Mapper.new a: 123, c: "Mapper"
-  account.b # => 123
-  account.d # => "Mapper"
-  account.original_attributes # => { a: 123, c: "Mapper" }
+  mapper = Mapper.new attributes
+  mapper.original_attributes # => {:a=>123, :c=>"Mapper", :e=>"Eee!", :f=>"F.", :g=>"Gee!"}
 
 == REQUIREMENTS
 

data/lib/attribute_cartographer.rb

@@ -1,5 +1,4 @@
 module AttributeCartographer
-  class InvalidBlockArityError < StandardError; end
   class InvalidArgumentError < StandardError; end
 
   class << self
@@ -12,19 +11,19 @@ module AttributeCartographer
   module ClassMethods
     def map *args
       @mapper ||= {}
-      block = (Proc === args.last) ? args.pop : ->(v) { v }
-
-      raise AttributeCartographer::InvalidArgumentError if block.arity > 1
-
-      if Array === args.first
-        raise AttributeCartographer::InvalidArgumentError if args.first.empty?
-        args.first.each { |arg| @mapper.merge! arg => [arg, block] }
-      elsif args.size == 2
-        from, to = args
-        @mapper.merge! from => [to, block]
-      elsif args.size == 1
-        from = args.pop
-        @mapper.merge! from => [from, block]
+
+      (from, to), (f1, f2) = args.partition { |a| !(Proc === a) }
+
+      raise AttributeCartographer::InvalidArgumentError if [f1,f2].compact.any? { |f| f.arity > 1 }
+
+      f1 ||= ->(v) { v }
+      to ||= from
+
+      if Array === from
+        from.each { |key| @mapper.merge! key => [key, f1] }
+      else
+        @mapper.merge! from => [to, f1]
+        @mapper.merge! to => [from, f2] if f2
       end
     end
   end
@@ -32,12 +31,9 @@ module AttributeCartographer
   module InstanceMethods
     def initialize attributes
       @_original_attributes = attributes
-      mapper = self.class.instance_variable_get(:@mapper)
+      @_mapped_attributes = {}
 
-      mapper.each { |from, (meth, block)|
-        value = attributes.has_key?(from) ? block.call(attributes[from]) : nil
-        self.send :define_singleton_method, meth, ->{ value }
-      } if mapper
+      map_attributes! attributes
 
       super
     end
@@ -45,5 +41,22 @@ module AttributeCartographer
     def original_attributes
       @_original_attributes
     end
+
+    def mapped_attributes
+      @_mapped_attributes
+    end
+
+  private
+
+    def map_attributes! attributes
+      mapper = self.class.instance_variable_get(:@mapper)
+
+      mapper.each { |original_key, (mapped_key, block)|
+        value = attributes.has_key?(original_key) ? block.call(attributes[original_key]) : nil
+        self.send :define_singleton_method, mapped_key, ->{ value }
+
+        @_mapped_attributes.merge! mapped_key => value
+      } if mapper
+    end
   end
 end

data/lib/attribute_cartographer/VERSION.rb

@@ -1,3 +1,3 @@
 module AttributeCartographer
-  VERSION = "0.0.1" unless defined?(::AttributeCartographer::VERSION)
+  VERSION = "0.0.2" unless defined?(::AttributeCartographer::VERSION)
 end

data/spec/attribute_cartographer_spec.rb

@@ -33,50 +33,93 @@ describe AttributeCartographer do
     end
   end
 
+  describe "#mapped_attributes" do
+    before { klass.map :a, :b, ->(v) { v + 1 } }
+
+    it "returns any attributes mapped by the mapper" do
+      klass.new(a: 1).mapped_attributes.should == { b: 2 }
+    end
+  end
+
   describe ".map" do
-    # tests about accepting strings or keys as both args
-    context "with a single argument given" do
-      before { klass.map :a }
+    context "with a single argument" do
+      context "and no lambda" do
+        before { klass.map :a }
 
-      it "creates an instance method matching the key name" do
-        klass.new(:a => :a_value).a.should == :a_value
+        it "creates an instance method matching the key name" do
+          klass.new(:a => :a_value).a.should == :a_value
+        end
       end
-    end
 
-    context "with an empty array" do
-      subject { klass.map [] }
+      context "and a lambda" do
+        before { klass.map :a, ->(v) { v.downcase } }
 
-      it "should raise an error" do
-        lambda { klass.map [] }.should raise_error(AttributeCartographer::InvalidArgumentError)
+        it "creates an instance method matching the key name, mapping the value with the lambda" do
+          klass.new(:a => "STRING").a.should == "string"
+        end
       end
     end
 
-    context "with a non-empty array" do
-      before { klass.map [:a, :b] }
+    context "with two arguments" do
+      context "and no lambda" do
+        before { klass.map :a, :b }
 
-      it "creates a method named for each key" do
-        instance = klass.new(a: :a_value, b: :b_value)
-        instance.a.should == :a_value
-        instance.b.should == :b_value
+        it "creates an instance method matching the key name" do
+          klass.new(:a => :a_value).b.should == :a_value
+        end
       end
 
-      it "makes nil methods for mapped keys which had no attributes passed in for them" do
-        instance = klass.new(a: :a_value)
-        instance.b.should == nil
+      context "and a single lambda" do
+        before { klass.map :a, :b, ->(v) { v.downcase } }
+
+        it "creates an instance method matching the key name, mapping the value with the lambda" do
+          klass.new(:a => "STRING").b.should == "string"
+        end
       end
-    end
 
-    context "with two keys and a 1-arity block given" do
-      before { klass.map :a, :b, ->(v) { v + 1 } }
+      context "and two lambdas" do
+        before { klass.map :a, :b, ->(v) { v.downcase }, ->(v) { v.upcase } }
 
-      it "creates a method named for the second key with the result of passing the associated value to the block" do
-        klass.new(:a => 1).b.should == 2
+        it "creates an instance method matching the second key name, mapping the value with the first lambda" do
+          klass.new(a: "STRING").b.should == "string"
+        end
+
+        it "creates an instance method matching the first key name, mapping the value with the second lambda" do
+          klass.new(b: "string").a.should == "STRING"
+        end
+      end
+
+      context "and a >1-arity lambda" do
+        it "raises an error" do
+          lambda { klass.map :a, :b, ->(k,v) { v + 1 } }.should raise_error(AttributeCartographer::InvalidArgumentError)
+        end
       end
     end
 
-    context "with two keys and a >1-arity block given" do
-      it "raises an error" do
-        lambda { klass.map :a, :b, ->(k,v) { v + 1 } }.should raise_error(AttributeCartographer::InvalidArgumentError)
+    context "with an array" do
+      context "with no lambda" do
+        before { klass.map [:a, :b] }
+
+        it "creates a method named for each key" do
+          instance = klass.new(a: :a_value, b: :b_value)
+          instance.a.should == :a_value
+          instance.b.should == :b_value
+        end
+
+        it "makes nil methods for mapped keys which had no attributes passed in for them" do
+          instance = klass.new(a: :a_value)
+          instance.b.should == nil
+        end
+      end
+
+      context "and a lambda" do
+        before { klass.map [:a, :b], ->(v) { v.downcase } }
+
+        it "creates a method named for each key using the lambda to map the values" do
+          instance = klass.new(a: "STRING1", b: "STRING2")
+          instance.a.should == "string1"
+          instance.b.should == "string2"
+        end
       end
     end
   end

metadata

@@ -1,35 +1,39 @@
---- !ruby/object:Gem::Specification
+--- !ruby/object:Gem::Specification 
 name: attribute_cartographer
-version: !ruby/object:Gem::Version
-  version: 0.0.1
+version: !ruby/object:Gem::Version 
   prerelease: 
+  version: 0.0.2
 platform: ruby
-authors:
+authors: 
 - Kris Hicks
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-05-09 00:00:00.000000000Z
-dependencies:
-- !ruby/object:Gem::Dependency
+
+date: 2011-05-10 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
   name: rspec
-  requirement: &2152785160 !ruby/object:Gem::Requirement
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '2.5'
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "2.5"
   type: :development
-  prerelease: false
-  version_requirements: *2152785160
-description: AttributeCartographer allows you to map an attributes hash into similarly
-  or differently named methods, using an optional block to map the values as well.
-email:
+  version_requirements: *id001
+description: AttributeCartographer allows you to map an attributes hash into similarly or differently named methods, using an optional block to map the values as well.
+email: 
 - krishicks@gmail.com
 executables: []
+
 extensions: []
+
 extra_rdoc_files: []
-files:
+
+files: 
 - .gitignore
 - .rspec
 - .rvmrc
@@ -42,31 +46,34 @@ files:
 - lib/attribute_cartographer/VERSION.rb
 - spec/attribute_cartographer_spec.rb
 - spec/spec_helper.rb
+has_rdoc: true
 homepage: https://github.com/krishicks/attribute-cartographer
 licenses: []
+
 post_install_message: 
 rdoc_options: []
-require_paths:
+
+require_paths: 
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement
+required_ruby_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
-required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
 requirements: []
+
 rubyforge_project: 
-rubygems_version: 1.7.2
+rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
-summary: Map an attributes hash to methods on Ruby object while transforming the values
-  to suit.
-test_files:
+summary: Map an attributes hash to methods on Ruby object while transforming the values to suit.
+test_files: 
 - spec/attribute_cartographer_spec.rb
 - spec/spec_helper.rb