carlosbrando-remarkable 0.0.99

data/History.txt

@@ -0,0 +1,6 @@
+== 1.0.0 2008-11-12
+
+* 1 major enhancement:
+  * Initial release
+  * All macros of Shoulda have been ported to RSpec.
+	* Two syntaxes of macros have been added: Shoulda and RSpec.

data/Manifest.txt

@@ -0,0 +1,124 @@
+History.txt
+Manifest.txt
+PostInstall.txt
+README.rdoc
+Rakefile
+init.rb
+lib/remarkable.rb
+lib/remarkable/active_record/active_record.rb
+lib/remarkable/active_record/helpers.rb
+lib/remarkable/active_record/macros/associations/belong_to.rb
+lib/remarkable/active_record/macros/associations/have_and_belong_to_many.rb
+lib/remarkable/active_record/macros/associations/have_many.rb
+lib/remarkable/active_record/macros/associations/have_one.rb
+lib/remarkable/active_record/macros/database/have_db_column.rb
+lib/remarkable/active_record/macros/database/have_db_columns.rb
+lib/remarkable/active_record/macros/database/have_indices.rb
+lib/remarkable/active_record/macros/validations/allow_values_for.rb
+lib/remarkable/active_record/macros/validations/ensure_length_at_least.rb
+lib/remarkable/active_record/macros/validations/ensure_length_in_range.rb
+lib/remarkable/active_record/macros/validations/ensure_length_is.rb
+lib/remarkable/active_record/macros/validations/ensure_value_in_range.rb
+lib/remarkable/active_record/macros/validations/have_class_methods.rb
+lib/remarkable/active_record/macros/validations/have_instance_methods.rb
+lib/remarkable/active_record/macros/validations/have_named_scope.rb
+lib/remarkable/active_record/macros/validations/have_readonly_attributes.rb
+lib/remarkable/active_record/macros/validations/only_allow_numeric_values_for.rb
+lib/remarkable/active_record/macros/validations/protect_attributes.rb
+lib/remarkable/active_record/macros/validations/require_acceptance_of.rb
+lib/remarkable/active_record/macros/validations/require_attributes.rb
+lib/remarkable/active_record/macros/validations/require_unique_attributes.rb
+lib/remarkable/controller/controller.rb
+lib/remarkable/controller/helpers.rb
+lib/remarkable/controller/macros/assign_to.rb
+lib/remarkable/controller/macros/filter_params.rb
+lib/remarkable/controller/macros/redirect_to.rb
+lib/remarkable/controller/macros/render_a_form.rb
+lib/remarkable/controller/macros/render_template.rb
+lib/remarkable/controller/macros/render_with_layout.rb
+lib/remarkable/controller/macros/respond_with.rb
+lib/remarkable/controller/macros/respond_with_content_type.rb
+lib/remarkable/controller/macros/return_from_session.rb
+lib/remarkable/controller/macros/route.rb
+lib/remarkable/controller/macros/set_the_flash_to.rb
+lib/remarkable/example/example_methods.rb
+lib/remarkable/private_helpers.rb
+rails/init.rb
+script/console
+script/destroy
+script/generate
+spec/controllers/posts_controller_spec.rb
+spec/controllers/users_controller_spec.rb
+spec/fixtures/addresses.yml
+spec/fixtures/friendships.yml
+spec/fixtures/posts.yml
+spec/fixtures/products.yml
+spec/fixtures/taggings.yml
+spec/fixtures/tags.yml
+spec/fixtures/users.yml
+spec/models/address_spec.rb
+spec/models/dog_spec.rb
+spec/models/flea_spec.rb
+spec/models/friendship_spec.rb
+spec/models/post_spec.rb
+spec/models/product_spec.rb
+spec/models/tag_spec.rb
+spec/models/tagging_spec.rb
+spec/models/user_spec.rb
+spec/rails_root/app/controllers/application.rb
+spec/rails_root/app/controllers/posts_controller.rb
+spec/rails_root/app/controllers/users_controller.rb
+spec/rails_root/app/helpers/application_helper.rb
+spec/rails_root/app/helpers/posts_helper.rb
+spec/rails_root/app/helpers/users_helper.rb
+spec/rails_root/app/models/address.rb
+spec/rails_root/app/models/dog.rb
+spec/rails_root/app/models/flea.rb
+spec/rails_root/app/models/friendship.rb
+spec/rails_root/app/models/post.rb
+spec/rails_root/app/models/product.rb
+spec/rails_root/app/models/tag.rb
+spec/rails_root/app/models/tagging.rb
+spec/rails_root/app/models/user.rb
+spec/rails_root/app/views/layouts/posts.rhtml
+spec/rails_root/app/views/layouts/users.rhtml
+spec/rails_root/app/views/layouts/wide.html.erb
+spec/rails_root/app/views/posts/edit.rhtml
+spec/rails_root/app/views/posts/index.rhtml
+spec/rails_root/app/views/posts/new.rhtml
+spec/rails_root/app/views/posts/show.rhtml
+spec/rails_root/app/views/users/edit.rhtml
+spec/rails_root/app/views/users/index.rhtml
+spec/rails_root/app/views/users/new.rhtml
+spec/rails_root/app/views/users/show.rhtml
+spec/rails_root/config/boot.rb
+spec/rails_root/config/database.yml
+spec/rails_root/config/environment.rb
+spec/rails_root/config/environments/sqlite3.rb
+spec/rails_root/config/initializers/new_rails_defaults.rb
+spec/rails_root/config/initializers/shoulda.rb
+spec/rails_root/config/routes.rb
+spec/rails_root/db/migrate/001_create_users.rb
+spec/rails_root/db/migrate/002_create_posts.rb
+spec/rails_root/db/migrate/003_create_taggings.rb
+spec/rails_root/db/migrate/004_create_tags.rb
+spec/rails_root/db/migrate/005_create_dogs.rb
+spec/rails_root/db/migrate/006_create_addresses.rb
+spec/rails_root/db/migrate/007_create_fleas.rb
+spec/rails_root/db/migrate/008_create_dogs_fleas.rb
+spec/rails_root/db/migrate/009_create_products.rb
+spec/rails_root/db/migrate/010_create_friendships.rb
+spec/rails_root/db/schema.rb
+spec/rails_root/log/.keep
+spec/rails_root/log/sqlite3.log
+spec/rails_root/public/.htaccess
+spec/rails_root/public/404.html
+spec/rails_root/public/422.html
+spec/rails_root/public/500.html
+spec/rails_root/script/console
+spec/rails_root/script/generate
+spec/rails_root/vendor/plugins/.keep
+spec/rcov.opts
+spec/spec.opts
+spec/spec_helper.rb
+tasks/rspec.rake

