Exspec 1.0.1

data/lib/exspec/irb/irb_exspec.rb

@@ -0,0 +1,40 @@
+require_relative "../../exspec"
+require_relative "irb_context_manager"
+require_relative "irb_patch"
+
+module Exspec
+  class IrbExspec < Exspec
+    def initialize(context, workspace)
+      @irb_context = context
+      @irb_workspace = workspace
+      @irb_context_manager = IrbContextManager.new self
+      super :context_manager => @irb_context_manager
+    end
+
+    attr_reader :irb_context, :irb_workspace
+
+    def irb_execute(line, &eval)
+      @irb_context_manager.define_eval &eval if block_given?
+      execute line
+    end
+
+    def expect_inspect(expect=nil, comment=nil)
+      if expect.nil? && @irb_context.io.is_a?(IRB::ReadlineInputMethod)
+        puts "What inspect value do you expect (only the static content, press up to get the last one):"
+        history = @irb_context.io.history
+        @irb_context.io.history = [inspect_last_value]
+        @irb_context.io.prompt = "fuzzy expectation: "
+        input = @irb_context.io.gets.strip
+        @irb_context.io.history = history
+        expect = input.empty? ? expect : input
+      end
+      super expect, comment
+    end
+
+    def self.start_irb
+      require_relative "irb_patch"
+      started = Extension.apply :start_irb, nil, true
+      IRB.start unless started
+    end
+  end
+end

data/lib/exspec/irb/irb_patch.rb

@@ -0,0 +1,51 @@
+require "irb"
+require_relative "irb_exspec"
+
+require 'io/console'
+
+module IRB
+  class Context
+    alias_method :_initialize, :initialize
+    alias_method :_evaluate, :evaluate
+
+    def initialize(irb, workspace = nil, input_method = nil, output_method = nil)
+      _initialize(irb, workspace, input_method, output_method)
+      @exspec = Exspec::IrbExspec.new self, @workspace
+    end
+
+    def evaluate(line, line_no)
+      @exspec.irb_execute line do |instruction|
+        _evaluate instruction, line_no
+      end
+    end
+
+    def inspect
+      "#<#{self.class.name}>"
+    end
+  end
+
+  class ReadlineInputMethod
+    def history
+      HISTORY.collect.to_a
+    end
+
+    def history=(value)
+      HISTORY.clear
+      HISTORY.push(*value)
+    end
+  end
+end
+
+class RubyLex
+  alias_method :_lex, :lex
+
+  def lex
+    if peek_equal?(Exspec::COMMAND_PREFIX)
+      identify_comment
+      ungetc
+      token
+      return get_readed
+    end
+    _lex
+  end
+end

data/lib/exspec/logger.rb

@@ -0,0 +1,71 @@
+module Exspec
+  class Logger
+    def initialize
+      @log = []
+      @enabled = true
+      @erased_last = false
+    end
+
+    def enabled?
+      @enabled
+    end
+
+    def enabled=(value)
+      @enabled = value
+    end
+
+    def entries
+      @log
+    end
+
+    def instructions
+      @log.map{ |entry| entry[:instruction] }
+    end
+
+    def clear
+      @log.clear
+    end
+
+    def log(instruction, value)
+      if @enabled
+        instruction.gsub! /\n+/, ";\n"
+        @log << {:instruction => instruction.strip, :value => value}
+        @erased_last = false
+      end
+      value
+    end
+
+    def erase_last_instruction
+      erasing = !@erased_last
+      if erasing
+        @log.pop
+        @erased_last = true
+      end
+      erasing
+    end
+
+    def last_instruction
+      return nil if @log.empty?
+      @log.last[:instruction]
+    end
+
+    def last_value
+      return nil if @log.empty?
+      @log.last[:value]
+    end
+
+    def last_entry
+      return nil if @log.empty?
+      @log.last
+    end
+
+    def without_logging
+      enabled = enabled?
+      self.enabled = false
+      val = yield
+    ensure
+      self.enabled = enabled
+      val
+    end
+  end
+end

data/lib/exspec/regression_test_reporter.rb

