veneer 0.1.3 → 0.2.0

data/..gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "./version"
+
+Gem::Specification.new do |s|
+  s.name        = "."
+  s.version     = .::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["TODO: Write your name"]
+  s.email       = ["TODO: Write your email address"]
+  s.homepage    = ""
+  s.summary     = %q{TODO: Write a gem summary}
+  s.description = %q{TODO: Write a gem description}
+
+  s.rubyforge_project = "."
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/.gitignore

@@ -1,6 +1,3 @@
-*.sw?
-.DS_Store
-coverage
-rdoc
-pkg
+pkg/*
 *.gem
+.bundle

data/Gemfile

@@ -0,0 +1,4 @@
+#source "http://rubygems.org"
+
+# Specify your gem's dependencies in ..gemspec
+gemspec

data/README.md

@@ -0,0 +1,171 @@
+# veneer
+
+Veneer is an interface that sits above Data Sources.  A data source may be an ORM like ActiveRecord or DataMapper, or it could be a document store like MongoMapper, Mongoid, a key value storage like Moneta, or even an adapter could be setup to use for an external API.
+
+Veneer aims to provide plugin, engine, and library authors with a consistant interface to any of these libraries so that plugins, engines, stacks and gems may be used across data store types.  Reusable code FTW!
+
+It differs from ActiveModel in that it doesn't provide any validation support, serialization, callbacks, state machine or anything like that.  Veneer is intended to work _with_ ActiveModel to provide a data store independant interface to create reusable code.
+
+Veneer instead aims to provide a simple interface for
+* querying
+* creating
+* saving
+* deleting
+* basic lifecycle hooks
+** before validation
+** before save
+** after save
+** before destroy
+** after destroy
+
+There is no interface for validations, since this interface is handled as part of ActiveModel
+
+## Creating and Saving an instance
+
+To create an instance of an object wrap the class in a vaneer call and create or get a new instance.
+
+<pre><code>obj = Veneer(MyModel).new(:some => "hash", :of => "attributes")
+obj.save
+
+ # OR
+
+obj = Veneer(MyModel).create(:some => "hash", :of => "attributes")
+</code></pre>
+
+There are also version that will raise an exception if it could not save
+
+<pre><code>obj = Veneer(MyModel).new(:some => "attribute").save!
+
+# OR
+
+obj = Veneer(MyModel).create!(:some => "attribute")
+</code></pre>
+
+h2. Deleting
+
+You can delete all the instances of a model or a single instance.
+
+<pre><code>Veneer(MyModel).destroy\_all # delete all instances
+
+@some\_veneer\_model.destroy
+</code></pre>
+
+### Updating
+
+To update an instance:
+
+<pre><code>@some\_veneer\_instance.update(:with => "attributes")
+
+OR
+
+@some\_veneer\_instance.update!(:with => "attributes") # raise on error
+</code></pre>
+
+## Queries
+
+Veneer lets you query models with a simple interface.  Only simple queries are supported.
+
+You can query a single object, or multiple objects.
+
+<pre><code>Veneer(MyModel).first(:conditions => {:name => "foo"})
+
+Veneer(MyModel).all(:conditions => {:age => 18}, :limit => 5)
+</code></pre>
+
+The supported options are:
+
+* :limit
+* :offset
+* :order
+* :conditions
+
+## Limit & Offset
+
+The :limit option will limit the number of returned results.
+
+The :offset option, when set to an integer x will begin the results at the xth result.
+
+## Order
+
+Ordering should be set as an array.  By default, the order is decending.
+
+The format of the array is:
+
+<pre><code>["<field> <directon>", "<field>"]
+
+### Example
+  Veneer(MyModel).all(:order => [:name, "age desc")
+</code></pre>
+
+## Conditions
+
+Conditions are a very simple set of conditions on the fields of the model.  The for of the conditions are:
+
+<pre><code>:conditions => {:field => value}</code></pre>
+
+<pre><code>
+  Veneer(MyModel).all(:conditions => {:name => ["fred", "barney"], :age => (18..18)})
+  Veneer(MyModel).first(:conditions => {:name => "fred"})
+</code></pre>
+
+Condition fields should be ready to accept:
+
+* String
+* Range (Between clauses)
+* Array (IN clauses)
+* nil
+
+The results of a query are all wrapped as Veneer instances.
+
+## All Together
+
+<pre><code>Veneer(MyModel).all(:order => [:name, "age asc"], :limit => 5, :offset => 15, :conditions => {:name => "betty", :age => (0..18)})
+</code></pre>
+
+## Object methods
+
+All methods that aren't found on the adapter, are passed through to the instance.  So to access any attributes on the actual model instance, just call the method on it. This can be handy to access things that should be avaialble with an ActiveModel.
+
+## Current Support
+
+Veneer currently has built in support for ActiveRecord and DataMapper.
+
+Veneer works on a VeneerInterface inner module though so you can easily impelment your adapter without requiring it to be in the veneer repo (although pull requests are welcome) (see Building Your Adapter)
+
+To use DataMapper or ActiveRecord
+
+<pre><code>
+require 'veneer/adapters/activerecord'
+require 'veneer/adapters/datamapper'
+</code></pre>
+
+## Building Your own Adapter
+
+Veneer is made so that you don't need to have access to the main repository to create an adapter.  Veneer looks for an inner constant in the klass or object. For example, in ActiveRecord, to provide the adapter, Veneer will look for the adapter in ActiveRecord::VeneerInterface.  VeneerInterface should define two classes:
+
+* ClassWrapper
+* InstanceWrapper
+
+So, you'd end up with
+
+* ActiveRecord::Base::VeneerInterface::ClassWrapper < Veneer::Base::ClassWrapper
+* ActiveRecord::Base::VeneerInterface::InstanceWrapper < Veneer::Base::InstanceWrapper
+
+By using inner constants, no behavior of the base implementation is overwritten, or will clash with potential methods implented in the base data store.
+
+It also means that any adapter can be created without direct access to the Veneer repository.
+
+## Note on Patches/Pull Requests
+
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but
+   bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+## Copyright
+
+Copyright (c) 2009 Daniel Neighman. See LICENSE for details.

data/Rakefile

@@ -1,24 +1,5 @@
-require 'rubygems'
-require 'rake'
-
-begin
-  require 'jeweler'
-  Jeweler::Tasks.new do |gem|
-    gem.name = "veneer"
-    gem.summary = %Q{A thin veneer over data stores}
-    gem.description = %Q{Veneer provides basic querying, saving, deleteing and creating of data stores.}
-    gem.email = "has.sox@gmail.com"
-    gem.homepage = "http://github.com/hassox/veneer"
-    gem.authors = ["Daniel Neighman"]
-    gem.rubyforge_project = "veneer"
-    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
-  end
-  Jeweler::RubyforgeTasks.new do |rubyforge|
-    rubyforge.doc_task = "rdoc"
-  end
-rescue LoadError
-  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
-end
+require 'bundler'
+Bundler::GemHelper.install_tasks
 
 task :default => [:test_units]
 require 'rake/testtask'
@@ -28,21 +9,7 @@ Rake::TestTask.new("test"){ |test|
   test.verbose = true
   test.warning = true
   test.libs << "test"
-  test.test_files = FileList["test/test*.rb", "test/**/*_test.rb"]
+  test.test_files = FileList["test/test*.rb", "test/**/test*.rb"]
 }
 
