assert-view 0.1.0 → 0.2.0

data/Gemfile.lock

@@ -1,15 +1,18 @@
 PATH
   remote: .
   specs:
-    assert-view (0.1.0)
+    assert-view (0.2.0)
+      undies (~> 1.1)
 
 GEM
   remote: http://rubygems.org/
   specs:
     ansi (1.3.0)
-    assert (0.3.0)
+    assert (0.4.0)
       ansi (~> 1.3)
+      assert-view
     rake (0.9.2)
+    undies (1.1.0)
 
 PLATFORMS
   ruby

data/assert-view.gemspec

@@ -19,4 +19,6 @@ Gem::Specification.new do |s|
 
   s.add_development_dependency("bundler")
   s.add_development_dependency("assert")
+
+  s.add_dependency("undies", ["~> 1.1"])
 end

data/lib/assert/view/base.rb

@@ -1,4 +1,5 @@
 require 'assert/options'
+require 'assert/view/renderer'
 
 module Assert::View
 
@@ -12,49 +13,103 @@ module Assert::View
       default_errored_abbrev  'E'
     end
 
-    attr_reader :suite
+    # the Renderer defines the hooks and callbacks needed for the runner to
+    # work with the view.  It provides:
+    # * 'render': called by the runner to render the view
+    # * 'self.helper': used to provide helper mixins to the renderer template
+    include Renderer
+
+    attr_accessor :suite, :output_io, :runtime_result_callback
 
     def initialize(output_io, suite=Assert.suite)
-      @suite = suite
-      @out = output_io
+      self.suite = suite
+      self.output_io = output_io
     end
 
-    # override this to define how a view calls the runner and renders its results
-    def render(*args, &runner)
+    def view
+      self
     end
 
-    def handle_runtime_result(result)
+
+
+    # TODO: look for files in the .assert dir
+    # TODO: allow option for specifying which template to use
+    # TODO: test
+    def template_file
+      File.expand_path("./templates/#{self.options.template}.rb", File.dirname(__FILE__))
     end
 
-    protected
 
-    def io_puts(msg, opts={})
-      @out.puts(io_msg(msg, opts={}))
+
+    # called by the view template
+    # store off any result_callback
+    # call the runner callback to actually run the tests
+    def run_tests(runner_callback, &result_callback)
+      self.runtime_result_callback = result_callback
+      runner_callback.call if runner_callback
     end
 
-    def io_print(msg, opts={})
-      @out.print(io_msg(msg, opts={}))
+    # callback used by the runner to notify the view of any new results
+    # pipes the runtime result to any result callback block
+    def handle_runtime_result(result)
+      self.runtime_result_callback.call(result) if self.runtime_result_callback
     end
 
+    # get the formatted suite run time
     def run_time(format='%.6f')
-      format % @suite.run_time
+      format % self.suite.run_time
     end
 
     def runner_seed
-      @suite.runner_seed
+      self.suite.runner_seed
     end
 
     def count(type)
-      @suite.count(type)
+      self.suite.count(type)
+    end
+
+    # TODO: test
+    def tests?
+      self.count(:tests) > 0
+    end
+
+    def all_passed?
+      self.count(:passed) == self.count(:results)
     end
 
-    private
+    # return a list of result symbols that have actually occurred
+    def ocurring_result_types
+      @result_types ||= [
+        :passed, :failed, :ignored, :skipped, :errored
+      ].select { |result_sym| self.count(result_sym) > 0 }
+    end
+
+    # print a result summary message for a given result type
+    def result_summary_msg(result_type)
+      if result_type == :passed && self.all_passed?
+        self.all_passed_result_summary_msg
+      else
+        "#{self.count(result_type)} #{result_type.to_s}"
+      end
+    end
+
+    # generate an appropriate result summary msg for all tests passing
+    def all_passed_result_summary_msg
+      if self.count(:results) < 1
+        "uhh..."
+      elsif self.count(:results) == 1
+        "it passed"
+      else
+        "all passed"
+      end
+    end
 
-    def io_msg(msg, opts={})
-      if msg.kind_of?(::Symbol) && self.respond_to?(msg)
-        self.send(msg).to_s
+    # generate a comma-seperated sentence fragment given a list of things
+    def to_sentence(things)
+      if things.size <= 2
+        things.join(things.size == 2 ? ' and ' : '')
       else