@@ -0,0 +1,93 @@
+module Exspec
+  class RegressionTestReporter < Reporter
+    SpecFailedError = Class.new(StandardError)
+
+    def initialize
+      @indent = 0
+      @specs = []
+      @failed = []
+      super
+    end
+
+    alias_method :_puts, :puts
+    alias_method :_print, :print
+
+    attr_reader :specs, :failed
+
+    def indent
+      " " * (@indent * 4)
+    end
+
+    def puts(text); end
+    def print(text); end
+
+    def puts_indented(text)
+      _puts "" if !@on_new_line
+      _puts indent + text
+      @on_new_line = true
+      $stdout.flush
+    end
+
+    def print_indented(text)
+      _print indent if @on_new_line
+      _print text
+      @on_new_line = false
+      $stdout.flush
+    end
+
+    def start_stack(spec)
+      puts_indented "Start spec stack #{spec.full_name}"
+      @indent += 1
+    end
+
+    def finish_stack(spec)
+      @indent -= 1
+      puts_indented "Finished spec stack #{spec.full_name}"
+      puts_indented "---------------------------------" if @indent == 0
+    end
+
+    def start_spec(spec)
+      @spec = spec
+      @specs << spec unless @specs.include?(spec)
+      puts_indented "Start test #{spec.full_name}"
+      @indent += 1
+    end
+
+    def finish_spec(spec)
+      @indent -= 1
+      puts_indented "Finished test #{spec.full_name}"
+    end
+
+    def execute_instruction(instruction, index, line)
+      @line = line
+      @instruction = instruction
+      print_indented "."
+    end
+
+    def skip_signal
+      raise SkipSignal
+    end
+
+    def spec_failed(message)
+      failed << @spec unless failed.include?(@spec)
+      puts_indented "==> #{message}"
+      _print "XXXX"
+      puts_indented "(line: #{@line}, instruction: \"#{@instruction}\")"
+      raise SpecFailedError.new message
+    end
+
+    def spec_succeeded(message)
+      puts_indented "==> #{message}"
+    end
+
+    def exception(exception)
+      if exception.is_a?(SpecFailedError)
+        raise exception
+      end
+    end
+
+    def show_comment(text)
+      puts_indented("#" + text)
+    end
+  end
+end

data/lib/exspec/reporter.rb

@@ -0,0 +1,29 @@
+module Exspec
+  class Reporter
+    def start_stack(spec); end
+    def finish_stack(spec); end
+    def start_spec(spec); end
+    def finish_spec(spec); end
+    def execute_instruction(instruction, index, line); end
+    def executed_instruction(instruction, index, line); end
+    def exception(exception); end
+    def skip_signal(breaking); end
+    def show_comment(text); end
+
+    def puts(text)
+      Kernel.puts text
+    end
+
+    def print(text)
+      Kernel.print text
+    end
+
+    def spec_failed(message)
+      puts message
+    end
+
+    def spec_succeeded(message)
+      puts message
+    end
+  end
+end

data/lib/exspec/spec.rb

@@ -0,0 +1,107 @@
+require "active_support/core_ext"
+
+class Spec
+  def self.name(description)
+    name = File.basename(description, File.extname(description))
+    name = name.split(".").last.strip
+    name.gsub(/ +/, "_").underscore
+  end
+
+  def initialize(spec_manager, name, file, parent=nil)
+    @spec_manager = spec_manager
+    @name = name
+    @file = file
+    @parent = parent
+  end
+
+  attr_reader :name, :file
+
+  def full_name
+    ".#{stack.map(&:name).join "."}"
+  end
+
+  def description
+    name.gsub("_", " ").capitalize + "."
+  end
+
+  def full_description
+    stack.map(&:description).join " "
+  end
+
+  def parent
+    @parent || @spec_manager.parent(self)
+  end
+
+  def exist?
+    File.file? file
+  end
+
+  def for_instructions(&block)
+    content = File.read(file)
+    buffer = []
+    index = 0
+    content.each_line.with_index do |line, line_index|
+      line.strip!
+      if line.end_with? ";"
+        buffer << line.chop
+      else
+        buffer << line
+        block.call buffer.join("\n"), index, (line_index + 1)
+        buffer.clear
+        index += 1
+      end
+    end
+  end
+
+  def stack
+    return @stack if @stack
+    reverse_stack = []
+    reverse_stack << self
+    spec = self
+    while spec = spec.parent
+      reverse_stack << spec
+    end
+    @stack = reverse_stack.reverse
+  end
+
+  def directory
+    file.chomp(File.extname(file))
+  end
+
+  def load
+    @spec_manager.exspec.load self
+  end
+
+  def run
+    @spec_manager.exspec.run self
+  end
+
+  def run
+    @spec_manager.exspec.run_stack self
+  end
+
+  def include
+    @spec_manager.exspec.include self
+  end
+
+  def children
+    @spec_manager.specs self
+  end
+
+  def hash
+    file.hash
+  end
+
+  def ==(spec)
+    return false if !spec.is_a?(self.class)
+    file.eql? spec.file
+  end
+
+  def eql?(spec)
+    self == spec
+  end
+
+  def inspect
+    "#<Spec:#{full_name}>"
+  end
+end

