rhodes-framework 1.0.10 → 1.1.0

data/spec/app/mspec/matchers/equal_utf16.rb

@@ -0,0 +1,34 @@
+class EqualUtf16Matcher
+  def initialize(expected)
+    @expected = expected
+  end
+
+  def matches?(actual)
+    @actual = actual
+    @actual == @expected || @actual == expected_swapped
+  end
+
+  def expected_swapped
+    if @expected.respond_to?(:to_str)
+      @expected_swapped ||= @expected.to_str.gsub(/(.)(.)/, '\2\1')
+    else
+      @expected_swapped ||= @expected.collect { |s| s.to_str.gsub(/(.)(.)/, '\2\1') }
+    end
+  end
+
+  def failure_message
+    ["Expected #{@actual.pretty_inspect}",
+     "to equal #{@expected.pretty_inspect} or #{expected_swapped.pretty_inspect}"]
+  end
+
+  def negative_failure_message
+    ["Expected #{@actual.pretty_inspect}",
+     "not to equal #{@expected.pretty_inspect} nor #{expected_swapped.pretty_inspect}"]
+  end
+end
+
+class Object
+  def equal_utf16(expected)
+    EqualUtf16Matcher.new(expected)
+  end
+end

data/spec/app/mspec/matchers/have_constant.rb

@@ -0,0 +1,30 @@
+require 'mspec/matchers/stringsymboladapter'
+
+class HaveConstantMatcher
+  include StringSymbolAdapter
+
+  def initialize(name)
+    @name = convert_name name
+  end
+
+  def matches?(mod)
+    @mod = mod
+    @mod.constants.include? @name
+  end
+
+  def failure_message
+    ["Expected #{@mod} to have constant '#{@name.to_s}'",
+     "but it does not"]
+  end
+
+  def negative_failure_message
+    ["Expected #{@mod} NOT to have constant '#{@name.to_s}'",
+     "but it does"]
+  end
+end
+
+class Object
+  def have_constant(name)
+    HaveConstantMatcher.new name
+  end
+end

data/spec/app/mspec/matchers/have_instance_method.rb

@@ -0,0 +1,24 @@
+require 'mspec/matchers/method'
+
+class HaveInstanceMethodMatcher < MethodMatcher
+  def matches?(mod)
+    @mod = mod
+    mod.instance_methods(@include_super).include? @method
+  end
+
+  def failure_message
+    ["Expected #{@mod} to have instance method '#{@method.to_s}'",
+     "but it does not"]
+  end
+
+  def negative_failure_message
+    ["Expected #{@mod} NOT to have instance method '#{@method.to_s}'",
+     "but it does"]
+  end
+end
+
+class Object
+  def have_instance_method(method, include_super=true)
+    HaveInstanceMethodMatcher.new method, include_super
+  end
+end

data/spec/app/mspec/matchers/have_method.rb

@@ -0,0 +1,24 @@
+require 'mspec/matchers/method'
+
+class HaveMethodMatcher < MethodMatcher
+  def matches?(mod)
+    @mod = mod
+    @mod.methods(@include_super).include? @method
+  end
+
+  def failure_message
+    ["Expected #{@mod} to have method '#{@method.to_s}'",
+     "but it does not"]
+  end
+
+  def negative_failure_message
+    ["Expected #{@mod} NOT to have method '#{@method.to_s}'",
+     "but it does"]
+  end
+end
+
+class Object
+  def have_method(method, include_super=true)
+    HaveMethodMatcher.new method, include_super
+  end
+end

data/spec/app/mspec/matchers/have_private_instance_method.rb

@@ -0,0 +1,24 @@
+require 'mspec/matchers/method'
+
+class HavePrivateInstanceMethodMatcher < MethodMatcher
+  def matches?(mod)
+    @mod = mod
+    mod.private_instance_methods(@include_super).include? @method
+  end
+
+  def failure_message
+    ["Expected #{@mod} to have private instance method '#{@method.to_s}'",
+     "but it does not"]
+  end
+
+  def negative_failure_message
+    ["Expected #{@mod} NOT to have private instance method '#{@method.to_s}'",
+     "but it does"]
+  end
+end
+
+class Object
+  def have_private_instance_method(method, include_super=true)
+    HavePrivateInstanceMethodMatcher.new method, include_super
+  end
+end

