arbs 0.1.0 → 0.2.0

data/lib/active_record/base.rb

@@ -1,7 +1,10 @@
 module ActiveRecord #:nodoc:
   class Base #:nodoc:
-    stub_class_methods :belongs_to, :has_many, :before_save, :validates_presence_of, :validates_uniqueness_of, 
-                        :validates_confirmation_of, :serialize, :validates_length_of, :before_save, :attr_accessible
+    stub_class_methods :has_many, :before_save, :validates_presence_of, :validates_uniqueness_of, 
+                        :validates_confirmation_of, :serialize, :validates_length_of, :before_save, 
+                        :attr_accessible, :attr_protected, :after_create, :before_validation_on_create,
+                        :validates_format_of, :validate
+                        
 
     def initialize(attributes={})
       attributes.each do |key, value|
@@ -16,5 +19,21 @@ module ActiveRecord #:nodoc:
     def write_attribute(method_name, value)
       instance_variable_set "@#{method_name}", value
     end
+    
+    class << self
+      def belongs_to(association_name)
+        attr_accessor association_name
+      end
+      
+      def has_many(association_name)
+        attr_writer association_name
+        define_method association_name do
+          read_attribute(association_name) || write_attribute(association_name, [])
+        end
+      end
+      
+      alias has_and_belongs_to_many has_many
+    end
+    
   end
 end

data/lib/behavior_appender.rb

@@ -16,19 +16,11 @@ class BehaviorAppender #:nodoc:
     end
   end
   
-  [:string, :text, :integer, :datetime, :boolean].each do |column_type|
+  [:string, :text, :integer, :float, :decimal, :datetime, :timestamp, :time, :date, :binary, :boolean].each do |column_type|
     define_method column_type do |*args|
       args.pop if args.last.is_a?(Hash)
-      args.each do |arg|
-        klass.class_eval do
-          attr_reader arg.to_sym unless instance_methods.include?(arg.to_s)
-          attr_writer arg.to_sym unless instance_methods.include?("#{arg}=")
-          if column_type == :boolean
-            define_method "#{arg}?".to_sym do
-              self.send name
-            end
-          end
-        end
+      args.each do |name|
+        column name, column_type
       end
     end
   end

data/rakefile.rb

@@ -33,7 +33,7 @@ Gem::manage_gems
 specification = Gem::Specification.new do |s|
 	s.name   = "arbs"
   s.summary = "A duck that acts like ActiveRecord::Base, but doesn't have any of the AR::B functionality."
-	s.version = "0.1.0"
+	s.version = "0.2.0"
 	s.author = 'Jay Fields'
 	s.description = "A duck that acts like ActiveRecord::Base, but doesn't have any of the AR::B functionality."
   s.homepage = 'http://arbs.rubyforge.org'

data/test/active_record/base_test.rb

@@ -1,57 +1,105 @@
-require File.dirname(__FILE__) + '/../test_helper'
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
 
-unit_tests do
-
-  test "stub belongs_to" do
-    assert_equal true, ActiveRecord::Base.methods.include?("belongs_to")
-  end
-
-  test "stub has_many" do
-    assert_equal true, ActiveRecord::Base.methods.include?("has_many")
-  end
-
-  test "stub before_save" do
-    assert_equal true, ActiveRecord::Base.methods.include?("before_save")
-  end
-
-  test "stub validates_presence_of" do
-    assert_equal true, ActiveRecord::Base.methods.include?("validates_presence_of")
-  end
-
-  test "stub validates_uniqueness_of" do
-    assert_equal true, ActiveRecord::Base.methods.include?("validates_uniqueness_of")
-  end
-
-  test "stub validates_confirmation_of" do
-    assert_equal true, ActiveRecord::Base.methods.include?("validates_confirmation_of")
-  end
-
-  test "stub serialize" do
-    assert_equal true, ActiveRecord::Base.methods.include?("serialize")
+Expectations do
+  %w(
+    after_create
+    attr_accessible
+    attr_protected
+    before_save 
+    before_validation_on_create
+    serialize 
+    validates_presence_of 
+    validates_uniqueness_of 
+    validates_confirmation_of 
+    validates_length_of 
+    validates_format_of
+    validate
+  ).each do |noop_class_method|
+    expect true do
+      ActiveRecord::Base.methods.include?(noop_class_method) || noop_class_method
+    end
   end
   
-  test "initialize via options" do
+  expect ["foo", "bar"] do
     klass = Class.new(ActiveRecord::Base) do
       attr_accessor :foo, :bar
     end
     instance = klass.new(:foo=>"foo", :bar=>"bar")
