rhodes 2.0.3 → 2.1.0

data/spec/framework_spec/app/mspec/runner/formatters/yaml.rb

@@ -1,44 +0,0 @@
-require 'mspec/expectations/expectations'
-require 'mspec/runner/formatters/dotted'
-
-class YamlFormatter < DottedFormatter
-  def initialize(out=nil)
-    @exception = @failure = false
-    @exceptions = []
-    @count = 0
-    @out = $stdout
-
-    if out.nil?
-      @finish = $stdout
-    else
-      @finish = File.open out, "w"
-    end
-  end
-
-  def switch
-    @out = @finish
-  end
-
-  def after(state)
-  end
-
-  def finish
-    switch
-
-    print "---\n"
-    print "exceptions:\n"
-    @exceptions.each do |exc|
-      outcome = exc.failure? ? "FAILED" : "ERROR"
-      str =  "#{exc.description} #{outcome}\n"
-      str << exc.message << "\n" << exc.backtrace
-      print "- ", str.inspect, "\n"
-    end
-
-    print "time: ",         @timer.elapsed,              "\n"
-    print "files: ",        @tally.counter.files,        "\n"
-    print "examples: ",     @tally.counter.examples,     "\n"
-    print "expectations: ", @tally.counter.expectations, "\n"
-    print "failures: ",     @tally.counter.failures,     "\n"
-    print "errors: ",       @tally.counter.errors,       "\n"
-  end
-end

data/spec/framework_spec/app/mspec/runner/formatters.rb

@@ -1,10 +0,0 @@
-require 'mspec/runner/formatters/describe'
-require 'mspec/runner/formatters/dotted'
-require 'mspec/runner/formatters/file'
-require 'mspec/runner/formatters/specdoc'
-require 'mspec/runner/formatters/html'
-require 'mspec/runner/formatters/summary'
-require 'mspec/runner/formatters/unit'
-require 'mspec/runner/formatters/spinner'
-require 'mspec/runner/formatters/method'
-require 'mspec/runner/formatters/yaml'

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

