veneer 0.1.3 → 0.2.0

data/lib/veneer/base/class_wrapper.rb

@@ -1,52 +1,87 @@
 module Veneer
   module Base
+    # Required methods
+    # new
+    # find_many
+    # destroy_all
+    #
+    # Optional Methods
+    # find_first
+    # create!
+    # create
+    #
     class ClassWrapper < BasicObject
       attr_reader :klass, :opts
       def initialize(klass, opts)
         @klass, @opts = klass, opts
       end
 
+      # Create an instance of the object.
+      # That is, instantiate and persist it in one step.
+      # Raise an error if the object is not persisted
       # @api public
+      # @see create
       def create!(opts = {})
         instance = new(opts)
         instance.save!
         instance
       end
 
+      # Create an instance of the object.
+      # That is, instantiate and persist it in one step.
       # @api public
+      # @see create!
       def create(opts = {})
         instance = new(opts)
         instance.save
         instance
       end
 
+      # Instantiate an item
+      # The interface required is that a hash of attributes is passed
+      # The object should take each key, and set the value provided
       # @api implementor
       def new(opts = {})
-        ::Kernel.raise Errors::NotImplemented
+        klass.new(opts)
       end
 
+      # Provides query access to the first item who meets the conditions in the passed in options hash
+      #
       # @api public
+      # @see Veneer::Base::ClassWrapper.all
       def first(opts={})
-        conditional = ::Veneer::Conditional.from_hash(opts)
-        ::Kernel.Veneer(find_first(conditional))
+        ::Kernel.Veneer(find_first(Hashie::Mash.new(opts)))
       end
 
+      # Provides an interface to query the objects
+      #
+      # Options that must be supported are
+      #
+      #   * :limit
+      #   * :offset
+      #   * :conditions
+      #   * :order
+      #
       # @api public
       def all(opts={})
-        conditional = ::Veneer::Conditional.from_hash(opts)
-        find_many(conditional).map{|element| ::Kernel.Veneer(element)}
+        find_many(Hashie::Mash.new(opts)).map{|element| ::Kernel.Veneer(element)}
       end
 
-      # Should return an array or array like structure with elements matching the provided conditional
+      # Should return an array or array like structure with elements matching the provided conditions hash
       # @api implementor
-      def find_many(conditional)
+      # @see Veneer::Base::ClassWrapper.all
+      def find_many(opts)
         ::Kernel.raise Errors::NotImplemented
       end
 
-      # A single object matching the conditional
-      # @api_implementor
-      def find_first(conditional)
-        ::Kernel.raise Errors::NotImplemented
+      def find_first(opts)
+        opts[:limit] = 1
+        find_many(opts).first
+      end
+
+      private
+      def method_missing(meth, *args, &blk)
+        @klass.__send__(meth, *args, &blk)
       end
     end
   end

data/lib/veneer/base/instance_wrapper.rb

@@ -1,5 +1,13 @@
 module Veneer
   module Base
+    # required methods
+    #
+    # save
+    # save! # failure should raise ::Veneer::Errors::NotSaved
+    # update
+    # destroy
+    # new_record?
+
     class InstanceWrapper
       attr_accessor :instance, :options
       def initialize(instance, opts = {})
@@ -10,20 +18,6 @@ module Veneer
         @instance.class
       end
 
-      def handle_before_save_error(e)
-        if instance.respond_to?(:errors) && instance.errors.respond_to?(:add)
-          case e.message
-          when Array
-            instance.errors.add(e.message[0], e.message[1])
-          when String
-            instance.errors.add("", e.message)
-          end
-        else
-          ::STDOUT.puts e.message
-        end
-        false
-      end
-
       # Checks equality of the instances
       # @api public
       def ==(other)
@@ -47,6 +41,10 @@ module Veneer
         save
       end
 
+      def update!(attributes = {})
+        raise Veneer::Errors::NotSaved unless update(attributes)
+      end
+
       # send all methods to the instance
       def method_missing(*args, &blk)
         instance.send(*args, &blk)

