attribute_cartographer 0.0.5 → 0.0.6

data/README

@@ -21,32 +21,29 @@ Then run:
     include AttributeCartographer
 
     # one-way mapping
-    map :a
-    map :b,     ->(v) { v.downcase }
-    map :e, :f, ->(v) { v.downcase }
+    map "UnchangedKey"                                                              # map a single key, value untouched
+    map %w{ UnchangedKey1 UnchangedKey2 }                                           # same as above, but for multiple in a single statement
 
-    map :O,     ->(k,v) { [k.downcase, v.downcase] }
+    map "SameKeyNewValue", ->(v) { v.downcase }                                     # maps the key, using the lambda for the value
+    map %w{ SameKeyNewValue1 SameKeyNewValue2 }, ->(v) { v.upcase }                 # same as above, but for multiple in a single statement
 
-    map [:i, :j, :k]
-    map [:l, :m, :n], ->(v) { v.upcase }
+    map "OldKey", "new_key", ->(v) { v.downcase }                                   # maps the left key to the right key, using the lambda for the value
+    map "DowncasedKeyAndValue", ->(k,v) { [k.downcase, v.downcase] }                # maps the key and value using the lambda for both
+    map %w{ NewKeyAndValue1 NewKeyAndValue2 }, ->(k,v) { [k.downcase, v.downcase] } # same as the example above, but for multiple in a single statement
 
     # two-way mapping
-    map :c, :d
-    map :g, :h, ->(v) { v.downcase }, ->(v) { v.upcase }
+    map "AnotherOldKey", "another_new_key"                                          # map the left key to the right key and vice-versa, value untouched
+    map "ThisKey", "to_this_key", ->(v) { v.downcase }, ->(v) { v.upcase }          # map the left key to the right key with the first lambda,
+                                                                                    # and the right key to the left key with the second lambda
 
-    map [:P, :Q, :R], ->(k,v) { [k.downcase, v.downcase] }
   end
 
-  Mapper.new(a: 2, b: "STRING")
+  Mapper.new("UnchangedKey" => "UnchangedValue", "OldKey" => "OldValue")            # etc. 
 
-  For each mapping defined, an instance method is created that returns the mapped
-  value. This can be mapped directly, with a lambda to map the value or key and
-  value, with an explicit key mapping and lambda value mapping (with an optional
-  reverse-value map lambda), with a directly-mapped array, a directly-mapped array
-  with value mapping, or with an array with keys and values mapped with lambdas.
-
-  Mapper#original_attributes is the original hash passed in
-  Mapper#mapped_attributes is a hash representing the mapped keys and their mapped values
+  For each mapping defined, an entry in mapped_attributes will be made using the
+  logic defined in the mapping. You also get another method, original_attributes,
+  that retains the entire hash that was passed to #initialize, whether the keys
+  were mapped or not.
 
 == REQUIREMENTS
 

data/lib/attribute_cartographer.rb

@@ -16,6 +16,7 @@ module AttributeCartographer
 
       passthrough = ->(v) { v }
       f1 ||= passthrough
+      f2 ||= passthrough
 
       if Array === from
         if f1.arity == 1
@@ -26,15 +27,14 @@ module AttributeCartographer
       else
         raise AttributeCartographer::InvalidArgumentError if to && f1.arity == 2
 
-        to ||= from
-        @mapper[from] = (f1.arity == 1 ? [to, f1] : f1)
-        @mapper[to] = [from, (f2 ? f2 : passthrough)] if to != from
+        @mapper[from] = (f1.arity == 1 ? [to || from, f1] : f1)
+        @mapper[to] = [from, f2] if to && (f1 == f2 || f2 != passthrough)
       end
     end
   end
 
   module InstanceMethods
-    def initialize attributes
+    def initialize attributes = {}
       @_original_attributes = attributes
       @_mapped_attributes = {}
 
@@ -67,7 +67,6 @@ module AttributeCartographer
           mapped_key, value = mapping.call(key, attributes[key])
         end
 
