mspec 1.5.17 → 1.5.18

data/lib/mspec/guards.rb

@@ -1,5 +1,6 @@
 require 'mspec/utils/ruby_name'
 require 'mspec/guards/background'
+require 'mspec/guards/block_device'
 require 'mspec/guards/bug'
 require 'mspec/guards/compliance'
 require 'mspec/guards/conflict'

data/lib/mspec/guards/block_device.rb

@@ -0,0 +1,22 @@
+require 'mspec/guards/guard'
+
+class BlockDeviceGuard < SpecGuard
+  def match?
+    platform_is_not :freebsd, :windows do
+      block = `find /dev /devices -type b 2> /dev/null`
+      return !(block.nil? || block.empty?)
+    end
+
+    false
+  end
+end
+
+class Object
+  def with_block_device
+    g = BlockDeviceGuard.new
+    g.name = :with_block_device
+    yield if g.yield?
+  ensure
+    g.unregister
+  end
+end

data/lib/mspec/guards/guard.rb

@@ -32,6 +32,16 @@ class SpecGuard
     @guards = []
   end
 
+  @@ruby_version_override = nil
+
+  def self.ruby_version_override=(version)
+    @@ruby_version_override = version
+  end
+
+  def self.ruby_version_override
+    @@ruby_version_override
+  end
+
   # Returns a partial Ruby version string based on +which+. For example,
   # if RUBY_VERSION = 8.2.3 and RUBY_PATCHLEVEL = 71:
   #
@@ -54,7 +64,7 @@ class SpecGuard
 
     patch = RUBY_PATCHLEVEL.to_i
     patch = 0 if patch < 0
-    version = "#{RUBY_VERSION}.#{patch}"
+    version = "#{ruby_version_override || RUBY_VERSION}.#{patch}"
     version.split('.')[0,n].join('.')
   end
 
@@ -123,6 +133,8 @@ class SpecGuard
         RUBY_NAME =~ /^macruby/
       when :maglev
         RUBY_NAME =~ /^maglev/
+      when :topaz
+        RUBY_NAME =~ /^topaz/
       else
         false
       end
@@ -153,7 +165,7 @@ class SpecGuard
 
   def os?(*oses)
     oses.any? do |os|
-      host_os = Config::CONFIG['host_os'] || RUBY_PLATFORM
+      host_os = RbConfig::CONFIG['host_os'] || RUBY_PLATFORM
       host_os.downcase!
       host_os.match(os.to_s) || windows?(os, host_os)
     end

data/lib/mspec/helpers.rb

@@ -1,21 +1,21 @@
 require 'mspec/helpers/argv'
-require 'mspec/helpers/bignum'
 require 'mspec/helpers/const_lookup'
+require 'mspec/helpers/datetime'
 require 'mspec/helpers/ducktype'
 require 'mspec/helpers/encode'
 require 'mspec/helpers/enumerator_class'
 require 'mspec/helpers/environment'
 require 'mspec/helpers/fixture'
 require 'mspec/helpers/flunk'
-require 'mspec/helpers/fmode'
 require 'mspec/helpers/fs'
 require 'mspec/helpers/hash'
-require 'mspec/helpers/infinity'
 require 'mspec/helpers/io'
 require 'mspec/helpers/language_version'
-require 'mspec/helpers/metaclass'
 require 'mspec/helpers/mock_to_path'
-require 'mspec/helpers/nan'
+require 'mspec/helpers/numeric'
+require 'mspec/helpers/pack'
 require 'mspec/helpers/ruby_exe'
 require 'mspec/helpers/scratch'
+require 'mspec/helpers/stasy'
+require 'mspec/helpers/singleton_class'
 require 'mspec/helpers/tmp'

data/lib/mspec/helpers/const_lookup.rb

@@ -1,9 +1,14 @@
+require 'mspec/utils/version'
+
 module Kernel
   def const_lookup(c)
+    extra_arg = SpecVersion.new(RUBY_VERSION) >= "1.9"
+
     names = c.split '::'
     names.shift if names.first.empty?
+
     names.inject(Object) do |m, n|
