arel 0.3.1 → 0.3.2

data/lib/arel/engines/sql/predicates.rb

@@ -26,6 +26,10 @@ module Arel
       end
     end
 
+    class Not < Binary
+      def predicate_sql; '!=' end
+    end
+
     class GreaterThanOrEqualTo < Binary
       def predicate_sql; '>=' end
     end

data/lib/arel/engines/sql/primitives.rb

@@ -16,10 +16,6 @@ module Arel
       original_relation.column_for(self)
     end
 
-    def type_cast(value)
-      root.relation.format(self, value)
-    end
-
     def format(object)
       object.to_sql(Sql::Attribute.new(self))
     end

data/lib/arel/engines/sql/relations/compiler.rb

@@ -8,17 +8,17 @@ module Arel
       end
 
       def select_sql
-        build_query \
+        query = build_query \
           "SELECT     #{select_clauses.join(', ')}",
           "FROM       #{from_clauses}",
           (joins(self)                                   unless joins(self).blank? ),
           ("WHERE     #{where_clauses.join(" AND ")}"    unless wheres.blank?      ),
           ("GROUP BY  #{group_clauses.join(', ')}"       unless groupings.blank?   ),
           ("HAVING    #{having_clauses.join(', ')}"      unless havings.blank?     ),
-          ("ORDER BY  #{order_clauses.join(', ')}"       unless orders.blank?      ),
-          ("LIMIT     #{taken}"                          unless taken.blank?       ),
-          ("OFFSET    #{skipped}"                        unless skipped.blank?     ),
-          ("#{locked}"                                   unless locked.blank?)
+          ("ORDER BY  #{order_clauses.join(', ')}"       unless orders.blank?      )
+          engine.add_limit_offset!(query,{ :limit => taken, :offset => skipped }) if taken || skipped
+          query << " #{locked}" unless locked.blank?
+          query
       end
 
       def delete_sql

data/lib/arel/engines/sql/relations/operations/join.rb

@@ -1,5 +1,5 @@
 module Arel
-  class Join < Relation
+  class Join
     def table_sql(formatter = Sql::TableReference.new(self))
       relation1.externalize.table_sql(formatter)
     end

data/lib/arel/engines/sql/relations/relation.rb

@@ -1,5 +1,5 @@
 module Arel
-  class Relation
+  module Relation
     @@connection_tables_primary_keys = {}
 
     def compiler

data/lib/arel/engines/sql/relations/table.rb

@@ -1,12 +1,13 @@
 module Arel
-  class Table < Relation
-    include Recursion::BaseCase
+  class Table
+    include Relation, Recursion::BaseCase
 
     cattr_accessor :engine, :tables
     attr_reader :name, :engine, :table_alias, :options
 
     def initialize(name, options = {})
       @name = name.to_s
+      @table_exists = nil
 
       if options.is_a?(Hash)
         @options = options
@@ -41,7 +42,9 @@ module Arel
     def attributes
       return @attributes if defined?(@attributes)
       if table_exists?
-        @attributes = columns.collect { |column| Attribute.new(self, column.name.to_sym) }
+        @attributes = columns.collect do |column|
+          Sql::Attributes.for(column).new(column, self, column.name.to_sym)
+        end
       else
         []
       end
@@ -55,10 +58,6 @@ module Arel
       @hash ||= :name.hash
     end
 
-    def format(attribute, value)
-      attribute.column.type_cast(value)
-    end
-
     def column_for(attribute)
       has_attribute?(attribute) and columns.detect { |c| c.name == attribute.name.to_s }
     end

data/lib/arel/engines/sql/relations/utilities/compound.rb

@@ -1,5 +1,5 @@
 module Arel
-  class Compound < Relation
+  class Compound
     delegate :table, :table_sql, :to => :relation
 
     def build_query(*parts)

data/lib/arel/engines/sql/relations/utilities/nil.rb

@@ -1,5 +1,5 @@
 module Arel
-  class Nil < Relation
+  class Nil
     def table_sql(formatter = nil); '' end
     def name; '' end
   end

data/lib/arel/session.rb

@@ -11,13 +11,13 @@ module Arel
           begin
             @started = true
             @instance = manufacture
-            metaclass.class_eval do
+            singleton_class.class_eval do
               undef :new
               alias_method :new, :instance
             end
             yield
           ensure
-            metaclass.class_eval do
+            singleton_class.class_eval do
               undef :new
               alias_method :new, :manufacture
             end

data/lib/arel/version.rb

@@ -0,0 +1,3 @@
+module Arel
+  VERSION = "0.3.2" unless defined?(Arel::VERSION)
+end