-        self.send :define_singleton_method, mapped_key, ->{ value }
         @_mapped_attributes[mapped_key] = value
       end
     end

data/lib/attribute_cartographer/version.rb

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

data/spec/attribute_cartographer_spec.rb

@@ -12,96 +12,122 @@ describe AttributeCartographer do
   }
 
   describe "#initialize" do
-    context "with nothing mapped" do
-      it "does not try to map anything when map was not called" do
-        lambda { klass.new(a: :b) }.should_not raise_error
-      end
-    end
 
-    context "with attributes that don't match mapped values" do
-      before { klass.map :a, :b, ->(v) { v + 1 } }
 
-      it "doesn't map attributes when no mappable attribute was passed in" do
-        lambda { klass.new(c: :d).b }.should raise_error(NoMethodError)
-      end
+    it "doesn't require an argument" do
+      lambda { klass.new }.should_not raise_error
     end
   end
 
   describe "#original_attributes" do
-    it "returns any attributes given to initialize" do
+    it "is the attributes given on initialize" do
       klass.new(a: :b).original_attributes.should == { a: :b }
     end
   end
 
   describe "#mapped_attributes" do
-    before { klass.map :a, :b, ->(v) { v + 1 } }
+    subject { klass.new(attributes).mapped_attributes }
+
+    context "with no mapping" do
+      let(:attributes) { { "Attribute" => "Value" } }
+
+      it { should be_empty }
+    end
+
+    context "with a mapping" do
+      before { klass.map "Attribute", "attribute" }
+
+      context "and no attributes to map" do
+        let(:attributes) { {} }
+
+        it { should be_empty }
+      end
 
-    it "returns any attributes mapped by the mapper" do
-      klass.new(a: 1).mapped_attributes.should == { b: 2 }
+      context "and attributes to map" do
+        let(:attributes) { { "Attribute" => "Value" } }
+
+        it { should == { "attribute" => "Value" } }
+      end
     end
   end
 
   describe ".map" do
     context "with a single argument" do
       context "and no lambda" do
-        before { klass.map :a }
+        before { klass.map "Attribute" }
 
-        it "creates an instance method matching the key name" do
-          klass.new(:a => :a_value).a.should == :a_value
+        it "creates an entry in mapped_attributes matching the key name" do
+          klass.new("Attribute" => "Value").mapped_attributes["Attribute"].should == "Value"
         end
       end
 
       context "and a 1-arity lambda" do
-        before { klass.map :a, ->(v) { v.downcase } }
+        before { klass.map "Attribute", ->(v) { v.downcase } }
 
-        it "creates an instance method matching the key name, mapping the value with the lambda" do
-          klass.new(:a => "STRING").a.should == "string"
+        it "creates an entry in mapped_attributes matching the key name, mapping the value with the lambda" do
+          klass.new("Attribute" => "Value").mapped_attributes["Attribute"].should == "value"
         end
       end
 
       context "and a 2-arity lambda" do
-        before { klass.map :A, ->(k,v) { [k.downcase, v.downcase] } }
+        before { klass.map "Attribute", ->(k,v) { [k.downcase, v.downcase] } }
 
-        it "maps the key and value using the lambda and creates an instance method accordingly" do
-          klass.new(A: "STRING").a.should == "string"
+        it "creates an entry in mapped_attributes using the lambda for the key and value" do
+          klass.new("Attribute" => "Value").mapped_attributes["attribute"].should == "value"
         end
 
         it "doesn't raise an error when the attributes hash is missing a mapped key" do
-          lambda { klass.new(c: 2) }.should_not raise_error
+          lambda { klass.new("OtherAttribute" => "OtherValue") }.should_not raise_error
         end
       end
     end
 
     context "with two arguments" do
       context "and no lambda" do
-        before { klass.map :a, :b }
+        before { klass.map "Attribute", "attribute" }
 
-        it "maps the from to the to" do
-          klass.new(:a => :a_value).mapped_attributes[:b].should == :a_value
+        context "with attributes matching the left key, passing the value through" do
+          it "maps the left key to the right key" do
+            klass.new("Attribute" => "Value").mapped_attributes["attribute"].should == "Value"
+          end
         end
 