-    assert_equal ["foo", "bar"], [instance.foo, instance.bar]
+    [instance.foo, instance.bar]
   end
-
-  test "read attribute returns the instance_variable" do
+  
+  expect "foo" do
     klass = Class.new(ActiveRecord::Base) do
       attr_accessor :foo
     end
-    assert_equal "foo", klass.new(:foo=>"foo").read_attribute(:foo)
+    klass.new(:foo=>"foo").read_attribute(:foo)
   end
-
-  test "write attribute sets the instance_variable" do
+  
+  expect 1 do
     klass = Class.new(ActiveRecord::Base) do
       attr_accessor :foo
     end
     instance = klass.new(:foo=>"foo")
     instance.write_attribute(:foo, 1)
-    assert_equal 1, instance.foo 
+    instance.foo
+  end
+  
+  expect :some_fake_associated_object do
+    klass = Class.new(ActiveRecord::Base) do
+      belongs_to :foo
+    end
+    instance = klass.new
+    instance.foo = :some_fake_associated_object
+    instance.foo
+  end
+  
+  expect :some_fake_associated_object do
+    klass = Class.new(ActiveRecord::Base) do
+      belongs_to :foo
+    end
+    instance = klass.new(:foo => :some_fake_associated_object)
+    instance.foo
+  end
+  
+  expect [] do
+    klass = Class.new(ActiveRecord::Base) do
+      has_many :foos
+    end
+    instance = klass.new
+    instance.foos
+  end
+  
+  expect [:value] do
+    klass = Class.new(ActiveRecord::Base) do
+      has_many :foos
+    end
+    instance = klass.new
+    instance.foos << :value
+    instance.foos
+  end
+  
+  expect [:value] do
+    klass = Class.new(ActiveRecord::Base) do
+      has_many :foos
+    end
+    instance = klass.new
+    instance.foos = [:value]
+    instance.foos
+  end
+  
+  expect [:value] do
+    klass = Class.new(ActiveRecord::Base) do
+      has_many :foos
+    end
+    instance = klass.new(:foos => [:value])
+    instance.foos
+  end
+  
+  expect [] do
+    klass = Class.new(ActiveRecord::Base) do
+      has_and_belongs_to_many :foos
+    end
+    instance = klass.new
+    instance.foos
   end
-
 end

data/test/active_record/schema_test.rb

@@ -1,18 +1,18 @@
-require File.dirname(__FILE__) + '/../test_helper'
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
 
-unit_tests do
-  test "stub add index" do
-    assert_equal true, ActiveRecord::Schema.instance_methods.include?("add_index")
+Expectations do
+  expect true do
+    ActiveRecord::Schema.instance_methods.include?("add_index")
   end
 
-  test "stub foreign key" do
-    assert_equal true, ActiveRecord::Schema.instance_methods.include?("add_foreign_key")
+  expect true do
+    ActiveRecord::Schema.instance_methods.include?("add_foreign_key")
   end
   
-  Table = 1
-  test "create table" do
+  Widget = :the_model_class
+  expect Widget do
     schema = ActiveRecord::Schema.new
-    assert_equal 1, schema.create_table("tables", nil) { |val| val.klass } 
+    schema.create_table('widgets', nil) { |val| val.klass } 
   end
   
 end

data/test/behavior_appender_test.rb

@@ -1,31 +1,30 @@
-require File.dirname(__FILE__) + '/test_helper'
+require File.expand_path(File.dirname(__FILE__) + '/test_helper')
 
-unit_tests do
+Expectations do
 
-  test "column creates readers for each column" do
+  expect true do
     klass = Class.new
     BehaviorAppender.new(klass).column("foo", "string")
-    assert_equal true, klass.instance_methods.include?("foo")
+    klass.instance_methods.include?("foo")
   end
 
-  test "column creates writers for each column" do
+  expect true do
     klass = Class.new
     BehaviorAppender.new(klass).column("foo", "string")
-    assert_equal true, klass.instance_methods.include?("foo=")
+    klass.instance_methods.include?("foo=")
   end
 
-  test "column doesnt create readers if methods already exist" do
+  expect "foo" do
     klass = Class.new do
       def foo
         "foo"
       end
     end
     BehaviorAppender.new(klass).column("foo", "string")
-    instance = klass.new
-    assert_equal "foo", instance.foo
+    klass.new.foo
   end
 
