rhodes-framework 1.0.10 → 1.1.0

data/spec/app/mspec/guards/superuser.rb

@@ -0,0 +1,17 @@
+require 'mspec/guards/guard'
+
+class SuperUserGuard < SpecGuard
+  def match?
+    Process.euid == 0
+  end
+end
+
+class Object
+  def as_superuser
+    g = SuperUserGuard.new
+    g.name = :as_superuser
+    yield if g.yield?
+  ensure
+    g.unregister
+  end
+end

data/spec/app/mspec/guards/support.rb

@@ -0,0 +1,20 @@
+require 'mspec/guards/guard'
+
+class SupportedGuard < SpecGuard
+  def match?
+    if @args.include? :ruby
+      raise Exception, "improper use of not_supported_on guard"
+    end
+    standard? or !implementation?(*@args)
+  end
+end
+
+class Object
+  def not_supported_on(*args)
+    g = SupportedGuard.new(*args)
+    g.name = :not_supported_on
+    yield if g.yield?
+  ensure
+    g.unregister
+  end
+end

data/spec/app/mspec/guards/tty.rb

@@ -0,0 +1,20 @@
+require 'mspec/guards/guard'
+
+# If a spec depends on STDOUT being a tty, use this guard. For specs that may
+# block if run as a background process, see BackgroundGuard.
+
+class TTYGuard < SpecGuard
+  def match?
+    STDOUT.tty?
+  end
+end
+
+class Object
+  def with_tty
+    g = TTYGuard.new
+    g.name = :with_tty
+    yield if g.yield?
+  ensure
+    g.unregister
+  end
+end

data/spec/app/mspec/guards/version.rb

@@ -0,0 +1,38 @@
+require 'mspec/utils/version'
+require 'mspec/guards/guard'
+
+class VersionGuard < SpecGuard
+  def initialize(version)
+    case version
+    when String
+      @version = SpecVersion.new version
+    when Range
+      a = SpecVersion.new version.first
+      b = SpecVersion.new version.last
+      @version = version.exclude_end? ? a...b : a..b
+    end
+    self.parameters = [version]
+  end
+
+  def ruby_version
+    @ruby_version ||= SpecVersion.new self.class.ruby_version(:full)
+  end
+
+  def match?
+    if Range === @version
+      @version.include? ruby_version
+    else
+      ruby_version >= @version
+    end
+  end
+end
+
+class Object
+  def ruby_version_is(*args)
+    g = VersionGuard.new(*args)
+    g.name = :ruby_version_is
+    yield if g.yield?
+  ensure
+    g.unregister
+  end
+end

data/spec/app/mspec/helpers.rb

@@ -0,0 +1,11 @@
+require 'mspec/helpers/argv'
+require 'mspec/helpers/bignum'
+require 'mspec/helpers/const_lookup'
+require 'mspec/helpers/environment'
+require 'mspec/helpers/fixture'
+require 'mspec/helpers/flunk'
+require 'mspec/helpers/io'
+require 'mspec/helpers/language_version'
+require 'mspec/helpers/ruby_exe'
+require 'mspec/helpers/scratch'
+require 'mspec/helpers/tmp'

data/spec/app/mspec/helpers/argv.rb

@@ -0,0 +1,43 @@
+class Object
+  # Convenience helper for altering ARGV. Saves the
+  # value of ARGV and sets it to +args+. If a block
+  # is given, yields to the block and then restores
+  # the value of ARGV. The previously saved value of
+  # ARGV can be restored by passing +:restore+. The
+  # former is useful in a single spec. The latter is
+  # useful in before/after actions. For example:
+  #
+  #   describe "This" do
+  #     before do
+  #       argv ['a', 'b']
+  #     end
+  #
+  #     after do
+  #       argv :restore
+  #     end
+  #
+  #     it "does something" do
+  #       # do something
+  #     end
+  #   end
+  #
+  #   describe "That" do
+  #     it "does something" do
+  #       argv ['a', 'b'] do
+  #         # do something
+  #       end
+  #     end
+  #   end
+  def argv(args)
+    if args == :restore
+      ARGV.replace(@__mspec_saved_argv__ || [])
+    else
+      @__mspec_saved_argv__ = ARGV
+      ARGV.replace args
+      if block_given?
+        yield
+        argv :restore
+      end
+    end
+  end
+end

data/spec/app/mspec/helpers/bignum.rb

@@ -0,0 +1,5 @@
+class Object
+  def bignum_value(plus=0)
+    0x8000_0000_0000_0000 + plus
+  end
+end

