veneer 0.1.0

data/lib/veneer/adapters/datamapper/instance_wrapper.rb

@@ -0,0 +1,23 @@
+module DataMapper
+  module Resource
+    module VeneerInterface
+      class InstanceWrapper < ::Veneer::Base::InstanceWrapper
+
+        def save!
+          r = instance.save
+          raise ::Veneer::Errors::NotSaved unless r
+          r
+        end
+
+        def new_record?
+          instance.respond_to?(:new?) ? instance.new? : instance.new_record?
+        end
+
+        def destroy
+          instance.destroy
+          self
+        end
+      end
+    end
+  end
+end

data/lib/veneer/base/class_wrapper.rb

@@ -0,0 +1,53 @@
+module Veneer
+  module Base
+    class ClassWrapper < BasicObject
+      attr_reader :klass, :opts
+      def initialize(klass, opts)
+        @klass, @opts = klass, opts
+      end
+
+      # @api public
+      def create!(opts = {})
+        instance = new(opts)
+        instance.save!
+        instance
+      end
+
+      # @api public
+      def create(opts = {})
+        instance = new(opts)
+        instance.save
+        instance
+      end
+
+      # @api implementor
+      def new(opts = {})
+        ::Kernel.raise Errors::NotImplemented
+      end
+
+      # @api public
+      def first(opts={})
+        conditional = ::Veneer::Conditional.from_hash(opts)
+        ::Kernel.Veneer(find_first(conditional))
+      end
+
+      # @api public
+      def all(opts={})
+        conditional = ::Veneer::Conditional.from_hash(opts)
+        find_many(conditional).map{|element| ::Kernel.Veneer(element)}
+      end
+
+      # Should return an array or array like structure with elements matching the provided conditional
+      # @api implementor
+      def find_many(conditional)
+        ::Kernel.raise Errors::NotImplemented
+      end
+
+      # A single object matching the conditional
+      # @api_implementor
+      def find_first(conditional)
+        ::Kernel.raise Errors::NotImplemented
+      end
+    end
+  end
+end

data/lib/veneer/base/conditional.rb

@@ -0,0 +1,77 @@
+module Veneer
+  class Conditional
+
+    def self.from_hash(hash)
+      new(hash)
+    end
+
+    attr_reader :options
+    def initialize(opts)
+      @options = HashWithIndifferentAccess.new(opts || {})
+      odr = Array.new([@options.delete(:order)].flatten.compact)
+      @ordering = odr.nil? || odr.empty? ? [] : begin
+        odr.map do |order|
+          field, direction = order.split(" ")
+          Order.new(field, (direction || :desc))
+        end
+      end
+
+      conds = opts.fetch(:conditions, {})
+      @conditions = conds.map do |k,v|
+        field, operator = k.to_s.split(" ")
+        args = [field, v]
+        args << operator.to_sym if operator
+        Veneer::Conditional::Condition.new(*args)
+      end
+    end
+
+    def limit
+      @options[:limit]
+    end
+
+    def offset
+      @options[:offset]
+    end
+
+    def order
+      @ordering
+    end
+
+    def conditions
+      @conditions
+    end
+
+    class Order
+      attr_reader :field, :direction
+      def initialize(field, direction = :desc)
+        @field = field.to_sym
+        @direction = direction.to_sym
+      end
+
+      def ascending?
+        direction == :asc
+      end
+
+      def decending?
+        !ascending?
+      end
+
+      def ==(other)
+        self.class ==  other.class &&
+        field == other.field &&
+        direction == other.direction
+      end
+    end
+
+    class Condition
+      attr_accessor :field, :operator, :value
+
+      VALID_OPERATORS = [:eql, :gt, :gte, :lt, :lte, :in, :not]
+
+      def initialize(field, value, operator = :eql)
+        @field, @value, @operator = field.to_sym, value, operator.to_sym
+        raise Veneer::Errors::ConditionalOperatorNotSupported, "#{operator.inspect} not a valid operator" unless VALID_OPERATORS.include?(operator)
+      end
+    end
+  end
+end

data/lib/veneer/base/instance_wrapper.rb

@@ -0,0 +1,38 @@
+module Veneer
+  module Base
+    class InstanceWrapper
+      attr_accessor :instance, :options
+      def initialize(instance, opts = {})
+        @instance, @options = instance, opts
+      end
+
+      # Checks equality of the instances
+      # @api public
+      def ==(other)
+        case other
+        when Veneer::Base::InstanceWrapper
+          instance == other.instance
+        else
+          instance == other
+        end
+      end
+
+      # Updates the attributes by trying to use the keys of the
+      # attributes hash as a setter method (:"#{key}=") to the value of the hash
+      # then the object is saved
+      # Adapter implementors may want to overwrite may want to overwrite
+      # @api public
+      def update(attributes = {})
+        attributes.each do |attr,value|
+          instance.send(:"#{attr}=",value)
+        end
+        save
+      end
+
+      # send all methods to the instance
+      def method_missing(*args, &blk)
+        instance.send(*args, &blk)
+      end
+    end
+  end
+end

data/lib/veneer/core_ext/kernel.rb