data/spec/{arel/algebra → algebra}/unit/relations/where_spec.rb

@@ -9,6 +9,7 @@ module Arel
 
     describe '#initialize' do
       it "manufactures nested where relations if multiple predicates are provided" do
+        pending "This is not true anymore"
         another_predicate = @relation[:name].lt(2)
         Where.new(@relation, @predicate, another_predicate). \
           should == Where.new(Where.new(@relation, another_predicate), @predicate)

data/spec/attributes/boolean_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+module Arel
+  describe "Attributes::Boolean" do
+
+    before :all do
+      @relation = Model.build do |r|
+        r.engine Testing::Engine.new
+        r.attribute :awesome, Attributes::Boolean
+      end
+    end
+
+    def type_cast(val)
+      @relation[:awesome].type_cast(val)
+    end
+
+    describe "#type_cast" do
+      it "returns same value if passed a boolean" do
+        val = true
+        type_cast(val).should eql(val)
+      end
+
+      it "returns boolean representation (false) of nil" do
+        type_cast(nil).should eql(false)
+      end
+
+      it "returns boolean representation of 'true', 'false'" do
+        type_cast('true').should eql(true)
+        type_cast('false').should eql(false)
+      end
+
+      it "returns boolean representation of :true, :false" do
+        type_cast(:true).should eql(true)
+        type_cast(:false).should eql(false)
+      end
+
+      it "returns boolean representation of 0, 1" do
+        type_cast(1).should == true
+        type_cast(0).should == false
+      end
+
+      it "calls #to_s on arbitrary objects" do
+        obj = Object.new
+        obj.extend Module.new { def to_s ; 'true' ; end }
+        type_cast(obj).should == true
+      end
+
+      [ Object.new, 'string', '00.0', 5 ].each do |value|
+        it "raises exception when attempting type_cast of non-boolean value #{value.inspect}" do
+          lambda do
+            type_cast(value)
+          end.should raise_error(TypecastError, /could not typecast/)
+        end
+      end
+    end
+  end
+end

data/spec/attributes/float_spec.rb

@@ -0,0 +1,119 @@
+require 'spec_helper'
+require 'bigdecimal'
+
+module Arel
+  describe "Attributes::Float" do
+
+    before :all do
+      @relation = Model.build do |r|
+        r.engine Testing::Engine.new
+        r.attribute :percentage, Attributes::Float
+      end
+    end
+
+    def type_cast(val)
+      @relation[:percentage].type_cast(val)
+    end
+
+    describe "#type_cast" do
+      it "returns same value if an float" do
+        type_cast(24.01).should eql(24.01)
+      end
+
+      it "returns nil if passed nil" do
+        type_cast(nil).should be_nil
+      end
+
+      it "returns nil if passed empty string" do
+        type_cast('').should be_nil
+      end
+
+      it "returns float representation of a zero string float" do
+        type_cast('0').should eql(0.0)
+      end
+
+      it "returns float representation of a positive string integer" do
+        type_cast('24').should eql(24.0)
+      end
+
+      it "returns float representation of a positive string integer with spaces" do
+        type_cast('  24').should eql(24.0)
+        type_cast('24  ').should eql(24.0)
+      end
+
+      it "returns float representation of a negative string float" do
+        type_cast('-24.23').should eql(-24.23)
+      end
+
+      it "returns float representation of a negative string integer with spaces" do
+        type_cast('-24 ').should eql(-24.0)
+        type_cast(' -24').should eql(-24.0)
+      end
+
+      it "returns integer representation of a zero string float" do
+        type_cast('0.0').should eql(0.0)
+      end
+
+      it "returns integer representation of a positive string float" do
+        type_cast('24.35').should eql(24.35)
+      end
+
+      it "returns integer representation of a positive string float with spaces" do
+        type_cast(' 24.35').should eql(24.35)
+        type_cast('24.35 ').should eql(24.35)
+      end
+
+      it "returns integer representation of a negative string float" do
+        type_cast('-24.35').should eql(-24.35)
+      end
+
+      it "returns integer representation of a negative string float with spaces" do
+        type_cast(' -24.35 ').should eql(-24.35)
+      end
+
+      it "returns integer representation of a zero string float, with no leading digits" do
+        type_cast('.0').should eql(0.0)
+      end
+
+      it "returns integer representation of a zero string float, with no leading digits with spaces" do
+        type_cast(' .0').should eql(0.0)
+      end
+
+      it "returns integer representation of a positive string float, with no leading digits" do
+        type_cast('.41').should eql(0.41)
+      end
+
+      it "returns integer representation of a zero float" do
+        type_cast(0.0).should eql(0.0)
+      end
+
+      it "returns integer representation of a positive float" do
+        type_cast(24.35).should eql(24.35)
+      end
+
+      it "returns integer representation of a negative float" do
+        type_cast(-24.35).should eql(-24.35)
+      end
+
+      it "returns integer representation of a zero decimal" do
+        type_cast(BigDecimal('0.0')).should eql(0.0)
+      end
+
+      it "returns integer representation of a positive decimal" do
+        type_cast(BigDecimal('24.35')).should eql(24.35)
+      end
+
+      it "returns integer representation of a negative decimal" do
+        type_cast(BigDecimal('-24.35')).should eql(-24.35)
+      end
+
+      [ Object.new, true, '00.0', '0.', 'string' ].each do |value|
+        it "raises exception when attempting type_cast of non-numeric value #{value.inspect}" do
+          lambda do
+            type_cast(value)
+          end.should raise_error(TypecastError, /could not typecast/)
+        end
+      end
+    end
+  end
+end

