generator-spec 0.3.3

data/lib/rspec_for_generators.rb

@@ -0,0 +1,11 @@
+require 'rspec'
+require 'rake'            
+require 'rails'
+require 'require_all'
+require 'rails/generators'
+require 'rspec_for_generators/main'
+
+RSpec.configure do |config|
+  config.include(RSpec::FileMatchers)
+  config.include(RSpec::RubyContentMatchers)  
+end

data/lib/rspec_for_generators/fixtures/routes.rb

@@ -0,0 +1,2 @@
+Rails.application.routes.draw do |map|
+end

data/lib/rspec_for_generators/generator_spec_helper.rb

@@ -0,0 +1,95 @@
+require 'test/unit'
+require 'rails/all'
+require 'rails/generators'
+require 'rails/generators/test_case'
+
+require 'rspec_for_generators/rails_spec_helper'
+
+# Call configure to load the settings from
+# Rails.application.config.generators to Rails::Generators
+
+# require the generators
+def require_generators *generator_list
+  generator_list.each do |name, generators|    
+    if !generators || generators.empty
+      require File.join('generators', name.to_s, "#{name.to_s}_generator")      
+    else  
+      generators.each do |generator_name|
+        require File.join('generators', name.to_s, generator_name.to_s, "#{generator_name}_generator")
+      end    
+    end
+  end
+end  
+alias :require_generator :require_generators
+
+module RSpec    
+  module Generator
+    class << self  
+      attr_accessor :generator, :test_method_name
+
+      def remove_rails_dir!
+        FileUtils.rm_rf ::TmpRails.root
+      end
+
+      def configure_root_dir path, options = {}
+        ::Rails.application.configure do
+          config.root_dir = options == :custom ? TmpRails.root_dir(File.dirname(path) + '/../tmp', :custom) : TmpRails.root_dir(path)
+        end
+
+        ::RSpec::Generators::TestCase.destination ::Rails.root      
+        ::Rails::Generators.configure! 
+        
+        ::RSpec.configure do |config|
+          config.after(:suite) do
+            ::RSpec::Generator.remove_rails_dir!
+          end
+        end        
+      end
+
+      def run_generator *args, &block
+        generator.run_generator *args
+        if block
+          block.arity < 1 ? generator.instance_eval(&block) : block.call(generator, self)  
+        end      
+      end
+
+      def check(&block)
+        if block
+          block.arity < 1 ? self.instance_eval(&block) : block.call(self)  
+        end      
+      end
+
+      def with(generator, &block)
+        if block
+          block.arity < 1 ? generator.instance_eval(&block) : block.call(generator, self, generator.class)  
+        end
+      end
+    
+      def with_generator &block
+        with(get_generator, &block)
+      end
+
+      def setup_generator test_method_name=nil, &block
+        clean! if test_method_name  
+        generator = get_generator(test_method_name).extend(RSpec::Generator::Helpers)
+        if block
+          block.arity < 1 ? generator.class.instance_eval(&block) : block.call(generator.class)  
+        end
+      end
+
+      protected
+      
+      def clean!
+        if generator
+          generator.class.generator_class = nil 
+        end
+        @generator = nil
+      end
+    
+      def get_generator test_method_name=nil
+        @generator ||= RSpec::Generators::TestCase.new(test_method_name + '_spec')
+      end
+      
+    end # class self
+  end
+end

data/lib/rspec_for_generators/main.rb

@@ -0,0 +1,18 @@
+require 'rspec_for_generators/rails_spec_helper'
+require 'rspec_for_generators/rspec_test_case'
+require 'rspec_for_generators/generator_spec_helper'
+
+module RSpec
+  module RubyContentMatchers
+  end
+end
+
+module RSpec
+  module FileMatchers
+  end
+end
+
+require_all File.dirname(__FILE__) + '/matchers/helpers'
+require_all File.dirname(__FILE__) + '/matchers/content'
+require_all File.dirname(__FILE__) + '/matchers/file'
+require_all File.dirname(__FILE__) + '/matchers/migration'

data/lib/rspec_for_generators/matchers/content/have_block.rb

