qed 2.6.3 → 2.7.0

data/lib/qed/settings.rb

@@ -1,21 +1,33 @@
 module QED
 
-  # Ecapsulate confiduration information needed for QED
+  # Ecapsulate configuration information needed for QED to
   # run and set user and project options.
+  #
+  # Configuration for QED is placed in a `.config.rb` or `config.rb` file.
+  # In this file special configuration setups can be placed to automatically
+  # effect QED execution, in particular optional profiles can be defined.
+  #
+  #   qed do
+  #     profile :coverage do
+  #       require 'simplecov'
+  #       SimpleCov.start do
+  #         coverage_dir 'log/coverage'
+  #         add_group "Shared" do |src_file|
+  #           /lib\/dotruby\/v(\d+)(.*?)$/ !~ src_file.filename
+  #         end
+  #         add_group "Revision 0", "lib/dotruby/v0"
+  #       end
+  #     end
+  #   end
+  # 
   class Settings
 
     require 'tmpdir'
     require 'fileutils'
-
-    # Configuration directory `.qed`, `.config/qed` or `config/qed`.
-    # In this directory special configuration files can be placed
-    # to autmatically effect qed execution. In particular you can
-    # add a `profiles.yml` file to setup convenient execution
-    # scenarios.
-    CONFIG_PATTERN = "{.,.set/,set/.config/,config/}qed"
+    require 'confection'
 
     # Glob pattern used to search for project's root directory.
-    ROOT_PATTERN = '{.ruby,.git/,.hg/,_darcs/,.qed/,.set/qed/,set/qed/.config/qed/,config/qed/}'
+    ROOT_PATTERN = '{.confile,.confile.rb,confile,confile.rb,.ruby,.git/,.hg/,_darcs/}'
 
     # Home directory.
     HOME = File.expand_path('~')
@@ -23,29 +35,39 @@ module QED
     #
     def initialize(options={})
       @rootless = options[:rootless]
+      @profiles = {}
+
+      @root = @rootless ? system_tmpdir : find_root
+
+      # Set global. TODO: find away to not need this ?
+      $ROOT = @root
+
+      confection('qed').exec
     end
 
+    # Operate relative to project root directory, or use system's location.
     #
     def rootless?
       @rootless
     end
 
     # Project's root directory.
+    #
     def root_directory
-      @root_directory ||= find_root
+      @root
     end
 
-    # Project's QED configuration directory.
-    # TODO: rename to `config_directory` ?
-    def settings_directory
-      @settings_directory ||= find_settings
-    end
+    # Shorthand for `#root_directory`.
+    alias_method :root, :root_directory
 
+    # Temporary directory. If `#rootless?` return true then this will be
+    # a system's temporary directory (e.g. `/tmp/qed/foo/20111117242323/`).
+    # Otherwise, it will local to the project's root int `tmp/qed/`.
     #
     def temporary_directory
       @temporary_directory ||= (
         if rootless?
-          File.join(Dir.tmpdir, 'qed', File.filename(Dir.pwd), Time.new.strftime("%Y%m%d%H%M%S"))
+          system_tmpdir
         else
           File.join(root_directory, 'tmp', 'qed')
         end
@@ -53,7 +75,7 @@ module QED
       )
     end
 
-    #
+    # Shorthand for `#temporary_directory`.
     alias_method :tmpdir, :temporary_directory
 
     # Remove and recreate temporary working directory.
@@ -62,39 +84,61 @@ module QED
       FileUtils.mkdir_p(tmpdir)
     end
 
-    # Profile configurations.
-    def profiles
-      @profiles ||= (
-        files = Dir["#{settings_directory}/*.rb"]
-        files.map do |file|
-          File.basename(file).chomp('.rb')
-        end
-      )
+    # Define a profile.
+    #
+    # @param [#to_s] name
+    #   Name of profile.
+    #
+    # @yield Procedure to run for profile.
+    #
+    # @return [Proc] The procedure.
+    def profile(name, &block)
+      @profiles[name.to_s] = block
     end
 
-    # Require requirement file (from -e option).
-    def require_profile(profile)
-      return unless settings_directory
-      if file = Dir["#{settings_directory}/#{profile}.rb"].first
-        require(file)
+    # Keeps a list of defined profiles.
+    attr_accessor :profiles
+
+    # Profile configurations.
+    #def profiles
+    #  @profiles ||= (
+    #    files = Dir["#{settings_directory}/*.rb"]
+    #    files.map do |file|
+    #      File.basename(file).chomp('.rb')
+    #    end
+    #  )
+    #end
+
+    # Load QED profile (from -e option).
+    def load_profile(name)
+      if profile = profiles[name.to_s]
+        instance_eval(&profile)
+        #eval('self', TOPLEVEL_BINDING).instance_eval(&prof)
       end