data/spec/app/mspec/matchers/include.rb

@@ -0,0 +1,32 @@
+class IncludeMatcher
+  def initialize(*expected)
+    @expected = expected
+  end
+
+  def matches?(actual)
+    @actual = actual
+    @expected.each do |e|
+      @element = e
+      unless @actual.include?(e)
+        return false
+      end
+    end
+    return true
+  end
+
+  def failure_message
+    ["Expected #{@actual.inspect}", "to include #{@element.inspect}"]
+  end
+
+  def negative_failure_message
+    ["Expected #{@actual.inspect}", "not to include #{@element.inspect}"]
+  end
+end
+
+# Cannot override #include at the toplevel in MRI
+module MSpec
+  def include(*expected)
+    IncludeMatcher.new(*expected)
+  end
+  module_function :include
+end

data/spec/app/mspec/matchers/match_yaml.rb

@@ -0,0 +1,47 @@
+class MatchYAMLMatcher
+
+  def initialize(expected)
+    if valid_yaml?(expected)
+      @expected = expected
+    else
+      @expected = expected.to_yaml
+    end
+  end
+
+  def matches?(actual)
+    @actual = actual    
+    clean_yaml(@actual) == @expected
+  end
+
+  def failure_message
+    ["Expected #{@actual.inspect}", " to match #{@expected.inspect}"]
+  end
+
+  def negative_failure_message
+    ["Expected #{@actual.inspect}", " to match #{@expected.inspect}"]
+  end
+  
+  protected
+  
+  def clean_yaml(yaml)
+    yaml.gsub(/([^-])\s+\n/, "\\1\n")
+  end
+
+  def valid_yaml?(obj)
+    require 'yaml'
+    begin
+      YAML.load(obj)
+    rescue
+      false
+    else
+      true
+    end
+  end
+end
+
+class Object
+  def match_yaml(expected)
+    MatchYAMLMatcher.new(expected)
+  end
+end
+

data/spec/app/mspec/matchers/method.rb

@@ -0,0 +1,14 @@
+require 'mspec/matchers/stringsymboladapter'
+
+class MethodMatcher
+  include StringSymbolAdapter
+
+  def initialize(method, include_super=true)
+    @include_super = include_super
+    @method = convert_name method
+  end
+
+  def matches?(mod)
+    raise Exception, "define #matches? in the subclass"
+  end
+end

data/spec/app/mspec/matchers/output.rb

@@ -0,0 +1,67 @@
+require 'mspec/helpers/io'
+
+class OutputMatcher
+  def initialize(stdout, stderr)
+    @out = stdout
+    @err = stderr
+  end
+
+  def matches?(proc)
+    @saved_out = $stdout
+    @saved_err = $stderr
+    @stdout = $stdout = IOStub.new
+    @stderr = $stderr = IOStub.new
+
+    proc.call
+
+    unless @out.nil?
+      case @out
+      when Regexp
+        return false unless $stdout =~ @out
+      else
+        return false unless $stdout == @out
+      end
+    end
+
+    unless @err.nil?
+      case @err
+      when Regexp
+        return false unless $stderr =~ @err
+      else
+        return false unless $stderr == @err
+      end
+    end
+
+    return true
+  ensure
+    $stdout = @saved_out
+    $stderr = @saved_err
+  end
+
+  def failure_message
+    expected_out = "\n"
+    actual_out = "\n"
+    unless @out.nil?
+      expected_out << "  $stdout: #{@out.inspect}\n"
+      actual_out << "  $stdout: #{@stdout.chomp.inspect}\n"
+    end
+    unless @err.nil?
+      expected_out << "  $stderr: #{@err.inspect}\n"
+      actual_out << "  $stderr: #{@stderr.chomp.inspect}\n"
+    end
+    ["Expected:#{expected_out}", "     got:#{actual_out}"]
+  end
+
+  def negative_failure_message
+    out = ""
+    out << "  $stdout: #{@stdout.chomp.dump}\n" unless @out.nil?
+    out << "  $stderr: #{@stderr.chomp.dump}\n" unless @err.nil?
+    ["Expected output not to be:\n", out]
+  end
+end
+
+class Object
+  def output(stdout=nil, stderr=nil)
+    OutputMatcher.new(stdout, stderr)
+  end
+end

