graham 0.0.0

data/README.md

@@ -0,0 +1,36 @@
+# Graham #
+
+Graham is a tiny-yet-useful testing library based on Mallow - in fact it _is_ Mallow, with a tweaked DSL and some extra exception handling, bundled with a trivial pretty printer and a helper for Rake tasks. It was written to handle Mallow's unit tests because:
+* Test::Unit was too ugly
+* TestRocket was too minimal
+* RSpec was too verbose (not to mention ridiculous overkill)
+
+## How i graham ##
+
+Graham test cases are instance methods on classes defined in Graham's namespace:
+```ruby
+  class Graham::TestCases
+    def initialize
+      @number = 1
+    end
+    def Case1
+      @number ** 2
+    end
+    def Case2
+      @number / 0
+    end
+    def Case3
+      Graham.this_is_not_a_method
+    end
+  end
+```
+Then test your cases:
+```ruby
+  Graham.test(:TestCases) do |that|
+    that.Case1.is_such_that { self == 1 }
+    that.Case2.is_a(Fixnum).such_that {self > 1}
+    that.Case3.does_not_raise_an_exception
+  end #=> {:Case1=>true, :Case2=>#<ZeroDivisionError>, :Case3=>false}
+```
+Calling Graham#pp instead will call Graham#test and run the output through Graham's built-in pretty printer.
+

data/Rakefile

@@ -0,0 +1,17 @@
+$LOAD_PATH << File.expand_path('../lib', __FILE__)
+require 'rake'
+require 'graham/rake_task'
+
+Graham::RakeTask.new
+task default: :test
+
+namespace :gem do
+  task :build do
+    sh "gem b graham.gemspec"
+  end
+  task :install do
+    sh "gem i #{Dir.glob('graham-*.gem').sort.last}"
+  end
+end
+task gem: %w{ gem:build gem:install }
+

data/graham.gemspec

@@ -0,0 +1,17 @@
+$LOAD_PATH << File.expand_path('../lib', __FILE__)
+require 'rake'
+require 'graham/version'
+
+graham = Gem::Specification.new do |spec|
+  spec.add_dependency 'mallow'
+  spec.name        = 'graham'
+  spec.version     = Graham::VERSION
+  spec.author      = 'feivel jellyfish'
+  spec.email       = 'feivel@sdf.org'
+  spec.files       = FileList['README.md','graham.gemspec', 'lib/**/*.rb']
+  spec.test_files  = FileList['Rakefile','test/**/*.rb']
+  spec.homepage    = 'http://github.com/gwentacle/graham'
+  spec.summary     = 'Miniature test engine based on Mallow'
+  spec.description = 'Miniature test engine based on Mallow'
+end
+

data/lib/graham/pp.rb

@@ -0,0 +1,34 @@
+# A trivial pretty printer for test output.
+# TODO: replace with something better
+module Graham
+  class PP
+    attr_reader :results
+    attr_accessor :bt, :out, :color
+    BOLD  = "\x1b[1m"
+    PLAIN = "\x1b[0m"
+    GREEN = "\x1b[32m"
+    RED   = "\x1b[31m"
+    def initialize(results, bt=0, out=$stdout, color=true)
+      @results, @bt, @out, @color = results, bt, out, color
+    end
+    def pp
+      results.each do |name, result|
+        out.puts case result
+        when true
+          [hi('PASS', GREEN), lo(name)]
+        when false
+          [hi('FAIL', RED),   lo(name)]
+        else
+          [hi('XPTN', RED),   lo(name), result.class.name, result.message] + backtrace(result, bt)
+        end.join ' :: '
+      end
+    end
+    private
+    def backtrace(e,n)
+      n>0 ? ["\n" << e.backtrace.first(n).map {|s| "  "+s}.join("\n")] : []
+    end
+
+    def hi(str, c); (color ? BOLD+c : '')+str.to_s  end
+    def lo(str);    (color ? PLAIN  : '')+str.to_s  end
+  end
+end

data/lib/graham/rake_task.rb