-task :test => :check_dependencies
-
-require 'rake/rdoctask'
-Rake::RDocTask.new do |rdoc|
-  if File.exist?('VERSION')
-    version = File.read('VERSION')
-  else
-    version = ""
-  end
 
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "veneer #{version}"
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end

data/lib/..rb

@@ -0,0 +1,3 @@
+module .
+  # Your code goes here...
+end

data/lib/veneer/adapters/active_record.rb

@@ -1 +1 @@
-require ~'./activerecord'
+require 'veneer/adapters/activerecord'

data/lib/veneer/adapters/activerecord/class_wrapper.rb

@@ -10,92 +10,24 @@ module ActiveRecord
           klass.destroy_all
         end
 
-        def find_first(conditional)
-          opts = conditional_to_ar_opts(conditional)
-          klass.find(:first, opts)
+        def find_first(opts)
+          build_query(opts).first
         end
 
-        def find_many(conditional)
-          opts = conditional_to_ar_opts(conditional)
-          klass.find(:all,opts)
-        end
-
-        def before_save(*methods)
-          klass.before_save *methods
-        end
-
-        %w(
-          validates_presence_of
-          validates_uniqueness_of
-          validates_confirmation_of
-        ).each do |meth|
-        class_eval <<-RUBY
-          def #{meth}(*args)
-            klass.#{meth}(*args)
-          end
-          RUBY
-        end
-
-        def validates_with_method(*methods)
-          methods.each do |meth|
-            @klass.validate meth
-          end
+        def find_many(opts)
+          build_query(opts)
         end
 
         private