@@ -0,0 +1,47 @@
+module RSpec::RubyContentMatchers
+  class HaveBlock
+    attr_reader :name, :args, :block_args
+
+    def initialize(name, options={})
+      @name = name
+      @args = options[:args]
+      @block_args = options[:block_args]      
+    end
+
+    def matches?(content)            
+      match_res = match(content)
+      if block_given? && $1
+        ruby_content = $1.strip.extend(RSpec::RubyContent::Helpers)
+        yield ruby_content 
+      else
+        match_res
+      end
+    end          
+  
+    def failure_message
+      return "Expected there to be a block #{name} with arguments #{args}, but there wasn't"
+    end 
+    
+    def negative_failure_message                                      
+      return "Did not expect there to be a block #{name} with arguments #{args}, but there was"
+    end               
+    
+    protected
+
+    def match content
+      content =~ /#{name}\s+#{args_expr}do\s+#{block_args_expr}(.*?)end/m
+    end
+
+    def args_expr
+      args ? "\(?\s*#{args}\s*\)?\s+" : ''
+    end      
+
+    def block_args_expr
+      args ? "\|\s*#{block_args}\s*\|" : ''
+    end    
+  end
+  
+  def have_block(name, options={})
+    HaveBlock.new(name, options)
+  end    
+end

data/lib/rspec_for_generators/matchers/content/have_call.rb

@@ -0,0 +1,42 @@
+# This method tries to see if a specific method is contained in the generated file.
+# It can operate (should) on either a file name or the raw content 
+#
+#   generated_file_name.should have_method "hello" # 'my/path/say_hello.rb'.should have_method "hello"
+#
+#   say_hello_file_content.should have_method "hello"
+#
+module RSpec::RubyContentMatchers
+  class HaveCall
+    attr_reader :method, :args
+
+    def initialize(method, args = nil)
+      @method = method.to_s
+      @args = args
+    end
+
+    def matches?(content)
+      content =~ /#{method}\s+#{args_expr}/m
+    end          
+  
+    def failure_message
+      return "Expected there to be the call to #{method} with args #{args}, but there wasn't" if args
+      "Expected there to be the call to #{method}, but there wasn't"
+    end 
+    
+    def negative_failure_message                                      
+      return "Did not expect there to be the call to #{method} with args #{args}, but there was" if args
+      "Did not expect there to be the call to #{method}, but there was"
+    end
+             
+    protected
+    
+    def args_expr
+      args ? "\(?\s*#{args}\s*\)?\s+" : ''
+    end      
+               
+  end
+  
+  def have_call(method, args = nil)
+    HaveCall.new(method, args)
+  end  
+end

data/lib/rspec_for_generators/matchers/content/have_class.rb