data/PostInstall.txt

@@ -0,0 +1,7 @@
+
+For more information on remarkable, see http://remarkable.rubyforge.org
+
+NOTE: Change this information in PostInstall.txt 
+You can also delete it if you don't want it.
+
+

data/README.rdoc

@@ -0,0 +1,48 @@
+= remarkable
+
+* http://www.nomedojogo.com
+
+== DESCRIPTION:
+
+FIX (describe your package)
+
+== FEATURES/PROBLEMS:
+
+* FIX (list of features or problems)
+
+== SYNOPSIS:
+
+  FIX (code sample of usage)
+
+== REQUIREMENTS:
+
+* FIX (list of requirements)
+
+== INSTALL:
+
+* FIX (sudo gem install, anything else)
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2008 FIXME full name
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,29 @@
+%w[rubygems rake rake/clean fileutils newgem rubigen].each { |f| require f }
+require File.dirname(__FILE__) + '/lib/remarkable'
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+$hoe = Hoe.new('remarkable', Remarkable::VERSION) do |p|
+  p.developer('Carlos Brando', 'eduardobrando@gmail.com')
+  p.changes              = p.paragraphs_of("History.txt", 0..1).join("\n\n")
+  p.post_install_message = 'PostInstall.txt' # TODO remove if post-install message not required
+  p.rubyforge_name       = p.name # TODO this is default value
+  p.extra_deps         = [
+    ['rspec','>= 1.1.11'],
+    ['rspec-rails','>= 1.1.11']
+  ]
+  p.extra_dev_deps = [
+    ['newgem', ">= #{::Newgem::VERSION}"]
+  ]
+  
+  p.clean_globs |= %w[**/.DS_Store tmp *.log]
+  path = (p.rubyforge_name == p.name) ? p.rubyforge_name : "\#{p.rubyforge_name}/\#{p.name}"
+  p.remote_rdoc_dir = File.join(path.gsub(/^#{p.rubyforge_name}\/?/,''), 'rdoc')
+  p.rsync_args = '-av --delete --ignore-errors'
+end
+
+require 'newgem/tasks' # load /tasks/*.rake
+Dir['tasks/**/*.rake'].each { |t| load t }
+
+# TODO - want other tests/tasks run by default? Add them to the list
+task :default => [:spec, :features]

data/init.rb

@@ -0,0 +1 @@
+require File.join(File.dirname(__FILE__), 'rails', 'init')

data/lib/remarkable.rb

@@ -0,0 +1,13 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+module Remarkable
+  VERSION = '0.0.99'
+end
+
+require "spec"
+
+require 'remarkable/example/example_methods'
+require 'remarkable/private_helpers'
+require 'remarkable/active_record/active_record'
+require 'remarkable/controller/controller'

data/lib/remarkable/active_record/active_record.rb

@@ -0,0 +1,21 @@
+require 'remarkable/active_record/helpers'
+%w( database associations validations ).each do |folder|
+  Dir[File.join(File.dirname(__FILE__), "macros", folder, '*')].each do |file|
+    require file
+  end
+end
+
+module Spec
+  module Rails
+    module Matchers
+      include Remarkable::Private
+      include Remarkable::ActiveRecord::Helpers
+    end
+  end
+end
+
+Spec::Rails::Matchers.send(:include, Remarkable::Syntax::RSpec)
+
+Spec::Example::ExampleGroupMethods.send(:include, Remarkable::Private)
+Spec::Example::ExampleGroupMethods.send(:include, Remarkable::ActiveRecord::Helpers)
+Spec::Example::ExampleGroupMethods.send(:include, Remarkable::Syntax::Shoulda)

data/lib/remarkable/active_record/helpers.rb

@@ -0,0 +1,16 @@
+module Remarkable # :nodoc:
+  module ActiveRecord # :nodoc:
+    module Helpers # :nodoc:
+      private # :enddoc:
+
+      def model_class
+        self.described_type
+      end
+      
+      def fail_with(message)
+        Spec::Expectations.fail_with(message)
+      end
+
+    end
+  end
+end

data/lib/remarkable/active_record/macros/associations/belong_to.rb

@@ -0,0 +1,81 @@
+module Remarkable
+  module Syntax
+
+    module RSpec
+      class BelongTo
+        include Remarkable::Private
+
+        def initialize(*associations)
+          get_options!(associations)
+          @associations = associations
+        end
+
+        def matches?(klass)
+          @klass = klass
+
+          begin
+            @associations.each do |association|
+              reflection = klass.reflect_on_association(association)
+              fail("#{klass.name} does not have any relationship to #{association}") unless reflection && reflection.macro == :belongs_to
+
+              unless reflection.options[:polymorphic]
+                associated_klass = (reflection.options[:class_name] || association.to_s.camelize).constantize
+                fk = reflection.options[:foreign_key] || reflection.primary_key_name
+                fail("#{klass.name} does not have a #{fk} foreign key.") unless klass.column_names.include?(fk.to_s)
+              end
+            end
+
+            true
+          rescue Exception => e
+            false
+          end
+        end
+
+        def description
+          "belong to #{@associations.to_sentence}"
+        end
+
+        def failure_message
+          @failure_message || "expected #{@klass.name} to belong to #{@associations.to_sentence}, but it didn't"
+        end
+
+        def negative_failure_message
+          "expected #{@klass.name} not to belong to #{@associations.to_sentence}, but it did"
+        end
+      end
+
+      # Ensure that the belongs_to relationship exists.
+      #
+      #   it { Post.should belong_to(:user) }
+      #
+      def belong_to(*associations)
+        Remarkable::Syntax::RSpec::BelongTo.new(*associations)
+      end
+    end
+
+    module Shoulda
+      # Ensure that the belongs_to relationship exists.
+      #
+      #   should_belong_to :parent
+      #
+      def should_belong_to(*associations)
+        get_options!(associations)
+        klass = model_class
+        associations.each do |association|
+          it "should belong to #{association}" do
+            reflection = klass.reflect_on_association(association)
+            fail_with("#{klass.name} does not have any relationship to #{association}") unless reflection
+            reflection.macro.should == :belongs_to
+            
+            unless reflection.options[:polymorphic]
+              associated_klass = (reflection.options[:class_name] || association.to_s.camelize).constantize
+              fk = reflection.options[:foreign_key] || reflection.primary_key_name
+              fail_with("#{klass.name} does not have a #{fk} foreign key.") unless klass.column_names.include?(fk.to_s)
+            end
+          end
+        end
+      end
+    end
+
+  end 
+end

data/lib/remarkable/active_record/macros/associations/have_and_belong_to_many.rb

@@ -0,0 +1,77 @@
+module Remarkable
+  module Syntax
+
+    module RSpec
+      class HaveAndBelongToMany
+        include Remarkable::Private
+
+        def initialize(*associations)
+          get_options!(associations)
+          @associations = associations
+        end
+
+        def matches?(klass)
+          @klass = klass
+
+          begin
+            @associations.each do |association|
+              reflection = klass.reflect_on_association(association)
+              fail("#{klass.name} does not have any relationship to #{association}") unless reflection && reflection.macro == :has_and_belongs_to_many
+
+              table = reflection.options[:join_table]
+              fail("table #{table} doesn't exist") unless ::ActiveRecord::Base.connection.tables.include?(table.to_s)
+            end
+
+            true
+          rescue Exception => e
+            false
+          end
+        end
+
+        def description
+          "should have and belong to many #{@associations.to_sentence}"
+        end
+
+        def failure_message
+          @failure_message || "expected #{@klass.name} to have and belong to many #{@associations.to_sentence}, but it didn't"
+        end
+
+        def negative_failure_message
+          "expected #{@klass.name} not to have and belong to many #{@associations.to_sentence}, but it did"
+        end
+      end
+
+      # Ensures that the has_and_belongs_to_many relationship exists, and that the join
+      # table is in place.
+      #
+      #   it { User.should have_and_belong_to_many(:posts, :cars) }
+      #
+      def have_and_belong_to_many(*associations)
+        Remarkable::Syntax::RSpec::HaveAndBelongToMany.new(*associations)
+      end
+    end
+
+    module Shoulda
+      # Ensures that the has_and_belongs_to_many relationship exists, and that the join
+      # table is in place.
+      #
+      #   should_have_and_belong_to_many :posts, :cars
+      #
+      def should_have_and_belong_to_many(*associations)
+        get_options!(associations)
+        klass = model_class
+
+        associations.each do |association|
+          it "should have and belong to many #{association}" do
+            reflection = klass.reflect_on_association(association)
+            fail_with("#{klass.name} does not have any relationship to #{association}") unless reflection
+            reflection.macro.should == :has_and_belongs_to_many
+            table = reflection.options[:join_table]
+            fail_with("table #{table} doesn't exist") unless ::ActiveRecord::Base.connection.tables.include?(table.to_s)
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/remarkable/active_record/macros/associations/have_many.rb

@@ -0,0 +1,160 @@
+module Remarkable
+  module Syntax
+
+    module RSpec
+      class HaveMany
+        include Remarkable::Private
+        
+        def initialize(*associations)
+          @through, @dependent = get_options!(associations, :through, :dependent)
+          @associations = associations
+        end
+
+        def matches?(klass)
+          @klass = klass
+
+          begin
+            @associations.each do |association|
+              reflection = klass.reflect_on_association(association)
+              fail("#{klass.name} does not have any relationship to #{association}") unless reflection && reflection.macro == :has_many
+
+              if @through
+                through_reflection = klass.reflect_on_association(@through)
+                fail("#{klass.name} does not have any relationship to #{@through}") unless through_reflection && @through == reflection.options[:through]
+              end
+
+              if @dependent
+                fail("#{association} should have #{@dependent} dependency") unless @dependent.to_s == reflection.options[:dependent].to_s
+              end
+
+              # Check for the existence of the foreign key on the other table
+              unless reflection.options[:through]
+                if reflection.options[:foreign_key]
+                  fk = reflection.options[:foreign_key]
+                elsif reflection.options[:as]
+                  fk = reflection.options[:as].to_s.foreign_key
+                else
+                  fk = reflection.primary_key_name
+                end
+
+                associated_klass_name = (reflection.options[:class_name] || association.to_s.classify)
+                associated_klass = associated_klass_name.constantize
+
+                fail("#{associated_klass.name} does not have a #{fk} foreign key.") unless associated_klass.column_names.include?(fk.to_s)
+              end
+            end
+
+            true
+          rescue Exception => e
+            false
+          end
+        end
+
+        def description
+          message = "have many #{@associations.to_sentence}"
+          message += " through #{@through}" if @through
+          message += " dependent => #{@dependent}" if @dependent
+          message
+        end
+
+        def failure_message
+          message = "expected #{@klass.name} to have many #{@associations.to_sentence}"
+          message += " through #{@through}" if @through
+          message += " dependent => #{@dependent}" if @dependent
+          message += ", but it didn't"
+          @failure_message || message
+        end
+
+        def negative_failure_message
+          message = "expected #{@klass.name} not to have many #{@associations.to_sentence}"
+          message += " through #{@through}" if @through
+          message += " dependent => #{@dependent}" if @dependent
+          message += ", but it did"
+          message
+        end
+      end
+
+      # Ensures that the has_many relationship exists.  Will also test that the
+      # associated table has the required columns.  Works with polymorphic
+      # associations.
+      #
+      # Options:
+      # * <tt>:through</tt> - association name for <tt>has_many :through</tt>
+      # * <tt>:dependent</tt> - tests that the association makes use of the dependent option.
+      #
+      # Example:
+      #   it { User.should have_many(:friends) }
+      #   it { User.should have_many(:enemies, :through => :friends) }
+      #   it { User.should have_many(:friends, :dependent => :destroy) }
+      #
+      def have_many(*associations)
+        Remarkable::Syntax::RSpec::HaveMany.new(*associations)
+      end
+    end
+
+    module Shoulda
+      # Ensures that the has_many relationship exists.  Will also test that the
+      # associated table has the required columns.  Works with polymorphic
+      # associations.
+      #
+      # Options:
+      # * <tt>:through</tt> - association name for <tt>has_many :through</tt>
+      # * <tt>:dependent</tt> - tests that the association makes use of the dependent option.
+      #
+      # Example:
+      #   should_have_many :friends
+      #   should_have_many :enemies, :through => :friends
+      #   should_have_many :enemies, :dependent => :destroy
+      #
+      def should_have_many(*associations)
+        through, dependent = get_options!(associations, :through, :dependent)
+        klass = model_class
+        associations.each do |association|
+          name = "should have many #{association}"
+          name += " through #{through}" if through
+          name += " dependent => #{dependent}" if dependent
+          it name do
+            reflection = klass.reflect_on_association(association)
+            unless reflection
+              fail_with("#{klass.name} does not have any relationship to #{association}")
+            end
+            reflection.macro.should == :has_many
+
+            if through
+              through_reflection = klass.reflect_on_association(through)
+              unless through_reflection
+                fail_with("#{klass.name} does not have any relationship to #{through}")
+              end
+              reflection.options[:through].should == through
+            end
+
+            if dependent
+              unless reflection.options[:dependent].to_s == dependent.to_s
+                fail_with("#{association} should have #{dependent} dependency")
+              end
+            end
+
+            # Check for the existence of the foreign key on the other table
+            unless reflection.options[:through]
+              if reflection.options[:foreign_key]
+                fk = reflection.options[:foreign_key]
+              elsif reflection.options[:as]
+                fk = reflection.options[:as].to_s.foreign_key
+              else
+                fk = reflection.primary_key_name
+              end
+
+              associated_klass_name = (reflection.options[:class_name] || association.to_s.classify)
+              associated_klass = associated_klass_name.constantize
+
+              unless associated_klass.column_names.include?(fk.to_s)
+                fail_with("#{associated_klass.name} does not have a #{fk} foreign key.") 
+              end
+            end
+          end
+        end
+      end
+    end
+
+  end
+end