-        def conditional_to_ar_opts(c)
-          opts = {}
-          opts[:limit]  = c.limit   if c.limit
-          opts[:offset] = c.offset  if c.offset
-
-          unless c.order.blank?
-            opts[:order] = c.order.inject([]) do |ary, cnd|
-              ary << "#{cnd.field} #{cnd.direction}"
-            end.join(",")
-          end
-
-          unless c.conditions.blank?
-            val_array = []
-            cnds = c.conditions.inject([]) do |ary, cd|
-              case cd.operator
-              when :eql
-                if cd.value.nil?
-                  ary << "#{cd.field} IS ?"
-                else
-                  ary << "#{cd.field} = ?"
-                end
-                val_array << cd.value
-              when :not
-                if cd.value.nil?
-                  ary << "#{cd.field} IS NOT ?"
-                else
-                  ary << "#{cd.field} <> ?"
-                end
-                val_array << cd.value
-              when :gt
-                ary << "#{cd.field} > ?"
-                val_array << cd.value
-              when :gte
-                ary << "#{cd.field} >= ?"
-                val_array << cd.value
-              when :lt
-                ary << "#{cd.field} < ?"
-                val_array << cd.value
-              when :lte
-                ary << "#{cd.field} <= ?"
-                val_array << cd.value
-              when :in
-                ary << "#{cd.field} IN ( ? )"
-                val_array << cd.value
-              end
-              ary
-            end
-            opts[:conditions] = [cnds.join(" AND "), *val_array]
-          end
-          opts
+        def build_query(opts)
+          query = klass
+          query.where(opts.conditions) if opts.conditions.present?
+          query.limit(opts.limit)      if opts.limit?
+          query.offset(opts.offset)    if opts.offset?
+          query.order(opts.order)      if opts.order?
+          query
         end
       end # ClassWrapper
-
     end
   end
 end

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

@@ -4,20 +4,12 @@ module ActiveRecord
       class InstanceWrapper < Veneer::Base::InstanceWrapper
         def update(attributes = {})
           instance.update_attributes(attributes)
-        rescue Veneer::Errors::BeforeSaveError => e
-          handle_before_save_error(e)
         end
 
         def save!
-          instance.save!
-        rescue ActiveRecord::RecordInvalid, Veneer::Errors::BeforeSaveError=> e
-          raise ::Veneer::Errors::NotSaved, e.message
-        end
-
-        def save
-          instance.save
-        rescue Veneer::Errors::BeforeSaveError => e
-          handle_before_save_error(e)
+          instance.save ?
+            true :
+            raise ::Veneer::Errors::NotSaved
         end
       end # InstanceWrapper
     end # VeneerInterface

data/lib/veneer/adapters/activerecord/pre_3.0_class_wrapper.rb

