genspec 0.1.1 → 0.2.0.prerails3.1

data/lib/genspec/matchers.rb

@@ -0,0 +1,59 @@
+require 'genspec/matchers/base'
+require 'genspec/matchers/result_matcher'
+require 'genspec/matchers/generation_method_matcher'
+require 'genspec/matchers/output_matcher'
+
+module GenSpec
+  module Matchers
+    # Valid types: :dependency, :class_collisions, :file, :template, :complex_template, :directory, :readme,
+    # :migration_template, :route_resources
+    def generate(kind, *args, &block)
+      if kind.kind_of?(Symbol)
+        call_action(kind, *args, &block)
+      else
+        GenSpec::Matchers::ResultMatcher.new(kind, &block)
+      end
+    end
+    
+    def call_action(kind, *args, &block)
+      unless matcher = GenSpec::Matchers::GenerationMethodMatcher.for_method(kind, *args, &block)
+        raise "Could not find a matcher for '#{kind.inspect}'!\n\n" \
+              "If this is a custom action, try adding the Thor Action module to GenSpec:\n\n" \
+              "GenSpec::Matchers::GenerationMethodMatcher.GENERATION_CLASSES << 'My::Actions'"
+      end
+      matcher
+    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::Matchers::OutputMatcher.new(text_or_regexp)
+    end
+    
+    class << self
+      def add_shorthand_methods(base)
+        instance_methods = base.instance_methods.collect { |m| m.to_s }
+        GenSpec::Matchers::GenerationMethodMatcher.generation_methods.each do |method_name|
+          # don't overwrite existing methods. since the user expects this to fire FIRST,
+          # it's as if this method's been "overridden".
+          next if instance_methods.include?(method_name)
+          base.class_eval <<-end_code
+            def #{method_name}(*args, &block)                    # def create_file(*args, &block)
+              call_action(#{method_name.inspect}, *args, &block) #   call_action('create_file', *args, &block)
+            end                                                  # end
+          end_code
+        end 
+      end
+      
+      # this is to delay definition of the generation method matchers (like #create_file) until
+      # after initialization, in order to facilitate custom Thor actions.
+      def included(base)
+        add_shorthand_methods(base)
+      end
+      
+      def extended(base)
+        add_shorthand_methods(class << base; self; end)
+      end
+    end
+  end
+end

data/lib/genspec/matchers/base.rb

@@ -0,0 +1,148 @@
+module GenSpec
+  module Matchers
+    class Base
+      attr_reader :block, :generator, :args, :described
+      delegate :source_root, :to => :generator
+      attr_reader :destination_root
+      attr_accessor :error
+      
+      def initialize(&block)
+        @block = block if block_given?
+        @matched = false
+      end
+      
+      def match!
+        @matched = true
+      end
+      
+      def matches?(generator)
+        @described = generator[:described]
+        @args = generator[:args]
+        
+        if @described.kind_of?(Array)
+          @generator = Rails::Generators.find_by_namespace(*@described)
+        else
+          @generator = Rails::Generators.find_by_namespace(@described)
+        end
+        
+        raise "Could not find generator: #{@described.inspect}" unless @generator
+        
+        localize_generator!
+        inject_error_handlers!
+        invoking
+        invoke
+        matched?
+      end
+      
+      def matched?
+        @matched
+      end
+    
+      def failure_message
+        "was supposed to match and didn't"
+      end
+        
+      def negative_failure_message
+        "was supposed to not match and did"
+      end
+      
+      protected
+      # callback which fires just before a generator has been invoked.
+      def invoking
+      end
+      
+      # callback which fires just after a generator has run and after error checking has
+      # been performed, if applicable.
+      def generated
+      end
+      
+      def temporary_root
+        Dir.mktmpdir do |dir|
+          # need to copy a few files for some methods, ie route_resources
+          FileUtils.touch(File.join(dir, "Gemfile"))
+          
+          # all set.
+          yield dir
+        end
+      end
+      
+      def spec_file_contents(filename)
+        if @block
+          content = File.read(filename)
+          @block.call(content)
+        end
+      end
+      
+      protected
+      # Causes errors not to be raised if a generator fails. Useful for testing output,
+      # rather than results.
+      def silence_errors!
+        @errors_silenced = true
+      end
+      
+      def silence_thor!
+        @generator.instance_eval do
+          alias thor_method_added method_added
+
+          # to silence callbacks and errors about reserved keywords
+          def method_added(meth)
+          end
+        end
+        
+        yield
+        
+        # un-silence errors and callbacks
+        @generator.instance_eval { alias thor_method_added method_added }
+      end
+      
+      private
+      def check_for_errors
+        # generation is complete - check for errors and re-raise it if it's there
+        raise error if error && !@errors_silenced
+      end
+      
+      def invoke
+        temporary_root do |tempdir|
+          @destination_root = tempdir
+          @generator.start(@args || [], {:destination_root => destination_root})
+          check_for_errors
+          generated
+        end
+      end
+      
+      def inject_error_handlers!
+        silence_thor! do
+          @generator.class_eval do
+            def invoke_with_genspec_error_handler(*names, &block)
+              invoke_without_genspec_error_handler(*names, &block)
+            rescue Thor::Error => err
+              interceptor.error = err
+              raise err
+            end
+            
+            alias invoke_without_genspec_error_handler invoke
+            alias invoke invoke_with_genspec_error_handler
+          end
+        end
+      end
+      
+      def localize_generator!
+        # subclass the generator in question so that aliasing its methods doesn't
+        # impact the root generator (which would be a Bad Thing for other specs)
+        gen = @generator
+        generator = Class.new(gen)
+        # we have to force the name in order to avoid nil errors within Thor.
+        generator.instance_eval "def self.name; #{gen.name.inspect}; end"
+        @generator = generator
+
+        
+        # add self as the "interceptor" so that our generator's wrapper methods can
+        # gain access to this object.
+        def @generator.interceptor; @interceptor; end
+        def @generator.interceptor=(a); @interceptor = a; end
+    
+        @generator.interceptor = self
+      end
+    end
+  end
+end

data/lib/genspec/matchers/generation_method_matcher.rb

@@ -0,0 +1,88 @@
+class GenSpec::Matchers::GenerationMethodMatcher < GenSpec::Matchers::Base
+  GENERATION_CLASSES = [ 'Thor::Actions', 'Rails::Generators::Actions' ]
+  
+  attr_reader :method_name, :method_args
+  
+  def initialize(method_name, *args, &block)
+    @method_name = method_name
+    @method_args = args
+    @actual_args = nil
+    super(&block)
+  end
+  
+  def report_actual_args(args)
+    # save a reference to the set of args that most *closely* matched the expectation.
+    return(@actual_args = args) if @actual_args.nil?
+    matches = (method_args % args).length
+    if matches > (method_args % @actual_args).length
+      @actual_args = args
+    end
+  end
+  
+  def failure_message
+    "expected to generate a call to #{method_name.inspect}#{with_args} but #{what}"
+  end
+  
+  def negative_failure_message
+    "expected not to generate a call to #{method_name.inspect}#{with_args} but it happened anyway"
+  end
+  
+  private
+  def with_args
+    if @method_args.empty?
+      ''
+    else
+      " "+@method_args.inspect
+    end
+  end
+  
+  def what
+    if @actual_args.nil?
+      "that did not happen"
+    else
+      "received #{@actual_args.inspect} instead"
+    end
+  end
+  
+  protected
+  def invoking
+    silence_thor! do
+      generator.class_eval <<-end_code
+        def #{method_name}_with_intercept(*argus, &block)
+          expected_args = self.class.interceptor.method_args
+          if expected_args.length > 0
+            actual_args = argus[0...expected_args.length]
+            if actual_args == expected_args
+              self.class.interceptor.match!
+            else
+              self.class.interceptor.report_actual_args(actual_args)
+            end
+          else
+            # we've already matched the method, and there are no expected args.
+            self.class.interceptor.match!
+          end
+
+          #{method_name}_without_intercept(*argus, &block)
+        end
+      end_code
+      generator.send(:alias_method_chain, method_name, :intercept)
+    end    
+  end
+  
+  public
+  class << self
+    def generation_methods
+      GENERATION_CLASSES.inject([]) do |arr, mod|
+        mod = mod.constantize if mod.kind_of?(String)
+        arr.concat mod.public_instance_methods.collect { |i| i.to_s }.reject { |i| i =~ /=/ }
+        arr
+      end
+    end
+    
+    def for_method(which, *args, &block)
+      if generation_methods.include?(which.to_s) then self.new(which, *args, &block)
+      else nil
+      end
+    end
+  end
+end

data/lib/genspec/matchers/output_matcher.rb

@@ -0,0 +1,34 @@
+module GenSpec
+  module Matchers
+    class OutputMatcher < GenSpec::Matchers::Base
+      def output
+        Thor::Base.shell.output.string
+      end
+      
+      def initialize(text_or_regexp)
+        regexp = if text_or_regexp.kind_of?(Regexp)
+                   text_or_regexp
+                 else
+                   Regexp.compile(Regexp.escape(text_or_regexp), Regexp::MULTILINE)
+                 end
+        @regexp = regexp
+        super()
+        silence_errors!
+      end
+      
+      def generated
+        match! if output =~ @regexp
+      end
+      
+      def failure_message
+        output + "\n" \
+          "expected to match #{@regexp.inspect}, but did not"
+      end
+
+      def negative_failure_message
+        output + "\n" \
+          "expected not to match #{@regexp.inspect}, but did"
+      end
+    end
+  end
+end

data/lib/genspec/matchers/result_matcher.rb

@@ -0,0 +1,28 @@
+module GenSpec
+  module Matchers
+    class ResultMatcher < GenSpec::Matchers::Base
+      attr_reader :filename
+      
+      def initialize(filename, &block)
+        @filename = filename
+        super(&block)
+      end
+      
+      def generated
+        path = File.join(destination_root, filename)
+        if File.exist?(path)
+          match!
+          spec_file_contents(path)
+        end
+      end
+      
+      def failure_message
+        "Expected to generate #{filename}"
+      end
+        
+      def negative_failure_message
+        "Expected to not generate #{filename}"
+      end
+    end
+  end
+end

data/lib/genspec/shell.rb

@@ -0,0 +1,99 @@
+module GenSpec
+  # Just like a Thor::Shell::Basic except that input and output are both redirected to
+  # the specified streams. By default, these are initialized to instances of StringIO.
+  class Shell < Thor::Shell::Basic
+    attr_accessor :input, :output
+    
+    def initialize(output="", input="")
+      super()
+      new(output, input)
+    end
+    
+    # Reinitializes this Shell with the given input and output streams.
+    def new(output="", input="")
+      init_stream(:output, output)
+      init_stream(:input,  input)
+      self
+    end
+    
+    # Ask something to the user and receives a response.
+    #
+    # ==== Example
+    # ask("What is your name?")
+    #
+    def ask(statement, color=nil)
+      say("#{statement} ", color)
+      input.gets.strip
+    end
+
+    # Say (print) something to the user. If the sentence ends with a whitespace
+    # or tab character, a new line is not appended (print + flush). Otherwise
+    # are passed straight to puts (behavior got from Highline).
+    #
+    # ==== Example
+    # say("I know you knew that.")
+    #
+    def say(message="", color=nil, force_new_line=(message.to_s !~ /( |\t)$/))
+      message  = message.to_s
+      message  = set_color(message, color) if color
+
+      if force_new_line
+        output.puts(message)
+      else
+        output.print(message)
+        output.flush
+      end
+    end
+
+    # Prints a table.
+    #
+    # ==== Parameters
+    # Array[Array[String, String, ...]]
+    #
+    # ==== Options
+    # ident<Integer>:: Ident the first column by ident value.
+    #
+    def print_table(table, options={})
+      return if table.empty?
+
+      formats, ident = [], options[:ident].to_i
+      options[:truncate] = terminal_width if options[:truncate] == true
+
+      0.upto(table.first.length - 2) do |i|
+        maxima = table.max{ |a,b| a[i].size <=> b[i].size }[i].size
+        formats << "%-#{maxima + 2}s"
+      end
+
+      formats[0] = formats[0].insert(0, " " * ident)
+      formats << "%s"
+
+      table.each do |row|
+        sentence = ""
+
+        row.each_with_index do |column, i|
+          sentence << formats[i] % column.to_s
+        end
+
+        sentence = truncate(sentence, options[:truncate]) if options[:truncate]
+        output.puts sentence  
+      end
+    end
+
+    # Called if something goes wrong during the execution. This is used by Thor
+    # internally and should not be used inside your scripts. If someone went
+    # wrong, you can always raise an exception. If you raise a Thor::Error, it
+    # will be rescued and wrapped in the method below.
+    #
+    def error(statement)
+      output.puts statement
+    end
+    
+    private
+    def init_stream(which, value)
+      if value.kind_of?(String)
+        value = StringIO.new(value)
+      end
+      send("#{which}=", value)
+    end
+  end
+end