quarry 0.4.0 → 0.5.0

data/lib/quarry/assert.rb

@@ -1,198 +0,0 @@
-# Assertion is a special subclass of Exception used 
-# to raise assertion errors.
-#
-# Assertions are generally invoked via the #assert or #should
-# functors. For instance to assert that 4 == 4 use:
-#
-#   4.assert == 4
-#
-# If the assertion does not hold true an Assertion exception
-# will be raised.
-#
-# You can also create your own assertion "macros" simply by
-# defining applicable methods resuing previous assertion methods.
-#
-#   class Module
-#     def should_be_enumerable(module)
-#       should < Enumerable
-#       instance_methods.should.include?('each')
-#     end
-#   end
-#
-# As fancy as assertion functors may seem, under the hood they
-# translate into quite simple code. Consider this valid macro:
-#
-#   def assert_fail_every_time
-#     raise Assertion, "this will fail every time"
-#   end
-#
-# Not very useful, but completely valid.
-#
-# == Concerning Nomenclature
-#
-# Unfortunately there's a bit of rift in the naming scheme of
-# assertion methods. With TDD the term 'assert' became the 
-# standard. However, with the advent of BDD, 'should' has 
-# become the dominant term.
-#
-# If I had my druthers I would probably have picked 'must'
-# since it is short and carries the semantics of enforcement.
-#
-class Assertion < Exception
-end
-
-# = Assertion::True
-#
-class Assertion::True
-
-  hide = instance_methods.reject { |m| m.to_s =~ /^__/ }
-  hide.each { |m| protected m  }
-
-private
-
-  #
-  def initialize(delegate)
-    @delegate = delegate
-  end
-
-  # TODO: Not sure about the raises here.
-  def method_missing(sym, *a, &b)
-    #case sym
-    #when :raise?, :raises?
-    #  begin
-    #    @delegate.call #yield
-    #    assert false, "Expected #{a[0]} to be raised"
-    #  rescue Exception => e
-    #    assert a[0] === e, "Expected #{a[0]} to be raised, but got #{e.class}"
-    #    return e
-    #  end
-    #else
-      assert(@delegate.__send__(sym, *a, &b), message(@delegate, sym, *a, &b))
-    #end
-  end
-
-  #
-  def assert(assertion, msg="failed assertion (no message given)")
-    raise Assertion, msg unless assertion
-  end
-
-  #
-  def message(obj, sym, *a, &b)
-    #self.class.message(sym)[@delegate, *a] )
-    "#{obj.inspect} #{sym} #{a.collect{|x| x.inspect}.join(',')}"
-  end
-
-  # TODO: Ultimately better messages would be nice.
-
-  #
-  def self.message(op,&block)
-    @message ||= {}
-    block ? @message[op.to_sym] = block : @message[op.to_sym]
-  end
-
-  #
-  message(:==){ |*a| "Expected #{a[0].inspect} to be equal to #{a[1].inspect}" }
-
-end
-
-# = Assertion::False
-#
-class Assertion::False < Assertion::True
-  message(:==){ |*a| "Expected #{a[0].inspect} not to be equal to #{a[1].inspect}" }
-
-  def assert(assertion, msg="failed assertion (no message given)")
-    raise Assertion, msg if assertion
-  end
-
-  def message( obj, sym, *a, &b )
-    #self.class.message(sym)[@delegate, *a] )
-    "NOT #{obj.inspect} #{sym} #{a.collect{|x| x.inspect}.join(',')}"
-  end
-end
-
-
-class Object
-  # Assert a operational relationship.
-  #
-  # 4.assert == 3  #=> Assertion Error
-  #
-  def assert
-    return Assertion::True.new(self)
-  end
-
-  # The term 'should' has basically become the defacto
-  # standard for BDD assertions, so Quarry will support
-  # this nomenclature as well. 
-  #
-  # AUTHOR'S NOTE: Left to my own choosing, I likely 
-  # would have picked #must, myself, since it is shorter 
-  # and more convincing. ;)
-  #
-  alias_method :should, :assert
-
-  # Assert not an operational relationship.
-  # Read it as "assert not".
-  #
-  #   4.assert! == 4  #=> Assertion Error
-  #
-  # AUHTOR'S NOTE: This method would not be necessary
-  # if Ruby would allow +!=+ to be define as a method,
-  # or at least +!+ as a unary method.
-  #
-  def assert!
-    return Assertion::False.new(self)
-  end
-
-  # Same as #assert!.
-  #
-  # 4.refute == 4  #=> Assertion Error
-  #
-  alias_method :refute, :assert!
-
-  # See the note on #should.
-  #
-  alias_method :should_not, :refute
-
-  # Provides a way to assert that a procedure
-  # raises an exception.
-  #
-  #   assert_raises(StandardError){ raise }
-  #
-  def assert_raises(exception, &block)
-    Assertion::True.new(
-      lambda do |*a|
-        begin
-          block.call(*a)
-          false
-        rescue exception
-          true
-        end
-      end
-    )
-  end
-
-  alias_method :should_raise, :assert_raises
-
-  # Provides a way to assert that a procedure
-  # does not raise an exception.
-  #
-  #   refute_raises(StandardError){ raise }
-  #
-  def refute_raises(exception, &block)
-    Assertion::True.new(
-      begin
-        block.call(*a)
-        true
-      rescue exception
-        false
-      end
-    )
-  end
-
-  alias_method :assert_raises!, :refute_raises
-
-  alias_method :should_not_raise, :refute_raises
-end
-
-# Copyright (c) 2008 Tiger Ops
-