@@ -0,0 +1,24 @@
+module ActiveRecord
+  class Base
+    module VeneerInterface
+      class ClassWrapper < Veneer::Base::ClassWrapper
+        def new(opts = {})
+          ::Kernel::Veneer(klass.new(opts))
+        end
+
+        def destroy_all
+          klass.destroy_all
+        end
+
+        def find_first(opts)
+          klass.find(:first, opts.to_hash.symbolize_keys)
+        end
+
+        def find_many(opts)
+          klass.find(:all,opts.to_hash.symbolize_keys)
+        end
+      end # ClassWrapper
+
+    end
+  end
+end

data/lib/veneer/adapters/activerecord/pre_3.0_instance_wrapper.rb

@@ -0,0 +1,15 @@
+module ActiveRecord
+  class Base
+    module VeneerInterface
+      class InstanceWrapper < Veneer::Base::InstanceWrapper
+        def update(attributes = {})
+          instance.update_attributes(attributes)
+        end
+
+        def save!
+          instance.save ? true : (raise ::Veneer::Errors::NotSaved)
+        end
+      end # InstanceWrapper
+    end # VeneerInterface
+  end # Base
+end # ActiveRecord

data/lib/veneer/adapters/activerecord.rb

@@ -1,2 +1,9 @@
-require 'veneer/adapters/activerecord/class_wrapper'
-require 'veneer/adapters/activerecord/instance_wrapper'
+if defined?(ActiveRecord::Base)
+  if ActiveRecord::VERSION::MAJOR < 3
+    require 'veneer/adapters/activerecord/pre_3.0_class_wrapper'
+    require 'veneer/adapters/activerecord/pre_3.0_instance_wrapper'
+  else
+    require 'veneer/adapters/activerecord/class_wrapper'
+    require 'veneer/adapters/activerecord/instance_wrapper'
+  end
+end

data/lib/veneer/adapters/data_mapper.rb

@@ -1 +1 @@
-require ~'./datamapper'
+require 'veneer/adapters/datamapper'

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

@@ -10,69 +10,48 @@ module DataMapper
           klass.all.destroy
         end
 
-        def find_first(conditional)
-          opts = opts_from_conditional_for_dm(conditional)
-          klass.first(opts)
+        def find_first(opts)
+          klass.first(dm_conditions_from_opts(opts))
         end
 
-        def find_many(conditional)
-          opts = opts_from_conditional_for_dm(conditional)
-          klass.all(opts)
+        def find_many(opts)
+          klass.all(dm_conditions_from_opts(opts))
         end
 
-        def before_save(*methods)
-          klass.class_eval do
-            methods.each do |meth|
-              before :save, meth
-            end
-          end
-        end
-
-        [
-          %w(validates_presence_of      validates_present),
-          %w(validates_uniqueness_of    validates_is_unique),
-          %w(validates_confirmation_of  validates_is_confirmed),
-          %w(validates_with_method      validates_with_method)
-        ].each do |(meth,natural)|
-          class_eval <<-RUBY
-            def #{meth}(*args)
-              ensure_validations_loaded!
-              klass.#{natural}(*args)
-            end
-          RUBY
+        private
+        def order_from_string(str)
+          field, direction = str.split " "
+          direction ||= "asc"
+          field.to_sym.send(direction) if allowed_field?(field)
         end
 
-        private
-        def ensure_validations_loaded!
-          unless defined?(::DataMapper::Validate)
-            ::Kernel.require 'dm-validations'
-            @klass.class_eval{include ::DataMapper::Validate}
-          end
+        def allowed_field?(field)
+          @allowed ||= klass.properties.map(&:name).map(&:to_s)
+          @allowed.include?(field.to_s)
         end
 
-        def opts_from_conditional_for_dm(c)
+        def dm_conditions_from_opts(raw)
           opts = {}
 