@@ -0,0 +1,17 @@
+module Kernel
+  def Veneer(obj, opts = {})
+    case obj
+    when Class
+      obj::VeneerInterface::ClassWrapper.new(obj, opts)
+    when Veneer::Base::ClassWrapper, Veneer::Base::InstanceWrapper
+      obj
+    when nil
+      nil
+    else
+      obj.class::VeneerInterface::InstanceWrapper.new(obj, opts)
+    end
+  rescue NameError => e
+    puts e.message
+    raise Veneer::Errors::NotCompatible
+  end # Veneer()
+end

data/lib/veneer/errors.rb

@@ -0,0 +1,9 @@
+module Veneer
+  module Errors
+    class VeneerError                     < StandardError;  end
+    class NotCompatible                   < VeneerError;    end
+    class NotSaved                        < VeneerError;    end
+    class ConditionalOperatorNotSupported < VeneerError;    end
+    class NotImplemented                  < VeneerError;    end
+  end
+end

data/lib/veneer/proxy.rb

@@ -0,0 +1,4 @@
+module Veneer
+  class Proxy < ::BasicObject
+  end
+end

data/test/macros/class_wrapper/create_macro.rb

@@ -0,0 +1,54 @@
+class Test::Unit::TestCase
+  def self.veneer_should_implement_create_with_valid_attributes
+    context "implements create with valid attributes" do
+      should "setup the spec correctly" do
+        assert_not_nil @klass
+        assert_kind_of Class, @klass
+        assert_not_nil @valid_attributes
+        assert_kind_of Hash, @valid_attributes
+      end
+
+      teardown do
+        Veneer(@klass).destroy_all
+      end
+
+      should "create the object from the hash" do
+        r = Veneer(@klass).create(@valid_attributes)
+        assert_instance_of @klass::VeneerInterface::InstanceWrapper, r
+      end
+
+      should "create the object from the hash with create!" do
+        r = Veneer(@klass).create!(@valid_attributes)
+        assert_instance_of @klass::VeneerInterface::InstanceWrapper, r
+      end
+
+      should "create a new instance of the object" do
+        r = Veneer(@klass).new(@valid_attributes)
+        assert_instance_of @klass::VeneerInterface::InstanceWrapper, r
+      end
+    end
+
+    def self.veneer_should_implement_create_with_invalid_attributes
+      context "implements create! with invalid attributes" do
+        should "setup the spec correctly" do
+          assert_not_nil @klass
+          assert_kind_of Class, @klass
+          assert_not_nil @invalid_attributes
+          assert_kind_of Hash, @invalid_attributes
+        end
+
+        should "raise when creating could not save" do
+          assert_raise Veneer::Errors::NotSaved do
+            Veneer(@klass).create!(@invalid_attributes)
+          end
+        end
+
+        should "not raise when create can not save" do
+          assert_nothing_raised do
+            Veneer(@klass).create(@invalid_attributes)
+          end
+        end
+      end
+    end
+  end
+end

data/test/macros/class_wrapper/delete_macro.rb

@@ -0,0 +1,31 @@
+class Test::Unit::TestCase
+  def self.veneer_should_impelement_destroy_all
+    context "implements destroy_all" do
+      should "setup the test correctly" do
+        assert_not_nil @klass
+        assert_kind_of Class, @klass
+        assert_not_nil @valid_attributes
+        assert_kind_of Hash, @valid_attributes
+      end
+
+      context "destroy_all" do
+        setup do
+          Veneer(@klass).destroy_all
+          assert_equal 0, Veneer(@klass).all.size
+          (0..5).each do |i|
+            Veneer(@klass).new(:name => "foo#{i}", :order_field1 => i).save
+          end
+        end
+
+        should "setup the spec correctly" do
+          assert_equal 6, Veneer(@klass).all.size
+        end
+
+        should "destroy all records" do
+          Veneer(@klass).destroy_all
+          assert_equal 0, Veneer(@klass).all.size
+        end
+      end
+    end
+  end
+end

data/test/macros/class_wrapper/find_macro.rb

