generator-spec 0.4.5 → 0.4.7

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

@@ -7,53 +7,60 @@
 #
 module RSpec::RubyContentMatchers
   class HaveMethod < RSpec::RubyContentMatcher
-    attr_reader :method, :type
+    attr_reader :method, :type, :args
 
-    def initialize(method, type=nil)
+    def initialize(method, type=nil, options = {})
       @method = method.to_s
+      super method
       @type = type      
+      @args = options[:args]
     end
 
-    def matches?(content) 
-      super
-      match_res = case type
-      when :class
-        content =~ /def\s+self.#{method}#{args_expr}(.*?)#{end_expr}/m
-      else
-        content =~ /def\s+#{method}#{args_expr}(.*?)#{end_expr}/m
-      end   
-      if block_given? && $2
-        ruby_content = $2.strip.extend(RSpec::RubyContent::Helpers)
-        ruby_content << "\nend" if !(ruby_content =~ /\nend$/)
-        yield ruby_content         
-      end      
-      match_res
+    def index
+      1
     end          
   
     def failure_message
       super
-      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"        
+      "Expected there to be the #{class_msg} method #{method}, but there wasn't"
     end 
     
     def negative_failure_message                                      
       super
-      return "Did not expect there to be the class method #{method}, but there was" if type == :class
-      "Did not expect there to be the method #{method}, but there was"
+      "Did not expect there to be the #{class_msg} method #{method}, but there was"
     end
 
     protected
 
+    def class_msg
+      (type == :class) ? 'class' : ''
+    end
+
+    def main_expr
+      'def' + SPACES + "#{self_expr}#{method}#{args_expr}" + ANY_GROUP
+    end
+
     def args_expr
-      '\s*(\(.+\))?'
+      return super if args
+      any_args_expr
     end
-    
-    def end_expr
-      "(def|end|# #{method})"
+       
+    def self_expr 
+      type == :class ? 'self.' : ''
     end
+            
+    def alt_end
+      'def'
+    end               
+    
   end
   
   def have_method(method, type = nil)
     HaveMethod.new(method, type)
   end  
+
+  def have_args_method(method, options = {})
+    HaveMethod.new(method, options[:type], options)
+  end  
+
 end

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

@@ -1,36 +1,66 @@
 module RSpec::RubyContentMatchers
   class HaveModule < RSpec::RubyContentMatcher
-    attr_reader :module_name
+    attr_reader :name, :type, :postfix
 
-    def initialize(module_name)
-      @module_name = module_name.to_s.camelize
+    def initialize(name, postfix=nil)
+      @name = name.to_s.camelize
+      super @name
+      @postfix = postfix.to_s.camelize if postfix
+      @type = :module
     end
-
-    def matches?(content)            
-      super
-      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
       super
-      "Expected there to be the module #{module_name}"
+      "Expected there to be the #{type} #{name}"
     end 
     
     def negative_failure_message
       super
-      "Did no expected there to be the module #{module_name}"
+      "Did not expected there to be the #{type} #{name}"
+    end
+
+    protected
+    
+    def main_expr
+      "#{type}" + SPACES + "#{name}#{postfix}" + SPACES + ANY_GROUP
     end
-               
+    
+    def alt_end
+      type
+    end
+  end
+
+  class HaveClass < HaveModule
+
+    def initialize(name, postfix) 
+      super name, postfix
+      @type = :class
+    end    
   end
   
-  def have_module(module_name)
-    HaveModule.new(module_name)
+  def have_module(module_name, postfix=nil)
+    HaveModule.new(module_name, postfix)
   end       
   alias_method :be_module, :have_module  
+  
+  def have_class(module_name)
+    HaveModule.new(module_name, :class)
+  end       
+
+  def have_class(klass, postfix = nil)
+    HaveClass.new(klass, postfix)
+  end    
+  alias_method :be_class, :have_class
+
+  def have_helper_class(klass)
+    HaveClass.new(klass, :helper)
+  end    
+  alias_method :be_helper_class, :have_helper_class
+
+
+  def have_controller_class(klass)
+    HaveClass.new(klass, :controller)
+  end
+  alias_method :be_controller_class, :have_controller_class  
+  
 end  

data/lib/generator_spec/matchers/content/have_region.rb