-        msg.to_s
+        [things[0..-2].join(", "), things.last].join(", and ")
       end
     end
 

data/lib/assert/view/helpers/ansi.rb

@@ -0,0 +1,25 @@
+require 'ansi/code'
+
+module Assert::View::Helpers
+
+  module AnsiStyles
+
+    def result_ansi_styles(result)
+      view.options.styled ? view.options.send("#{result.to_sym}_styles") : []
+    end
+
+    def ansi_styled_msg(msg, styles=[])
+      if !(style = ansi_style(*styles)).empty?
+        style + msg + ANSI.send(:reset)
+      else
+        msg
+      end
+    end
+
+    def ansi_style(*ansi_codes)
+      ansi_codes.collect{|code| ANSI.send(code) rescue nil}.compact.join('')
+    end
+
+  end
+
+end

data/lib/assert/view/renderer.rb

@@ -0,0 +1,45 @@
+require 'undies'
+
+module Assert::View
+
+  # this module is mixed in to the Assert::View::Base class
+  # it use Undies to define and render view templates
+  module Renderer
+
+    def self.included(receiver)
+      receiver.send(:extend, ClassMethods)
+    end
+
+    # define rendering template class to use for rendering
+    # need to overwrite the '_' and '__' meths to add trailing newlines
+    # b/c streaming output doesn't add any whitespace
+    class Template < ::Undies::Template
+
+      def _(data="", nl=true);  super(data.to_s + (nl ? "\n" : "")); end
+      def __(data="", nl=true); super(data.to_s + (nl ? "\n" : "")); end
+
+    end
+
+    # this method is required by assert and is called by the test runner
+    # use Undies to render the template
+    # using the view's template file
+    # streaming to the view's output io
+    # passing in the view itself and any runner_callback as locals
+    def render(*args, &runner_callback)
+      Template.new(File.expand_path(self.template_file), self.output_io, {
+        :view => self,
+        :runner => runner_callback
+      })
+    end
+
+    module ClassMethods
+
+      # make any helper methods available to the template
+      def helper(helper_klass)
+        Template.send(:include, helper_klass)
+      end
+
+    end
+
+  end
+end

data/lib/assert/view/templates/assert.ansi.rb

@@ -0,0 +1,36 @@
+__
+__ view.loaded_tests_statement
+
+if view.tests?
+
+  __ view.running_tests_statement
+
+  view.run_tests(runner) do |each_result|
+    result_sym = each_result.to_sym
+    result_abbrev = view.options.send("#{result_sym}_abbrev")
+    __ ansi_styled_msg(result_abbrev, result_ansi_styles(result_sym)), false
+  end
+  __ "\n"  # add a newline after streamed runner output
+
+  view.detailed_results do |result, output|
+    __ ansi_styled_msg(result.to_s, result_ansi_styles(result))
+
+    if !output.empty?
+      __ view.result_output_start_msg
+      __ output, false
+      __ view.result_output_end_msg
+    end
+
+    __
+  end
+
+end
+
+# build a summary sentence w/ styled results breakdown
+styled_results_breakdown_statement = view.results_breakdown_statement do |msg, result_type|
+  ansi_styled_msg(msg, result_ansi_styles(result_type))
+end
+
+__ [ view.result_count_statement, ": ", styled_results_breakdown_statement ].join('')
+__
+__ view.run_time_statement

data/lib/assert/view/terminal.rb

@@ -1,129 +1,64 @@
-require 'assert/view/base'
 require 'assert/result'
-
-require 'ansi/code'
+require 'assert/options'
+require 'assert/view/base'
 
 module Assert::View
 
   class Terminal < Base
 
-    options do
-      default_styled          false
-      default_passed_styles   :green
-      default_failed_styles   :red, :bold
-      default_errored_styles  :yellow, :bold
-      default_skipped_styles  :cyan
-      default_ignored_styles  :magenta
-    end
-
-    def render(*args, &runner)
-      self.io_puts(:load_stmt)
-
-      if count(:tests) > 0
-        self.io_puts(:run_stmt)
-        runner.call if runner
-        self.io_puts(:detailed_results)
-      end
-
-      self.io_puts(:results_stmt)
+    def loaded_tests_statement
+      "Loaded suite (#{view.count(:tests)} test#{'s' if view.count(:tests) != 1})"
     end
 