data/spec/attributes/integer_spec.rb

@@ -0,0 +1,119 @@
+require 'spec_helper'
+require 'bigdecimal'
+
+module Arel
+  describe "Attributes::Integer" do
+
+    before :all do
+      @relation = Model.build do |r|
+        r.engine Testing::Engine.new
+        r.attribute :age, Attributes::Integer
+      end
+    end
+
+    def type_cast(val)
+      @relation[:age].type_cast(val)
+    end
+
+    describe "#type_cast" do
+      it "returns same value if an integer" do
+        type_cast(24).should eql(24)
+      end
+
+      it "returns nil if passed nil" do
+        type_cast(nil).should be_nil
+      end
+
+      it "returns nil if passed empty string" do
+        type_cast('').should be_nil
+      end
+
+      it "returns integer representation of a zero string integer" do
+        type_cast('0').should eql(0)
+      end
+
+      it "returns integer representation of a positive string integer" do
+        type_cast('24').should eql(24)
+      end
+
+      it "returns integer representation of a positive string integer with spaces" do
+        type_cast('  24').should eql(24)
+        type_cast('24  ').should eql(24)
+      end
+
+      it "returns integer representation of a negative string integer" do
+        type_cast('-24').should eql(-24)
+      end
+
+      it "returns integer representation of a negative string integer with spaces" do
+        type_cast('-24 ').should eql(-24)
+        type_cast(' -24').should eql(-24)
+      end
+
+      it "returns integer representation of a zero string float" do
+        type_cast('0.0').should eql(0)
+      end
+
+      it "returns integer representation of a positive string float" do
+        type_cast('24.35').should eql(24)
+      end
+
+      it "returns integer representation of a positive string float with spaces" do
+        type_cast(' 24.35').should eql(24)
+        type_cast('24.35 ').should eql(24)
+      end
+
+      it "returns integer representation of a negative string float" do
+        type_cast('-24.35').should eql(-24)
+      end
+
+      it "returns integer representation of a negative string float with spaces" do
+        type_cast(' -24.35 ').should eql(-24)
+      end
+
+      it "returns integer representation of a zero string float, with no leading digits" do
+        type_cast('.0').should eql(0)
+      end
+
+      it "returns integer representation of a zero string float, with no leading digits with spaces" do
+        type_cast(' .0').should eql(0)
+      end
+
+      it "returns integer representation of a positive string float, with no leading digits" do
+        type_cast('.41').should eql(0)
+      end
+
+      it "returns integer representation of a zero float" do
+        type_cast(0.0).should eql(0)
+      end
+
+      it "returns integer representation of a positive float" do
+        type_cast(24.35).should eql(24)
+      end
+
+      it "returns integer representation of a negative float" do
+        type_cast(-24.35).should eql(-24)
+      end
+
+      it "returns integer representation of a zero decimal" do
+        type_cast(BigDecimal('0.0')).should eql(0)
+      end
+
+      it "returns integer representation of a positive decimal" do
+        type_cast(BigDecimal('24.35')).should eql(24)
+      end
+
+      it "returns integer representation of a negative decimal" do
+        type_cast(BigDecimal('-24.35')).should eql(-24)
+      end
+
+      [ Object.new, true, '00.0', '0.', 'string' ].each do |value|
+        it "raises exception when attempting type_cast of non-numeric value #{value.inspect}" do
+          lambda do
+            type_cast(value)
+          end.should raise_error(TypecastError, /could not typecast/)
+        end
+      end
+    end
+  end
+end