-      defined = RUBY_VERSION =~ /^1.9/ ? m.const_defined?(n, false) : m.const_defined?(n)
+      defined = extra_arg ? m.const_defined?(n, false) : m.const_defined?(n)
       defined ? m.const_get(n) : m.const_missing(n)
     end
   end

data/lib/mspec/helpers/datetime.rb

@@ -0,0 +1,28 @@
+class Object
+  # The new_datetime helper makes writing DateTime specs more simple by
+  # providing default constructor values and accepting a Hash of only the
+  # constructor values needed for the particular spec. For example:
+  #
+  #   new_datetime :hour => 1, :minute => 20
+  #
+  # Possible keys are:
+  #   :year, :month, :day, :hour, :minute, :second, :offset and :sg.
+
+  def new_datetime(opts={})
+    require 'date'
+
+    value = {
+      :year   => -4712,
+      :month  => 1,
+      :day    => 1,
+      :hour   => 0,
+      :minute => 0,
+      :second => 0,
+      :offset => 0,
+      :sg     => Date::ITALY
+    }.merge opts
+
+    DateTime.new value[:year], value[:month], value[:day], value[:hour],
+      value[:minute], value[:second], value[:offset], value[:sg]
+  end
+end

data/lib/mspec/helpers/ducktype.rb

@@ -1,6 +1,6 @@
 class Object
   def responds_to(sym)
-    metaclass.class_eval <<-END
+    singleton_class.class_eval <<-END
       def respond_to?(sym, include_private=false)
         sym.to_sym == #{sym.to_sym.inspect} ? true : super
       end
@@ -8,7 +8,7 @@ class Object
   end
 
   def does_not_respond_to(sym)
-    metaclass.class_eval <<-END
+    singleton_class.class_eval <<-END
       def respond_to?(sym, include_private=false)
         sym.to_sym == #{sym.to_sym.inspect} ? false : super
       end
@@ -16,7 +16,7 @@ class Object
   end
 
   def undefine(sym)
-    metaclass.class_eval <<-END
+    singleton_class.class_eval <<-END
       undef_method #{sym.to_sym.inspect}
     END
   end
@@ -24,7 +24,7 @@ class Object
   def fake!(sym, value=nil)
     responds_to sym
 
-    metaclass.class_eval <<-END
+    singleton_class.class_eval <<-END
       def method_missing(sym, *args)
         return #{value.inspect} if sym.to_sym == #{sym.to_sym.inspect}
       end

data/lib/mspec/helpers/environment.rb

@@ -13,7 +13,7 @@ class Object
 
   def windows_env_echo(var)
     `cmd.exe /C ECHO %#{var}%`.strip
-  end  
+  end
 
   def username
     user = ""
@@ -28,5 +28,22 @@ class Object
   def home_directory
     return ENV['HOME'] unless PlatformGuard.windows?
     windows_env_echo('HOMEDRIVE') + windows_env_echo('HOMEPATH')
-  end  
+  end
+
+  def dev_null
+    if PlatformGuard.windows?
+      "NUL"
+    else
+      "/dev/null"
+    end
+  end
+
+  def hostname
+    commands = ['hostname', 'uname -n']
+    commands.each do |command|
+      name = `#{command}`
+      return name.strip if $?.success?
+    end
+    raise Exception, "hostname: unable to find a working command"
+  end
 end

data/lib/mspec/helpers/fs.rb

@@ -37,7 +37,11 @@ class Object
         raise ArgumentError, "#{path} is not prefixed by #{prefix}"
       end
 
-      if File.directory? path
+      # File.symlink? needs to be checked first as
+      # File.exists? returns false for dangling symlinks
+      if File.symlink? path
+        File.unlink path
+      elsif File.directory? path
         Dir.entries(path).each { |x| rm_r "#{path}/#{x}" unless x =~ /^\.\.?$/ }
         Dir.rmdir path
       elsif File.exists? path

data/lib/mspec/helpers/io.rb

@@ -1,3 +1,5 @@
+require 'mspec/guards/feature'
+
 class IOStub < String
   def write(*str)
     self << str.join
@@ -25,12 +27,48 @@ class Object
   # with any Ruby object). The file descriptor can safely be passed
   # to IO.new without creating a Ruby object alias to the fd.
   def new_fd(name, mode="w:utf-8")
