genspec 0.1.1

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Colin MacKenzie IV
+
+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/README.rdoc

@@ -0,0 +1,122 @@
+= genspec
+
+Simple, expressive Rails generator testing for RSpec.
+
+== Installation
+
+  sudo gem install genspec
+
+...then, in your config/environments/test.rb...
+
+  config.gem 'genspec'
+  
+== Usage
+
+Just like rspec-rails uses the structure of your spec/ directory to infer which test is being run (controllers,
+helpers, lib, etc.), you just need to create a spec/generators directory and put your generator specs in there.
+A basic generator spec might look something like this:
+
+  # in spec/generators/custom_controller_spec.rb
+  require 'spec_helper'
+  
+  describe :custom_controller do
+    context "with no arguments or options" do
+      it "should generate a help message" do
+        subject.should output("A Help Message")
+      end
+    end
+    
+    context "with a name argument" do
+      with_args :users
+      
+      it "should generate a UsersController" do
+        subject.should generate("app/controllers/users_controller.rb")
+      end
+    end
+  end
+  
+=== Checking for Output
+
+If you need to test the generator's feedback rather than the generator's results, you can use the _output_ matcher to
+assert that your generator has produced some specific content in its output (which would be either a logger of some
+sort or $stdout). This is helpful for making sure your help message is accurate, for instance.
+
+  # Ex 1: String
+  it "should generate a help message" do
+    subject.should output("A Help Message")
+  end
+  
+  # Ex 2: Regular Expression
+  it "should generate a help message" do
+    subject.should output(/A [hH]elp Message/)
+  end
+
+
+=== Checking Generated Files
+
+This is the preferred way to test which files were actually generated, because this matcher checks your
+generator's *behavior*. That means it won't care _how_ a file is generated, as long as it _is_ generated. It's as simple
+as passing the name of the file you expected to be generated:
+
+  it "should generate a readme file" do
+    subject.should generate("README")
+  end
+  
+You can also check the generated file's content by simply passing a block. The argument in the block is the plaintext
+content of the file:
+
+  it "should generate a model called 'user'" do
+    subject.should generate("app/models/user.rb") { |content|
+      content.should =~ /class User < ActiveRecord\:\:Base/
+    }
+  end
+
+=== Checking Generation Methods
+
+This is the most intrusive form of generation matching, and should be avoided where possible. However, in some cases
+you just can't check behavior directly (migrations are a case in point, because the version number is unpredictable).
+In that case, you can verify that a particular method is called within the generator's manifest like so:
+
+  it "should generate a user migration template" do
+    subject.should generate(:migration_template, "migration_template.erb", "db/migrate", :migration_file => "create_users")
+  end
+  
+You can stop passing arguments at any time. This has the effect of widening the range of acceptable parameters. For
+instance, the following example does the same thing but will accept _any_ migration file name in _any_ destination
+directory, as long as the "migration_template.erb" file is used for the source:
+
+  it "should generate a migration template" do
+    subject.should generate(:migration_template, "migration_template.rb")
+  end
+
+Any method that is normally available to Rails generators can be tested in this way:
+
+  it "should test one of each generation type" do
+    subject.should generate(:directory, "db/migrate")
+    subject.should generate(:file, "input_file", "output_file")
+    subject.should generate(:template, "input_template", "output_template")
+    subject.should generate(:class_collisions, 'ActionController::Base')
+    subject.should generate(:migration_template, "file", "directory", :migration_file_name => "filename")
+    subject.should generate(:resource_routes, 'model_name')
+    subject.should generate(:readme, "README")
+  end
+  
+But again... Use these as last resorts, for the most part. Technically, you will probably need this for
+:migration_template and :resource_routes, but anything else should really be tested for _behavior_. Like any other
+class, you should really only care about how the generator interacts with other objects -- in this case, your file
+system -- and not so much about what it's doing on the inside.
+
+  
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2010 Colin MacKenzie IV. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,55 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "genspec"
+    gem.summary = "Simple, expressive Rails generator testing for RSpec."
+    gem.description = "Just like rspec-rails uses the structure of your spec/ directory to infer which test is being run (controllers, helpers, lib, etc.), you just need to create a spec/generators directory and put your generator specs in there."
+    gem.email = "sinisterchipmunk@gmail.com"
+    gem.homepage = "http://www.thoughtsincomputation.com"
+    gem.authors = ["Colin MacKenzie IV"]
+    gem.files = FileList['**/*']
+    gem.add_dependency "rspec"
+    gem.add_dependency "sc-core-ext", ">= 1.2.0"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/test_*.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "genspec #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.1