data/lib/quarry/break.rb

@@ -1,51 +0,0 @@
-module Quarry
-
-  # = Exception Break and Edit
-  #
-  class Break
-
-    attr :exception
-
-    alias_method :error, :exception
-
-    #
-    def initialize(exception)
-      @exception = exception
-    end
-
-    #
-    def edit
-      file, line = *exception.backtrace[0].split(':')
-      line = line.to_i
-
-      puts exception
-
-      e = "# DEBUG " + exception.to_s
-      e.gsub!("`","'")
-
-      e = Regexp.escape(e)
-
-      case ed = ENV['EDITOR']
-      when 'vi', 'vim', 'gvim'
-        cmd = []
-        cmd << "#{ed} -e -s #{file} <<-EOS"
-        cmd << ":#{line}"
-        cmd << "a"
-        cmd << "#{e}"
-        cmd << "."
-        cmd << ":.,+#{e.size}"
-        cmd << "EOS"
-        cmd = cmd.join("\n")
-      when nil
-        puts "EDITOR environment variable not set"
-      else
-        puts "EDITOR environment variable not supported"
-      end
-
-      system cmd
-    end
-
-  end #class Break
-
-end #module Quarry
-

data/lib/quarry/spec/document.rb

@@ -1,130 +0,0 @@
-require 'erb'
-require 'fileutils'
-
-module Quarry
-
-  module Spec
-
-    # = Document
-    #
-    # TODO: css and javascripts have fixed location
-    # -     need to make more flexible.
-    class Document
-
-      DEFAULT_TITLE = "Specifictions"
-      DEFAULT_CSS   = "../assets/styles/spec.css"
-      DEFAULT_FILE  = "doc/spec/index.html"
-      DEFAULT_PATH  = ["spec/**/*"]
-
-      attr_accessor :title
-      attr_accessor :css
-      attr_accessor :paths
-      attr_accessor :dryrun
-      attr_accessor :quiet
-
-      # Ouput file.
-      attr_accessor :output    
-
-      # New Spec Document object.
-      def initialize(options)
-        options.each do |k,v|
-          __send__("#{k}=", v)
-        end
-
-        @title  ||= DEFAULT_TITLE
-        @css    ||= DEFAULT_CSS
-        @output ||= DEFAULT_FILE
-        @paths  ||= []
-
-        @paths  = DEFAULT_PATH if @paths.empty?
-      end
-
-      # Supress output.
-      def quiet? ; @quiet ; end
-
-      # Generate specification document.
-      def generate
-        files = []
-        paths.each do |path|
-          files.concat(Dir.glob(path).select{ |f| File.file?(f) })
-        end
-
-        text = ''
-        files.each do |file|
-          puts file unless quiet?
-          case ext = File.extname(file)
-          when '.rd', '.rdoc'
-            require_rdoc
-            markup = SM::SimpleMarkup.new
-            formatter = SM::ToHtml.new
-            text << markup.convert(File.read(file), formatter)
-          when '.md', '.markdown'
-            # TODO
-          end
-          text << "\n"
-        end
-
-        temp = Template.new(template, text, title, css)
-        html = temp.parse_template
-
-        save(html)
-      end
-
-      # Load specification HTML template.
-      def template
-        @template ||= (
-          file = File.join(File.dirname(__FILE__), 'template.rhtml')
-          File.read(file)
-        )
-      end
-
-      # Save specification document.
-      def save(text)
-        if dryrun
-          puts "\nwrite #{output}"
-        else
-          FileUtils.mkdir_p(File.dirname(output))
-          File.open(output, 'wb') do |f|
-            f << text
-          end
-        end
-      end
-
-    private
-
-      #
-      def require_rdoc
-        @require_rdoc ||= (
-          require 'rdoc/markup/simple_markup'
-          require 'rdoc/markup/simple_markup/to_html'
-          true
-        )
-      end
-
-    end
-
-    # = Document Template
-    #
-    class Template
-      attr :spec
-      attr :title
-      attr :css
-
-      #
-      def initialize(template, spec, title, css)
-        @template = template
-        @spec     = spec
-        @title    = title
-        @css      = css
-      end
-
-      def parse_template
-        erb = ERB.new(@template)
-        erb.result(binding)
-      end
-    end
-
-  end
-
-end
-