data/spec/app/mspec/matchers/output_to_fd.rb

@@ -0,0 +1,71 @@
+# require 'mspec/helpers/tmp'
+# require 'fileutils'
+# 
+# # Lower-level output speccing mechanism for a single
+# # output stream. Unlike OutputMatcher which provides
+# # methods to capture the output, we actually replace
+# # the FD itself so that there is no reliance on a
+# # certain method being used.
+# class OutputToFDMatcher
+#   def initialize(expected, to)
+#     @to, @expected = to, expected
+# 
+#     case @to
+#     when STDOUT
+#       @to_name = "STDOUT"
+#     when STDERR
+#       @to_name = "STDERR"
+#     when IO
+#       @to_name = @to.object_id.to_s
+#     else
+#       raise ArgumentError, "#{@to.inspect} is not a supported output target"
+#     end
+#   end
+# 
+#   def matches?(block)
+#     old_to = @to.dup
+#     out = File.open(tmp("mspec_output_to_#{$$}_#{Time.now.to_i}"), 'w+')
+# 
+#     # Replacing with a file handle so that Readline etc. work
+#     @to.reopen out
+# 
+#     block.call
+# 
+#   ensure
+#     begin
+#       @to.reopen old_to
+# 
+#       out.rewind
+#       @actual = out.read
+# 
+#       case @expected
+#         when Regexp
+#           return !(@actual =~ @expected).nil?
+#         else
+#           return @actual == @expected
+#       end
+# 
+#     # Clean up
+#     ensure
+#       out.close unless out.closed?
+#       FileUtils.rm out.path
+#     end
+# 
+#     return true
+#   end
+# 
+#   def failure_message()
+#     ["Expected (#{@to_name}): #{@expected.inspect}\n",
+#      "#{'but got'.rjust(@to_name.length + 10)}: #{@actual.inspect}\nBacktrace"]
+#   end
+# 
+#   def negative_failure_message()
+#     ["Expected output (#{@to_name}) to NOT be:\n", @actual.inspect]
+#   end
+# end
+# 
+# class Object
+#   def output_to_fd(what, where = STDOUT)
+#     OutputToFDMatcher.new what, where
+#   end
+# end

data/spec/app/mspec/matchers/raise_error.rb

@@ -0,0 +1,48 @@
+class RaiseErrorMatcher
+  def initialize(exception, message, &block)
+    @exception = exception
+    @message = message
+    @block = block
+  end
+
+  def matches?(proc)
+    proc.call
+    return false
+  rescue Exception => @actual
+    return false unless @exception === @actual
+    if @message then
+      case @message
+      when String then
+        return false if @message != @actual.message
+      when Regexp then
+        return false if @message !~ @actual.message
+      end
+    end
+
+    @block[@actual] if @block
+
+    return true
+  end
+
+  def failure_message
+    message = ["Expected #{@exception}#{%[ (#{@message})] if @message}"]
+
+    if @actual then
+      message << "but got #{@actual.class}#{%[ (#{@actual.message})] if @actual.message}"
+    else
+      message << "but no exception was raised"
+    end
+
+    message
+  end
+
+  def negative_failure_message
+    ["Expected to not get #{@exception}#{%[ (#{@message})] if @message}", ""]
+  end
+end
+
+class Object
+  def raise_error(exception=Exception, message=nil, &block)
+    RaiseErrorMatcher.new(exception, message, &block)
+  end
+end

data/spec/app/mspec/matchers/respond_to.rb

@@ -0,0 +1,24 @@
+class RespondToMatcher
+  def initialize(expected)
+    @expected = expected
+  end
+
+  def matches?(actual)
+    @actual = actual
+    @actual.respond_to?(@expected)
+  end
+
+  def failure_message
+    ["Expected #{@actual.inspect} (#{@actual.class})", "to respond to #{@expected}"]
+  end
+
+  def negative_failure_message
+    ["Expected #{@actual.inspect} (#{@actual.class})", "not to respond to #{@expected}"]
+  end
+end
+
+class Object
+  def respond_to(expected)
+    RespondToMatcher.new(expected)
+  end
+end