-  test "column doesnt create writer if methods already exist" do
+  expect "foo" do
     klass = Class.new do
       def foo=(value)
         @foo = "foo"
@@ -34,60 +33,96 @@ unit_tests do
     BehaviorAppender.new(klass).column("foo", "string")
     instance = klass.new
     instance.foo = 3
-    assert_equal "foo", instance.foo
+    instance.foo
   end
-  
-  test "boolean method is defined if the type is boolean" do
+
+  expect true do
     klass = Class.new
     BehaviorAppender.new(klass).column("foo", "boolean")
-    assert_equal true, klass.instance_methods.include?("foo?")
+    klass.instance_methods.include?("foo?")
   end
-  
-  test "string columns are created" do
+
+  expect true do
     klass = Class.new
     BehaviorAppender.new(klass).string("foo")
-    assert_equal true, klass.instance_methods.include?("foo")
+    klass.instance_methods.include?("foo")
   end
 
-  test "datetime columns are created" do
+  expect true do
     klass = Class.new
     BehaviorAppender.new(klass).datetime("foo")
-    assert_equal true, klass.instance_methods.include?("foo")
+    klass.instance_methods.include?("foo")
   end
 
-  test "boolean columns are created" do
+  expect true do
     klass = Class.new
     BehaviorAppender.new(klass).boolean("foo")
-    assert_equal true, klass.instance_methods.include?("foo")
+    klass.instance_methods.include?("foo")
   end
 
-  test "boolean columns are created with writer" do
+  expect true do
     klass = Class.new
     BehaviorAppender.new(klass).boolean("foo")
-    assert_equal true, klass.instance_methods.include?("foo=")
+    klass.instance_methods.include?("foo=")
   end
 
-  test "boolean columns are created with ?" do
+  expect true do
     klass = Class.new
     BehaviorAppender.new(klass).boolean("foo")
-    assert_equal true, klass.instance_methods.include?("foo?")
+    klass.instance_methods.include?("foo?")
   end
 
-  test "integer columns are created" do
+  expect true do
     klass = Class.new
     BehaviorAppender.new(klass).integer("foo")
-    assert_equal true, klass.instance_methods.include?("foo")
+    klass.instance_methods.include?("foo")
   end
 
-  test "text columns are created" do
+  expect true do
     klass = Class.new
     BehaviorAppender.new(klass).text("foo")
-    assert_equal true, klass.instance_methods.include?("foo")
+    klass.instance_methods.include?("foo")
+  end
+
+  expect true do
+    klass = Class.new
+    BehaviorAppender.new(klass).float("foo")
+    klass.instance_methods.include?("foo")
+  end
+
+  expect true do
+    klass = Class.new
+    BehaviorAppender.new(klass).decimal("foo")
+    klass.instance_methods.include?("foo")
+  end
+
+  expect true do
+    klass = Class.new
+    BehaviorAppender.new(klass).timestamp("foo")
+    klass.instance_methods.include?("foo")
+  end
+
+  expect true do
+    klass = Class.new
+    BehaviorAppender.new(klass).time("foo")
+    klass.instance_methods.include?("foo")
+  end
+
+  expect true do
+    klass = Class.new
+    BehaviorAppender.new(klass).date("foo")
+    klass.instance_methods.include?("foo")
+  end
+
+  expect true do
+    klass = Class.new
+    BehaviorAppender.new(klass).binary("foo")
+    klass.instance_methods.include?("foo")
   end
 
-  test "string options are ignored" do
+  expect true do
     klass = Class.new
     BehaviorAppender.new(klass).string("foo" => "bar")
-    assert_equal true, klass.instance_methods(false).empty?
+    klass.instance_methods(false).empty?
   end
 end

data/test/test_helper.rb

@@ -1,5 +1,4 @@
-require 'test/unit'
 require 'rubygems'
-require 'dust'
+require 'expectations'
 require 'active_support'
 require File.dirname(__FILE__) + '/../lib/arbs'

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification 
 name: arbs
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
-platform: ""
+  version: 0.2.0
+platform: ruby
 authors: 
 - Jay Fields
 autorequire: arbs
 bindir: bin
 cert_chain: []
 
-date: 2007-12-21 00:00:00 -08:00
+date: 2008-04-15 00:00:00 -04:00
 default_executable: 
 dependencies: []
 
@@ -61,7 +61,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: arbs
-rubygems_version: 0.9.5
+rubygems_version: 1.0.1
 signing_key: 
 specification_version: 2
 summary: A duck that acts like ActiveRecord::Base, but doesn't have any of the AR::B functionality.