qed 1.3 → 2.0.0

data/lib/qed.rb

@@ -1,6 +1,6 @@
 module QED
-  VERSION="1.2"  #:till: VERSION="<%= version %>"
+  VERSION="2.0.0"  #:till: VERSION="<%= version %>"
 end
 
-require 'qed/runner'
+require 'qed/session'
 

data/lib/qed/advice.rb

@@ -0,0 +1,61 @@
+module QED
+
+  require 'qed/advice/events'
+  require 'qed/advice/patterns'
+
+  # = Advice
+  #
+  # This class tracks advice defined by demo scripts
+  # and helpers. It is instantiated in Scope, so that
+  # the advice methods will have access to the same
+  # local binding and the demo scripts themselves.
+  #
+  class Advice
+
+    attr :patterns
+
+    attr :events
+
+    def initialize
+      @patterns = Patterns.new
+      @events   = Events.new
+    end
+
+    def call(type, *args)
+      case type
+      when :when
+        @patterns.call(*args)
+      else
+        @events.call(type, *args)
+      end
+    end
+  end
+
+  #
+  module Advisable
+
+    def __advice__
+      @__advice__ ||= Advice.new
+    end
+
+    def When(pattern, &procedure)
+      case pattern
+      when Symbol
+        __advice__.events.add(:"#{pattern}", &procedure)
+      else
+        __advice__.patterns.add(pattern, &procedure)
+      end
+    end
+
+    def Before(type=:code, &procedure)
+      __advice__.events.add(:"before_#{type}", &procedure)
+    end
+
+    def After(type=:code, &procedure)
+      __advice__.events.add(:"after_#{type}", &procedure)
+    end
+
+  end
+
+end
+

data/lib/qed/advice/events.rb

@@ -0,0 +1,54 @@
+module QED
+
+  class Advice
+
+    # Event advice: Before, After and Upon.
+    #
+    class Events
+
+      #
+      attr :signals
+
+      #
+      def initialize
+        @signals = [{}]
+      end
+
+      #
+      def add(type, &procedure)
+        @signals.last[type.to_sym] = procedure
+      end
+
+      #
+      def call(type, *args)
+        @signals.each do |set|
+          proc = set[type.to_sym]
+          proc.call(*args) if proc
+        end
+      end
+
+      # Clear last set of advice.
+      def reset
+        @signals.pop
+      end
+
+      #
+      def setup
+        @signals.push {}
+      end
+
+      # Clear advice.
+      def clear(type=nil)
+        if type
+          @signals.each{ |set| set.delete(type.to_sym) }
+        else
+          @signals = [{}]
+        end
+      end
+
+    end
+
+  end
+
+end
+

data/lib/qed/advice/patterns.rb

@@ -0,0 +1,64 @@
+module QED
+
+  # = Patter Advice (When)
+  #
+  # This class tracks When advice defined by demo scripts
+  # and helpers. It is instantiated in Scope, so that
+  # the advice methods will have access to the same
+  # local binding and the demo scripts themselves.
+  #
+  class Patterns
+
+    attr :when
+
+    def initialize
+      @when = []
+    end
+
+    #
+    def add(pattern, &procedure)
+      @when << [pattern, procedure]
+    end
+
+    #
+    def call(match, *args)
+      @when.each do |(pattern, proc)|
+        case pattern
+        when Regexp
+          regex = pattern
+        else
+          regex = when_string_to_regexp(pattern)
+        end
+        if md = regex.match(match)
+          proc.call(*md[1..-1])
+        end
+      end
+    end
+
+  private
+
+    #
+    def when_string_to_regexp(str)
+      str = str.split(/(\(\(.*?\)\))(?!\))/).map{ |x|
+        x =~ /\A\(\((.*)\)\)\z/ ? $1 : Regexp.escape(x)
+      }.join
+      str = str.gsub(/(\\\ )+/, '\s+')
+      Regexp.new(str, Regexp::IGNORECASE)
+
+      #rexps = []
+      #str = str.gsub(/\(\((.*?)\)\)/) do |m|
+      #  rexps << '(' + $1 + ')'
+      #  "\0"
+      #end
+      #str = Regexp.escape(str)
+      #rexps.each do |r|
+      #  str = str.sub("\0", r)
+      #end
+      #str = str.gsub(/(\\\ )+/, '\s+')
+      #Regexp.new(str, Regexp::IGNORECASE)
+    end
+
+  end
+
+end
+