+    mode = options_or_mode(mode)
+
+    if mode.kind_of? Hash
+      if mode.key? :mode
+        mode = mode[:mode]
+      else
+        raise ArgumentError, "new_fd options Hash must include :mode"
+      end
+    end
+
     IO.sysopen name, fmode(mode)
   end
 
   # Creates an IO instance for a temporary file name. The file
   # must be deleted.
   def new_io(name, mode="w:utf-8")
-    IO.new new_fd(name, fmode(mode))
+    IO.new new_fd(name, options_or_mode(mode)), options_or_mode(mode)
+  end
+
+  # This helper simplifies passing file access modes regardless of
+  # whether the :encoding feature is enabled. Only the access specifier
+  # itself will be returned if :encoding is not enabled. Otherwise,
+  # the full mode string will be returned (i.e. the helper is a no-op).
+  def fmode(mode)
+    if FeatureGuard.enabled? :encoding
+      mode
+    else
+      mode.split(':').first
+    end
+  end
+
+  # This helper simplifies passing file access modes or options regardless of
+  # whether the :encoding feature is enabled. Only the access specifier itself
+  # will be returned if :encoding is not enabled. Otherwise, the full mode
+  # string or option will be returned (i.e. the helper is a no-op).
+  def options_or_mode(oom)
+    return fmode(oom) if oom.kind_of? String
+
+    if FeatureGuard.enabled? :encoding
+      oom
+    else
+      fmode(oom[:mode] || "r:utf-8")
+    end
   end
 end

data/lib/mspec/helpers/numeric.rb

@@ -0,0 +1,89 @@
+class Object
+  def nan_value
+    0/0.0
+  end
+
+  def infinity_value
+    1/0.0
+  end
+
+  def bignum_value(plus=0)
+    0x8000_0000_0000_0000 + plus
+  end
+
+  # This is a bit hairy, but we need to be able to write specs that cover the
+  # boundary between Fixnum and Bignum for operations like Fixnum#<<. Since
+  # this boundary is implementation-dependent, we use these helpers to write
+  # specs based on the relationship between values rather than specific
+  # values.
+  guard = SpecGuard.new
+
+  if guard.standard? or guard.implementation? :topaz
+    if guard.wordsize? 32
+      def fixnum_max()
+        (2**30) - 1
+      end
+
+      def fixnum_min()
+        -(2**30)
+      end
+    elsif guard.wordsize? 64
+      def fixnum_max()
+        (2**62) - 1
+      end
+
+      def fixnum_min()
+        -(2**62)
+      end
+    end
+  elsif guard.implementation? :rubinius
+    def fixnum_max()
+      Fixnum::MAX
+    end
+
+    def fixnum_min()
+      Fixnum::MIN
+    end
+  elsif guard.implementation? :jruby
+    # Values from jruby/test/testFixnumBignumAutoconversion.rb
+    def fixnum_max()
+      9223372036854775807
+    end
+
+    def fixnum_min()
+      -9223372036854775808
+    end
+  elsif guard.implementation? :ironruby
+    def fixnum_max()
+      raise "fixnum_max() helper not implemented"
+    end
+
+    def fixnum_min()
+      raise "fixnum_min() helper not implemented"
+    end
+  elsif guard.implementation? :maglev
+    def fixnum_max()
+      raise "fixnum_max() helper not implemented"
+    end
+
+    def fixnum_min()
+      raise "fixnum_min() helper not implemented"
+    end
+  elsif guard.implementation? :macruby
+    def fixnum_max()
+      raise "fixnum_max() helper not implemented"
+    end
+
+    def fixnum_min()
+      raise "fixnum_min() helper not implemented"
+    end
+  else
+    def fixnum_max()
+      raise "unknown implementation for fixnum_max() helper"
+    end
+
+    def fixnum_min()
+      raise "unknown implementation for fixnum_min() helper"
+    end
+  end
+end

data/lib/mspec/helpers/pack.rb

@@ -0,0 +1,3 @@
+def pack_int(*ary)
+  ary.pack("i*")
+end

data/lib/mspec/helpers/ruby_exe.rb

@@ -22,15 +22,19 @@ require 'mspec/guards/platform'
 #
 #   `#{RUBY_EXE} -e #{'puts "hello, world."'}`
 #