data/lib/exspec/spec_manager.rb

@@ -0,0 +1,93 @@
+require "fileutils"
+require_relative "spec"
+
+module Exspec
+  class SpecManager
+    def initialize(exspec)
+      @exspec = exspec
+      @current_spec = nil
+    end
+
+    attr_reader :exspec
+    attr_accessor :current_spec
+
+    def save(logger, description)
+      spec = create_spec description
+      file = spec.file
+      FileUtils.mkdir_p(File.dirname(file))
+      File.open(file, "w") do |f|
+        f.write(logger.instructions.join "\n")
+      end
+      @current_spec = spec
+    end
+
+    def spec(description)
+      return description if description.kind_of?(Spec) || description.nil?
+
+      description = description.strip
+      parent = description.start_with?(SPEC_SEPARATOR) ? nil : current_spec
+      parent_dir = parent.nil? ? TEST_DIR : parent.directory
+      file = File.expand_path(description, parent_dir)
+      return create_spec file if File.file?(file)
+
+      current = parent
+      description.split(SPEC_SEPARATOR).each do |spec|
+        spec.strip!
+        next if spec.empty?
+        current = create_spec spec, current
+      end
+      current
+    end
+
+    def parent(description)
+      spec = spec(description)
+      parent_dir = File.dirname(spec.file)
+      parent_file = parent_dir + SPEC_EXTENSION
+      return nil if parent_dir == TEST_DIR || !File.exist?(parent_file)
+      parent_name = Spec.name(parent_file)
+      create_spec parent_name, nil, parent_file
+    end
+
+    def specs(parent=current_spec, recursive=false)
+      parent = "" if parent.nil?
+      if parent.is_a?(String)
+        parent = parent.strip
+        relative_directory = current_spec.nil? ? TEST_DIR : current_spec.directory
+        parent_directory = File.expand_path(parent, relative_directory)
+        return find_specs(parent_directory, recursive) if File.directory?(parent_directory)
+      end
+      parent = spec(parent)
+      return [] if parent.nil? || !parent.exist?
+      find_specs(parent.directory, recursive)
+    end
+
+    private
+
+    def file(name, parent)
+      directory = parent.nil? ? TEST_DIR : parent.file.chomp(SPEC_EXTENSION)
+      File.join(directory, name + SPEC_EXTENSION)
+    end
+
+    def create_spec(description, parent=current_spec, file=nil)
+      name = Spec.name description
+      parent = (parent.nil? || !parent.exist?) ? nil : parent
+      file = File.file?(description) ? description : file(name, parent) if file.nil?
+      Spec.new self, name, file, parent
+    end
+
+    def find_specs(directory, recursively=false)
+      specs = []
+      return specs unless File.directory? directory
+      Dir.entries(directory).sort.each do |file|
+        next if file.gsub(".", "").empty?
+        file = File.expand_path(file, directory)
+        if File.directory? file
+          specs.push(*find_specs(file, recursively)) if recursively
+        elsif file.end_with? SPEC_EXTENSION
+          specs << create_spec(file)
+        end
+      end
+      specs
+    end
+  end
+end

data/lib/exspec/spec_runner.rb

@@ -0,0 +1,55 @@
+module Exspec
+  class SpecRunner
+    def initialize(exspec)
+      @exspec = exspec
+    end
+
+    delegate :reporter, :to => :@exspec
+
+    attr_accessor :break_on_skip_signal
+
+    def run(specs)
+      return run_specs specs if specs.is_a? Enumerable
+      spec = @exspec.spec(specs)
+      val = nil
+      reporter.start_spec spec
+      spec.for_instructions do |instruction, index, line|
+        reporter.execute_instruction instruction, index, line
+        begin
+          val = @exspec.execute instruction
+        rescue SkipSignal
+          reporter.skip_signal break_on_skip_signal
+          break if break_on_skip_signal
+        rescue Exception => e
+          reporter.exception e
+        ensure
+          reporter.executed_instruction instruction, index, line
+        end
+      end
+      val
+    ensure
+      reporter.finish_spec spec
+    end
+
+    def run_stack(spec)
+      spec = @exspec.spec(spec)
+      reporter.start_stack spec
+      spec.stack.each do |spec|
+        begin
+          run spec
+        rescue
+          break
+        end
+      end
+    ensure
+      reporter.finish_stack spec
+    end
+
+    def run_specs(specs)
+      specs.each do |spec|
+        @exspec.reset
+        run_stack(spec)
+      end
+    end
+  end
+end