@@ -0,0 +1,65 @@
+require 'graham'
+# Rake task generator for Graham. Usage is just:
+#  # in Rakefile
+#  require 'graham/rake_task'
+#  Graham::RakeTask.new( options )
+# Options (all optional) are:
+# :dir:: The directory (relative to the Rakefile) where Graham should look for
+#        tests. Default is 'test'
+# :name:: The namespace for generated Rake tasks. Default is 'test'
+# :ignore:: Directories under the test directory that will be ignored for the
+#           purpose of generating namespaced Rake tasks.
+# Let _name_ be the chosen namespace for tests. Then this will
+# 1. Create the task _name_:_folder_ for each subfolder _folder_ under the
+#    testing directory, which (non-recursively) loads each file in _folder_;
+# 2. Create the task _name_, which pulls in all tasks created by (1);
+# 3. For each task _t_ created by (1) and (2), create the task _t_:timed that 
+#    outputs the running time of _t_ once it finishes.
+#
+class Graham::RakeTask
+  include Rake::DSL
+  def initialize(opts = {})
+    @dir    = opts[:dir]    || :test
+    @ignore = opts[:ignore] || []
+    @name   = opts[:name]   || @dir
+    make_task
+  end
+
+  private
+  def make_task
+    tests = []
+    namespace @name do
+      namespace :timed do
+        task :start do
+          @start = Time.now
+        end
+        task :stop do
+          puts "Finished in #{Time.now - @start} seconds."
+        end
+      end
+      test_groups.each do |group|
+        tests << name = group.sub(/\//,?:).sub(@dir.to_s,@name.to_s)
+        desc "[Graham] load files in #{group}"
+        task name.sub(/^#{@name}:/,'') do
+          Dir["#{group}/*.rb"].each do |file|
+            puts "\x1b[4m        #{file.sub(/\.rb$/,'')}\x1b[0m"
+            load file
+          end
+        end
+      end
+      task timed: [ "#{@name}:timed:start", @name, "#{@name}:timed:stop" ]
+    end
+    desc "[Graham] load all test files"
+    task @name => tests
+    tests.each do |test|
+      task "#{test}:timed" => [ "#{@name}:timed:start", test, "#{@name}:timed:stop" ]
+    end
+  end
+
+  def test_groups
+    ignore = [*@ignore].map {|d| %r|^#{@dir}/#{d}|}
+    FileList["#{@dir}/**/*"].select {|f| File.directory? f}
+      .reject {|d| ignore.any? {|i| d=~i}}
+  end
+end
+

data/lib/graham/version.rb

@@ -0,0 +1,3 @@
+module Graham
+  VERSION = '0.0.0'
+end

data/lib/graham.rb

@@ -0,0 +1,178 @@
+$LOAD_PATH << File.dirname(__FILE__)
+require 'mallow'
+require 'graham/version'
+# == A miniature test engine powered by Mallow
+# ---
+# Test cases are instance methods on classes defined in Graham's namespace,
+# and expectations on their return values are enumerated using a very slightly
+# modified Mallow::DSL.
+# 
+#  class Graham::Cases
+#    def test1; 4 + 5 end
+#    def test2; 'test'.upcase end
+#    def test3; 1/0 end
+#  end
+#
+#  Graham.test { |that|
+#    that.test1.returns_a(Fixnum).such_that {self < 100}
+#    that.test2.returns 'TeST'
+#    that.test3.returns_a Numeric
+#  } #=> {:test1=>true, :test2=>false, :test3=>#<ZeroDivisionError>}
+#
+# A side effect of this approach is that you can use RDoc to document your
+# tests, gauge coverage, etc.
+#
+# === N.B.
+# Since a Graham test is basically a Mallow pattern matcher, only the first
+# test on a case will actually be executed, as subsequent invocations of the
+# test case will be matched by the first rule. This can lead to confusing
+# results:
+#
+#  Graham.test { |that|
+#    that.test1.returns_a(Fixnum)
+#    that.test1.returns_a(String)
+#  } #=> {:test1=>true}
+#
+# To avoid this issue, either run separate tests:
+#
+#  Graham.test {|that| that.test1.returns_a Fixnum} #=> {:test1=>true}
+#  Graham.test {|that| that.test1.returns_a String} #=> {:test1=>false}
+# 
+# Or (better) chain the tests you want to run:
+# 
+#  Graham.test { |that|
+#    that.test1.returns_a(Fixnum).and_returns_a(String)
+#  } #=> {:test1=>false}
+#
+module Graham
+  autoload :PP,       'graham/pp'
+  autoload :RakeTask, 'graham/rake_task'
+  # Namespace for test cases; see documentation for Graham
+  class Cases; end
+  class << self
+    # A convenience method that builds and executes a Graham::Core
+    # in the given namespace (defaults to Cases). See documentation for
+    # Graham for more on usage.
+    def test(ns=self::Cases, &b)
+      ns=const_get(ns) if ns.is_a? Symbol
+      Graham::Core.build(ns, &b).test
+    end
+    # A convenience methods that calls ::test and passes the output to a
+    # pretty printer.
+    def pp(ns=self::Cases, &b)
+      PP.new(test ns,&b).pp
+    end
+
+    def compose(ns=nil, *test_groups)
+
+    end
+
+    alias test_in test
+
+    private
+    def ns_compose(test_groups)
+      test_groups.map do |ns, tests|
+        [ ns, tests.map {|test| test ns, &test} ]
+      end
+    end
+
+  end
+
+  class Core < Mallow::Core
+    attr_accessor :cases
+    def initialize(*args)
+      @cases = []
+      super
+    end
+
+    def _fluff1(e)
+      [e.name] << begin
+        super e
+        true
+      rescue Mallow::DeserializationException
+        false
+      rescue => err
+        err
+      end
+    end
+
+    def test; Hash[_fluff @cases] end
+    def self.build(ns, &b); DSL.build ns, &b end
+  end
+
+  class DSL < Mallow::DSL
+
+    def self.build(ns)
+      yield(dsl = new(ns))
+      dsl.finish!
+    end
+
+    def initialize(ns)
+      @core, @cases = Core.new, ns.new
+      reset!
+    end
+
+    def method_missing(msg, *args, &b)
+      case msg.to_s
+      when /^((and|that)_)+(.+)$/
+        respond_to?($3)? send($3, *args, &b) : super
+      else
+        core.cases << (_case = @cases.method msg) rescue super
+        rule!._this _case
+      end
+    end
+
+    def _where(&b); push b, :conditions              end
+    def _this(o);   _where {|e|e==o}                 end
+    def where(&b);  _where {|e| preproc(b)[e.call] } end
+
+    def raises(x=nil)
+      _where {
+        begin
+          call
+          false
+        rescue x => e
+          true
+        rescue   => e
+          x ? raise(e) : true
+        end
+      }
+    end
+
+    def does_not_raise(x=nil)
+      _where {
+        begin
+          call
+          true
+        rescue x => e
+          false
+        rescue   => e
+          x ? raise(e) : false
+        end
+      }
+    end
+
+    alias is      this
+    alias returns this
+
+    alias is_such_that where
+    alias such_that    where
+    alias and          where
+    alias that         where
+
+    alias raises_an           raises
+    alias raises_a            raises
+    alias raises_an_exception raises
+
+    alias returns_                    does_not_raise
+    alias does_not_raise_a            does_not_raise
+    alias does_not_raise_an           does_not_raise
+    alias does_not_raise_an_exception does_not_raise
+
+    alias is_a       a
+    alias is_an      a
+    alias returns_a  a
+    alias returns_an a
+
+  end
+end

data/test/case/control.rb

@@ -0,0 +1,10 @@
+class Graham::Cases
+  def NinetyNine; 99 end
+  def NameError; raise Asdf.qwer.ty / 0 end
+end
+
+Graham.pp {|that|
+  that.NinetyNine.returns_a(Fixnum).such_that {self==99}.and_that_is 99
+  that.NameError.raises.and_raises_a NameError
+}
+

data/test/case/test.rb

@@ -0,0 +1,57 @@
+class Graham::Cases
+  def DocTest1; 4 + 5 end
+  def DocTest2; 'test'.upcase end
+  def DocTest3; 1/0  end
+  def RDocExample
+    Graham.test { |that|
+      that.DocTest1.returns_a(Fixnum).such_that {self < 100}
+      that.DocTest2.returns 'TeST'
+      that.DocTest3.returns_a Numeric
+    }
+  end
+
+  def initialize
+    @number = 1
+  end
+  def ReadmeCase1
+    @number ** 2
+  end
+  def ReadmeCase2
+    @number / 0
+  end
+  def ReadmeCase3
+    Graham.this_is_not_a_method
+  end
+  def ReadmeExample
+    Graham.test do |that|
+      that.ReadmeCase1.is_such_that { self == 1 }
+      that.ReadmeCase2.is_a(Fixnum).such_that {self > 1}
+      that.ReadmeCase3.does_not_raise_an_exception
+    end 
+  end
+end
+
+class Graham::Namespace
+  def Namespacing; self end
+end
+
+Graham.pp do |that|
+  that.RDocExample.returns_a(Hash).of_size(3).such_that {
+    self[:DocTest1] == true  and
+    self[:DocTest2] == false and
+    self[:DocTest3].is_a? ZeroDivisionError
+  }
+  that.ReadmeExample.returns_a(Hash).of_size(3).such_that {
+    self[:ReadmeCase1] == true and
+    self[:ReadmeCase2].is_a? ZeroDivisionError and
+    self[:ReadmeCase3] == false
+  }
+end
+
+Graham.pp(:Namespace) do |that|
+  that.Namespacing.is_such_that {
+    self.class == Graham::Namespace
+  }.and {!respond_to? :DocExample
+  }.and { respond_to? :Namespacing}
+end
+

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification
+name: graham
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+  prerelease: 
+platform: ruby
+authors:
+- feivel jellyfish
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-11-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mallow
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Miniature test engine based on Mallow
+email: feivel@sdf.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- graham.gemspec
+- lib/graham.rb
+- lib/graham/rake_task.rb
+- lib/graham/pp.rb
+- lib/graham/version.rb
+- Rakefile
+- test/case/control.rb
+- test/case/test.rb
+homepage: http://github.com/gwentacle/graham
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Miniature test engine based on Mallow
+test_files:
+- Rakefile
+- test/case/control.rb
+- test/case/test.rb