-# The ruby_exe helper also accepts an options hash with two
-# keys: :options and :args. For example:
+# The ruby_exe helper also accepts an options hash with three
+# keys: :options, :args and :env. For example:
 #
-#   ruby_exe('file.rb', :options => "-w", :args => "> file.txt")
+#   ruby_exe('file.rb', :options => "-w",
+#                       :args => "> file.txt",
+#                       :env => { :FOO => "bar" })
 #
 # will be executed as
 #
 #   `#{RUBY_EXE} -w #{'file.rb'} > file.txt`
 #
+# with access to ENV["FOO"] with value "bar".
+#
 # If +nil+ is passed for the first argument, the command line
 # will be built only from the options hash.
 #
@@ -73,47 +77,81 @@ class Object
     when :engine
       case RUBY_NAME
       when 'rbx'
-        "bin/rbx"
+        if SpecGuard.ruby_version < "1.9"
+          "bin/rbx"
+        else
+          "bin/rbx -X19"
+        end
       when 'jruby'
         "bin/jruby"
       when 'maglev'
         "maglev-ruby"
+      when 'topaz'
+        "topaz"
       when 'ironruby'
         "ir"
       end
     when :name
-      bin = RUBY_NAME + (Config::CONFIG['EXEEXT'] || Config::CONFIG['exeext'] || '')
+      bin = RUBY_NAME + (RbConfig::CONFIG['EXEEXT'] || RbConfig::CONFIG['exeext'] || '')
       File.join(".", bin)
     when :install_name
-      bin = Config::CONFIG["RUBY_INSTALL_NAME"] || Config::CONFIG["ruby_install_name"]
-      bin << (Config::CONFIG['EXEEXT'] || Config::CONFIG['exeext'] || '')
-      File.join(Config::CONFIG['bindir'], bin)
+      bin = RbConfig::CONFIG["RUBY_INSTALL_NAME"] || RbConfig::CONFIG["ruby_install_name"]
+      bin << (RbConfig::CONFIG['EXEEXT'] || RbConfig::CONFIG['exeext'] || '')
+      File.join(RbConfig::CONFIG['bindir'], bin)
     end
   end
 
   def resolve_ruby_exe
     [:env, :engine, :name, :install_name].each do |option|
       next unless cmd = ruby_exe_options(option)
-      exe = cmd.split.first
+      exe, *rest = cmd.split(" ")
 
       # It has been reported that File.executable is not reliable
       # on Windows platforms (see commit 56bc555c). So, we check the
-      # platform. 
+      # platform.
       if File.exists?(exe) and (PlatformGuard.windows? or File.executable?(exe))
-        return cmd
+        return [File.expand_path(exe), *rest].join(" ")
       end
     end
     nil
   end
 
   def ruby_exe(code, opts = {})
-    body = code
+    env = opts[:env] || {}
     working_dir = opts[:dir] || "."
     Dir.chdir(working_dir) do
-      body = "-e #{code.inspect}" if code and not File.exists?(code)
-      cmd = [RUBY_EXE, ENV['RUBY_FLAGS'], opts[:options], body, opts[:args]]
-      `#{cmd.compact.join(' ')}`
+      saved_env = {}
+      env.each do |key, value|
+        key = key.to_s
+        saved_env[key] = ENV[key] if ENV.key? key
+        ENV[key] = value
+      end
+
+      begin
+        `#{ruby_cmd(code, opts)}`
+      ensure
+        saved_env.each { |key, value| ENV[key] = value }
+        env.keys.each do |key|
+          key = key.to_s
+          ENV.delete key unless saved_env.key? key
+        end
+      end
+    end
+  end
+
+  def ruby_cmd(code, opts = {})
+    body = code
+
+    if code and not File.exists?(code)
+      if opts[:escape]
+        code = "'#{code}'"
+      else
+        code = code.inspect
+      end
+      body = "-e #{code}"
     end
+
+    [RUBY_EXE, ENV['RUBY_FLAGS'], opts[:options], body, opts[:args]].compact.join(' ')
   end
 
   unless Object.const_defined?(:RUBY_EXE) and RUBY_EXE