data/spec/app/mspec/helpers/const_lookup.rb

@@ -0,0 +1,9 @@
+module Kernel
+  def const_lookup(c)
+    names = c.split '::'
+    names.shift if names.first.empty?
+    names.inject(Object) do |m, n|
+      m.const_defined?(n) ? m.const_get(n) : m.const_missing(n)
+    end
+  end
+end

data/spec/app/mspec/helpers/environment.rb

@@ -0,0 +1,23 @@
+require 'mspec/guards/guard'
+
+class Object
+  def env
+    env = ""
+    if SpecGuard.windows?
+      env = Hash[*`cmd.exe /C set`.split("\n").map { |e| e.split("=", 2) }.flatten]
+    else
+      env = Hash[*`env`.split("\n").map { |e| e.split("=", 2) }.flatten]
+    end
+    env
+  end
+
+  def username
+    user = ""
+    if SpecGuard.windows?
+      user = `cmd.exe /C ECHO %USERNAME%`.strip
+    else
+      user = `whoami`.strip
+    end
+    user
+  end
+end

data/spec/app/mspec/helpers/fixture.rb

@@ -0,0 +1,20 @@
+class Object
+  # Returns the name of a fixture file by adjoining the directory
+  # of the +dir+ argument with "fixtures" and the contents of the
+  # +args+ array. For example,
+  #
+  #   +dir+ == "some/path"
+  #
+  # and
+  #
+  #   +args+ == ["dir", "file.txt"]
+  #
+  # then the result is the expanded path of
+  #
+  #   "some/fixtures/dir/file.txt".
+  def fixture(dir, *args)
+    path = File.dirname(dir)
+    path = path[0..-7] if path[-7..-1] == "/shared"
+    File.expand_path(File.join(path, "fixtures", args))
+  end
+end

data/spec/app/mspec/helpers/flunk.rb

@@ -0,0 +1,5 @@
+class Object
+  def flunk(msg="This example is a failure")
+    Expectation.fail_with "Failed:", msg
+  end
+end

data/spec/app/mspec/helpers/io.rb

@@ -0,0 +1,17 @@
+class IOStub < String
+  def write(*str)
+    self << str.to_s
+  end
+
+  def print(*str)
+    write(str.to_s + $\.to_s)
+  end
+
+  def puts(*str)
+    write(str.collect { |s| s.to_s.chomp }.concat([nil]).join("\n"))
+  end
+
+  def flush
+    self
+  end
+end

data/spec/app/mspec/helpers/language_version.rb

@@ -0,0 +1,20 @@
+require 'mspec/guards/guard'
+
+class Object
+  # Helper for syntax-sensitive specs. The specs should be placed in a file in
+  # the +versions+ subdirectory. For example, suppose language/method_spec.rb
+  # contains specs whose syntax depends on the Ruby version. In the
+  # language/method_spec.rb use the helper as follows:
+  #
+  #   language_version __FILE__, "method"
+  #
+  # Then add a file "language/versions/method_1.8.rb" for the specs that are
+  # syntax-compatible with Ruby 1.8.x.
+  def language_version(dir, name)
+    path = File.dirname(File.expand_path(dir))
+    name = "#{name}_#{SpecGuard.ruby_version}.rb"
+    file = File.join path, "versions", name
+
+    require file if File.exists? file
+  end
+end

data/spec/app/mspec/helpers/ruby_exe.rb