@@ -4,17 +4,8 @@ module RSpec::RubyContentMatchers
 
     def initialize(region)
       @region = region.to_s
+      super @region      
     end
-
-    def matches?(content) 
-      super
-      match_res = (content =~ /#{region}(.*)#{end_epxr}/m)
-      if block_given? && $1
-        ruby_content = $1.strip.extend(RSpec::RubyContent::Helpers)
-        yield ruby_content        
-      end
-      match_res
-    end          
   
     def failure_message 
       super
@@ -27,11 +18,19 @@ module RSpec::RubyContentMatchers
     end               
     
     protected
+
+    def main_expr
+      "#{region}" + ANY_GROUP     
+    end
     
     def end_expr
       '(private|protected|public|$)'
     end
   end
+
+  def have_region name
+    HaveRegion.new name
+  end    
   
   def have_public
     HaveRegion.new :public

data/lib/generator_spec/matchers/content/have_subclass.rb

@@ -3,22 +3,12 @@ module RSpec::RubyContentMatchers
     attr_reader :klass, :superclass, :type
 
     def initialize(klass, superclass, type=nil)
-      @klass      = klass.to_s.camelize
+      @klass      = klass.to_s.camelize       
+      super @klass
       @superclass = superclass.to_s.camelize
       @type       = type.to_s.camelize if type      
     end
 
-    def matches?(content) 
-      super
-      match_res = (content =~ /class\s+#{klass}#{type}\s+<\s+#{superclass}(.*)#{end_expr}/m)
-      if block_given? && $1
-        ruby_content = $1.strip.extend(RSpec::RubyContent::Helpers)
-        yield ruby_content 
-      else
-        match_res
-      end
-    end          
-
     def failure_message  
       super
       "Expected there to be the subclass #{klass} of #{superclass}"
@@ -29,10 +19,14 @@ module RSpec::RubyContentMatchers
       "Did no expected there to be the subclass #{klass} of #{superclass}"
     end   
 
-    protected
+    protected 
+    
+    def main_expr
+      'class' + SPACES + "#{klass}#{type}" + OPT_SPACES + '<' + OPT_SPACES + "#{superclass}" + ANY_GROUP      
+    end
 
-    def end_expr
-      "(end$|# #{klass})"
+    def alt_end
+      'class'
     end
     
   end

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

@@ -1,20 +1,15 @@
 module RSpec::RubyContentMatchers
   class IncludeModule < RSpec::RubyContentMatcher
-    attr_reader :module_name
+    attr_reader :module_name, :type
 
-    def initialize module_name
+    def initialize module_name, type=nil
       @module_name = module_name.to_s.camelize
+      @type = type || :include
     end
 
     def matches?(content)      
-      super
-      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
+      @content = content
+      (content =~ /#{type}\s+#{module_name}/)
     end          
   
     def failure_message
@@ -33,6 +28,10 @@ module RSpec::RubyContentMatchers
     IncludeModule.new(module_name)
   end    
 
+  def extend_module(module_name)
+    IncludeModule.new(module_name, :extend)
+  end    
+
   def be_dm_resource
     IncludeModule.new 'DataMapper::Resource'
   end    

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

@@ -4,18 +4,12 @@ module RSpec::RubyContentMatchers
 
     def initialize klass
       @klass = klass.to_s.camelize
+      super @klass
     end
 
-    def matches?(content)
-      super      
-      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 index
+      1
+    end
   
     def failure_message
       super
@@ -26,6 +20,12 @@ module RSpec::RubyContentMatchers
       super
       "Did not expect the class to inherit from #{klass}"
     end
+    
+    protected
+
+    def main_expr
+      'class' + SPACES + Q_ANY_GROUP + '<' + OPT_SPACES + "#{klass}" + ANY_GROUP
+    end
   end
   
   def inherit_from(klass)

data/lib/generator_spec/matchers/file/generate_file.rb

@@ -5,15 +5,15 @@
 #            
 
 module RSpec::FileMatchers
-  class GenerateFile
-
+  class GenerateFile    
     attr_accessor :relative_path
 
     def initialize(relative_path, type = nil)
       @relative_path = relative_rails_file(relative_path, type)
     end
 
-    def matches?(generator, &block)              
+    def matches?(generator, &block)          
+      puts "relative_path"    
       file = File.expand_path(relative_path, generator.class.destination_root)
       file_exists = File.exists?(file)
       if block && file_exists
@@ -80,32 +80,25 @@ module RSpec::FileMatchers
   def generate_file(relative, type = nil)
     GenerateFile.new(relative, type)
   end
-  alias_method :have_file, :generate_file
 
   def generate_model(relative)
     GenerateFile.new(relative, :model)
   end
-  alias_method :have_model, :generate_model
 
   def generate_controller(relative) 
-    puts "Generate controller: #{relative}"
     GenerateFile.new(relative, :controller)
   end
-  alias_method :have_controller, :generate_controller
 
   def generate_helper(relative)
     GenerateFile.new(relative, :helper)
   end
-  alias_method :have_helper, :generate_helper
 
   def generate_view(relative, action, ext)
     GenerateFile.new("#{relative}/#{action}.#{ext}", :view)
   end
-  alias_method :have_view, :generate_view
   
   def generate_observer(relative)
     GenerateFile.new(relative, :observer)
-  end  
-  alias_method :have_observer, :generate_observer  
+  end
 end
 

data/lib/generator_spec/matchers/file/generate_migration.rb

@@ -41,11 +41,7 @@ module RSpec
         dirname = migration_dir
         file_name = relative.sub(/\.rb$/, '')
         migrations = Dir.glob("#{dirname}/[0-9]*_*.rb")
-        if !migrations.empty? 
-          migrations.grep(/\d+_#{file_name}\.rb$/).first 
-        else 
-          false
-        end
+        !migrations.empty? ? migrations.grep(/\d+_#{file_name}\.rb$/).first : false
       end
       
     end

data/lib/generator_spec/matchers/file/have_file.rb

@@ -0,0 +1,115 @@
+# 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 HaveFile    
+    attr_accessor :relative_path
+
+    def initialize(relative_path, type = nil)
+      @relative_path = relative_rails_file(relative_path, type)
+    end
+
+    def matches?(generator, &block)
+      file = File.expand_path(relative_path, Rails.root)
+      file_exists = File.exists?(file)
+      if block && file_exists
+        read = File.read(file)
+        ruby_content = read.extend(RSpec::RubyContent::Helpers)
+        yield ruby_content
+      else
+        file_exists
+      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_file path, type = nil                       
+      path = path.to_s
+      f_name = file_name(path, type)      
+      return File.join(::Rails.root, base_dir(type), folder(type), f_name) if type        
+      File.join(::Rails.root, path)
+    end
+    
+    def file_name path, type
+      return "#{path}#{postfix(type)}.rb" if !path.include? '.'
+      path
+    end
+      
+
+    def postfix type
+      "_#{type}" if [:helper, :controller, :observer].include?(type)
+    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, :mailer
+        'app'
+      when :migration
+        'db'
+      when :javascript, :stylesheet
+        'public'
+      when :initializer, :locale
+        'config'
+      else
+        ''          
+      end
+    end
+  end
+
+  def have_file(relative, type = nil)
+    HaveFile.new(relative, type)
+  end
+  alias_method :contain_file, :have_file
+
+  def have_model(relative)
+    HaveFile.new(relative, :model)
+  end
+  alias_method :contain_model, :have_model
+
+  def have_controller(relative) 
+    HaveFile.new(relative, :controller)
+  end
+  alias_method :contain_controller, :have_controller
+
+  def have_helper(relative)
+    HaveFile.new(relative, :helper)
+  end
+  alias_method :contain_helper, :have_helper
+
+  def have_view(relative, action, ext='html.erb')
+    HaveFile.new("#{relative}/#{action}.#{ext}", :view)
+  end
+  alias_method :contain_view, :have_view
+  
+  def have_observer(relative)
+    HaveFile.new(relative, :observer)
+  end  
+  alias_method :contain_observer, :have_observer  
+
+  def have_mailer(relative)
+    HaveFile.new(relative, :mailer)
+  end  
+  alias_method :contain_mailer, :have_mailer
+
+end
+

data/lib/generator_spec/rails_helpers/rails_controller.rb

@@ -1,38 +1,36 @@
-module RSpec  
-  module Rails
-    module Controller     
-      include RSpec::Rails::App
-          
-      def create_controller name, content=nil
-        file = controller_file_name(name)
-        unless File.exist?(file)    
-          FileUtils.mkdir_p File.dirname(file)
-          content ||= yield if block_given?          
-          File.open(file, 'w') do |f|  
-            f.puts controller_content(name, content)
-          end
+module RSpec::Rails
+  module Controller     
+    include RSpec::Rails::App
+        
+    def create_controller name, content=nil
+      file = controller_file_name(name)
+      unless File.exist?(file)    
+        FileUtils.mkdir_p File.dirname(file)
+        content ||= yield if block_given?          
+        File.open(file, 'w') do |f|  
+          f.puts controller_content(name, content)
         end
-      end  
-
-      def controller_content name, content=nil
-        %Q{class #{name.to_s.camelize}Controller < ActionController::Base
-          #{content}
-        end}        
       end
+    end  
 
-      def remove_controller name
-        file = controller_file_name(name)
-        FileUtils.rm_f(file) if File.exist?(file)
-      end
+    def controller_content name, content=nil
+      %Q{class #{name.to_s.camelize}Controller < ActionController::Base
+        #{content}
+      end}        
+    end
 
-      def remove_controllers *names
-        names.each{|name| remove_controller name }
-      end     
-      
-      def controller_file_name name
-        File.join(controller_dir, "#{name}_controller.rb")
-      end        
-      
+    def remove_controller name
+      file = controller_file_name(name)
+      FileUtils.rm_f(file) if File.exist?(file)
     end
+
+    def remove_controllers *names
+      names.each{|name| remove_controller name }
+    end     
+    
+    def controller_file_name name
+      File.join(controller_dir, "#{name}_controller.rb")
+    end        
+    
   end
-end
+end

data/lib/generator_spec/rails_helpers/rails_model.rb

@@ -6,7 +6,8 @@ module RSpec::Rails
       file = model_file_name(name)
       unless File.exist?(file)    
         FileUtils.mkdir_p File.dirname(file)
-        File.open(file, 'w') do |f|  
+        File.open(file, 'w') do |f|
+          raise "You must include an ORM helper in your model spec, fx: include RSpec::Rails::Orm::ActiveRecord" if !respond_to? :file_content
           f.puts file_content(name, type)
           yield f if block_given?
         end

data/lib/generator_spec/rails_helpers/rails_view.rb

@@ -2,7 +2,8 @@ module RSpec::Rails
   module View
     include RSpec::Rails::App    
     
-    def create_view name, action, type, content=nil
+    def create_view name, action='show', *args
+      type, content = parse_args(*args)
       file = view_file_name(name, action, type)
       unless File.exist?(file)    
         FileUtils.mkdir_p File.dirname(file)
@@ -14,12 +15,27 @@ module RSpec::Rails
       end
     end  
 
-    def remove_view name, action, type
+    def parse_args *args
+      type='html.erb'
+      content=nil       
+      if args && args[0]
+        case args[0]
+        when String
+          content = args[0]
+        when Symbol
+          type = args[0]
+          content = args[1] if args.size > 1
+        end
+      end
+      [type, content]
+    end
+
+    def remove_view name, action='show', type='html.erb'
       file = view_file_name(name, action, type)
       FileUtils.rm_f(file) if File.exist?(file)
     end
     
-    def view_file_name name, action, type
+    def view_file_name name, action='show', type='html.erb'
       File.join(view_dir, name.to_s, "#{action}.#{type}")
     end        
     

data/spec/generator_spec/matchers/content/class_self_spec.rb

@@ -0,0 +1,32 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe 'class_self matcher' do    
+  context "content without class << self" do
+    not_class_self = %q{
+        def hello
+        end}    
+    
+    it "should not have class << self" do            
+      not_class_self.should_not have_class_self do |content|
+        puts content
+      end
+    end
+  end
+  
+  context "content with class << self" do  
+    class_self = %q{
+      class << self
+        def hello
+        end
+      end # class self}    
+
+    it "should have class << self" do            
+      class_self.should have_class_self do |content|
+        puts "content: #{content}"
+      end
+    end
+  end
+end
+
+
+