depict 0.1.0

data/lib/depict.rb

@@ -0,0 +1,7 @@
+require 'depict/version'
+
+require 'depict/presenter'
+require 'depict/mapping'
+require 'depict/presentable'
+
+require 'depict/converters/unix_timestamp'

data/lib/depict/converters/unix_timestamp.rb

@@ -0,0 +1,24 @@
+
+module Depict
+   module Converters
+      module UnixTimestamp
+
+         def self.serialize(value)
+            if value.respond_to? :utc
+               value.utc.to_i * 1000
+            else
+               nil
+            end
+         end
+
+         def self.deserialize(value)
+            if value.respond_to? :to_f
+               Time.at(value.to_f / 1000.0).utc
+            else
+               nil
+            end
+         end
+
+      end
+   end
+end

data/lib/depict/mapping.rb

@@ -0,0 +1,54 @@
+
+module Depict
+   class Mapping
+      attr_reader :name
+
+      attr_reader :target_name
+
+      attr_reader :converter
+
+      attr_reader :serializer
+
+      attr_reader :deserializer
+
+      def initialize(name, options={})
+         @name = name.to_sym
+
+         @target_name = options.fetch(:as, @name)
+
+         @converter = options[:with]
+
+         @serializer = options[:serialize_with]
+
+         @deserializer = options[:deserialize_with]
+      end
+
+      def serialize(object, attributes)
+         value = object.send(name)
+         
+         if serializer
+            attributes[target_name] = serializer.call(value)
+         elsif converter
+            attributes[target_name] = converter.serialize(value)
+         else
+            attributes[target_name] = value
+         end
+
+         nil
+      end
+
+      def deserialize(object, attributes)
+         value = attributes[target_name]
+
+         if deserializer
+            object.send("#{name}=", deserializer.call(value))
+         elsif converter
+            object.send("#{name}=", converter.deserialize(value))
+         else
+            object.send("#{name}=", value)
+         end
+
+         nil
+      end
+   end
+end

data/lib/depict/presentable.rb

