Exspec 1.0.1

data/bin/exspec

@@ -0,0 +1,34 @@
+#!/usr/bin/env ruby
+
+require "exspec"
+
+if ARGV.empty?
+  started = Exspec::Extension.start_exspec
+  Exspec::IrbExspec.start_irb unless started
+else
+  exspec = Exspec::Exspec.new
+
+  spec_arg = ARGV.join " "
+  spec = exspec.spec spec_arg
+
+  reporter = Exspec::REGRESSION_TEST_REPORTER.new
+  if !spec.nil? && spec.exist?
+    exspec.report_to(reporter) { exspec.run_stack spec }
+  else
+    specs = exspec.specs spec_arg, true
+    specs.each do |spec|
+      spec.stack.each do |parent|
+        if parent != spec
+          specs.delete(parent)
+        end
+      end
+    end
+    exspec.report_to(reporter) { exspec.run_specs specs }
+  end
+
+  failed = reporter.failed
+  puts "#{failed.length} of #{reporter.specs.length} specs failed" + (failed.empty? ? "!" : ":")
+  reporter.failed.each do |spec|
+    puts "- #{spec.full_description}"
+  end
+end

data/lib/exspec/context_manager.rb

@@ -0,0 +1,75 @@
+module Exspec
+  class ContextManager
+    def initialize(exspec)
+      @exspec = exspec
+      @global_context = context
+      setup_global_context
+      setup_exspec_context
+      start_new_context
+    end
+
+    attr_reader :exspec, :last_value
+    attr_accessor :last_exspec_value
+
+    def start_new_context
+      context = global_eval "lambda { binding }.call"
+      self.context = context
+      Extension.setup_context self
+      context
+    end
+
+    def context
+      @binding ||= Object.new.instance_eval "binding"
+    end
+
+    def context=(value)
+      @binding = value
+    end
+
+    def last_value=(value)
+      @last_value=value
+      global_eval "_ = exspec.last_value"
+      value
+    end
+
+    def last_exspec_value
+      @last_exspec_value
+    end
+
+    def last_exspec_value=(value)
+      @last_exspec_value = value
+      exspec_eval "_ = exspec.last_exspec_value"
+    end
+
+    def eval(statement)
+      self.last_value = raw_eval statement
+    end
+
+    def raw_eval(statement)
+      context.eval statement
+    end
+
+    def global_eval(statement)
+      @global_context.eval statement
+    end
+
+    def exspec_eval(statement)
+      @exspec_context.eval statement
+    end
+
+    private
+
+    def setup_global_context
+      global_instance = global_eval "self"
+      global_instance.instance_variable_set :@exspec, @exspec
+      global_instance.class.send :attr_reader, :exspec
+      global_eval "_ = nil"
+      Extension.setup_global_context self
+    end
+
+    def setup_exspec_context
+      @exspec_context = global_eval "lambda { |_| binding }.call nil"
+      Extension.setup_exspec_context self
+    end
+  end
+end

data/lib/exspec/execute_callbacks.rb

@@ -0,0 +1,24 @@
+module Exspec
+  class ExecuteCallbacks
+    def initialize
+      @before = []
+      @after = []
+    end
+
+    def before(command=nil, params=nil, &block)
+      if block_given?
+        @before << block
+      else
+        @before.each { |proc| proc.call(command, params) }
+      end
+    end
+
+    def after(command=nil, params=nil, value=nil, &block)
+      if block_given?
+        @after << block
+      else
+        @after.each { |proc| proc.call(command, params, value) }
+      end
+    end
+  end
+end

data/lib/exspec/executor.rb