+      #return unless settings_directory
+      #if file = Dir["#{settings_directory}/#{profile}.rb"].first
+      #  require(file)
+      #end
     end
 
     # Locate project's root directory. This is done by searching upward
-    # in the file heirarchy for the existence of one of the following
-    # path names, each group being tried in turn.
+    # in the file heirarchy for the existence of one of the following:
     #
-    # * .git/
-    # * .hg/
-    # * _darcs/
-    # * .config/qed/
-    # * config/qed/
-    # * .qed/
-    # * .ruby
+    #   .confile
+    #   confile
+    #   .confile.rb
+    #   confile.rb
+    #   .ruby
+    #   .git/
+    #   .hg/
+    #   _darcs/
     #
     # Failing to find any of these locations, resort to the fallback:
     # 
-    # * lib/
+    #   lib/
+    #
+    # If that isn't found, then returns a temporary system location.
+    # and sets `rootless` to true.
     #
     def find_root(path=nil)
       path = File.expand_path(path || Dir.pwd)
@@ -103,45 +147,31 @@ module QED
       root = lookup(ROOT_PATTERN, path)
       return root if root
 
-      #root = lookup(path, '{.qed,.config/qed,config/qed}/')
-      #return root if root
-
-      #root = lookup(path, '{qed,demo,demos}/')
+      #root = lookup(path, '{qed,demo,spec}/')
       #return root if root
 
       root = lookup('lib/', path)
 
-      return root if root
+      if !root
+        warn "QED is running rootless."
+        root = system_tmpdir
+        @rootless = true
+      end
 
-      abort "QED failed to resolve project's root location.\n" +
-            "QED looks for following entries to identify the root:\n" +
-            "  .set/qed/\n" +
-            "  set/qed/\n" +
-            "  .config/qed/\n" +
-            "  config/qed/\n" +
-            "  .qed/\n" +
-            "  .ruby\n" +
-            "  lib/\n" +
-            "Please add one of them to your project to proceed."
-    end
+      return root
 
-    # Locate configuration directory by seaching up the 
-    # file hierachy relative to the working directory
-    # for one of the following paths:
-    #
-    # * .config/qed/
-    # *  config/qed/
-    # * .qed/
-    #
-    def find_settings
-      Dir[File.join(root_directory,CONFIG_PATTERN)].first
+      #abort "QED failed to resolve project's root location.\n" +
+      #      "QED looks for following entries to identify the root:\n" +
+      #      ROOT_PATTERN +
+      #      "Please add one of them to your project to proceed."
     end
 
+    # TODO: Use Dir.ascend from Ruby Facets.
+
     # Lookup path +glob+, searching each higher directory
     # in turn until just before the users home directory
     # is reached or just before the system's root directory.
     #
-    # TODO: include HOME directory in search?
     def lookup(glob, path=Dir.pwd)
       until path == HOME or path == '/' # until home or root
         mark = Dir.glob(File.join(path,glob), File::FNM_CASEFOLD).first
@@ -150,6 +180,13 @@ module QED
       end
     end
 
+    #
+    def system_tmpdir
+      @system_tmpdir ||= (
+        File.join(Dir.tmpdir, 'qed', File.basename(Dir.pwd), Time.new.strftime("%Y%m%d%H%M%S"))
+      )
+    end
+
   end
 
 end

data/lib/qed/step.rb