-          opts[:limit]  = c.limit  if c.limit
-          opts[:offset] = c.offset if c.offset
-
-          unless c.order.empty?
-            opts[:order] = c.order.inject([]) do |ary, cnd|
-              ary << cnd.field.send(cnd.direction)
-              ary
+          opts[:limit]  = raw.limit  if raw.limit?
+          opts[:offset] = raw.offset if raw.offset?
+
+          if raw.order.present?
+            opts[:order] = case raw.order
+            when Array
+              raw.order.inject([]) do |ary, str|
+                ary << order_from_string(str)
+              end.compact
+            when String
+              order_from_string(raw.order)
+            when Symbol
+              raw.order
             end
           end
 
-          unless c.conditions.empty?
-            c.conditions.each do |cd|
-              case cd.operator
-              when :eql
-                opts[cd.field] = cd.value
-              when :not, :gt, :gte, :lt, :lte
-                opts[cd.field.send(cd.operator)] = cd.value
-              when :in
-                opts[cd.field] = ::Array.new([cd.value].flatten.compact)
-              end
+          if raw.conditions.present?
+            raw.conditions.each do |field, value|
+              opts[field] = value if allowed_field?(field)
             end
           end
           opts

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

@@ -4,25 +4,14 @@
         class InstanceWrapper < ::Veneer::Base::InstanceWrapper
 
           def save
-            result = false
-            instance.class.transaction do
-              result = instance.save
-            end
-            result
-          rescue ::Veneer::Errors::BeforeSaveError => e
-            handle_before_save_error(e)
+            instance.save
           end
 
           def save!
             result = false
-            instance.class.transaction do
-              result = instance.save
-              raise ::Veneer::Errors::NotSaved unless result
-              result
-            end
+            result = instance.save
+            raise ::Veneer::Errors::NotSaved unless result
             result
-          rescue ::Veneer::Errors::BeforeSaveError => e
-            raise ::Veneer::Errors::NotSaved, e.message
           end
 
           def new_record?

data/lib/veneer/adapters/mongomapper/class_wrapper.rb

@@ -10,67 +10,13 @@ module MongoMapper
           klass.destroy_all
         end
 
-        def find_first(conditional)
-          opts = conditional_to_mongo_opts(conditional)
+        def find_first(opts)
           klass.first(opts)
         end
 
-        def find_many(conditional)
-          opts = conditional_to_mongo_opts(conditional)
+        def find_many(opts)
           klass.all(opts)
         end
-
-        def before_save(*methods)
-          klass.before_save *methods
-        end
-
-        %w(
-          validates_presence_of
-          validates_uniqueness_of
-          validates_confirmation_of
-        ).each do |meth|
-          class_eval <<-RUBY
-            def #{meth}(*args)
-              klass.#{meth}(*args)
-            end
-          RUBY
-        end
-
-        def validates_with_method(*methods)
-          methods.each do |meth|
-            klass.validates_each(nil, :logic => ::Proc.new{ send(meth)})
-          end
-        end
-
-        private
-        def conditional_to_mongo_opts(c)
-          opts = {}
-          opts[:limit]  = c.limit if c.limit
-          opts[:offset] = c.offset if c.offset
-
-          unless c.order.blank?
-            opts[:order] = c.order.inject([]) do |ary, cnd|
-              ary << "#{cnd.field} #{cnd.direction}"
-            end.join(",")
-          end
-
-          unless c.conditions.blank?
-            cnds = c.conditions.inject({}) do |hsh, c|
-              case c.operator
-              when :eql
-                hsh[c.field] = c.value
-              when :not
-                hsh[c.field] = {"$ne" => c.value}
-              when :gt, :gte, :lt, :lte, :in
-                hsh[c.field] = {"$#{c.operator}" => c.value}
-              end
-              ::STDOUT.puts hsh.inspect
-              hsh
-            end
-            opts[:conditions] = cnds
-          end
-          opts
-        end
       end
     end
   end

data/lib/veneer/adapters/mongomapper.rb

@@ -1,3 +1,3 @@
-require ~'./mongomapper/class_wrapper'
-require ~'./mongomapper/instance_wrapper'
+require 'veneer/adapters/mongomapper/class_wrapper'
+require 'veneer/adapters/mongomapper/instance_wrapper'