lemon 0.8.4 → 0.8.5

data/work/deprecated/command/generate.rb

@@ -0,0 +1,124 @@
+module Lemon
+module Command
+  require 'lemon/command/abstract'
+
+  # Lemon Generate Command-line tool.
+  class Generate < Abstract
+    require 'lemon/coverage'
+
+    #
+    def self.subcommand
+      'generate' #['-g', '--generate']
+    end
+
+    # Initialize and run.
+    def self.run
+      new.run
+    end
+
+    # New Command instance.
+    def initialize
+      @requires    = []
+      @includes    = []
+      @namespaces  = []
+      @public_only = false
+      @uncovered   = false
+    end
+
+    # TODO: Support output ? perhaps complex scaffolding
+    #attr_accessor :output
+
+    #
+    attr_accessor :public_only
+
+    #
+    attr_accessor :uncovered
+
+    #
+    def public_only?
+      @public_only
+    end
+
+    #
+    def uncovered_only?
+      @uncovered
+    end
+
+    # Get or set librarires to pre-require.
+    def requires(*paths)
+      @requires.concat(paths) unless paths.empty?
+      @requires
+    end
+
+    # Get or set paths to include in $LOAD_PATH.
+    def includes(*paths)
+      @includes.concat(paths) unless paths.empty?
+      @includes
+    end
+
+    #
+    def namespaces(*names)
+      @namespaces.concat(names) unless names.empty?
+      @namespaces
+    end
+
+    # Instance of OptionParser.
+    def parser
+      @parser ||= OptionParser.new do |opt|
+        opt.banner = "lemon generate [OPTIONS]"
+        opt.separator("Generate unit test scaffolding.")
+        opt.on("--namespace", "-n [NAME]", "limit tests to this namespace") do |name|
+          namespaces(name)
+        end
+        opt.on("--public", "-p", "only include public methods") do
+          self.public_only = true
+        end
+        opt.on("--uncovered", "-u", "only include uncovered methods") do
+          self.uncovered = true
+        end
+        #opt.on("--output", "-o [PATH]", "output directory") do |path|
+        #  self.output = path
+        #end
+        opt.on("-r [FILES]" , "library files to require") do |files|
+          files = files.split(/[:;]/)
+          requires(*files)
+        end
+        opt.on("-I [PATH]" , "include in $LOAD_PATH") do |path|
+          path = path.split(/[:;]/)
+          includes(*path)
+        end
+        opt.on("--debug" , "turn on debugging mode") do
+          $DEBUG = true
+        end
+        opt.on_tail("--help", "-h", "show this help message") do
+          puts opt
+          exit
+        end
+      end
+    end
+
+    # Generate test skeletons.
+    def run
+      parser.parse!
+
+      test_files = ARGV.dup
+
+      includes.each{ |path| $LOAD_PATH.unshift(path) }
+      requires.each{ |path| require(path) }
+
+      suite = Lemon::Test::Suite.new(test_files, :cover=>true)
+      cover = Lemon::Coverage.new(suite, namespaces, :public=>public_only?)
+      #cover  = Lemon::Coverage.new([], namespaces, :public=>public_only?, :uncovered=>uncovered_only?)
+
+      if uncovered_only?
+        puts cover.generate_uncovered #(output)
+      else
+        puts cover.generate #(output)
+      end
+    end
+
+  end
+
+end
+end
+

data/work/deprecated/command/test.rb

@@ -0,0 +1,112 @@
+module Lemon
+module Command
+  require 'lemon/command/abstract'
+
+  # Lemon Test Command-line tool.
+  class Test < Abstract
+    require 'lemon/runner'
+
+    def self.subcommand
+      'test'
+    end
+
+    # Initialize and run.
+    def self.run
+      new.run
+    end
+
+    # New Command instance.
+    def initialize
+      @format      = nil
+      @cover       = false
+      @requires    = []
+      @includes    = []
+      @namespaces  = []
+    end
+
+    #
+    attr_accessor :format
+
+    #
+    attr_accessor :cover
+
+    # Get or set librarires to pre-require.
+    def requires(*paths)
+      @requires.concat(paths) unless paths.empty?
+      @requires
+    end
+
+    # Get or set paths to include in $LOAD_PATH.
+    def includes(*paths)
+      @includes.concat(paths) unless paths.empty?
+      @includes
+    end
+
+    #
+    def namespaces(*names)
+      @namespaces.concat(names) unless names.empty?
+      @namespaces
+    end
+
+    # Instance of OptionParser.
+    def parser
+      @parser ||= OptionParser.new do |opt|
+        opt.banner = "lemon [options] [test-files ...]"
+        opt.separator("Run unit tests.")
+        opt.separator("OPTIONS:")
+        #opt.on('--coverage', '-c', "include coverage informarton") do
+        #  self.cover = true
+        #end
+        opt.on('--verbose', '-v', "select verbose report format") do |type|
+          self.format = :verbose
+        end
+        opt.on('--outline', '-o', "select outline report format") do |type|
+          self.format = :outline
+        end
+        opt.on('--format', '-f [TYPE]', "select report format") do |type|
+          self.format = type
+        end
+        opt.on("--namespace", "-n [NAME]", "limit testing to this namespace") do |name|
+          namespaces(name)
+        end
+        opt.on("-r [FILES]" , 'library files to require') do |files|
+          files = files.split(/[:;]/)
+          requires(*files)
+        end
+        opt.on("-I [PATH]" , 'include in $LOAD_PATH') do |path|
+          paths = path.split(/[:;]/)
+          includes(*paths)
+        end
+        opt.on("--debug" , 'turn on debugging mode') do
+          $DEBUG = true
+        end
+        opt.on_tail('--help', '-h', 'show this help message') do
+          puts opt
+          exit
+        end
+      end
+    end
+
+    # Run unit tests.
+    def run
+      parser.parse!
+
+      files = ARGV.dup
+
+      includes.each{ |path| $LOAD_PATH.unshift(path) }
+      requires.each{ |path| require(path) }
+
+      #suite  = Lemon::Test::Suite.new(files, :cover=>cover)
+      #runner = Lemon::Runner.new(suite, :format=>format, :cover=>cover, :namespaces=>namespaces)
+
+      suite  = Lemon::Test::Suite.new(files)
+      runner = Lemon::Runner.new(suite, :format=>format, :namespaces=>namespaces)
+
+      runner.run
+    end
+
+  end
+
+end
+end
+