@@ -0,0 +1,227 @@
+require_relative "execute_callbacks"
+
+module Exspec
+  class Executor
+    def initialize(exspec)
+      @exspec = exspec
+    end
+
+    delegate :puts, :print, :return_spec, :context, :to => :@exspec
+    attr_reader :exspec
+
+    def eval(instruction, &callback_block)
+      callbacks = ExecuteCallbacks.new
+      Extension.set_execute_callbacks callbacks
+      callback_block.call callbacks if block_given?
+      instruction.strip!
+      eval = true
+      val = nil
+      if instruction.start_with? COMMAND_PREFIX
+        parts = instruction.split " "
+        command = parts[0][1..-1]
+        param_string = parts[1..-1].join " "
+        eval = false
+        val = Extension.execute_command self, command, param_string, callbacks
+        if val.nil?
+          val = case command
+                  when ""
+                    execute(command, parameters(param_string), callbacks) do
+                      exspec.exspec_eval param_string
+                    end
+                  when "_"
+                    execute(command, parameters(param_string), callbacks) do
+                      exspec.last_exspec_value
+                    end
+                  when "inspect"
+                    execute(command, callbacks) do
+                      exspec.inspect_last_value
+                    end
+                  when "redo"
+                    execute(command, callbacks) do
+                      exspec.redo
+                    end
+                  when "retry", "rerun", "again"
+                    execute(command, callbacks) do
+                      exspec.retry
+                    end
+                  when "save"
+                    execute(command, parameters(param_string, COMMENT_SIGN), callbacks) do |params|
+                      exspec.save *params
+                    end
+                  when "include", "call", "include_segment", "call_segment"
+                    execute(command, parameters(param_string), callbacks) do |params|
+                      exspec.include *params
+                    end
+                  when "run", "run_spec", "run_segment"
+                    execute(command, parameters(param_string), callbacks) do |params|
+                      exspec.run *params
+                    end
+                  when "run_stack"
+                    execute(command, parameters(param_string), callbacks) do |params|
+                      exspec.run_stack *params
+                    end
+                  when "load"
+                    execute(command, parameters(param_string), callbacks) do |params|
+                      exspec.load *params
+                    end
+                  when "comment", "#"
+                    execute(command, parameters(param_string), callbacks) do |params|
+                      exspec.comment *params
+                    end
+                  when "assert"
+                    execute(command, parameters(param_string, COMMENT_SIGN), callbacks) do |params|
+                      exspec.assert *params
+                    end
+                  when "expect"
+                    execute(command, parameters(param_string, COMMENT_SIGN), callbacks) do |params|
+                      exspec.expect *params
+                    end
+                  when "expect_inspect"
+                    execute(command, parameters(param_string, COMMENT_SIGN), callbacks) do |params|
+                      exspec.expect_inspect *params
+                    end
+                  when "skip"
+                    execute(command, callbacks) do
+                      SkipSignal
+                    end
+                  when "load_current", "reload_current", "discard"
+                    execute(command, callbacks) do
+                      exspec.load exspec.current_spec
+                    end
+                  when "load_parent", "up", "independent"
+                    execute(command, callbacks) do
+                      spec = exspec.current_spec
+                      spec = spec.parent unless spec.nil?
+                      exspec.load spec
+                    end
+                  when "load#"
+                    execute(command, parameters(param_string), callbacks) do |params|
+                      menu_action(params, Spec) { |spec| spec.load }
+                    end
+                  when "run#", "run_spec#", "run_segment#"
+                    execute(command, parameters(param_string), callbacks) do |params|
+                      menu_action(params, Spec) { |spec| spec.run }
+                    end
+                  when "run_stack#"
+                    execute(command, parameters(param_string), callbacks) do |params|
+                      menu_action(params, Spec) { |spec| spec.run_stack }
+                    end
+                  when "include#", "include_segment#", "call#", "call_segment#"
+                    execute(command, parameters(param_string), callbacks) do |params|
+                      menu_action(params, Spec) { |spec| spec.include }
+                    end
+                  when "ignore", "erase", "delete"
+                    execute(command, callbacks) do
+                      exspec.erase_last_instruction
+                      return_spec exspec.logger.last_value
+                    end
+                  when "ignore#", "erase#", "delete#"
+                    execute(command, parameters(param_string), callbacks) do |params|
+                      menu_action(params) do |entry|
+                        exspec.logger.entries.delete entry
+                      end
+                      return_spec exspec.logger.last_value
+                    end
+                  when "reset", "clear"
+                    execute(command, callbacks) do
+                      exspec.reset
+                    end
+                  when "log", "instructions", "history"
+                    execute(command, callbacks) do
+                      menu(exspec.logger.entries) { |entry| entry[:instruction] }
+                    end
+                  when "stack"
+                    execute(command, callbacks) do
+                      menu(exspec.current_spec && exspec.current_spec.stack) do |spec|
+                        spec.name
+                      end
+                    end
+                  when "specs", "tests"
+                    execute(command, parameters(param_string), callbacks) do |params|
+                      menu(exspec.specs *params) { |spec| spec.name }
+                    end
+                  when "specs#", "tests#"
+                    execute(command, parameters(param_string), callbacks) do |params|
+                      menu_action(params, Spec) do |spec|
+                        menu(spec.children) { |spec| spec.name }
+                      end
+                    end
+                  when "no_log", "without_logging", "silent"
+                    val = exspec.without_logging { exspec.execute param_string }
+                    return_spec exspec.logger.last_value
+                    val
+                  when "log_off", "disable_log"
+                    execute(command, callbacks) do
+                      exspec.logger.enabled = false
+                      exspec.last_value
+                    end
+                  when "log_on", "enable_log"
+                    execute(command, callbacks) do
+                      exspec.logger.enabled = true
+                      return_spec exspec.logger.last_value
+                    end
+                  else
+                    eval = true
+                end
+        end
+      end
+      if eval
+        val = execute(callbacks) do
+          exspec.eval instruction
+        end
+      end
+      val
+    end
+
+    private
+
+    def menu(options=nil)
+      return @menu || [] unless options.is_a?(Array)
+      @menu = options
+      puts '====================================='
+      @menu.each.with_index do |option, index|
+        puts "#{index}. #{block_given? ? yield(option) : option}"
+      end
+      puts '====================================='
+      @menu
+    end
+
+    def menu_action(params, type=nil)
+      index = params.is_a?(Array) ? params[0] : nil
+      return nil if index.nil?
+      index = index.to_i
+      element = menu[index]
+      return element unless type.nil? || element.is_a?(type)
+      yield element, index
+    end
+
+    def execute(command=nil, params=nil, callbacks, &execute)
+      val = nil
+      callbacks.before command, params
+      begin
+        val = execute.call params
+      rescue Exception => e
+        val = e
+        raise
+      ensure
+        callbacks.after command, params, val
+      end
+      val
+    end
+
+    def parameters(param_string, *separators)
+      param_string.strip!
+      params = []
+      separators.each do |separator|
+        parts = " #{param_string}".split separator
+        if parts.length > 1
+          param = parts[0].strip
+          params << (param.empty? ? nil : param)
+          param_string = parts[1..-1].join(separator).strip
+        end
+      end
+      params << (param_string.empty? ? nil : param_string)
+      params.reverse.drop_while(&:nil?).reverse
+    end
+  end
+end