@@ -1,361 +0,0 @@
-require 'mspec/runner/context'
-require 'mspec/runner/exception'
-require 'mspec/runner/tag'
-require 'mspec/fileutils'
-require 'mspec/pp'
-
-module MSpec
-  @count = 0
-  @exc_count = 0
-
-  @exit    = nil
-  @start   = nil
-  @enter   = nil
-  @before  = nil
-  @after   = nil
-  @leave   = nil
-  @finish  = nil
-  @exclude = nil
-  @include = nil
-  @leave   = nil
-  @load    = nil
-  @unload  = nil
-  @current = nil
-  @modes   = []
-  @shared  = {}
-  @guarded = []
-  @exception    = nil
-  @randomize    = nil
-  @expectation  = nil
-  @expectations = false
-  @backtrace = false
-  @file_count = 0
-  
-  def self.exc_count
-    @exc_count
-  end
-  
-  def self.count
-    @count
-  end
-  
-  def self.file_count
-    @file_count
-  end
-  
-  def self.backtrace=(backtrace)
-    @backtrace = backtrace
-  end
-
-  def self.describe(mod, options=nil, &block)
-    state = ContextState.new mod, options
-    state.parent = current
-
-    MSpec.register_current state
-    state.describe(&block)
-    @count+=state.examples.length
-    state.process unless state.shared? or current
-  end
-
-  def self.process
-    actions :start
-    files
-    actions :finish
-  end
-  
-  def self.files
-    return unless files = retrieve(:files)
-
-    shuffle files if randomize?
-    files.each do |file|
-      @env = Object.new
-      @env.extend MSpec
-
-      store :file, file
-      actions :load
-      protect("loading #{file}") { Kernel.load file }
-      actions :unload
-    end
-  end
-
-  def self.actions(action, *args)
-    actions = retrieve(action)
-    actions.each { |obj| obj.send action, *args } if actions
-  end
-
-  def self.protect(location, &block)
-    begin
-      @env.instance_eval(&block)
-      return true
-    rescue SystemExit
-      raise
-    rescue Exception => exc
-      puts "FAIL: #{current} - #{exc.message}\n" + (@backtrace ? exc.backtrace.join("\n") : "")
-      @exc_count+=1
-      register_exit 1
-      actions :exception, ExceptionState.new(current && current.state, location, exc)
-      return false
-    end
-  end
-
-  # Guards can be nested, so a stack is necessary to know when we have
-  # exited the toplevel guard.
-  def self.guard
-    @guarded << true
-  end
-
-  def self.unguard
-    @guarded.pop
-  end
-
-  def self.guarded?
-    not @guarded.empty?
-  end
-
-  # Sets the toplevel ContextState to +state+.
-  def self.register_current(state)
-    store :current, state
-  end
-
-  # Sets the toplevel ContextState to +nil+.
-  def self.clear_current
-    store :current, nil
-  end
-
-  # Returns the toplevel ContextState.
-  def self.current
-    retrieve :current
-  end
-
-  # Stores the shared ContextState keyed by description.
-  def self.register_shared(state)
-    @shared[state.to_s] = state
-  end
-
-  # Returns the shared ContextState matching description.
-  def self.retrieve_shared(desc)
-    @shared[desc.to_s]
-  end
-
-  # Stores the exit code used by the runner scripts.
-  def self.register_exit(code)
-    store :exit, code
-  end
-
-  # Retrieves the stored exit code.
-  def self.exit_code
-    retrieve(:exit).to_i
-  end
-
-  # Stores the list of files to be evaluated.
-  def self.register_files(files)
-    @file_count = files.length if files
-    store :files, files
-  end
-
-  # Stores one or more substitution patterns for transforming
-  # a spec filename into a tags filename, where each pattern
-  # has the form:
-  #
-  #   [Regexp, String]
-  #
-  # See also +tags_file+.
-  def self.register_tags_patterns(patterns)
-    store :tags_patterns, patterns
-  end
-
-  # Registers an operating mode. Modes recognized by MSpec:
-  #
-  #   :pretend - actions execute but specs are not run
-  #   :verify - specs are run despite guards and the result is
-  #             verified to match the expectation of the guard
-  #   :report - specs that are guarded are reported
-  #   :unguarded - all guards are forced off
-  def self.register_mode(mode)
-    modes = retrieve :modes
-    modes << mode unless modes.include? mode
-  end
-
-  # Clears all registered modes.
-  def self.clear_modes
-    store :modes, []
-  end
-
-  # Returns +true+ if +mode+ is registered.
-  def self.mode?(mode)
-    retrieve(:modes).include? mode
-  end
-
-  def self.retrieve(symbol)
-    instance_variable_get :"@#{symbol}"
-  end
-
-  def self.store(symbol, value)
-    instance_variable_set :"@#{symbol}", value
-  end
-
-  # This method is used for registering actions that are
-  # run at particular points in the spec cycle:
-  #   :start        before any specs are run
-  #   :load         before a spec file is loaded
-  #   :enter        before a describe block is run
-  #   :before       before a single spec is run
-  #   :add          while a describe block is adding examples to run later
-  #   :expectation  before a 'should', 'should_receive', etc.
-  #   :example      after an example block is run, passed the block
-  #   :exception    after an exception is rescued
-  #   :after        after a single spec is run
-  #   :leave        after a describe block is run
-  #   :unload       after a spec file is run
-  #   :finish       after all specs are run
-  #
-  # Objects registered as actions above should respond to
-  # a method of the same name. For example, if an object
-  # is registered as a :start action, it should respond to
-  # a #start method call.
-  #
-  # Additionally, there are two "action" lists for
-  # filtering specs:
-  #   :include  return true if the spec should be run
-  #   :exclude  return true if the spec should NOT be run
-  #
-  def self.register(symbol, action)
-    unless value = retrieve(symbol)
-      value = store symbol, []
-    end
-    value << action unless value.include? action
-  end
-
-  def self.unregister(symbol, action)
-    if value = retrieve(symbol)
-      value.delete action
-    end
-  end
-
-  def self.randomize(flag=true)
-    @randomize = flag
-  end
-
-  def self.randomize?
-    @randomize == true
-  end
-
-  def self.shuffle(ary)
-    return if ary.empty?
-
-    size = ary.size
-    size.times do |i|
-      r = rand(size - i - 1)
-      ary[i], ary[r] = ary[r], ary[i]
-    end
-  end
-
-  # Records that an expectation has been encountered in an example.
-  def self.expectation
-    store :expectations, true
-  end
-
-  # Returns true if an expectation has been encountered
-  def self.expectation?
-    retrieve :expectations
-  end
-
-  # Resets the flag that an expectation has been encountered in an example.
-  def self.clear_expectations
-    store :expectations, false
-  end
-
-  # Transforms a spec filename into a tags filename by applying each
-  # substitution pattern in :tags_pattern. The default patterns are:
-  #
-  #   [%r(/spec/), '/spec/tags/'], [/_spec.rb$/, '_tags.txt']
-  #
-  # which will perform the following transformation:
-  #
-  #   path/to/spec/class/method_spec.rb => path/to/spec/tags/class/method_tags.txt
-  #
-  # See also +register_tags_patterns+.
-  def self.tags_file
-    patterns = retrieve(:tags_patterns) ||
-               [[%r(spec/), 'spec/tags/'], [/_spec.rb$/, '_tags.txt']]
-    patterns.inject(retrieve(:file).dup) do |file, pattern|
-      file.gsub(*pattern)
-    end
-  end
-
-  # Returns a list of tags matching any tag string in +keys+ based
-  # on the return value of <tt>keys.include?("tag_name")</tt>
-  def self.read_tags(keys)
-    tags = []
-    file = tags_file
-    if File.exist? file
-      File.open(file, "r") do |f|
-        unless File.directory?(f)
-          f.each_line do |line|
-            line.chomp!
-            next if line.empty?
-            tag = SpecTag.new line.chomp
-            tags << tag if keys.include? tag.tag
-          end
-        end
-      end
-    end
-    tags
-  end
-
-  # Writes each tag in +tags+ to the tag file. Overwrites the
-  # tag file if it exists.
-  def self.write_tags(tags)
-    file = tags_file
-    path = File.dirname file
-    FileUtils.mkdir_p path unless File.exist? path
-    File.open(file, "w") do |f|
-      tags.each { |t| f.puts t }
-    end
-  end
-
-  # Writes +tag+ to the tag file if it does not already exist.
-  # Returns +true+ if the tag is written, +false+ otherwise.
-  def self.write_tag(tag)
-    string = tag.to_s
-    file = tags_file
-    path = File.dirname file
-    FileUtils.mkdir_p path unless File.exist? path
-    if File.exist? file
-      File.open(file, "r") do |f|
-        f.each_line { |line| return false if line.chomp == string }
-      end
-    end
-    File.open(file, "a") { |f| f.puts string }
-    return true
-  end
-
-  # Deletes +tag+ from the tag file if it exists. Returns +true+
-  # if the tag is deleted, +false+ otherwise. Deletes the tag
-  # file if it is empty.
-  def self.delete_tag(tag)
-    deleted = false
-    pattern = /#{tag.tag}.*#{Regexp.escape(tag.escape(tag.description))}/
-    file = tags_file
-    if File.exist? file
-      lines = IO.readlines(file)
-      File.open(file, "w") do |f|
-        lines.each do |line|
-          unless pattern =~ line.chomp
-            f.puts line unless line.empty?
-          else
-            deleted = true
-          end
-        end
-      end
-      File.delete file unless File.size? file
-    end
-    return deleted
-  end
-
-  # Removes the tag file associated with a spec file.
-  def self.delete_tags
-    file = tags_file
-    File.delete file if File.exists? file
-  end
-end