-        it "maps the to to the from" do
-          klass.new(:b => :b_value).mapped_attributes[:a].should == :b_value
+        context "with attributes matching the right key, passing the value through" do
+          it "maps the right key to the left key" do
+            klass.new("attribute" => "Value").mapped_attributes["Attribute"].should == "Value"
+          end
         end
       end
 
       context "and a single lambda" do
-        before { klass.map :a, :b, ->(v) { v.downcase } }
+        before { klass.map "Attribute", "attribute", ->(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"
+        context "with attributes matching the left key" do
+          it "maps the left key to the right key using the lambda to alter the value" do
+            klass.new("Attribute" => "Value").mapped_attributes["attribute"].should == "value"
+          end
+        end
+
+        context "with attributes matching the right key" do
+          it "doesn't map the right key as it's a one-way mapping" do
+            klass.new("attribute" => "value").mapped_attributes["Attribute"].should be_nil
+          end
         end
       end
 
       context "and two lambdas" do
-        before { klass.map :a, :b, ->(v) { v.downcase }, ->(v) { v.upcase } }
+        before { klass.map "Attribute", "attribute", ->(v) { v.downcase }, ->(v) { v.upcase } }
 
-        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"
+        context "with attributes matching the left key" do
+          it "maps the left key to the right key, using the first lambda to map the value" do
+            klass.new("Attribute" => "Value").mapped_attributes["attribute"].should == "value"
+          end
         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"
+        context "with attributes matching the right key, passing the value through" do
+          it "maps the right key to the left key, using the second lambda to map the value" do
+            klass.new("attribute" => "value").mapped_attributes["Attribute"].should == "VALUE"
+          end
         end
       end
 
@@ -113,38 +139,25 @@ describe AttributeCartographer do
     end
 
     context "with an array" do
-      context "with no lambda" do
-        before { klass.map [:a, :b] }
+      let(:attributes) { { "Attribute1" => "Value1", "Attribute2" => "Value2" } }
+      subject { klass.new(attributes).mapped_attributes }
 
-        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
+      context "and no lambda" do
+        before { klass.map %w{ Attribute1 Attribute2 } }
 
-        it "doesn't raise an error when the attributes hash is missing a mapped key" do
-          lambda { klass.new(a: :a_value).b }.should raise_error(NoMethodError)
-        end
+        it { should == attributes }
       end
 
       context "and a 1-arity lambda" do
-        before { klass.map [:a, :b], ->(v) { v.downcase } }
+        before { klass.map %w{ Attribute1 Attribute2 }, ->(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
+        it { should == { "Attribute1" => "value1", "Attribute2" => "value2" } }
       end
 
       context "and a 2-arity lambda" do
-        before { klass.map [:A, :B], ->(k,v) { [k.downcase, v.downcase] } }
+        before { klass.map %w{ Attribute1 Attribute2 }, ->(k,v) { [k.downcase, v.downcase] } }
 
-        it "maps the key and value using the lambda and creates an instance method accordingly" do
-          instance = klass.new(A: "ASTRING", B: "BSTRING")
-          instance.a.should == "astring"
-          instance.b.should == "bstring"
-        end
+        it { should == { "attribute1" => "value1", "attribute2" => "value2" } }
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: attribute_cartographer
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.6
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-05-25 00:00:00.000000000Z
+date: 2011-06-16 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &2153280180 !ruby/object:Gem::Requirement
+  requirement: &2153467360 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,7 +21,7 @@ dependencies:
         version: '2.5'
   type: :development
   prerelease: false
-  version_requirements: *2153280180
+  version_requirements: *2153467360
 description: AttributeCartographer allows you to map an attributes hash into similarly
   or differently named methods, using an optional lambda to map the values as well.
 email:
@@ -62,7 +62,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.2
+rubygems_version: 1.8.4
 signing_key: 
 specification_version: 3
 summary: Map an attributes hash to methods on Ruby object while transforming the values