-    def handle_runtime_result(result)
-      sym = result.to_sym
-      self.io_print(result_io_msg(self.options.send("#{sym}_abbrev"), sym))
-    end
-
-    protected
-
-    def load_stmt
-      tplur = (tcount = count(:tests)) == 1 ? "test": "tests"
-      "\nLoaded suite (#{tcount} #{tplur})"
+    def running_tests_statement
+      "Running tests in random order, seeded with: \"#{self.runner_seed}\""
     end
 
-    def run_stmt
-      "Running tests in random order, seed: '#{self.runner_seed}'"
+    # show test details in reverse order from how they were collected (FILO)
+    def detailed_tests
+      @detailed_tests ||= self.suite.ordered_tests.reverse
     end
 
-    def detailed_results
-      details = self.suite.ordered_tests.reverse.collect do |test|
-        test.results.collect do |result|
-          if show_result_details?(result)
-            [ result_io_msg(result.to_s, result.to_sym),
-              output_io_msg(test.output.to_s)
-            ].join("\n")
-          end
-        end
-      end.flatten.compact
-      "\n\n" + details.join("\n\n") if !details.empty?
+    # get all the results that have details to show
+    # in addition, if a block is given...
+    # yield each result with its test output
+    def detailed_results(test=nil)
+      tests = test.nil? ? self.detailed_tests : [test]
+      tests.collect do |test|
+        test.results.
+        select { |result| self.show_result_details?(result) }.
+        each {|r| yield r, test.output if block_given?}
+      end.compact.flatten
     end
 
-    def results_stmt
-      rplur = (rcount = count(:results)) == 1 ? "result" : "results"
-      [ "\n",
-        "#{rcount} test #{rplur}: ", results_breakdown, "\n\n",
-        "(#{self.run_time} seconds)"
-      ].join('')
+    # only show result details for failed or errored results
+    # show result details if a skip or passed result was issues w/ a message
+    def show_result_details?(result)
+      ([:failed, :errored].include?(result.to_sym)) ||
+      ([:skipped, :ignored].include?(result.to_sym) && result.message)
     end
 
-    def results_breakdown
-      if count(:passed) == count(:results)
-        stmnt = if count(:results) < 1
-          "uhh..."
-        elsif count(:results) == 1
-          "it passed"
-        else
-          "all passed"
-        end
-        result_io_msg(stmnt, :passed)
-      else
-        breakdowns = [:passed, :failed, :ignored, :skipped, :errored]
-        breakdowns = breakdowns.inject([]) do |results, result_sym|
-          results << (if count(result_sym) > 0
-            result_io_msg("#{count(result_sym)} #{result_sym}", result_sym)
-          end)
-        end.compact
-        if breakdowns.size < 2
-          breakdowns.join('')
-        elsif breakdowns.size == 2
-          breakdowns.join(" and ")
-        else
-          [breakdowns[0..-2].join(", "), breakdowns.last].join(", and ")
-        end
-      end
+    def result_output_start_msg
+      "--- stdout ---"
     end
-
-    def result_io_msg(msg, result_sym)
-      term_styles = if self.options.styled
-        self.options.send("#{result_sym}_styles")
-      end
-      io_msg(msg, :term_styles => term_styles)
+    def result_output_end_msg
+      "--------------"
     end
 
-    def output_io_msg(output)
-      if output && !output.empty?
-        [ "--- stdout ---",
-          io_msg(output),
-          "--------------"
-        ].collect{|i| i.strip}.join("\n")
-      end
+    # generate a sentence fragment describing the breakdown of test results
+    # if a block is given, yield each msg in the breakdown for custom template formatting
+    def results_breakdown_statement
+      self.to_sentence(self.ocurring_result_types.collect do |result_type|
+        yield(self.result_summary_msg(result_type), result_type) if block_given?
+      end)
     end
 
-    def io_msg(msg, opts={})
-      val = super
-      if !(style = term_style(*opts[:term_styles])).empty?
-        val = style + val + ANSI.send(:reset)
-      else
-        val
-      end
+    def result_count_statement
+      "#{self.count(:results)} test result#{'s' if self.count(:results) != 1}"
     end
 