data/spec/framework_spec/app/mspec/runner/object.rb

@@ -1,24 +0,0 @@
-class Object
-  def before(at=:each, &block)
-    MSpec.current.before at, &block
-  end
-
-  def after(at=:each, &block)
-    MSpec.current.after at, &block
-  end
-
-  def describe(mod, msg=nil, options=nil, &block)
-    MSpec.describe mod, msg, &block
-  end
-
-  def it(msg, &block)
-    MSpec.current.it msg, &block
-  end
-
-  def it_should_behave_like(desc)
-    MSpec.current.it_should_behave_like desc
-  end
-
-  alias_method :context, :describe
-  alias_method :specify, :it
-end

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

@@ -1,12 +0,0 @@
-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/framework_spec/app/mspec/runner/tag.rb

@@ -1,32 +0,0 @@
-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/framework_spec/app/mspec/runner.rb

@@ -1,15 +0,0 @@
-require 'mspec/mocks'
-require 'mspec/runner/mspec'
-require 'mspec/runner/context'
-require 'mspec/runner/example'
-require 'mspec/runner/object'
-require 'mspec/runner/formatters'
-require 'mspec/runner/actions'
-require 'mspec/runner/filters'
-require 'mspec/runner/shared'
-require 'mspec/runner/tag'
-
-def $stderr.write(str)
-  # The 'useless use of' warnings are a crime against OO.
-  str =~ /useless use of/ ? nil : super
-end

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

@@ -1,129 +0,0 @@
-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