@@ -0,0 +1,32 @@
+module RSpec::RubyContentMatchers
+  class HaveClass
+    attr_reader :klass
+
+    def initialize(klass)
+      @klass = klass.to_s.camelize      
+    end
+
+    def matches?(content)      
+      match_res = (content =~ /class\s+#{klass}\s+(.*)end/m)
+      if block_given? && $1
+        ruby_content = $1.strip.extend(RSpec::RubyContent::Helpers)
+        yield ruby_content 
+      else
+        match_res
+      end
+    end          
+  
+    def failure_message
+      "Expected there to be the class #{klass}"
+    end 
+    
+    def negative_failure_message
+      "Did no expected there to be the class #{klass}"
+    end
+               
+  end
+  
+  def have_class(klass)
+    HaveClass.new(klass)
+  end    
+end

data/lib/rspec_for_generators/matchers/content/have_method.rb

@@ -0,0 +1,41 @@
+# This method tries to see if a specific method is contained in the generated file.
+# It can operate (should) on either a file name or the raw content 
+#
+#   generated_file_name.should have_method "hello" # 'my/path/say_hello.rb'.should have_method "hello"
+#
+#   say_hello_file_content.should have_method "hello"
+#
+module RSpec::RubyContentMatchers
+  class HaveMethod
+    attr_reader :method
+
+    def initialize(method, type)
+      @type = type
+      @method = method.to_s
+    end
+
+    def matches?(content)      
+      case @type
+      when :class
+        content =~ /def\s+self.#{method}\s*(\(.+\))?(.*?)/m
+      else
+        content =~ /def\s+#{method}\s*(\(.+\))?(.*?)/m
+      end
+    end          
+  
+    def failure_message
+      return "Expected there to be the class method #{method}, but there wasn't" if @type == :class
+      "Expected there to be the method #{method}, but there wasn't"        
+    end 
+    
+    def negative_failure_message                                      
+      return "Did not expect there to be the method #{method}, but there was" if @type == :class
+      "Did not expect there to be the method #{method}, but there was"
+    end
+               
+  end
+  
+  def have_method(method, type = nil)
+    HaveMethod.new(method, type)
+  end  
+end

data/lib/rspec_for_generators/matchers/content/have_module.rb

@@ -0,0 +1,32 @@
+module RSpec::RubyContentMatchers
+  class HaveModule
+    attr_reader :module_name
+
+    def initialize(module_name)
+      @module_name = module_name.to_s.camelize
+    end
+
+    def matches?(content)            
+      match_res =~ /module\s+#{module_name}\s+(.*)end/m
+      if block_given? && match_res
+        ruby_content = $2.strip.extend(RSpec::RubyContent::Helpers)
+        yield ruby_content
+      else
+        match_res
+      end
+    end          
+  
+    def failure_message
+      "Expected there to be the module #{module_name}"
+    end 
+    
+    def negative_failure_message
+      "Did no expected there to be the module #{module_name}"
+    end
+               
+  end
+  
+  def have_module(module_name)
+    HaveModule.new(module_name)
+  end    
+end  

data/lib/rspec_for_generators/matchers/content/include_module.rb

@@ -0,0 +1,32 @@
+module RSpec::RubyContentMatchers
+  class IncludeModule
+    attr_reader :module_name
+
+    def initialize module_name
+      @module_name = module_name.to_s.camelize
+    end
+
+    def matches?(content)      
+      match_res = (content =~ /include\s+#{module_name}/)
+      if block_given? && match_res
+        ruby_content = content.extend(RSpec::RubyContent::Helpers)
+        yield ruby_content
+      else
+        match_res
+      end
+    end          
+  
+    def failure_message
+      "Expected there to be an inclusion of module #{module_name}"
+    end 
+    
+    def negative_failure_message
+      "Did not expect there to be an inclusion of module #{module_name}"
+    end
+               
+  end
+  
+  def include_module(module_name)
+    IncludeModule.new(module_name)
+  end    
+end  

data/lib/rspec_for_generators/matchers/content/inherit_from.rb

@@ -0,0 +1,31 @@
+module RSpec::RubyContentMatchers
+  class InheritFrom
+    attr_reader :klass
+
+    def initialize klass
+      @klass = klass.to_s.camelize
+    end
+
+    def matches?(content)      
+      match_res =~ /class\s+(.*?)<\s+#{klass}(.*)end/
+      if block_given? && match_res
+        ruby_content = $2.strip.extend(RSpec::RubyContent::Helpers)
+        yield ruby_content
+      else
+        match_res
+      end
+    end          
+  
+    def failure_message
+      "Expected the class to inherit from #{klass}"
+    end 
+    
+    def negative_failure_message
+      "Did not expect the class to inherit from #{klass}"
+    end
+  end
+  
+  def inherit_from(klass)
+    InheritFrom.new(klass)
+  end    
+end  

data/lib/rspec_for_generators/matchers/file/generate_directory.rb

@@ -0,0 +1,71 @@
+# Asserts a given file exists. You need to supply an absolute path or a path relative
+# to the configured destination:
+#
+#   generator.should have_generated_file "app/controller/products_controller.rb" 
+#            
+
+module RSpec::FileMatchers
+  class GenerateDir
+
+    def initialize(relative_path, type = nil)
+      @relative_path = relative_rails_dir relative_path, type
+    end
+
+    def matches?(generator, &block)              
+      @expected = File.expand_path(@relative_path, generator.class.destination_root)
+      ex = File.exists?(@expected)
+      if block && ex
+        read = File.read(@expected)
+        ruby_content = read.extend(RSpec::RubyContent::Helpers)
+        yield ruby_content
+      else
+        ex
+      end        
+    end          
+  
+    def failure_message
+      "Expected file #{@relative_path} to have been generated, but it was not"
+    end
+
+    def negative_failure_message
+      "Did not expected file #{@relative_path} to have been generated, but it was"
+    end
+    
+    protected
+    
+    def relative_rails_dir path, type = nil                             
+      return File.join(::Rails.root, base_dir(type), folder(type), "#{path.to_s}") if type        
+      File.join(::Rails.root, path)
+    end
+
+    def folder type
+      case type
+      when :observer
+        'models'
+      else
+        type.to_s.pluralize
+      end
+    end      
+    
+    def base_dir type
+      case type
+      when :model, :controller, :view, :helper, :observer
+        'app'
+      when :migration
+        'db'
+      when :javascript, :stylesheet
+        'public'
+      when :initializer, :locale
+        'config'
+      else
+        ''          
+      end
+    end
+  end
+
+  def generate_dir(relative, type = nil)
+    GenerateDir.new(relative, type)
+  end
+
+end
+