data/genspec.gemspec

@@ -0,0 +1,83 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{genspec}
+  s.version = "0.1.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Colin MacKenzie IV"]
+  s.date = %q{2010-06-21}
+  s.description = %q{Just like rspec-rails uses the structure of your spec/ directory to infer which test is being run (controllers, helpers, lib, etc.), you just need to create a spec/generators directory and put your generator specs in there.}
+  s.email = %q{sinisterchipmunk@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "genspec.gemspec",
+     "lib/genspec.rb",
+     "lib/genspec/generation_matchers.rb",
+     "lib/genspec/generation_matchers/generation_matcher.rb",
+     "lib/genspec/generation_matchers/result_matcher.rb",
+     "lib/genspec/generator_example_group.rb",
+     "pkg/genspec-0.0.0.gem",
+     "pkg/genspec-0.1.0.gem",
+     "rdoc/classes/GenSpec.html",
+     "rdoc/classes/GenSpec/GenerationMatchers.html",
+     "rdoc/classes/GenSpec/GenerationMatchers/GenerationMatcher.html",
+     "rdoc/classes/GenSpec/GenerationMatchers/ResultMatcher.html",
+     "rdoc/classes/GenSpec/GeneratorExampleGroup.html",
+     "rdoc/created.rid",
+     "rdoc/files/README_rdoc.html",
+     "rdoc/files/lib/genspec/generation_matchers/generation_matcher_rb.html",
+     "rdoc/files/lib/genspec/generation_matchers/result_matcher_rb.html",
+     "rdoc/files/lib/genspec/generation_matchers_rb.html",
+     "rdoc/files/lib/genspec/generator_example_group_rb.html",
+     "rdoc/files/lib/genspec_rb.html",
+     "rdoc/fr_class_index.html",
+     "rdoc/fr_file_index.html",
+     "rdoc/fr_method_index.html",
+     "rdoc/index.html",
+     "rdoc/rdoc-style.css",
+     "spec/environment_spec.rb",
+     "spec/generators/test_spec.rb",
+     "spec/spec_helper.rb",
+     "spec/support/generators/test/templates/file",
+     "spec/support/generators/test/test_generator.rb"
+  ]
+  s.homepage = %q{http://www.thoughtsincomputation.com}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{Simple, expressive Rails generator testing for RSpec.}
+  s.test_files = [
+    "spec/environment_spec.rb",
+     "spec/generators/test_spec.rb",
+     "spec/spec_helper.rb",
+     "spec/support/generators/test/test_generator.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<rspec>, [">= 0"])
+      s.add_runtime_dependency(%q<sc-core-ext>, [">= 1.2.0"])
+    else
+      s.add_dependency(%q<rspec>, [">= 0"])
+      s.add_dependency(%q<sc-core-ext>, [">= 1.2.0"])
+    end
+  else
+    s.add_dependency(%q<rspec>, [">= 0"])
+    s.add_dependency(%q<sc-core-ext>, [">= 1.2.0"])
+  end
+end
+

data/lib/genspec.rb

@@ -0,0 +1,14 @@
+require 'spec'
+require 'fileutils'
+
+require 'sc-core-ext'
+
+require 'genspec/generation_matchers'
+require 'genspec/generator_example_group'
+
+if defined?(RAILS_ROOT)
+  require 'rails_generator'
+  require 'rails_generator/scripts/generate'
+end
+
+Spec::Example::ExampleGroupFactory.register(:generator, GenSpec::GeneratorExampleGroup)

data/lib/genspec/generation_matchers.rb

@@ -0,0 +1,27 @@
+require 'genspec/generation_matchers/generation_matcher'
+require 'genspec/generation_matchers/result_matcher'
+
+module GenSpec
+  module GenerationMatchers
+    # Valid types: :dependency, :class_collisions, :file, :template, :complex_template, :directory, :readme,
+    # :migration_template, :route_resources
+    def generate(kind, *args, &block)
+      case kind.to_s
+        when *GenSpec::GenerationMatchers::GenerationMatcher.generation_methods
+          GenSpec::GenerationMatchers::GenerationMatcher.new(kind, *args, &block)
+        else
+          if kind.kind_of?(String)
+            GenSpec::GenerationMatchers::ResultMatcher.new(kind, &block)
+          else
+            raise ArgumentError, "No generator matcher for #{kind.inspect}"
+          end
+      end
+    end
+    
+    # This tests the content sent to the command line, instead of the generated product.
+    # Useful for testing help messages, etc.
+    def output(text_or_regexp)
+      GenSpec::GenerationMatchers::GenerationMatcher.new(:output, text_or_regexp)
+    end
+  end
+end

data/lib/genspec/generation_matchers/generation_matcher.rb

@@ -0,0 +1,147 @@
+module GenSpec
+  module GenerationMatchers
+    class GenerationMatcher
+      delegate :generation_methods, :to => 'self.class'
+      
+      def initialize(kind = nil, *args)
+        raise ArgumentError, "Call with kind" unless kind
+        @kind = kind.to_s
+        @args = args
+        @but_found = nil
+      end
+          
+      def self.generation_methods
+        @generation_methods ||= %w(dependency class_collisions file template complex_template directory readme
+                                   migration_template route_resources)
+      end
+      
+      def matches?(target)
+        # if it's a string then it's an error message or some such from the generator.
+        if target.kind_of?(Rails::Generator::GeneratorError)
+          # if we're not checking output then why hold on to it? Raise it like the error it is!
+          raise target unless @kind == 'output'
+          @log = target.message
+        else
+          temporary_root(target) do
+            swap_loggers(target) do
+              replay(target)
+            end
+          end
+        end
+        match_content
+        matched?
+      end
+      
+      def failure_message
+        "Expected to generate #{@kind}#{with_file}#{but_found}"
+      end
+      
+      def negative_failure_message
+        "Expected not to generate #{@kind}#{with_file}"
+      end
+      
+      protected
+      
+      def replay(target)
+        @create = Rails::Generator::Commands::Create.new(target)
+        target.manifest.replay(self)
+        after_replay(target)
+      end
+      
+      # hook
+      def after_replay(target)
+      end
+      
+      def matched!
+        @matched = true
+      end
+      
+      def matched?
+        !!@matched
+      end
+  
+      private
+      def temporary_root(target)
+        # We could bear to split this into two methods, one called #suspend_logging or some such.
+        original_root = target.instance_variable_get("@destination_root")
+  
+        Dir.mktmpdir do |dir|
+          # need to copy a few files for some methods, ie route_resources
+          Dir.mkdir(File.join(dir, "config"))
+          FileUtils.cp File.join(RAILS_ROOT, "config/routes.rb"), File.join(dir, "config/routes.rb")
+          target.instance_variable_set("@destination_root", dir)
+          yield
+        end
+      ensure
+        target.instance_variable_set("@destination_root", original_root)
+      end
+      
+      def swap_loggers(target)
+        @log = ""
+        original_logger = Rails::Generator::Base.logger
+        original_quiet = target.logger.quiet
+        target.logger.quiet = true
+        Rails::Generator::Base.logger = Rails::Generator::SimpleLogger.new(StringIO.new(@log))
+        
+        yield
+      rescue
+        if original_logger != Rails::Generator::Base.logger
+          Kernel::raise $!.class, "#{$!.message}\n#{@log}", $!.backtrace
+        else
+          Kernel::raise $!
+        end
+      ensure
+        Rails::Generator::Base.logger = original_logger
+        target.logger.quiet = original_quiet
+        line = "Generator '#{target.spec.name}'"
+        line << " with args #{target.args.inspect}" unless target.args.empty?
+        Rails.logger.debug line
+        Rails.logger.debug @log
+      end
+      
+      def match_content
+        # check for a match if #kind is 'output'
+        if @kind == 'output'
+          @but_found = @log.dup
+          if (text = @args.first).kind_of?(String)
+            if @log =~ /#{Regexp::escape text}/m
+              matched!
+            end
+          elsif (regexp = @args.first).kind_of?(Regexp)
+            if @log =~ regexp
+              matched!
+            end
+          end
+        end
+      end
+  
+      def but_found
+        if @but_found.nil?
+          ""
+        else
+          ",\n    but found #{@but_found.inspect}"
+        end
+      end
+      
+      def with_file
+        !@args.empty? ? "\n    with #{@args.inspect}" : ""
+      end
+  
+      def method_missing(name, *args, &block)
+        if generation_methods.include? name.to_s
+          @create.send(name, *args, &block)
+          if name.to_s == @kind && (@args.empty? || args == @args)
+            matched!
+          elsif name.to_s == @kind
+            @but_found = args
+          else
+            nil
+          end
+        else super
+        end
+      #rescue
+      #  Kernel::raise $!.class, $!.message, caller
+      end
+    end
+  end
+end