data/lib/veneer/core_ext/kernel.rb

@@ -11,7 +11,6 @@ module Kernel
       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

@@ -3,7 +3,6 @@ module Veneer
     class VeneerError                     < StandardError;  end
     class NotCompatible                   < VeneerError;    end
     class NotSaved                        < VeneerError;    end
-    class ConditionalOperatorNotSupported < VeneerError;    end
     class NotImplemented                  < VeneerError;    end
     class BeforeSaveError                 < VeneerError;    end
   end

data/lib/veneer/lint.rb

@@ -0,0 +1,183 @@
+module Veneer
+  module Lint
+    def self.included(base)
+      base.class_eval do
+        include ::Veneer::Lint::ClassWrapperLint
+        include ::Veneer::Lint::InstanceWrapperLint
+      end
+    end
+
+    def _veneer_teardown
+      Veneer(@klass).destroy_all
+    end
+
+    module ClassWrapperLint
+      def test_should_have_the_correct_inner_constants_for_veneer
+        assert_nothing_raised do
+          @klass::VeneerInterface
+          @klass::VeneerInterface::ClassWrapper
+          @klass::VeneerInterface::InstanceWrapper
+        end
+        assert @klass::VeneerInterface::ClassWrapper.ancestors.include?(::Veneer::Base::ClassWrapper)
+        assert @klass::VeneerInterface::InstanceWrapper.ancestors.include?(::Veneer::Base::InstanceWrapper)
+      end
+
+      def test_should_setup_the_veneer_lint_class_wrapper_with_a_klass
+        assert_not_nil @klass, "@klass should provide a class to test Veneer with"
+        assert_kind_of Class, @klass
+      ensure
+        _veneer_teardown
+      end
+
+      def test_should_provide_valid_attributes
+        assert_not_nil @valid_attributes
+        assert_kind_of Hash, @valid_attributes
+      ensure
+        _veneer_teardown
+      end
+
+      def test_should_provide_invalid_attributes
+        assert_not_nil @invalid_attributes
+        assert_kind_of Hash, @invalid_attributes
+      ensure
+        _veneer_teardown
+      end
+
+      def test_should_create_an_object_from_a_hash
+        r = Veneer(@klass).create(@valid_attributes)
+        assert_instance_of @klass::VeneerInterface::InstanceWrapper, r
+      ensure
+        _veneer_teardown
+      end
+
+      def test_should_create_the_object_from_the_hash_with_create!
+        r = Veneer(@klass).create!(@valid_attributes)
+        assert_instance_of @klass::VeneerInterface::InstanceWrapper, r
+      ensure
+        _veneer_teardown
+      end
+
+      def test_should_instantiate_a_new_instance_of_the_object
+        r = Veneer(@klass).new(@valid_attributes)
+        assert_instance_of @klass::VeneerInterface::InstanceWrapper, r
+      ensure
+        _veneer_teardown
+      end
+
+      def test_implementst_create_with_invalid_attributes
+        assert_raise Veneer::Errors::NotSaved do
+          Veneer(@klass).create!(@invalid_attributes)
+        end
+      ensure
+        _veneer_teardown
+      end
+
+      def test_should_not_raise_when_create_can_save
+        assert_nothing_raised do
+          Veneer(@klass).create(@invalid_attributes)
+        end
+      ensure
+        _veneer_teardown
+      end
+
+      def test_should_destory_all
+        Veneer(@klass).create(@valid_attributes)
+        assert Veneer(@klass).all.size > 0
+        Veneer(@klass).destroy_all
+        assert_equal 0, Veneer(@klass).all.size
+      end
+
+      def test_should_find_all
+        create_valid_items(4)
+        result = Veneer(@klass).all
+        assert_kind_of Array, result
+        assert_equal 4, result.size
+      ensure
+        _veneer_teardown
+      end
+
+      def test_should_find_first
+        create_valid_items(3)
+        result = Veneer(@klass).all
+        assert_not_nil result
+      ensure
+        _veneer_teardown
+      end
+
+      def test_should_implement_limit
+        create_valid_items(4)
+        result = Veneer(@klass).all(:limit => 2)
+        assert_equal 2, result.size
+      ensure
+        _veneer_teardown
+      end
+
+      def test_should_implement_order
+        create_valid_items(4)
+        key = @valid_attributes.keys.first
+        ordered_result = Veneer(@klass).all(:order => key)
+        result = Veneer(@klass).all
+        result = result.sort_by{ |i| i.send(key) }
+        assert_equal ordered_result, result
+      ensure
+        _veneer_teardown
+      end
+
+      def test_should_implement_order_with_desc
+        create_valid_items(4)
+        key = @valid_attributes.keys.first
+        ordered_result = Veneer(@klass).all(:order => "#{key} desc")
+        result = Veneer(@klass).all
+        result = result.sort_by{ |i| i.send(key) }.reverse
+        assert_equal ordered_result, result
+      ensure
+        _veneer_teardown
+      end
+
+      def test_should_implement_offset
+        create_valid_items(4)
+        result = Veneer(@klass).all
+        offset_result = Veneer(@klass).all(:offset => 2, :limit => 2)
+        assert_equal result[2..4], offset_result
+      ensure
+        _veneer_teardown
+      end
+
+      def test_conditions
+        create_valid_items(3)
+        Veneer(@klass).create(@valid_attributes)
+        result = Veneer(@klass).all(:conditions => @valid_attributes)
+        assert_equal 1, result.size
+      ensure
+        _veneer_teardown
+      end
+    end
+
+    module InstanceWrapperLint
+      def test_should_implement_destroy
+        item = Veneer(@klass).create(@valid_attributes)
+        assert Veneer(@klass).all.size > 0
+        assert item.kind_of?(Veneer::Base::InstanceWrapper)
+        item.destroy
+        assert Veneer(@klass).all.size == 0
+      ensure
+        _veneer_teardown
+      end
+
+      def test_should_implement_new_record?
+        item = Veneer(@klass).new(@valid_attributes)
+        assert item.new_record?
+        assert item.save
+        assert !item.new_record?
+      ensure
+        _veneer_teardown
+      end
+
+      def test_should_implement_save!
+        assert_raises Veneer::Errors::NotSaved do
+          Veneer(@klass).create!(@invalid_attributes)
+        end
+      end
+    end
+  end
+end