@@ -0,0 +1,102 @@
+
+module Depict
+   module Presentable
+      class UndefinedPresentationError < StandardError
+      end
+
+      def self.included(base)
+         base.send(:extend, ClassMethods)
+         base.send(:include, InstanceMethods)
+      end
+
+      module ClassMethods
+         def depict_presentations
+            @depict_presentations ||= {}
+         end
+
+         def define_presentation(name, options={}, &block)
+            if options[:extends]
+               extends_presenter = depict_presentations[options[:extends]]
+
+               if extends_presenter == nil
+                  raise UndefinedPresentationError.new("undefined presentation: #{options[:extends]}")
+               end
+            else
+               extends_presenter = Depict::Presenter
+            end
+
+            depict_presentations[name] = extends_presenter.define(&block)
+         end
+
+         def new_from_presentation(name, attrs)
+            object = self.new
+
+            presenter_class = depict_presentations[name]
+
+            if presenter_class
+               presenter = presenter_class.new(object)
+               presenter.attributes = attrs
+            end
+
+            object
+         end
+
+         def respond_to?(method, include_private=false)
+            names = depict_presentations.keys
+
+            if /^new_from_(#{names.join("|")})_presentation$/ =~ method.to_s
+               true
+            else
+               super(method, include_private)
+            end
+         end
+
+         def method_missing(method, *args)
+            names = depict_presentations.keys
+
+            match = /^new_from_(#{names.join("|")})_presentation$/.match(method.to_s)
+
+            if match
+               new_from_presentation(match[1].to_sym, *args)
+            else
+               super(method, *args)
+            end
+         end
+      end
+
+      module InstanceMethods
+         def to_presentation(presentation)
+            presenter = self.class.depict_presentations[presentation]
+
+            if presenter
+               presenter.new(self).to_hash
+            else
+               {}
+            end
+         end
+
+         def respond_to?(method, include_private=false)
+            names = self.class.depict_presentations.keys
+
+            if /^to_(#{names.join("|")})_presentation$/ =~ method.to_s
+               true
+            else
+               super(method, include_private)
+            end
+         end
+
+         def method_missing(method, *args)
+            names = self.class.depict_presentations.keys
+
+            match = /^to_(#{names.join("|")})_presentation$/.match(method.to_s)
+
+            if match
+               to_presentation(match[1].to_sym)
+            else
+               super(method, *args)
+            end
+         end
+      end
+
+   end
+end

data/lib/depict/presenter.rb

@@ -0,0 +1,57 @@
+
+module Depict
+   class Presenter
+      class << self
+         def define(&block)
+            klass = Class.new(self)
+            klass.instance_eval(&block)
+            klass
+         end
+
+         def mappings
+            @mappings ||= superclass == Object ? [] : superclass.mappings.dup
+         end
+
+         def target_attribute_names
+            mappings.map(&:target_name)
+         end
+
+         def maps(name, options={})
+            mappings.push Mapping.new(name, options)
+         end
+      end
+
+      def initialize(object)
+         @object = object
+      end
+
+      def to_hash
+         self.class.mappings.inject({}) {|attrs, mapping| mapping.serialize(@object, attrs); attrs }
+      end
+
+      def attributes=(attributes)
+         self.class.mappings.each {|mapping| mapping.deserialize(@object, attributes) }
+      end
+
+      def respond_to?(method, include_private=false)
+         if self.class.target_attribute_names.include? method
+            return true
+         else
+            super(method, include_private)
+         end
+      end
+
+      def method_missing(method, *args)
+         mapping = self.class.mappings.detect {|x| x.target_name == method }
+
+         if mapping
+            attrs = {}
+            mapping.serialize(@object, attrs)
+            attrs[method]
+         else
+            super(method, *args)
+         end
+      end
+
+   end
+end

data/lib/depict/version.rb

@@ -0,0 +1,11 @@
+
+module Depict
+  module Version
+     MAJOR = 0
+     MINOR = 1
+     PATCH = 0
+     BUILD = nil
+    
+     STRING = [MAJOR, MINOR, PATCH, BUILD].compact.join('.')
+  end
+end

data/spec/mapping_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+require 'time'
+
+describe Depict::Mapping do
+   subject { Depict::Mapping }
+
+   let(:name_mapping) { subject.new(:name) }
+
+   it "should assign the attribute name" do
+      subject.new(:id).name.should == :id
+   end
+
+   it "should symbolize string attribute names" do
+      subject.new("id").name.should == :id
+   end
+
+   it "should assign the :with object as the converter" do
+      mapping = subject.new(:created_at, :with => Depict::Converters::UnixTimestamp)
+
+      mapping.converter.should == Depict::Converters::UnixTimestamp
+   end
+
+   context "serialization" do
+      let(:attrs) { {} }
+      let(:object) { OpenStruct.new(:timestamp => Time.utc(2012, 1, 1, 0, 0, 0)) }
+      let(:serializer) { lambda {|x| x.utc.iso8601 } }
+
+      it "should assign a serialized value to a given hash" do      
+         subject.new(:timestamp).serialize(object, attrs)
+
+         attrs[:timestamp].should == Time.utc(2012, 1, 1, 0, 0, 0)
+      end
+
+      it "should assign a serialized value using the converter to a given hash" do
+         subject.new(:timestamp, :with => Depict::Converters::UnixTimestamp).serialize(object, attrs)
+
+         attrs[:timestamp].should == 1325376000000
+      end
+
+      it "should write to the :as attribute name" do
+         subject.new(:timestamp, :as => :created_at).serialize(object, attrs)
+
+         attrs[:created_at].should == Time.utc(2012, 1, 1, 0, 0, 0)
+      end
+
+      it "should use the lamda function passed as :serialize_with" do
+         subject.new(:timestamp, :serialize_with => serializer).serialize(object, attrs)
+
+         attrs[:timestamp].should == "2012-01-01T00:00:00Z"
+      end
+
+      it "should prefer the lambda function to the converter if both are given" do
+         mapping = subject.new(:timestamp, :with => Depict::Converters::UnixTimestamp, :serialize_with => serializer)
+
+         mapping.serialize(object, attrs)
+
+         attrs[:timestamp].should == "2012-01-01T00:00:00Z"
+      end
+
+   end
+
+   context "deserialization" do
+      let(:attrs) { {:timestamp => 1325376000000 } }
+      let(:object) { OpenStruct.new }
+      let(:deserializer) { lambda {|x| Time.iso8601(x) } }
+
+      it "should assign the value from the given hash" do
+         subject.new(:timestamp).deserialize(object, attrs)
+
+         object.timestamp.should == 1325376000000
+      end
+
+      it "should assign the value using the converter from the given hash" do
+         subject.new(:timestamp, :with => Depict::Converters::UnixTimestamp).deserialize(object, attrs)
+
+         object.timestamp.should == Time.utc(2012, 1, 1, 0, 0, 0)
+      end
+
+      it "should read from the :as attribute name" do
+         subject.new(:created_at, :as => :timestamp).deserialize(object, attrs)
+
+         object.created_at.should == 1325376000000
+      end
+
+      it "should use the lambda function passed as :deserialize_with" do
+         mapping = subject.new(:timestamp, :deserialize_with => deserializer)
+
+         mapping.deserialize(object, {:timestamp => "2012-01-01T00:00:00Z"})
+
+         object.timestamp.should == Time.utc(2012, 1, 1, 0, 0, 0)
+      end
+
+      it "should prefer the lambda function to the converter if both are given" do
+         mapping = subject.new(:timestamp, :with => Depict::Converters::UnixTimestamp, :deserialize_with => deserializer)
+
+         mapping.deserialize(object, {:timestamp => "2012-01-01T00:00:00Z"})
+
+         object.timestamp.should == Time.utc(2012, 1, 1, 0, 0, 0)
+      end
+   end
+
+end

data/spec/presentable_spec.rb

@@ -0,0 +1,117 @@
+require 'spec_helper'
+
+describe Depict::Presentable do
+   subject { Depict::Presentable }
+
+   let(:base_class) { Class.new }
+   let(:mixed_class) { base_class.send(:include, subject); base_class }
+
+   let(:user_model) do
+      mixed_class.define_presentation :user do
+         maps :id
+         maps :name
+      end
+
+      mixed_class.send(:attr_accessor, :id, :name, :role)
+
+      mixed_class
+   end
+
+   let(:user) do
+      user = user_model.new
+      user.id = 42
+      user.name = "foo"
+      user.role = "superuser"
+      user
+   end
+
+   context "defining presentations" do
+      it "should define #depict_presentations on the class that mixes it in" do
+         base_class.should_not respond_to :depict_presentations
+         base_class.send(:include, subject)
+         base_class.should respond_to :depict_presentations
+      end
+
+      it "should return an empty hash by default" do
+         mixed_class.depict_presentations.should == {}
+      end
+
+      it "should allow defining a presentation with #define_presentation" do
+         presentations = user_model.depict_presentations
+
+         presentations.keys.should == [:user]
+         presentations[:user].superclass.should == Depict::Presenter
+         presentations[:user].should have(2).mappings
+      end
+
+      it "should allow defining a super presentation with :extends" do
+         user_model.define_presentation :admin, :extends => :user do
+            maps :role
+         end
+         
+         presenter = user_model.depict_presentations[:admin]
+         presenter.superclass.should == user_model.depict_presentations[:user]
+         presenter.mappings.map(&:name).should == [:id, :name, :role]
+      end
+
+      it "should raise an UndefinedPresentationError if trying to extend an undefined presentation" do
+         lambda do
+            user_model.define_presentation :admin, :extends => :fake do
+               maps :role
+            end
+         end.should raise_error(Depict::Presentable::UndefinedPresentationError)
+      end
+   end
+
+   context "serializing as a presentation" do
+      it "should define :to_presentation on the instance level" do
+         user_model.new.should respond_to :to_presentation
+      end
+
+      it "should return the presentation specified" do
+         user.to_presentation(:user).should == {
+            :id => 42,
+            :name => "foo"
+         }
+      end
+
+      it "should respond to the #to_xyz_presentation methods" do
+         user.should respond_to :to_user_presentation
+      end
+
+      it "should use method_missing to support #to_xyz_presentation" do
+         user.to_user_presentation.should == {
+            :id => 42,
+            :name => "foo"
+         }
+      end
+
+      it "should return an empty hash if the presentation is not defined" do
+         user.to_presentation(:fake).should == {}
+      end
+   end
+
+   context "instantiation from presentations" do
+      it "should be serializable from a presentation" do
+         user = user_model.new_from_presentation(:user, :id => 99, :name => "bar")
+         user.id.should == 99
+         user.name.should == "bar"
+      end
+
+      it "should respond to #new_from_xyz_presentation" do
+         user_model.should respond_to :new_from_user_presentation
+      end
+
+      it "should use method_missing to support #new_from_xyz_presentation" do
+         user = user_model.new_from_user_presentation(:id => 80, :name => "baz")
+         user.id.should == 80
+         user.name.should == "baz"
+      end
+
+      it "should return a new object with nothing assigned if the presentation is not defined" do
+         user = user_model.new_from_presentation(:fake, {:id => 42, :name => "foo"})
+         user.id.should == nil
+         user.name.should == nil
+      end
+   end
+end

data/spec/presenter_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+require 'ostruct'
+
+describe Depict::Presenter do
+
+   let(:user_presenter) do
+      Depict::Presenter.define do
+         maps :database_id
+         maps :name
+         maps :email, :as => :login
+      end
+   end
+   
+   it "should call the block given" do
+      ran_block = false
+      Depict::Presenter.define { ran_block = true }
+      ran_block.should == true
+   end
+
+   it "should return a class which is a subclass of Depict::Presenter" do
+      presenter = Depict::Presenter.define {}
+      presenter.should be_an_instance_of Class
+      presenter.superclass.should eql Depict::Presenter
+   end
+
+   it "should return a class which also define's the same #define method" do
+      super_presenter = Depict::Presenter.define {}
+
+      inhereted_presenter = super_presenter.define {}
+
+      inhereted_presenter.superclass.should == super_presenter
+      inhereted_presenter.superclass.superclass.should == Depict::Presenter
+   end
+
+   it "should be able to access defined mappings" do
+      presenter = Depict::Presenter.define {}
+      presenter.mappings.should == []
+   end
+
+   it "should add a mapping for each call to #map" do
+      user_presenter.mappings.map(&:name).should == [:database_id, :name, :email]
+   end
+
+   it "should inherit all mappings of it's superclass without modifying them" do
+      admin_presenter = user_presenter.define do
+         maps :role
+      end
+
+      user_presenter.mappings.map(&:name).should == [:database_id, :name, :email]
+      admin_presenter.mappings.map(&:name).should == [:database_id, :name, :email, :role]
+   end
+
+   it "should be able to wrap an object and produce a hash of it's presentation" do
+      user = OpenStruct.new(:database_id => 42, :name => "foobar", :role => "admin")
+
+      user_presenter.new(user).to_hash.should == {
+         :database_id => 42,
+         :name => "foobar",
+         :login => nil
+      }
+   end
+
+   it "should be able to wrap an object and assign attributes from a hash" do
+      user = OpenStruct.new
+
+      user_presenter.new(user).attributes = {:database_id => 42, :name => "foobar"}
+
+      user.database_id.should == 42
+      user.name.should == "foobar"
+   end
+
+   it "should respond to any attribute defined on it" do
+      user_presenter.new(OpenStruct.new).should respond_to :login
+   end
+
+   it "should retrieve the value of the attribute when called" do
+      user = OpenStruct.new(:email => "foo@example.com")
+
+      user_presenter.new(user).login.should == "foo@example.com"
+   end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+require File.expand_path("../lib/depict", File.dirname(__FILE__))
+require 'ostruct'
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+end

metadata

@@ -0,0 +1,107 @@
+--- !ruby/object:Gem::Specification
+name: depict
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- William Howard
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-07-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.10.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.10.0
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- whoward.tke@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/depict/presentable.rb
+- lib/depict/version.rb
+- lib/depict/converters/unix_timestamp.rb
+- lib/depict/presenter.rb
+- lib/depict/mapping.rb
+- lib/depict.rb
+- spec/presenter_spec.rb
+- spec/mapping_spec.rb
+- spec/spec_helper.rb
+- spec/presentable_spec.rb
+homepage: http://github.com/whoward/depict
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Presentation library with support for multiple bidirectional presentations
+test_files:
+- spec/presenter_spec.rb
+- spec/mapping_spec.rb
+- spec/spec_helper.rb
+- spec/presentable_spec.rb