data/lib/exspec/extensions/extension.rb

@@ -0,0 +1,70 @@
+module Exspec::Extension
+  @@module = self
+  @@extensions = {}
+
+  def self.loaded
+    apply :loaded
+  end
+
+  def self.config(config)
+    apply :config, nil, false, config
+  end
+
+  def self.start_exspec
+    apply :start_exspec, nil, true
+  end
+
+  def self.set_execute_callbacks(options)
+    apply :set_execute_callbacks, nil, false, options
+  end
+
+  def self.initialize_exspec(exspec, components)
+    apply :initialize_exspec, exspec, false, components
+  end
+
+  def self.execute_command(executor, command, param_string, options)
+    apply :execute_command, executor, true, command, param_string, options
+  end
+
+  def self.setup_context(context_manager)
+    apply :setup_context, context_manager
+  end
+
+  def self.setup_global_context(context_manager)
+    apply :setup_global_context, context_manager
+  end
+
+  def self.setup_exspec_context(context_manager)
+    apply :setup_exspec_context, context_manager
+  end
+
+  def self.apply(extension_point, extended_instance=nil, return_first=false, *args)
+    extensions(extension_point).each do |extension|
+      val = if extended_instance
+              extended_instance.instance_exec *args, &extension
+            else
+              extension.call *args
+            end
+      return val if return_first && !val.nil?
+    end
+    return nil
+  end
+
+  def self.extensions(extension_point)
+    extension_point = extension_point.to_sym
+    extensions = (@@extensions[extension_point] = []) unless extensions = @@extensions[extension_point]
+    extensions
+  end
+
+  def method_missing(method, *args, &block)
+    def_extension method, block
+  end
+
+  def extensions(extension_point)
+    @@module.extensions extension_point
+  end
+
+  def def_extension(extension_point, block)
+    extensions(extension_point.to_sym) << block
+  end
+end