@@ -0,0 +1,112 @@
+class Test::Unit::TestCase
+  def self.veneer_should_implement_find
+    context "implements find" do
+      setup do
+        Veneer(@klass).destroy_all
+        (0..5).each do |i|
+          Veneer(@klass).new(:order_field1 => i).save!
+        end
+      end
+
+      teardown{ Veneer(@klass).destroy_all }
+
+      should "impelement a find_all method" do
+        result = Veneer(@klass).find_many(Veneer::Conditional.from_hash({}))
+        assert_kind_of Array, result
+      end
+
+      should "implement a find_first method" do
+        result = Veneer(@klass).find_first(Veneer::Conditional.from_hash({}))
+      end
+
+      should "implement limit" do
+        total = Veneer(@klass).find_many(Veneer::Conditional.from_hash({}))
+        assert_not_equal 3, total.size
+        result = Veneer(@klass).find_many(Veneer::Conditional.from_hash(:limit => 3))
+        assert_equal 3, result.size
+      end
+
+      should "implement order" do
+        result = Veneer(@klass).find_many(Veneer::Conditional.from_hash(:order => "order_field1"))
+        raw = result.map{|i| i.order_field1 }.compact
+        sorted = raw.sort.reverse
+        assert_equal raw, sorted
+      end
+
+      should "implement order decending" do
+        result = Veneer(@klass).find_many(Veneer::Conditional.from_hash(:order => "order_field1 desc"))
+        raw = result.map{|i| i.order_field1 }.compact
+        sorted = raw.sort.reverse
+        assert_equal raw, sorted
+      end
+
+      should "implement order ascending" do
+        result = Veneer(@klass).find_many(Veneer::Conditional.from_hash(:order => "order_field1 asc"))
+        raw = result.map{|i| i.order_field1}.compact
+        sorted = raw.sort
+        assert_equal raw, sorted
+      end
+
+      should "impelment offset" do
+        total = Veneer(@klass).find_many(Veneer::Conditional.from_hash({}))
+        result = Veneer(@klass).find_many(Veneer::Conditional.from_hash({:offset => 2, :limit => 2}))
+
+        assert_equal((total[2..3]), result)
+      end
+
+      context "conditions" do
+        setup do
+          Veneer(@klass).new(:name => "bar").save
+          Veneer(@klass).new(:name => "foo").save
+          Veneer(@klass).new(:name => "foobar").save
+        end
+
+        should "implement basic conditions" do
+          total = Veneer(@klass).find_many(Veneer::Conditional.from_hash({}))
+          result = Veneer(@klass).find_many(Veneer::Conditional.from_hash(:conditions => {:name => "foo"}))
+          assert_equal 1, result.size
+        end
+
+        should "implement :not conditions" do
+          Veneer(@klass).all(:conditions => {:name => nil}).map(&:destroy)
+          total = Veneer(@klass).find_many(Veneer::Conditional.from_hash({}))
+          result = Veneer(@klass).find_many(Veneer::Conditional.from_hash(:conditions => {"name not" => "bar"}))
+          assert_equal((total.size - 1), result.size)
+        end
+
+        should "implement gt conditions" do
+          total = Veneer(@klass).find_many(Veneer::Conditional.from_hash({}))
+          expected = total.select{|i| !i.order_field1.nil? && i.order_field1 > 3}
+          result = Veneer(@klass).find_many(Veneer::Conditional.from_hash(:conditions => {"order_field1 gt" => 3}))
+          assert_equal expected.size, result.size
+        end
+
+        should "implement gte conditions" do
+          total = Veneer(@klass).find_many(Veneer::Conditional.from_hash({}))
+          expected = total.select{|i| !i.order_field1.nil? && i.order_field1 >= 3}
+          result = Veneer(@klass).find_many(Veneer::Conditional.from_hash(:conditions => {"order_field1 gte" => 3}))
+          assert_equal 3, result.size
+        end
+
+        should "implement :lt condition" do
+          result = Veneer(@klass).find_many(Veneer::Conditional.from_hash(:conditions => {"order_field1 lt" => 3}))
+          assert_equal 3, result.size
+        end
+
+        should "implement a lte condition" do
+          total     = Veneer(@klass).find_many(Veneer::Conditional.from_hash({}))
+          expected  = total.select{|i| !i.order_field1.nil? && i.order_field1 <= 3}
+          result = Veneer(@klass).find_many(Veneer::Conditional.from_hash(:conditions => {"order_field1 lte" => 3}))
+          assert_equal expected.size, result.size
+        end
+
+        should "implement an :in condition" do
+          total = Veneer(@klass).find_many(Veneer::Conditional.from_hash({}))
+          expected = total.select{|i| ["foo", "bar"].include?(i.name)}
+          result = Veneer(@klass).find_many(Veneer::Conditional.from_hash(:conditions => {"name in" => ["foo", "bar"]}))
+          assert_equal expected.size, result.size
+        end
+      end
+    end
+  end
+end

data/test/macros/instance_wrapper/destroy_macro.rb

@@ -0,0 +1,36 @@
+class Test::Unit::TestCase
+  def self.veneer_should_implement_destroy
+    context "on an instance" do
+      should "setup the test correctly" do
+        assert_not_nil @klass
+        assert_kind_of Class, @klass
+        assert_not_nil @valid_attributes
+        assert_kind_of Hash, @valid_attributes
+      end
+
+      setup do
+        Veneer(@klass).destroy_all
+        @valid    = Veneer(@klass).new(@valid_attributes)
+      end
+
+      should "setup the spec" do
+        assert @valid.save
+        r = Veneer(@klass).first(:conditions => {:name => @valid.instance.name})
+        assert_equal @valid, r
+      end
+
+      should "destroy the object" do
+        @valid.save
+        v = @valid
+        assert_equal v, @valid.destroy
+      end
+
+      should "remove the object from the collection" do
+        @valid.save
+        assert_equal @valid, Veneer(@klass).first(:conditions => {:name => @valid.name})
+        @valid.destroy
+        assert_nil Veneer(@klass).first(:conditions => {:name => @valid.name})
+      end
+    end
+  end
+end