quarry 0.3.0 → 0.4.0

data/lib/quarry/extract.rb

@@ -0,0 +1,135 @@
+require 'fileutils'
+
+module Quarry
+
+  # Extractor is a tool for extracting code from embedded
+  # comment blocks.
+  #
+  # TODO:
+  #   - Should extract_block handle more than the first matching block?
+  #   - How can we handle embedded code in standard comments? Eg. #
+  #
+  module Extract
+
+    extend self
+
+    # Extract unit tests. This task scans every package script
+    # looking for sections of the form:
+    #
+    #     =begin test
+    #       ...
+    #     =end
+    #
+    # With appropriate headers, it copies these sections to files
+    # in your project's test/ dir, which then can be run using the
+    # Ratchet test task. The exact directory layout of the files to
+    # be tested is reflected in the test directory. You can then
+    # use project.rb's test task to run the tests.
+    #
+    #     files      Files to extract ['lib/**/*.rb']
+    #     output     Test directory   ['test/']
+    #
+
+    def test_extract(files=nil)
+      output = 'test/embedded'     # Don't think output should be setable.
+
+      files  = files || 'lib/**/*.rb'
+      files = 'lib/**/*.rb' if TrueClass == files
+      files = [files].flatten.compact
+
+      filelist = files.collect{ |f| Dir.glob(f) }
+      filelist.flatten!
+      if filelist.empty?
+        puts "No scripts found from which to extract tests."
+        return
+      end
+
+      FileUtils.mkdir_p(output) unless File.directory?(output)
+
+      #vrunner = VerbosityRunner.new("Extracting", verbosity?)
+      #vrunner.setup(filelist.size)
+
+      filelist.each do |file|
+        #vrunner.prepare(file)
+
+        testing = extract_test_from_file( file )
+        if testing.strip.empty?
+          status = "[NONE]"
+        else
+          complete_test = create_test(testing, file)
+          libpath = File.dirname(file)
+          testfile = "test_" + File.basename(file)
+          fp = File.join(output, libpath, testfile)
+          unless File.directory?( File.dirname(fp))
+            FileUtils.mkdir_p(File.dirname(fp))
+          end
+          File.open(fp, "w"){ |fw| fw << complete_test }
+          status = "[TEST]"
+        end
+
+        #vrunner.complete(file, status)
+      end
+
+      #vrunner.finish(
+      #  :normal => "#{filelist.size} files had tests extracted.",
+      #  :check => false
+      #)
+    end
+
+    private
+
+    # Extract test from a file's testing comments.
+
+    def extract_test_from_file(file)
+      return nil if ! File.file?(file)
+      tests = ""; inside = false
+      fstr = File.read(file)
+      fstr.split(/\n/).each do |l|
+        if l =~ /^=begin[ ]*test/i
+          tests << "\n"
+          inside = true
+          next
+        elsif inside and l =~ /^=[ ]*end/
+          inside = false
+          next
+        end
+        if inside
+          tests << l << "\n"
+        end
+      end
+      tests
+    end
+
+    # Generate the test.
+
+    def create_test(testing, file)
+      fp = file.split(/[\/]/)
+      if fp[0] == 'lib'
+        reqf = "require '#{fp[1..-1].join('/')}'"
+      else
+        reqf = ''
+      end
+      teststr = []
+      teststr << "#  _____         _"
+      teststr << "# |_   _|__  ___| |_"
+      teststr << "#   | |/ _ \\/ __| __|"
+      teststr << "#   | |  __/\\__ \\ |_"
+      teststr << "#   |_|\\___||___/\\__|"
+      teststr << "#"
+      teststr << "# for #{file}"
+      teststr << "#"
+      teststr << "# Extracted #{Time.now}"
+      teststr << "# Project.rb Test Extraction"
+      teststr << "#"
+      teststr << ""
+      teststr << "#{reqf}"
+      teststr << ""
+      teststr << testing
+      teststr << ""
+      teststr.join("\n")
+    end
+
+  end #module Extract
+
+end #module Quarry
+

data/lib/quarry/loadmonitor.rb

@@ -1,14 +1,19 @@
 BEGIN {
    module Kernel
+
      h = Hash.new
+
      define_method(:requiree) do
        h
      end
 
      r = method :require
+
      define_method(:require) do |a|
-       r.call a
+       r.call(a)
        h[a] = caller
      end
+
    end
 }
+

data/lib/quarry/spec/config.rb

@@ -0,0 +1,32 @@
+module Quarry
+
+  module Spec
+
+    # = Spec Configuration
+    #
+    class Config
+
+      def initialize
+      end
+
+      # Run at the start of a specification.
+      def before_spec
+      end
+
+      # Run at the start of the specification step.
+      def before
+      end
+
+      # Run at the end of a specification step.
+      def after
+      end
+
+      # Run at the end of a specification.
+      def after_spec
+      end
+
+    end
+
+  end
+
+end

data/lib/quarry/spec/context.rb

@@ -0,0 +1,19 @@
+module Quarry
+
+  module Spec
+
+    # = Spec Context
+    #
+    # Specifications are run within an instance of Context.
+    class Context < Module
+
+      def initialize
+        extend self
+      end
+
+    end #class Context
+
+  end #module Spec
+
+end #module Quarry
+

data/lib/quarry/spec/document.rb

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

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

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

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

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