-    def term_style(*ansi_codes)
-      ansi_codes.collect{|code| ANSI.send(code) rescue nil}.compact.join('')
-    end
-
-    def show_result_details?(result)
-      ([:failed, :errored].include?(result.to_sym)) ||
-      ([:skipped, :ignored].include?(result.to_sym) && result.message)
+    def run_time_statement
+      "(#{self.run_time} seconds)"
     end
 
   end

data/lib/assert/view/version.rb

@@ -1,5 +1,5 @@
 module Assert; end
 
 module Assert::View
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/assert/view.rb

@@ -1,2 +1,2 @@
 module Assert; end
-module Assert::Views; end
+module Assert::View; end

data/test/base_test.rb

@@ -7,16 +7,26 @@ require 'stringio'
 module Assert::View
 
   class BaseTest < Assert::Context
-    desc "the view base"
+    desc "the base view"
     setup do
       @view = Assert::View::Base.new(Assert::Suite.new, StringIO.new("", "w+"))
     end
     subject{ @view }
 
-    should have_reader :suite
-    should have_instance_methods :render, :handle_runtime_result, :options
+    should have_accessors :suite, :output_io, :runtime_result_callback
+    should have_instance_methods :template_file, :run_tests, :handle_runtime_result
+    should have_instance_methods :run_time, :runner_seed, :count, :tests?, :all_passed?
+    should have_instance_methods :ocurring_result_types, :result_summary_msg
+    should have_instance_methods :all_passed_result_summary_msg, :to_sentence
+
+    # options stuff
+    should have_instance_method :options
     should have_class_method :options
 
+    # renderer stuff
+    should have_instance_method :render
+    should have_class_method :helper
+
   end
 
   class BaseOptionsTest < Assert::Context
@@ -39,6 +49,4 @@ module Assert::View
 
   end
 
-
-
 end

data/test/terminal_test.rb

@@ -1,32 +1,22 @@
 require 'assert'
-require 'assert/options'
 
 require 'assert/view/terminal'
+require 'stringio'
 
 module Assert::View
 
-  class TerminalOptionsTest < Assert::Context
-    desc "options for the terminal view"
-    subject do
-      Assert::View::Terminal.options
+  class TerminalTest < Assert::Context
+    desc "the terminal view"
+    setup do
+      @view = Assert::View::Terminal.new(Assert::Suite.new, StringIO.new("", "w+"))
     end
+    subject{ @view }
 
-    should "be an Options::Base object" do
-      assert_kind_of Assert::Options::Base, subject
-    end
-
-    should "default the styled option" do
-      assert_equal false, subject.default_styled
-    end
-
-    should "default its result styles" do
-      assert_equal :green, subject.default_passed_styles
-      assert_equal [:red, :bold], subject.default_failed_styles
-      assert_equal :magenta, subject.default_ignored_styles
-      assert_equal :cyan, subject.default_skipped_styles
-      assert_equal [:yellow, :bold], subject.default_errored_styles
-    end
+    should have_instance_methods :loaded_tests_statement, :running_tests_statement
+    should have_instance_methods :detailed_tests, :detailed_results, :show_result_details?
+    should have_instance_methods :result_output_start_msg, :result_output_end_msg
+    should have_instance_methods :results_breakdown_statement, :result_count_statement
+    should have_instance_methods :run_time_statement
 
   end
-
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: assert-view
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 23
   prerelease: 
   segments: 
   - 0
-  - 1
+  - 2
   - 0
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Kelly Redding
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-08-31 00:00:00 Z
+date: 2011-09-08 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   type: :development
@@ -45,6 +45,21 @@ dependencies:
         version: "0"
   version_requirements: *id002
   name: assert
+- !ruby/object:Gem::Dependency 
+  type: :runtime
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 13
+        segments: 
+        - 1
+        - 1
+        version: "1.1"
+  version_requirements: *id003
+  name: undies
 description: A collection of views for use in the Assert testing framework
 email: 
 - kelly@kelredd.com
@@ -63,6 +78,9 @@ files:
 - assert-view.gemspec
 - lib/assert/view.rb
 - lib/assert/view/base.rb
+- lib/assert/view/helpers/ansi.rb
+- lib/assert/view/renderer.rb
+- lib/assert/view/templates/assert.ansi.rb
 - lib/assert/view/terminal.rb
 - lib/assert/view/version.rb
 - test/base_test.rb