data/lib/quarry/spec/markup.rb

@@ -1,85 +0,0 @@
-require 'quarry/spec/step'
-
-module Quarry
-
-  module Spec
-
-    # = Specification Markup
-    #
-    class Markup #Specification
-
-      attr :file
-      attr :steps
-
-      #
-      def initialize(file)
-        @file  = file
-        @steps = []
-        parse
-      end
-
-      #
-      def parse
-        lineno = 0
-        text   = ''
-        File.open(file, 'r') do |f|
-          f.readlines.each_with_index do |line, lineno|
-            case line
-            when /^\s*$/
-              parse_section(text, lineno)
-              text = ''
-            else
-              text << line
-            end
-          end
-        end
-      end
-
-      #
-      def parse_section(text, lineno)
-        return if text.strip == ''
-        case text
-        when /\A[-=].*?$/, /[-=]\s*\Z/
-          #text << line
-          steps << Header.new(self, text, lineno)
-        when /^\s+/
-          last = steps.last
-          case last
-          when Step, Macro
-            last.code << "\n\n#{text.rstrip}"
-          when Comment
-            if last.macro?
-              steps << Macro.new(self, text, lineno, last.type)
-            else
-              steps << Step.new(self, text, lineno)
-            end
-          else
-            steps << Step.new(self, text, lineno)
-          end
-        else
-          steps << Comment.new(self, text, lineno)
-        end
-      end
-
-      #
-      def description
-        File.basename(file)
-      end
-
-      # Convert Markdown Specification to Spec object.
-      #def to_spec
-      #  spec = Design::Spec.new(description)
-      #  clauses.each do |text, code|
-      #    spec.prove(text) do
-      #      instance_eval(code)
-      #    end
-      #  end
-      #  return spec
-      #end
-
-    end#class
-
-  end#module Spec
-
-end#module Quarry
-

data/lib/quarry/spec/reporter/dotprogress.rb

@@ -1,66 +0,0 @@
-require 'quarry/spec/reporter'
-
-module Quarry
-
-  module Spec
-
-    class Reporter
-
-      #
-      class DotProgress < Reporter
-
-        def report_intro
-          @start_time = Time.now
-          puts "Started"
-        end
-
-        def report_step(step)
-          super
-          if step.code
-            print "."
-            #str = "(%s) %s" % [count.join('.'), str.tab(6).strip]
-            #puts "* #{step.text.tab(2).strip}"
-            #puts "\n#{step.code}\n" if $VERBOSE
-          else
-            #puts "\n#{step.text}"
-          end
-        end
-
-        #def report(str)
-        #  count[-1] += 1 unless count.empty?
-        #  str = str.chomp('.') + '.'
-        #  str = count.join('.') + ' ' + str
-        #  puts str.strip
-        #end
-
-        def report_summary
-          puts "\nFinished in #{Time.now - @start_time} seconds.\n\n"
-
-          @error.each do |step, exception|
-            puts ANSICode.red("***** ERROR *****")
-            puts "#{exception}"
-            puts ":#{exception.backtrace[0]}:"
-            #puts ":#{exception.backtrace[1]}:"
-            #puts exception.backtrace[1..-1] if $VERBOSE
-            puts
-          end
-
-          @fail.each do |step, assertion|
-            puts ANSICode.red("***** FAIL *****")
-            puts ANSICode.bold("#{assertion}")
-            puts ":#{assertion.backtrace[2]}:"
-            #puts assertion if $VERBOSE
-            puts
-          end
-
-          puts "%s specs, %s steps, %s failures, %s errors" % [@specs, @steps, @fail.size, @error.size] #, @pass.size ]
-        end
-
-      end#class DotProgress
-
-    end#class Reporter
-
-  end#moudle Spec
-
-end#module Quarry
-

