rhodes-framework 1.0.10 → 1.1.0

data/spec/app/mspec/runner/shared.rb

@@ -0,0 +1,12 @@
+require 'mspec/runner/mspec'
+
+class Object
+  def it_behaves_like(desc, meth, obj=nil)
+    send :before, :all do
+      @method = meth
+      @object = obj if obj
+    end
+
+    send :it_should_behave_like, desc.to_s
+  end
+end

data/spec/app/mspec/runner/tag.rb

@@ -0,0 +1,32 @@
+class SpecTag
+  attr_accessor :tag, :comment, :description
+
+  def initialize(string=nil)
+    parse(string) if string
+  end
+
+  def parse(string)
+    m = /^([^()#:]+)(\(([^)]+)?\))?:(.*)$/.match string
+    @tag, @comment, description = m.values_at(1, 3, 4) if m
+    @description = unescape description
+  end
+
+  def unescape(str)
+    return unless str
+    str = str[1..-2] if str[0] == ?" and str[-1] == ?"
+    str.gsub(/\\n/, "\n")
+  end
+
+  def escape(str)
+    str = %["#{str.gsub(/\n/, '\n')}"] if /\n/ =~ str
+    str
+  end
+
+  def to_s
+    "#{@tag}#{ "(#{@comment})" if @comment }:#{escape @description}"
+  end
+
+  def ==(o)
+    @tag == o.tag and @comment == o.comment and @description == o.description
+  end
+end

data/spec/app/mspec/utils/name_map.rb

@@ -0,0 +1,129 @@
+require 'mspec/helpers/const_lookup'
+
+class NameMap
+  MAP = {
+    '`'   => 'backtick',
+    '+'   => 'plus',
+    '-'   => 'minus',
+    '+@'  => 'uplus',
+    '-@'  => 'uminus',
+    '*'   => 'multiply',
+    '/'   => 'divide',
+    '%'   => 'modulo',
+    '<<'  => {'Bignum' => 'left_shift',
+              'Fixnum' => 'left_shift',
+              'IO'     => 'output',
+              :default => 'append' },
+    '>>'  => 'right_shift',
+    '<'   => 'lt',
+    '<='  => 'lte',
+    '>'   => 'gt',
+    '>='  => 'gte',
+    '='   => 'assignment',
+    '=='  => 'equal_value',
+    '===' => 'case_compare',
+    '<=>' => 'comparison',
+    '[]'  => 'element_reference',
+    '[]=' => 'element_set',
+    '**'  => 'exponent',
+    '!'   => 'not',
+    '~'   => {'Bignum' => 'complement',
+              'Fixnum' => 'complement',
+              'Regexp' => 'match',
+              'String' => 'match' },
+    '!='  => 'not_equal',
+    '!~'  => 'not_match',
+    '=~'  => 'match',
+    '&'   => {'Bignum'     => 'bit_and',
+              'Fixnum'     => 'bit_and',
+              'Array'      => 'intersection',
+              'TrueClass'  => 'and',
+              'FalseClass' => 'and',
+              'NilClass'   => 'and',
+              'Set'        => 'intersection' },
+    '|'   => {'Bignum'     => 'bit_or',
+              'Fixnum'     => 'bit_or',
+              'Array'      => 'union',
+              'TrueClass'  => 'or',
+              'FalseClass' => 'or',
+              'NilClass'   => 'or',
+              'Set'        => 'union' },
+    '^'   => {'Bignum'     => 'bit_xor',
+              'Fixnum'     => 'bit_xor',
+              'TrueClass'  => 'xor',
+              'FalseClass' => 'xor',
+              'NilClass'   => 'xor',
+              'Set'        => 'exclusion'},
+  }
+
+  EXCLUDED = %w[
+    MSpecScript
+    MkSpec
+    DTracer
+    NameMap
+    OptionParser
+    YAML
+  ]
+
+  def initialize(filter=false)
+    @seen = {}
+    @filter = filter
+  end
+
+  def exception?(name)
+    return false unless c = class_or_module(name)
+    c == Errno or c.ancestors.include? Exception
+  end
+
+  def class_or_module(c)
+    const = const_lookup(c)
+    filtered = @filter && EXCLUDED.include?(const.name)
+    return const if Module === const and not filtered
+  rescue NameError
+  end
+
+  def namespace(mod, const)
+    return const.to_s if mod.nil? or %w[Object Class Module].include? mod
+    "#{mod}::#{const}"
+  end
+
+  def map(hash, constants, mod=nil)
+    @seen = {} unless mod
+
+    constants.each do |const|
+      name = namespace mod, const
+      m = class_or_module name
+      next unless m and not @seen[m]
+      @seen[m] = true
+
+      ms = m.methods false
+      hash["#{name}."] = ms.sort unless ms.empty?
+
+      ms = m.public_instance_methods(false) +
+           m.protected_instance_methods(false)
+      hash["#{name}#"] = ms.sort unless ms.empty?
+
+      map hash, m.constants, name
+    end
+
+    hash
+  end
+
+  def dir_name(c, base)
+    return File.join(base, 'exception') if exception? c
+
+    c.split('::').inject(base) do |dir, name|
+      name.gsub!(/Class/, '') unless name == 'Class'
+      File.join dir, name.downcase
+    end
+  end
+
+  def file_name(m, c)
+    if MAP.key?(m)
+      name = MAP[m].is_a?(Hash) ? MAP[m][c.split('::').last] || MAP[m][:default] : MAP[m]
+    else
+      name = m.gsub(/[?!=]/, '')
+    end
+    "#{name}_spec.rb"
+  end
+end

data/spec/app/mspec/utils/options.rb

@@ -0,0 +1,441 @@
+require 'mspec/version'
+
+class MSpecOption
+  attr_reader :short, :long, :arg, :description, :block
+
+  def initialize(short, long, arg, description, block)
+    @short       = short
+    @long        = long
+    @arg         = arg
+    @description = description
+    @block       = block
+  end
+
+  def arg?
+    @arg != nil
+  end
+
+  def match?(opt)
+    opt == @short or opt == @long
+  end
+end
+
+# MSpecOptions provides a parser for command line options. It also
+# provides a composable set of options from which the runner scripts
+# can select for their particular functionality.
+class MSpecOptions
+  # Raised if incorrect or incomplete formats are passed to #on.
+  class OptionError < Exception; end
+
+  # Raised if an unrecognized option is encountered.
+  class ParseError < Exception; end
+
+  attr_accessor :config, :banner, :width, :options
+
+  def initialize(banner="", width=30, config=nil)
+    @banner   = banner
+    @config   = config
+    @width    = width
+    @options  = []
+    @doc      = []
+    @extra    = []
+    @on_extra = lambda { |x|
+      raise ParseError, "Unrecognized option: #{x}" if x[0] == ?-
+      @extra << x
+    }
+
+    yield self if block_given?
+  end
+
+  # Registers an option. Acceptable formats for arguments are:
+  #
+  #  on "-a", "description"
+  #  on "-a", "--abdc", "description"
+  #  on "-a", "ARG", "description"
+  #  on "--abdc", "ARG", "description"
+  #  on "-a", "--abdc", "ARG", "description"
+  #
+  # If an block is passed, it will be invoked when the option is
+  # matched. Not passing a block is permitted, but nonsensical.
+  def on(*args, &block)
+    raise OptionError, "option and description are required" if args.size < 2
+
+    description = args.pop
+    short, long, argument = nil
+    args.each do |arg|
+      if arg[0] == ?-
+        if arg[1] == ?-
+          long = arg
+        else
+          short = arg
+        end
+      else
+        argument = arg
+      end
+    end
+
+    add short, long, argument, description, block
+  end
+
+  # Adds documentation text for an option and adds an +MSpecOption+
+  # instance to the list of registered options.
+  def add(short, long, arg, description, block)
+    s = short ? short.dup : "  "
+    s << (short ? ", " : "  ") if long
+    doc "   #{s}#{long} #{arg}".ljust(@width-1) + " #{description}"
+    @options << MSpecOption.new(short, long, arg, description, block)
+  end
+
+  # Searches all registered options to find a match for +opt+. Returns
+  # +nil+ if no registered options match.
+  def match?(opt)
+    @options.find { |o| o.match? opt }
+  end
+
+  # Processes an option. Calles the #on_extra block (or default) for
+  # unrecognized options. For registered options, possibly fetches an
+  # argument and invokes the option's block if it is not nil.
+  def process(argv, entry, opt, arg)
+    unless option = match?(opt)
+      @on_extra[entry]
+    else
+      if option.arg?
+        arg = argv.shift if arg.nil?
+        raise ParseError, "No argument provided for #{opt}" unless arg
+      end
+      option.block[arg] if option.block
+    end
+    option
+  end
+
+  # Splits a string at +n+ characters into the +opt+ and the +rest+.
+  # The +arg+ is set to +nil+ if +rest+ is an empty string.
+  def split(str, n)
+    opt  = str[0, n]
+    rest = str[n, str.size]
+    arg  = rest == "" ? nil : rest
+    return opt, arg, rest
+  end
+
+  # Parses an array of command line entries, calling blocks for
+  # registered options.
+  def parse(argv=ARGV)
+    argv = Array(argv).dup
+
+    while entry = argv.shift
+      # collect everything that is not an option
+      if entry[0] != ?- or entry.size < 2
+        @on_extra[entry]
+        next
+      end
+
+      # this is a long option
+      if entry[1] == ?-
+        opt, arg = entry.split "="
+        process argv, entry, opt, arg
+        next
+      end
+
+      # disambiguate short option group from short option with argument
+      opt, arg, rest = split entry, 2
+
+      # process first option
+      option = process argv, entry, opt, arg
+      next unless option and not option.arg?
+
+      # process the rest of the options
+      while rest.size > 0
+        opt, arg, rest = split rest, 1
+        opt = "-" + opt
+        option = process argv, opt, opt, arg
+        break if option.arg?
+      end
+    end
+
+    @extra
+  rescue ParseError => e
+    puts self
+    puts e
+    exit 1
+  end
+
+  # Adds a string of documentation text inline in the text generated
+  # from the options. See #on and #add.
+  def doc(str)
+    @doc << str
+  end
+
+  # Convenience method for providing -v, --version options.
+  def version(version, &block)
+    show = block || lambda { puts "#{File.basename $0} #{version}"; exit }
+    on "-v", "--version", "Show version", &show
+  end
+
+  # Convenience method for providing -h, --help options.
+  def help(&block)
+    help = block || lambda { puts self; exit 1 }
+    on "-h", "--help", "Show this message", &help
+  end
+
+  # Stores a block that will be called with unrecognized options
+  def on_extra(&block)
+    @on_extra = block
+  end
+
+  # Returns a string representation of the options and doc strings.
+  def to_s
+    @banner + "\n\n" + @doc.join("\n") + "\n"
+  end
+
+  # The methods below provide groups of options that
+  # are composed by the particular runners to provide
+  # their functionality
+
+  def configure(&block)
+    on("-B", "--config", "FILE",
+       "Load FILE containing configuration options", &block)
+  end
+
+  def name
+    on("-n", "--name", "RUBY_NAME",
+       "Set the value of RUBY_NAME (used to determine the implementation)") do |n|
+      Object.const_set :RUBY_NAME, n
+    end
+  end
+
+  def targets
+    on("-t", "--target", "TARGET",
+       "Implementation to run the specs, where:") do |t|
+      case t
+      when 'r', 'ruby'
+        config[:target] = 'ruby'
+      when 'r19', 'ruby19'
+        config[:target] = 'ruby1.9'
+      when 'x', 'rubinius'
+        config[:target] = './bin/rbx'
+      when 'X', 'rbx'
+        config[:target] = 'rbx'
+      when 'j', 'jruby'
+        config[:target] = 'jruby'
+      when 'i','ironruby'
+        config[:target] = 'ir'
+      else
+        config[:target] = t
+      end
+    end
+
+    doc ""
+    doc "     r or ruby              invokes ruby in PATH"
+    doc "     r19, ruby19 or ruby1.9 invokes ruby1.9 in PATH"
+    doc "     x or rubinius          invokes ./bin/rbx"
+    doc "     X or rbx               invokes rbx in PATH"
+    doc "     j or jruby             invokes jruby in PATH"
+    doc "     i or ironruby          invokes ir in PATH\n"
+
+    on("-T", "--target-opt", "OPT",
+       "Pass OPT as a flag to the target implementation") do |t|
+      config[:flags] << t
+    end
+    on("-I", "--include", "DIR",
+       "Pass DIR through as the -I option to the target") do |d|
+      config[:includes] << "-I#{d}"
+    end
+    on("-r", "--require", "LIBRARY",
+       "Pass LIBRARY through as the -r option to the target") do |f|
+      config[:requires] << "-r#{f}"
+    end
+  end
+
+  def formatters
+    on("-f", "--format", "FORMAT",
+       "Formatter for reporting, where FORMAT is one of:") do |o|
+      case o
+      when 's', 'spec', 'specdoc'
+        config[:formatter] = SpecdocFormatter
+      when 'h', 'html'
+        config[:formatter] = HtmlFormatter
+      when 'd', 'dot', 'dotted'
+        config[:formatter] = DottedFormatter
+      when 'b', 'describe'
+        config[:formatter] = DescribeFormatter
+      when 'f', 'file'
+        config[:formatter] = FileFormatter
+      when 'u', 'unit', 'unitdiff'
+        config[:formatter] = UnitdiffFormatter
+      when 'm', 'summary'
+        config[:formatter] = SummaryFormatter
+      when 'a', '*', 'spin'
+        config[:formatter] = SpinnerFormatter
+      when 't', 'method'
+        config[:formatter] = MethodFormatter
+      when 'y', 'yaml'
+        config[:formatter] = YamlFormatter
+      else
+        puts "Unknown format: #{o}"
+        puts @parser
+        exit
+      end
+    end
+
+    doc ""
+    doc "       s, spec, specdoc         SpecdocFormatter"
+    doc "       h, html,                 HtmlFormatter"
+    doc "       d, dot, dotted           DottedFormatter"
+    doc "       f, file                  FileFormatter"
+    doc "       u, unit, unitdiff        UnitdiffFormatter"
+    doc "       m, summary               SummaryFormatter"
+    doc "       a, *, spin               SpinnerFormatter"
+    doc "       t, method                MethodFormatter"
+    doc "       y, yaml                  YamlFormatter\n"
+
+    on("-o", "--output", "FILE",
+       "Write formatter output to FILE") do |f|
+      config[:output] = f
+    end
+  end
+
+  def filters
+    on("-e", "--example", "STR",
+       "Run examples with descriptions matching STR") do |o|
+      config[:includes] << o
+    end
+    on("-E", "--exclude", "STR",
+       "Exclude examples with descriptions matching STR") do |o|
+      config[:excludes] << o
+    end
+    on("-p", "--pattern", "PATTERN",
+       "Run examples with descriptions matching PATTERN") do |o|
+      config[:patterns] << Regexp.new(o)
+    end
+    on("-P", "--excl-pattern", "PATTERN",
+       "Exclude examples with descriptions matching PATTERN") do |o|
+      config[:xpatterns] << Regexp.new(o)
+    end
+    on("-g", "--tag", "TAG",
+       "Run examples with descriptions matching ones tagged with TAG") do |o|
+      config[:tags] << o
+    end
+    on("-G", "--excl-tag", "TAG",
+       "Exclude examples with descriptions matching ones tagged with TAG") do |o|
+      config[:xtags] << o
+    end
+    on("-w", "--profile", "FILE",
+       "Run examples for methods listed in the profile FILE") do |f|
+      config[:profiles] << f
+    end
+    on("-W", "--excl-profile", "FILE",
+       "Exclude examples for methods listed in the profile FILE") do |f|
+      config[:xprofiles] << f
+    end
+  end
+
+  def chdir
+    on("-C", "--chdir", "DIR",
+       "Change the working directory to DIR before running specs") do |d|
+      Dir.chdir d
+    end
+  end
+
+  def prefix
+    on("--prefix", "STR", "Prepend STR when resolving spec file names") do |p|
+      config[:prefix] = p
+    end
+  end
+
+  def pretend
+    on("-Z", "--dry-run",
+       "Invoke formatters and other actions, but don't execute the specs") do
+      MSpec.register_mode :pretend
+    end
+  end
+
+  def background
+    on("--background",
+       "Enable guard for specs that may hang in background processes") do
+      MSpec.register_mode :background
+    end
+  end
+
+  def unguarded
+    on("--unguarded", "Turn off all guards") do
+      MSpec.register_mode :unguarded
+    end
+    on("--no-ruby_bug", "Turn off the ruby_bug guard") do
+      MSpec.register_mode :no_ruby_bug
+    end
+  end
+
+  def randomize
+    on("-H", "--random",
+       "Randomize the list of spec files") do
+      MSpec.randomize
+    end
+  end
+
+  def verbose
+    on("-V", "--verbose", "Output the name of each file processed") do
+      obj = Object.new
+      def obj.start
+        @width = MSpec.retrieve(:files).inject(0) { |max, f| f.size > max ? f.size : max }
+      end
+      def obj.load
+        file = MSpec.retrieve :file
+        print "\n#{file.ljust(@width)}"
+      end
+      MSpec.register :start, obj
+      MSpec.register :load, obj
+    end
+
+    on("-m", "--marker", "MARKER",
+       "Output MARKER for each file processed") do |o|
+      obj = Object.new
+      obj.instance_variable_set :@marker, o
+      def obj.load
+        print @marker
+      end
+      MSpec.register :load, obj
+    end
+  end
+
+  def interrupt
+    on("--int-spec", "Control-C interupts the current spec only") do
+      config[:abort] = false
+    end
+  end
+
+  def verify
+    on("--report-on", "GUARD", "Report specs guarded by GUARD") do |g|
+      MSpec.register_mode :report_on
+      SpecGuard.guards << g.to_sym
+    end
+    on("-O", "--report", "Report guarded specs") do
+      MSpec.register_mode :report
+    end
+    on("-Y", "--verify",
+       "Verify that guarded specs pass and fail as expected") do
+      MSpec.register_mode :verify
+    end
+  end
+
+  def action_filters
+    on("-K", "--action-tag", "TAG",
+       "Spec descriptions marked with TAG will trigger the specified action") do |o|
+      config[:atags] << o
+    end
+    on("-S", "--action-string", "STR",
+       "Spec descriptions matching STR will trigger the specified action") do |o|
+      config[:astrings] << o
+    end
+  end
+
+  def actions
+    on("--spec-debug",
+       "Invoke the debugger when a spec description matches (see -K, -S)") do
+      config[:debugger] = true
+    end
+    on("--spec-gdb",
+       "Invoke Gdb when a spec description matches (see -K, -S)") do
+      config[:gdb] = true
+    end
+  end
+end