@@ -0,0 +1,237 @@
+module QED
+
+  # A Step consists of a flush region of text and the indented 
+  # text the follows it. QED breaks all demos down into step
+  # for evaluation.
+  #
+  # Steps form a doubly linkes list, each having access to the step
+  # before and the step after them. Potentially this could be used
+  # by very advnaced matchers, to vary executation by earlier or later
+  # content of a demo.
+  #
+  class Step
+
+    # Ths demo to which the step belongs.
+    # @return [Demo] demo
+    attr :demo
+
+    # Block lines code/text.
+    #attr :lines
+
+    # Previous step.
+    # @return [Step] previous step
+    attr :back_step
+
+    # Next step.
+    # @return [Step] next step
+    attr :next_step
+
+    # Step up a new step.
+    #
+    # @param [Demo] demo
+    #   The demo to which the step belongs.
+    #
+    # @param [Array<Array<Integer,String>]] explain_lines
+    #   The step's explaination text, broken down into an array
+    #   of `[line number, line text]` entries.
+    #
+    # @param [Array<Array<Integer,String>]] example_lines
+    #   The steps example text, broken down into an array
+    #   of `[line number, line text]` entries.
+    #
+    # @param [Step] last
+    #   The previous step in the demo.
+    #
+    def initialize(demo, explain_lines, example_lines, last)
+      #QED.all_steps << self
+
+      @demo = demo
+      @file = demo.file
+
+      #@lines = []
+
+      @explain_lines = explain_lines
+      @example_lines = example_lines
+
+      @back_step = last
+      @back_step.next_step = self if @back_step
+    end
+
+    # The step's explaination text, broken down into an array
+    # of `[line number, line text]` entries.
+    #
+    # @return [Array<Array<Integer,String>]] explain_lines
+    attr :explain_lines
+
+    # The steps example text, broken down into an array
+    # of `[line number, line text]` entries.
+    #
+    # @return [Array<Array<Integer,String>]] example_lines
+    attr :example_lines
+
+    # Ths file to which the step belongs.
+    #
+    # @return [String] file path
+    def file
+      demo.file
+    end
+
+    # Full text of block including both explination and example text.
+    def to_s
+      (@explain_lines + @example_lines).map{ |lineno, line| line }.join("")
+    end
+
+    # Description text.
+    def explain
+      @explain ||= @explain_lines.map{ |lineno, line| line }.join("")
+    end
+
+    # Alternate term for #explain.
+    alias_method :description, :explain
+
+    # @deprecated
+    alias_method :text, :explain
+
+    # TODO: Support embedded rule steps ?
+
+    #
+    #def rule?
+    #  @is_rule ||= (/\A(given|when|rule|before|after)[:.]/i.match(text))
+    #end
+
+    #
+    #def rule_text
+    #  rule?.post_match.strip
+    #end
+
+    # TODO: better name than :proc ?
+
+    # 
+    def type
+      assertive? ? :test : :proc
+    end
+
+    # A step is a heading if it's description starts with a '=' or '#'.
+    def heading?
+      @is_heading ||= (/\A[=#]/ =~ explain)
+    end
+
+    # Any commentary ending in `:` will mark the example
+    # text as a plain text *sample* and not code to be evaluated.
+    def data?
+      @is_data ||= explain.strip.end_with?(':')
+    end
+
+    # Is the example text code to be evaluated?
+    def code?
+      !data? && example?
+    end
+
+    # First line of example text.
+    def lineno
+      @lineno ||= (
+        if @example_lines.first
+          @example_lines.first.first
+        elsif @explain_lines.first
+          @explain_lines.first.first
+         else
+          1
+        end
+      )
+    end
+
+    def explain_lineno
+      @explain_lines.first ? @explain_lines.first.first : 1
+    end
+
+    def example_lineno
+      @example_lines.first ? @example_lines.first.first : 1
+    end
+
+    # Does the block have an example?
+    def example?
+      ! example.strip.empty?
+    end
+    alias has_example? example?
+
+    #
+    def example
+      @example ||= (
+        if data?
+          @example_lines.map{ |lineno, line| line }.join("")
+        else
+          tweak_code
+        end
+      )
+    end
+    alias_method :code, :example
+    alias_method :data, :example
+
+    # Returns any extra arguments the step passes along to rules.
+    def arguments
+      []
+    end
+
+    # Clean up the example text, removing unccesseary white lines
+    # and triple quote brackets, but keep indention intact.
+    #
+    def clean_example
+      str = example.chomp.sub(/\A\n/,'')
+      if md = /\A["]{3,}(.*?)["]{3,}\Z/.match(str)
+        str = md[1]
+      end
+      str.rstrip
+    end
+
+    # TODO: We need to preserve the indentation for the verbatim reporter.
+    #def clean_quote(text)
+    #  text = text.tabto(0).chomp.sub(/\A\n/,'')
+    #  if md = /\A["]{3,}(.*?)["]{3,}\Z/.match(text)
+    #    text = md[1]
+    #  end
+    #  text.rstrip
+    #end
+
+    # When the text is sample text and passed to an adivce block, this
+    # provides the prepared form of the example text, removing white lines,
+    # triple quote brackets and indention.
+    #
+    def sample_text
+      str = example.tabto(0).chomp.sub(/\A\n/,'')
+      if md = /\A["]{3,}(.*?)["]{3,}\Z/.match(str)
+        str = md[1]
+      end
+      str.rstrip
+    end
+
+    # TODO: object_hexid
+    def inspect
+      str = text[0,24].gsub("\n"," ")
+      %[\#<Step:#{object_id} "#{str} ...">]
+    end
+
+    #
+    def assertive?
+      @assertive ||= !text.strip.end_with?('^')
+    end
+
+  protected
+
+    #
+    def next_step=(n)
+      @next_step = n
+    end
+
+  private
+
+    #
+    def tweak_code
+      code = @example_lines.map{ |lineno, line| line }.join("")
+      code.gsub!(/\n\s*\#\ ?\=\>/, '.assert = ')
+      code.gsub!(/\s*\#\ ?\=\>/, '.assert = ')
+      code
+    end
+
+  end
+
+end