data/lib/quarry/spec/reporter/summary.rb

@@ -1,74 +0,0 @@
-require 'quarry/spec/reporter'
-
-module Quarry
-
-  module Spec #:nodoc:
-
-    class Reporter #:nodoc:
-
-      # = Summary Reporter
-      #
-      # Similar to the Verbatim reporter, but does
-      # not display test code for passing tests.
-
-      class Summary < Reporter
-
-        def report_header(step)
-          puts ANSICode.bold(step.text)
-        end
-
-        def report_comment(step)
-          txt = step.text.tabto(2)
-          txt[0,1] = "*"
-          puts txt 
-        end
-
-        def report_macro(step)
-          txt = step.text.tabto(2)
-          txt[0,1] = "*"
-          puts txt 
-          #puts
-          #puts ANSICode.magenta("#{step.code}")
-        end
-
-        def report_pass(step)
-          #puts ANSICode.green("#{step.code}")
-        end
-
-        def report_fail(step, assertion)
-          msg = ''
-          msg << "  ##### FAIL #####\n"
-          msg << "  # " + assertion.to_s
-          msg = ANSICode.magenta(msg)
-          puts msg
-          #puts
-          puts ANSICode.red("#{step.code}")
-        end
-
-        def report_error(step, exception)
-          raise exception if $DEBUG
-          msg = ''
-          msg << "  ##### ERROR #####\n"
-          msg << "  # " + exception.to_s + "\n"
-          msg << "  # " + exception.backtrace[0]
-          msg = ANSICode.magenta(msg)
-          puts msg
-          #puts
-          puts ANSICode.red("#{step.code}")
-        end
-
-        #def report(str)
-        #  count[-1] += 1 unless count.empty?
-        #  str = str.chomp('.') + '.'
-        #  str = count.join('.') + ' ' + str
-        #  puts str.strip
-        #end
-
-      end #class Summary
-
-    end #class Reporter
-
-  end #module Spec
-
-end #module Quarry
-

data/lib/quarry/spec/reporter/verbatim.rb

@@ -1,87 +0,0 @@
-require 'quarry/spec/reporter'
-
-module Quarry
-
-  module Spec
-
-    class Reporter
-
-      # = Verbatim Reporter
-      #
-      class Verbatim < Reporter
-
-        #def report_step(step)
-        #  super
-        #  if step.code
-        #    #str = "(%s) %s" % [count.join('.'), str.tab(6).strip]
-        #    #puts "* #{step.text.tab(2).strip}"
-        #    #puts
-        #    #puts step.text
-        #    #puts
-        #  else
-        #    #puts "#{step.text}\n"  # TODO: This never happens.
-        #  end
-        #end
-
-        def report_header(step)
-          puts ANSICode.bold(step.text)
-          puts
-        end
-
-        def report_comment(step)
-          puts step.text
-          puts
-        end
-
-        def report_macro(step)
-          #puts
-          #puts step.text
-          puts ANSICode.magenta("#{step.code}")
-          puts
-        end
-
-        def report_pass(step)
-          puts ANSICode.green("#{step.code}")
-          puts
-        end
-
-        def report_fail(step, assertion)
-          msg = ''
-          msg << "##### FAIL #####\n"
-          msg << assertion.to_s + "\n"
-          msg << assertion.backtrace[2]
-          msg = ANSICode.magenta(msg)
-          puts msg
-          puts
-          puts ANSICode.red("#{step.code}")
-          puts
-        end
-
-        def report_error(step, exception)
-          raise exception if $DEBUG
-          msg = ''
-          msg << "##### ERROR #####\n"
-          msg << exception.to_s + "\n"
-          msg << exception.backtrace[0]
-          msg = ANSICode.magenta(msg)
-          puts msg
-          puts
-          puts ANSICode.red("#{step.code}")
-          puts
-        end
-
-        #def report(str)
-        #  count[-1] += 1 unless count.empty?
-        #  str = str.chomp('.') + '.'
-        #  str = count.join('.') + ' ' + str
-        #  puts str.strip
-        #end
-
-      end
-
-    end
-
-  end
-
-end #module Quarry
-