data/lib/qed/command.rb

@@ -3,6 +3,7 @@
 require 'qed'
 require 'optparse'
 require 'shellwords'
+require 'tilt'
 
 module QED
 
@@ -13,6 +14,11 @@ module QED
     # Configuration directory.
     CONFDIR = "{.,}config/qed"
 
+    # Default location of demonstrations if no
+    # specific files or locations given. This
+    # is use in Dir.glob.
+    DEFAULT_DEMOS_LOCATION = '{qed}'
+
     # Initialize and execute.
     def self.execute
       new.execute
@@ -50,18 +56,18 @@ module QED
     attr_accessor :requires
 
     #
-    attr_accessor :env
+    attr_accessor :extension
 
-    #
+    # TODO: Should extension and profile have a common reference?
 
     def initialize
-      @format   = nil
-      @env      = nil
-      @profile  = nil
-      @requires = []
-      @loadpath = []
-      @files    = []
-      @options  = {}
+      @format    = :dotprogress
+      @extension = :default
+      @profile   = :default
+      @requires  = []
+      @loadpath  = []
+      @files     = []
+      @options   = {}
     end
 
     # Instance of OptionParser
@@ -75,31 +81,39 @@ module QED
           o = "--#{name}"
           opt.on(o, "#{name} custom profile") do
             @profile = name
-          end        
+          end
         end
 
-        opt.separator("Report Options (pick one):")
+        opt.separator("Report Formats (pick one):")
 
         opt.on('--dotprogress', '-d', "use dot-progress reporter [default]") do
-          @options[:format] = :summary
+          @options[:format] = :dotprogress
         end
 
         opt.on('--verbatim', '-v', "use verbatim reporter") do
           @options[:format] = :verbatim
         end
 
-        opt.on('--summary', '-s', "use summary reporter") do
-          @options[:format] = :summary
+        opt.on('--bullet', '-b', "use bullet-point reporter") do
+          @options[:format] = :bullet
+        end
+
+        opt.on('--html', '-h', "use underlying HTML reporter") do
+          @options[:format] = :html
         end
 
-        opt.on('--script', "psuedo-reporter") do
-          @options[:script]  # psuedo-reporter
+        opt.on('--format', '-f FORMAT', "use custom reporter") do |format|
+          @options[:format] = format
         end
 
+        #opt.on('--script', "psuedo-reporter") do
+        #  @options[:format] = :script  # psuedo-reporter
+        #end
+
         opt.separator("Control Options:")
 
-        opt.on('--env', '-e [NAME]', "runtime environment [default]") do |name|
-          @options[:env] = name
+        opt.on('--ext', '-e [NAME]', "runtime extension [default]") do |name|
+          @options[:extension] = name
         end
 
         opt.on('--loadpath', "-I PATH", "add paths to $LOAD_PATH") do |arg|
@@ -144,46 +158,32 @@ module QED
     #
 
     def demos
-      demo_files
-    end
-
-    #
-
-    def demo_files
       files = self.files
-
-      #if files.empty?
-      #  if File.directory?('test')
-      #    files << 'test/doc{,s}'
-      #    files << 'test/demo{,s}'
-      #  end
-      #end
-
+      types = Tilt.mappings.keys
+      if files.empty?
+        files << DEFAULT_DEMOS_LOCATION
+      end
       files = files.map do |pattern|
         Dir[pattern]
       end.flatten.uniq
-
       files = files.map do |file|
         if File.directory?(file)
-          Dir[File.join(file,'**','*{.qed,.rd,.rdoc,.md,.markdown}')]
+          Dir[File.join(file,'**','*.{' + types.join(',') + '}')]
         else
           file
         end
       end
-
-      files = files.flatten.uniq
-
+      files = files.flatten.uniq.sort
       #files = files.select do |file| 
       #  %w{.yml .yaml .rb}.include?(File.extname(file))
       #end
-
       files
     end
 
-    # Instance of Runner class.
+    # Session instance.
 