data/lib/veneer/version.rb

@@ -0,0 +1,3 @@
+module Veneer
+  VERSION = "0.2.0"
+end

data/lib/veneer.rb

@@ -1,8 +1,4 @@
 require 'hashie'
-require 'dirge'
-
-$:.unshift File.expand_path(File.join(File.dirname(__FILE__), "lib"))
-
 require 'veneer/core_ext/kernel'
 
 unless defined?(BasicObject)
@@ -28,6 +24,7 @@ module Veneer
   autoload :Errors,       'veneer/errors'
   autoload :Proxy,        'veneer/proxy'
   autoload :Conditional,  'veneer/base/conditional'
+  autoload :Lint,         'veneer/lint'
 
   module Base
     autoload :ClassWrapper,     'veneer/base/class_wrapper'

data/test/test_helper.rb

@@ -1,12 +1,13 @@
 require 'rubygems'
 require 'test/unit'
 require 'shoulda'
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'veneer/lint'
 
 Dir[File.join(File.dirname(__FILE__), "support", "**/*.rb")].each{|f| require f}
-Dir[File.join(File.dirname(__FILE__), "macros", "**/*.rb")].each{|f| require f}
 
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-$LOAD_PATH.unshift(File.dirname(__FILE__))
 require 'veneer'
 
 $validations = []