data/lib/exspec/extensions/mocking.rb

@@ -0,0 +1,125 @@
+module Exspec::Mocking
+  extend Exspec::Extension
+
+  execute_command do |command, param_string, options|
+    case command
+      when "mock", "stub"
+        execute(command, parameters(param_string), options) do |params|
+          if params.empty?
+            exspec.commit "#{Exspec::COMMAND_PREFIX}mock", Mock.new
+          else
+            mock_var = params[0]
+            exspec.commit "#{Exspec::COMMAND_PREFIX}mock #{mock_var}"
+            puts "assigning #{command} to #{mock_var}"
+            context.raw_eval "#{mock_var} = #{Mock.name}.new"
+          end
+        end
+    end
+  end
+
+  class Mock < BasicObject
+    def initialize
+      @methods = {}
+      @attributes = {}
+      @children = {}
+      @method_calls = []
+    end
+
+    def new(*args, &block)
+      _log_call :new, args, block
+      _defined?(:new) ? _call(:new, *args, &block) : self
+    end
+
+    def ==(*args, &block)
+      _log_call :==, args, block
+      _defined?(:==) ? _call(:==, *args, &block) : false
+    end
+
+    def inspect(*args, &block)
+      _log_call :inspect, args, block
+      _defined?(:inspect) ? _call(:inspect, *args, &block) : "#<Exspec Mock>"
+    end
+
+    def to_s(*args, &block)
+      _log_call :to_s, args, block
+      _defined?(:to_s) ? _call(:to_s, *args, &block) : "Exspec Mock"
+    end
+
+    def nil?(*args, &block)
+      _log_call :nil?, args, block
+      _defined?(:nil?) ? _call(:nil?, *args, &block) : false
+    end
+
+    def _def(method, &body)
+      @methods[method.to_sym] = body
+    end
+
+    def _defined?(method)
+      @methods.include? method.to_sym
+    end
+
+    def _method_calls(method=nil)
+      if method.nil?
+        @method_calls
+      else
+        @method_calls.select { |call| call[:method] == method.to_sym }
+      end
+    end
+
+    def _have_been_called?(method)
+      @method_calls.any? { |call| call[:method] == method.to_sym }
+    end
+
+    def _times_called(method)
+      @method_calls.count { |call| call[:method] == method.to_sym }
+    end
+
+    def _first_call(method)
+      @method_calls.find { |call| call[:method] == method.to_sym }
+    end
+
+    def _last_call(method)
+      @method_calls.reverse.find { |call| call[:method] == method.to_sym }
+    end
+
+    def _log_call(method, args, block)
+      @method_calls << { :method => method.to_sym, :args => args, :block => block }
+    end
+
+    def _attribute_set?(attribute)
+      @attributes.include? attribute.to_sym
+    end
+
+    def _attribute(attribute)
+      @attributes[attribute.to_sym]
+    end
+
+    def _set_attribute(attribute, value)
+      @attributes[attribute.to_sym] = value
+    end
+
+    def _child(name)
+      name = name.to_sym
+      if @children.include? name
+        @attributes[name]
+      else
+        @attributes[name] = Mock.new
+      end
+    end
+
+    def _call(method, *args, &block)
+      return @methods[method.to_sym].call (args + [block]) if _defined? method
+      if method.to_s.end_with?("=") && !args.empty?
+        return _set_attribute(method.to_s.chop, args[0])
+      elsif _attribute_set?(method)
+        return _attribute(method)
+      end
+      _child(method)
+    end
+
+    def method_missing(method, *args, &block)
+      _log_call method, args, block
+      _call(method, *args, &block)
+    end
+  end
+end