-    def runner
-      Runner.new(demos, :format=>format, :trace=>trace)
+    def session
+      @session ||= Session.new(demos, :format=>format, :trace=>trace)
     end
 
     # Parse command-line options along with profile options.
@@ -194,12 +194,13 @@ module QED
       opts.parse!(argv)
       @files.concat(argv)
 
-      if profile
-        args = profiles[profile]
+      #if profile
+      if args = profiles[profile]
         argv = Shellwords.shellwords(args)
         opts.parse!(argv)
         @files.concat(argv)
       end
+      #end
 
       options.each do |k,v|
         __send__("#{k}=", v)
@@ -216,17 +217,9 @@ module QED
       prepare_loadpath
 
       require_libraries
-      require_environment
+      require_profile
 
-      # TODO: Remove case, can :script be done with Reporter or do we ne need selectable Runner?
-      case format
-      when :script
-        demos.each do |spec|
-          puts spec.to_script
-        end
-      else
-        runner.check
-      end
+      session.run
     end
 
     # Profile configurations.
@@ -250,22 +243,40 @@ module QED
       requires.each{ |file| require(file) }
     end
 
-    # Require requirement file (from -e option.
+    # Require requirement file (from -e option).
 
-    def require_environment
-      if env
-        if file = Dir["#{CONFDIR}/{env,environments}/#{env}.rb"].first
-          require(file)
-        end
-      else
-        if file = Dir["#{CONFDIR}/env.rb"].first
-          require(file)
-        elsif file = Dir["#{CONFDIR}/{env,environments}/default.rb"].first
-          require(file)
-        end
+    def require_profile
+      return unless root
+
+      # common environment, always loaded if present.
+      #if file = Dir["#{root}/#{CONFDIR}/default.rb"].first
+      #  require(file)
+      #end
+
+      #env = env() || 'default'
+
+      if file = Dir["#{root}/#{CONFDIR}/#{extension}.rb"].first
+        require(file)
       end
     end
 
+    #
+    def root
+      QED.root
+    end
+
+  end
+
+  # Is there no perfect way to find root directory of a project?
+  def self.root(path=nil)
+    path ||= Dir.pwd
+    path = File.dirname(path) unless File.directory?(path)
+    until path == File.dirname(path)
+      mark = Dir[File.join(path, 'README*')].first
+      return path if mark
+      path = File.dirname(path)
+    end
+    nil
   end
 
 end

data/lib/qed/config.rb

@@ -1,25 +1,60 @@
 module QED
 
-  class Config
+=begin
+  # Setup global configuration.
+  #
+  #   QED.config do
+  #
+  #     Before(:session) do
+  #       # ...
+  #     end
+  #
+  #     After(:session) do
+  #       # ...
+  #     end
+  #
+  #   end
+  #
+  def self.configure(&block)
+    @config ||= Profile.new #(nil)
+    @config.instance_eval(&block) if block
+    @config
+  end
+=end
 
-    def initialize
-      @local = ['qed', 'demos', 'test/demos']
+  #
+  class Profile
 
-      if file = File.glob('{.,}config/qed.{yml,yaml}')
-        YAML.load(File.new(file)).each do |k,v|
-          __send__("#{k}=", v)
-        end
-      end
+    #
+    def initialize
+      #@local = ['test/demos', 'demos', 'qed']
+  
+      @before = { :session=>[], :demo=>[], :step=>[] }
+      @after  = { :session=>[], :demo=>[], :step=>[] }
+
+      #if file = Dir.glob('{.,}config/qed.{yml,yaml}').first
+      #  YAML.load(File.new(file)).each do |k,v|
+      #    __send__("#{k}=", v)
+      #  end
+      #end
     end
 
-    attr_accessor :local
+    #
+    #attr_accessor :local
 
-    # How ot identify a header?
-    #attr_accessor :header
+    #
+    def Before(type=:session, &procedure)
+      @before[type] << procedure if procedure
+      @before[type]
+    end
 
-    # How ot identify a footer?
-    #attr_accessor :footer
+    #
+    def After(type=:session, &procedure)
+      @after[type] << procedure if procedure
+      @after[type]
+    end
 
   end
 
 end
+