data/test/veneer/adapters/{active_record/active_record_setup.rb → test_active_record.rb}

@@ -1,3 +1,5 @@
+require File.join(File.dirname(__FILE__), "..", "..", "test_helper")
+
 require 'activerecord'
 require 'veneer/adapters/activerecord'
 ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
@@ -7,6 +9,8 @@ class CreateActiveRecordFoo < ActiveRecord::Migration
   def self.up
     create_table :active_record_foos, :force => true do |t|
       t.string  :name
+      t.string  :title
+      t.string  :description
       t.integer :order_field1
     end
   end
@@ -19,7 +23,6 @@ end
 CreateActiveRecordFoo.up
 
 class ActiveRecordFoo < ActiveRecord::Base
-  attr_accessor :password, :password_confirmation
   def self.veneer_spec_reset!
     delete_all
   end
@@ -32,3 +35,22 @@ class ActiveRecordFoo < ActiveRecord::Base
     errors.add(:name, "Name cannot be v_with_m_test") if name == "v_with_m_test"
   end
 end
+
+class ActiveRecordVeneerTest < ::Test::Unit::TestCase
+  include Veneer::Lint
+
+  def setup
+    @klass              = ::ActiveRecordFoo
+    @valid_attributes   = {:name => "foo", :title => "title", :description => "description"}
+    @invalid_attributes = @valid_attributes.dup.merge(:name => "invalid")
+  end
+
+  def create_valid_items(num)
+    attr = @valid_attributes
+
+    (1..num).each do |i|
+      ActiveRecordFoo.create(:name => "#{attr[:name]}#{i}", :title => "#{attr[:title]}#{i}", :description => "#{attr[:description]}#{i}")
+    end
+  end
+end
+

data/test/veneer/adapters/test_datamapper.rb

@@ -0,0 +1,56 @@
+require File.join(File.dirname(__FILE__), "..", "..", "test_helper")
+require 'dm-core'
+require 'dm-validations'
+require 'dm-migrations'
+require 'veneer/adapters/datamapper'
+
+DataMapper.setup(:default, 'sqlite3::memory:')
+
+class DMFoo
+  include DataMapper::Resource
+
+  property :id,           Serial
+  property :name,         String
+  property :title,        String
+  property :description,  String
+  property :order_field1, Integer
+
+  validates_with_method :name, :method => :check_name
+
+  def check_name
+    if name == "invalid"
+      [false, "Invalid name"]
+    else
+      true
+    end
+  end
+
+  def v_with_m_test
+    if name == "v_with_m_test"
+      [false, "name cannot be v_with_m_test"]
+    else
+      true
+    end
+  end
+end
+
+DataMapper.auto_migrate!
+
+class DataMapperVeneerTest < ::Test::Unit::TestCase
+  include Veneer::Lint
+
+  def setup
+    @klass              = ::DMFoo
+    @valid_attributes   = {:name => "foo", :title => "title", :description => "description"}
+    @invalid_attributes = @valid_attributes.dup.merge(:name => "invalid")
+  end
+
+  def create_valid_items(num)
+    attr = @valid_attributes
+
+    (1..num).each do |i|
+      DMFoo.create(:name => "#{attr[:name]}#{i}", :title => "#{attr[:title]}#{i}", :description => "#{attr[:description]}#{i}")
+    end
+  end
+end
+

data/test/veneer/adapters/test_mongomapper.rb