@@ -0,0 +1,123 @@
+# require 'mspec/utils/ruby_name'
+# require 'mspec/guards/guard'
+# 
+# # The ruby_exe helper provides a wrapper for invoking the
+# # same Ruby interpreter as the one running the specs and
+# # getting the output from running the code. If +code+ is a
+# # file that exists, it will be run. Otherwise, +code+ should
+# # be Ruby code that will be run with the -e command line
+# # option. For example:
+# #
+# #   ruby_exe('path/to/some/file.rb')
+# #
+# # will be executed as
+# #
+# #   `#{RUBY_EXE} #{'path/to/some/file.rb'}`
+# #
+# # while
+# #
+# #   ruby_exe('puts "hello, world."')
+# #
+# # will be executed as
+# #
+# #   `#{RUBY_EXE} -e #{'puts "hello, world."'}`
+# #
+# # The ruby_exe helper also accepts an options hash with two
+# # keys: :options and :args. For example:
+# #
+# #   ruby_exe('file.rb', :options => "-w", :args => "> file.txt")
+# #
+# # will be executed as
+# #
+# #   `#{RUBY_EXE} -w #{'file.rb'} > file.txt`
+# #
+# # If +nil+ is passed for the first argument, the command line
+# # will be built only from the options hash.
+# #
+# # The RUBY_EXE constant can be set explicitly since the value
+# # is used each time ruby_exe is invoked. The mspec runner script
+# # will set ENV['RUBY_EXE'] to the name of the executable used
+# # to invoke the mspec-run script. The value of RUBY_EXE will be
+# # constructed as follows:
+# #
+# #   1. the value of ENV['RUBY_EXE']
+# #   2. an explicit value based on RUBY_NAME
+# #   3. cwd/(RUBY_NAME + $(EXEEXT) || $(exeext) || '')
+# #   4. $(bindir)/$(RUBY_INSTALL_NAME)
+# #
+# # The value will only be used if the file exists and is executable.
+# #
+# # These 4 ways correspond to the following scenarios:
+# #
+# #   1. Using the MSpec runner scripts, the name of the
+# #      executable is explicitly passed by ENV['RUBY_EXE']
+# #      so there is no ambiguity.
+# #
+# #  Otherwise, if using RSpec (or something else)
+# #
+# #   2. Running the specs while developing an alternative
+# #      Ruby implementation. This explicitly names the
+# #      executable in the development directory based on
+# #      the value of RUBY_NAME, which is probably initialized
+# #      from the value of RUBY_ENGINE.
+# #   3. Running the specs within the source directory for
+# #      some implementation. (E.g. a local build directory.)
+# #   4. Running the specs against some installed Ruby
+# #      implementation.
+# 
+# class Object
+#   def ruby_exe_options(option)
+#     case option
+#     when :env
+#       ENV['RUBY_EXE']
+#     when :engine
+#       case RUBY_NAME
+#       when 'rbx'
+#         "bin/rbx"
+#       when 'jruby'
+#         "bin/jruby"
+#       when 'ironruby'
+#         "ir"
+#       end
+#     when :name
+#       bin = RUBY_NAME + (Config::CONFIG['EXEEXT'] || Config::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)
+#     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
+# 
+#       # It has been reported that File.executable is not reliable
+#       # on Windows platforms (see commit 56bc555c). So, we check the
+#       # platform. 
+#       if File.exists?(exe) and (SpecGuard.windows? or File.executable?(exe))
+#         return cmd
+#       end
+#     end
+#     nil
+#   end
+# 
+#   def ruby_exe(code, opts = {})
+#     body = code
+#     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(' ')}`
+#     end
+#   end
+# 
+#   unless Object.const_defined?(:RUBY_EXE) and RUBY_EXE
+#     require 'rbconfig'
+# 
+#     RUBY_EXE = resolve_ruby_exe or
+#       raise Exception, "Unable to find a suitable ruby executable."
+#   end
+# end

data/spec/app/mspec/helpers/scratch.rb

@@ -0,0 +1,17 @@
+module ScratchPad
+  def self.clear
+    @record = nil
+  end
+
+  def self.record(arg)
+    @record = arg
+  end
+
+  def self.<<(arg)
+    @record << arg
+  end
+
+  def self.recorded
+    @record
+  end
+end

data/spec/app/mspec/helpers/tmp.rb

@@ -0,0 +1,32 @@
+# The #tmp method provides a similar functionality
+# to that of Dir.tmpdir. This helper can be overridden
+# by different implementations to provide a more useful
+# behavior if needed.
+#
+# Usage in a spec:
+#
+#   File.open(tmp("tags.txt"), "w") { |f| f.puts "" }
+#
+# The order of directories below with "/private/tmp"
+# preceding "/tmp" is significant. On OS X, the directory
+# "/tmp" is a symlink to "private/tmp" with no leading
+# "/". Rather than futzing with what constitutes an
+# absolute path, we just look for "/private/tmp" first.
+
+class Object
+  def tmp(name)
+    unless @spec_temp_directory
+      [ "/private/tmp", "/tmp", "/var/tmp", ENV["TMPDIR"], ENV["TMP"],
+        ENV["TEMP"], ENV["USERPROFILE"] ].each do |dir|
+        if dir and File.directory?(dir) and File.writable?(dir)
+          temp = File.expand_path dir
+          temp = File.readlink temp if File.symlink? temp
+          @spec_temp_directory = temp
+          break
+        end
+      end
+    end
+
+    File.join @spec_temp_directory, name
+  end
+end