data/lib/exspec/extensions/rails.rb

@@ -0,0 +1,78 @@
+module Exspec::Rails
+  extend Exspec::Extension
+
+  @@rails = self
+  @@app_path = nil
+  @@enabled = true
+
+  def self.enabled=(value)
+    @@enabled = value
+  end
+
+  def self.is_available?
+    return @@enabled && !!app_path
+  end
+
+  def self.app_path
+    return @@app_path if @@app_path
+    parent_dirs do |path|
+      if File.file?(File.expand_path("config/boot.rb", path)) && File.file?(File.expand_path("config/application.rb", path))
+        @@app_path = path
+        return @@app_path
+      end
+    end
+    nil
+  end
+
+  def self.start_console
+    if is_available?
+      begin
+        require_environment
+        ::Rails::Console.start(::Rails.application)
+        return true
+      rescue Exception => e
+        @@enabled = false
+      end
+    end
+    return false
+  end
+
+  def self.require_environment
+    if is_available?
+      begin
+        require "rails"
+        require "rails/commands/console"
+        require File.expand_path("config/boot", app_path)
+        require File.expand_path("config/application", app_path)
+        ::Rails.application.require_environment!
+      rescue Exception => e
+        @@enabled = false
+      end
+    end
+  end
+
+  config do |config|
+    if is_available?
+      config[:test_dir] = File.expand_path(config[:test_dir], app_path)
+    end
+  end
+
+  setup_global_context do
+    @@rails.require_environment
+  end
+
+  setup_context do
+    if @@rails.is_available?
+      begin
+        ::ActionDispatch::Reloader.cleanup!
+        ::ActionDispatch::Reloader.prepare!
+      rescue Exception => e
+        @@enabled = false
+      end
+    end
+  end
+
+  start_irb do
+    start_console
+  end
+end

data/lib/exspec/helpers.rb

@@ -0,0 +1,10 @@
+def parent_dirs
+  root = File.expand_path "/"
+  level = 0
+  begin
+    relative = "../" * level
+    path = File.expand_path relative
+    yield path
+    level += 1
+  end until path == root
+end

data/lib/exspec/irb/irb_context_manager.rb

@@ -0,0 +1,35 @@
+require_relative "../context_manager"
+
+module Exspec
+  class IrbContextManager < ContextManager
+    delegate :irb_workspace, :irb_context, :to => :exspec
+
+    def context
+      irb_workspace.binding
+    end
+
+    def context=(value)
+      irb_workspace.instance_variable_set(:@binding, value)
+    end
+
+    def last_output
+      irb_context.inspect_last_value
+    end
+
+    def last_value
+      irb_context.last_value
+    end
+
+    def last_value=(value)
+      irb_context.set_last_value(value)
+    end
+
+    def define_eval(&eval)
+      @eval = eval
+    end
+
+    def eval(instruction)
+      @eval.call instruction
+    end
+  end
+end