data/work/reference/dsl2.rb

@@ -0,0 +1,136 @@
+require 'ae'
+
+module Lemon
+
+  def self.suite
+    @suite ||= Suite.new(Runner.new(Reporter.new))
+  end
+
+  def self.suite=(suite)
+    @suite = suite
+  end
+
+  class Context
+    def initialize(desc=nil)
+      @desc   = desc
+      @before = {}
+      @after  = {}
+    end
+
+    def description
+      @desc
+    end
+
+    def before(which, &block)
+      @before[which] = block if block
+      @before[which]
+    end
+
+    def after(which, &block)
+      @after[which] = block if block
+      @after[which]
+    end
+  end
+
+  class Suite
+    def initialize(runner)
+      @runner = runner
+    end
+
+    def before(which, &block)
+      @runner.before(which, &block)
+    end
+
+    def after(which, &block)
+      @runner.after(which, &block)
+    end
+
+    def unit(mod, meth, desc=nil, &block)
+      @runner.unit(mod, meth, desc, &block)
+    end
+
+    def context(desc, &block)
+      @runner.context(desc, &block)
+    end
+  end
+
+  # Runner is a listner.
+  class Runner
+    #
+    def initialize(*reporters)
+      @reporters = reporters
+      #@before = {} #Hash.new{|h,k| h[k]=[]}
+      #@after  = {} #Hash.new{|h,k| h[k]=[]}
+      @context_stack = [Context.new]
+    end
+
+    def before(which, &block)
+      @context_stack.last.before(which, &block)
+      @reporters.each do |reporter|
+        reporter.before(which, &block)
+      end
+    end
+
+    def after(which, &block)
+      @context_stack.last.after(which, &block)
+      @reporters.each do |reporter|
+        reporter.after(which, &block)
+      end
+    end
+
+    def instance(desc, &block)
+      @instance = Context.new(desc, &block)
+    end
+
+    def unit(mod, meth, desc=nil, &block)
+      @reporters.each do |reporter|
+        reporter.unit(mod, meth, desc, &block)
+      end
+
+      if @instance && block.arity != 0
+        block.call(@instance.call)
+      else
+        block.call
+      end
+
+    end
+  end
+
+  class Reporter
+    #
+    def initialize
+    end
+
+    def before(which, &block)
+    end
+
+    def after(which, &block)
+    end
+
+    def unit(mod, meth, desc=nil, &block)
+      puts "%s#%s %s" % [mod.name, meth.to_s, desc]
+    end
+  end
+
+end
+
+
+#
+def before(which, &block)
+  Lemon.suite.before(which, &block)
+end
+
+#
+def after(which, &block)
+  Lemon.suite.after(which, &block)
+end
+
+#
+def unit(mod, meth, desc=nil, &blk)
+  Lemon.suite.unit(mod, meth, desc, &blk)
+end
+
+def context(desc, &block)
+  Lemon.suite.context(desc, &block)
+end
+

data/work/reference/dynamic_constant_lookup.rb

@@ -0,0 +1,76 @@
+  #
+  module M
+    def m1; "m1"; end
+    module N
+      def self.n1; "n1"; end
+    end
+  end
+
+  class X
+    class << self
+      alias _new new
+      def new(&block)
+        klass = Class.new(self)
+        klass.module_eval(&block)
+        klass._new
+      end
+    end
+
+    def m ; m1 ; end
+    def n ; N.n1 ; end
+  end
+
+  x = X.new do
+    include M
+  end
+
+  p x.m
+  p x.n
+
+
+exit
+
+class X
+  attr :set
+  def initialize(&block)
+    @set = {}
+    instance_eval(&block)
+  end
+  def defset(name, &block)
+    @set[name] = block
+  end
+  def include(*mods)
+    (class << self; self; end).class_eval do
+      include *mods
+    end
+  end
+end
+
+#
+module M
+  def m1; "m1"; end
+  module N
+    def self.n1; "n1"; end
+  end
+end
+
+x = X.new do
+
+  include M
+
+  #Before /returns/ do |unit|
+  #  puts "returns something"
+  #end
+
+  defset :m do
+    m1 == "m1"
+  end
+
+  defset :n do
+    N.n1 == "n1"
+  end
+
+end
+
+x.set[:m].call
+x.set[:n].call