@@ -0,0 +1,49 @@
+require File.join(File.dirname(__FILE__), "..", "..", "test_helper")
+require 'mongo_mapper'
+
+require 'veneer/adapters/mongomapper'
+
+MongoMapper.connection = Mongo::Connection.new('127.0.0.1', 27017)
+MongoMapper.database = 'veneer_test'
+
+class MongoFoo
+  include MongoMapper::Document
+  attr_accessor :password, :password_confirmation
+
+  key :name,          String
+  key :title,         String
+  key :description,   String
+  key :order_field1,  Integer
+
+  validate_on_create :check_name
+
+  def check_name
+    errors.add(:name, "may not be invalid") if name == "invalid"
+  end
+
+  def v_with_m_test
+    errors.add(:name, "may not be v_with_m_test") if name == "v_with_m_test"
+  end
+end
+
+class MongoMapperVeneerTest < ::Test::Unit::TestCase
+  include Veneer::Lint
+
+  def setup
+    @klass              = ::MongoFoo
+    @valid_attributes   = {:name => "foo", :title => "title", :description => "description"}
+    @invalid_attributes = @valid_attributes.dup.merge(:name => "invalid")
+  end
+
+  def create_valid_items(num)
+    attr = @valid_attributes
+
+    (1..num).each do |i|
+      MongoFoo.create(:name => "#{attr[:name]}#{i}", :title => "#{attr[:title]}#{i}", :description => "#{attr[:description]}#{i}")
+    end
+  end
+end
+
+
+
+

data/test/veneer/proxy_test.rb

@@ -51,63 +51,38 @@ class VeneerProxyTest < Test::Unit::TestCase
               klass.collection.clear
             end
 
-            def find_first(conditional)
-              find_many(conditional).first
-            end
-
-            def find_many(conditional)
-              result = ::Foo.collection
-
-              unless conditional.order.empty?
-                order = conditional.order.first
-                result = result.sort_by{|i| i.send(order.field)}
-                result.reverse! if order.decending?
+            def find_many(opts)
+              result = ::Foo.collection.dup
+
+              case opts.order
+              when Array # first order only supported
+                item = opts.order.first
+                field, direction = item.split(" ")
+                result = result.sort_by{|i| i.send(field)}
+                result.reverse! if direction.to_s /desc/i
+              when String, Symbol
+                result = result.sort_by{|i| i.send(opts.order) }
               end
 
-              if conditional.offset
-                offset = conditional.offset.to_i
+              if opts.offset?
+                offset = opts.offset.to_i
                 result = result[offset..-1]
               end
 
-              conditional.conditions.each do |condition|
-                filtered = case condition.operator
-                when :eql
-                  result.select{|i| i.send(condition.field) == condition.value}
-                when :not
-                  result.select{|i| i.send(condition.field) != condition.value}
-                when :gt
-                  result.select{|i| !i.send(condition.field).nil? && (i.send(condition.field) > condition.value)}
-                when :gte
-                  result.select{|i| !i.send(condition.field).nil? && (i.send(condition.field) >= condition.value)}
-                when :lt
-                  result.select{|i| !i.send(condition.field).nil? && (i.send(condition.field) < condition.value)}
-                when :lte
-                  result.select{|i| !i.send(condition.field).nil? && (i.send(condition.field) <= condition.value)}
-                when :in
-                  result.select{|i| condition.value.include?(i.send(condition.field))}
-                else
-                  []
+              if opts.conditions?
+                opts.conditions.each do |field, value|
+                  result = result.select{|i| i.send(field) == value}.flatten.compact
                 end
-                result = filtered.flatten.compact
               end
-              if conditional.limit
-                result = result[0..(conditional.limit - 1)]
+
+              if opts.limit?
+                result = result[0..(opts.limit.to_i - 1)]
               end
               result
             end
-
           end
 
           class InstanceWrapper < Veneer::Base::InstanceWrapper
-
-            def new_record?
-              instance.new_record?
-            end
-
-            def save!
-              instance.save!
-            end
-
             def save
               instance.save
             rescue
@@ -170,7 +145,7 @@ class VeneerProxyTest < Test::Unit::TestCase
 
       teardown{ ::Foo.collection.clear }
 
-      should "get the correct resource with equal" do
+      should "get the correct resource" do
         expected = ::Foo.collection.select{|i| i.name == "foo1"}.first
         result = Veneer(::Foo).first(:conditions => {:name => "foo1"})
         assert_equal expected, result.instance