lizarb 1.0.4 → 1.0.6

data/lib/liza/test_parts/test_assertions_advanced_part.rb

@@ -1,125 +0,0 @@
-class Liza::TestAssertionsAdvancedPart < Liza::Part
-  insertion do
-    
-    def assert_equality a, b, msg = nil, kaller: nil
-      ret = a == b
-
-      if ret
-        self.class._assertion_passed
-        @last_result = :passed
-      else
-        self.class._assertion_failed msg
-        @last_result = :failed
-      end
-
-      kaller ||= caller
-      log_test_assertion __method__, kaller if _groups.empty?
-
-      if log_test_assertion_message?
-        msg ||= "#{__method__} #{a}, #{b} (== equality)"
-        log_test_assertion_message ret, msg
-      end
-
-      ret
-    end
-
-    def refute_equality a, b, msg = nil, kaller: nil
-      ret = a == b
-
-      if ret
-        self.class._assertion_failed msg
-        @last_result = :failed
-      else
-        self.class._assertion_passed
-        @last_result = :passed
-      end
-
-      kaller ||= caller
-      log_test_assertion __method__, kaller if _groups.empty?
-
-      if log_test_assertion_message?
-        msg ||= "#{__method__} #{a}, #{b} (== equality)"
-        log_test_assertion_message !ret, msg
-      end
-
-      ret
-    end
-
-    def assert_equality! a, b, msg = nil
-      critical assert_equality a, b, msg, kaller: caller
-    end
-
-    def refute_equality! a, b, msg = nil
-      critical refute_equality a, b, msg, kaller: caller
-    end
-
-    def assert_raises exception_klass, msg = nil, kaller: nil, &block
-      raise ArgumentError, "No block given" unless block_given?
-
-      ret = false
-      begin
-        yield
-      rescue => e
-        ret = exception_klass === e
-        error = e
-      end
-
-      if ret
-        self.class._assertion_passed
-        @last_result = :passed
-      else
-        self.class._assertion_failed msg
-        @last_result = :failed
-      end
-
-      kaller ||= caller
-      log_test_assertion __method__, kaller if _groups.empty?
-
-      if log_test_assertion_message?
-        msg ||= "#{__method__} (#{exception_klass}) #{error.inspect}"
-        log_test_assertion_message ret, msg
-      end
-
-      ret
-    end
-
-    def refute_raises exception_klass, msg = nil, kaller: nil, &block
-      raise ArgumentError, "No block given" unless block_given?
-
-      ret = false
-      begin
-        yield
-      rescue => e
-        ret = !exception_klass === e
-        error = e
-      end
-
-      if ret
-        self.class._assertion_failed msg
-        @last_result = :failed
-      else
-        self.class._assertion_passed
-        @last_result = :passed
-      end
-
-      kaller ||= caller
-      log_test_assertion __method__, kaller if _groups.empty?
-
-      if log_test_assertion_message?
-        msg ||= "#{__method__} (#{exception_klass}) #{error.inspect}"
-        log_test_assertion_message !ret, msg
-      end
-
-      ret
-    end
-
-    def assert_raises! e, msg = nil
-      critical assert_raises e, msg, kaller: caller
-    end
-
-    def refute_raises! e, msg = nil
-      critical refute_raises e, msg, kaller: caller
-    end
-
-  end
-end

data/lib/liza/test_parts/test_assertions_part.rb

@@ -1,109 +0,0 @@
-class Liza::TestAssertionsPart < Liza::Part
-  insertion do
-    # CLASS
-
-    def self.totals
-      @totals ||= {
-                    errors: [],
-                    todos: [],
-                    fails: [],
-                    passes: [],
-                  }
-    end
-
-    def self._assertion_todo msg
-      self.totals[:todos] << msg
-    end
-
-    def self._assertion_passed
-      self.totals[:passes] << 1
-    end
-
-    def self._assertion_failed msg
-      self.totals[:fails] << msg
-    end
-
-    def self._assertion_errored e
-      self.totals[:errors] << e
-    end
-
-    # INSTANCE
-
-    attr_writer :assertions
-
-    def assertions
-      @assertions ||= 0
-    end
-
-    def _inc_assertions
-      self.assertions += 1
-    end
-
-    # ASSERTIONS
-
-    def todo msg
-      self.class._assertion_todo msg
-      @last_result = :todo
-
-      log_test_assertion __method__, caller if _groups.empty?
-    end
-
-    def _groups
-      @_groups ||= []
-    end
-
-    def group kaller: nil, **_words, &block
-      block_given? || raise(ArgumentError, "No block given")
-
-      _groups << block
-      instance_exec(&block)
-      _groups.pop
-
-      kaller ||= caller
-      log_test_assertion __method__, kaller if _groups.empty?
-    end
-
-    def assert b, msg = "it should have been true", kaller: nil
-      if b
-        self.class._assertion_passed
-        @last_result = :passed
-      else
-        self.class._assertion_failed msg
-        @last_result = :failed
-      end
-
-      kaller ||= caller
-      log_test_assertion __method__, kaller if _groups.empty?
-
-      b
-    end
-
-    def refute b, msg = "it should have been false", kaller: nil
-      if b
-        self.class._assertion_failed msg
-        @last_result = :failed
-      else
-        self.class._assertion_passed
-        @last_result = :passed
-      end
-
-      kaller ||= caller
-      log_test_assertion __method__, kaller if _groups.empty?
-
-      b
-    end
-
-    def assert! b, msg = "it should have been true"
-      critical assert b, msg, kaller: caller
-    end
-
-    def refute! b, msg = "it should have been false"
-      critical refute b, msg, kaller: caller
-    end
-
-    def critical passed
-      throw :critical, :critical if not passed
-    end
-
-  end
-end

data/lib/liza/test_parts/test_dsl_part.rb

@@ -1,68 +0,0 @@
-class Liza::TestDslPart < Liza::Part
-  insertion do
-
-    def self.call class_index, class_count
-      counter_class = "#{class_index.to_s.rjust 3, "0"}/#{class_count.to_s.rjust 3, "0"}"
-
-      log "+ #{counter_class} #{self} class".bold.white
-
-      array = [test_tree]
-      while array.any?
-        node = array.pop
-        i = 0
-
-        node.tests.each do |test_words, test_block|
-          counter_instance = "#{(i+=1).to_s.rjust 2, '0'}/#{node.tests.size.to_s.rjust 2, '0'}"
-          label = test_words.to_a.flatten.join(" ")[0..25]
-
-          log "  #{ counter_class } #{ counter_instance } #{ label.ljust(27)} #{_log_test_block test_block}"
-
-          log_test_building node, test_block if log_test_building?
-          
-          instance = new test_words, node.before_stack, node.after_stack, &test_block
-          instance.call
-        end
-
-        array.concat node.children
-      end
-
-    end
-
-    attr_reader :test_words
-
-    def initialize test_words, before_stack, after_stack, &test_block
-      @test_words, @before_stack, @after_stack, @test_block = test_words, before_stack, after_stack, test_block
-    end
-
-    def call
-      catch :critical do
-        @before_stack.each do |stack|
-          log "               calling stacked before blocks #{stack.map { |bl| _log_test_block bl }}".magenta if log_test_building?
-          stack.each do |bl|
-            log_test_call "B&", &bl if log_test_call_block?
-            instance_exec(&bl)
-          end
-        end
-
-        bl = @test_block
-        log "                         calling test block #{_log_test_block bl}".magenta if log_test_building?
-        log_test_call "T&", &bl if log_test_call_block?
-        instance_exec(&bl)
-
-        @after_stack.each do |stack|
-          log "                calling stacked after blocks #{stack.map { |bl| _log_test_block bl }}".magenta if log_test_building?
-          stack.each do |bl|
-            log_test_call "A&", &bl if log_test_call_block?
-            instance_exec(&bl)
-          end
-        end
-      end
-    rescue Exception => e
-      self.class._assertion_errored e
-      log_test_call_rescue e
-    ensure
-      puts
-    end
-
-  end
-end

data/lib/liza/test_parts/test_log_part.rb

@@ -1,122 +0,0 @@
-class Liza::TestLogPart < Liza::Part
-
-  insertion do
-
-    LOG_BUILDING = false
-    LOG_ASSERTION = true
-    LOG_ASSERTION_MESSAGE = true
-    LOG_CALL_BLOCK = true
-
-    def self.log_test_building?
-      LOG_BUILDING
-    end
-
-    def log_test_building?
-      self.class.log_test_building?
-    end
-
-    def log_test_assertion?
-      LOG_ASSERTION
-    end
-
-    def log_test_assertion_message?
-      LOG_ASSERTION_MESSAGE
-    end
-
-    def log_test_call_block?
-      LOG_CALL_BLOCK
-    end
-
-    def log_test_call_rescue e
-      prefix = "error".yellow
-
-      kaller = e.backtrace
-
-      source_location = _caller_line_split(kaller[0])[0]
-      source_location = source_location.gsub("#{Lizarb::CUR_DIR}/", "")
-
-      log "                #{prefix} #{e.class.to_s.ljust 20} #{source_location}"
-
-      puts "Exception!".red
-      puts e.class.to_s.red
-      puts e.message.red
-      puts
-      puts e.backtrace.join("\n").red
-    end
-
-    def self.log_test_building node, test_block
-      log "                         the building blocks are".magenta
-
-      node.before_stack.each do |stack|
-        stack.each do |bl|
-          log "                               before block #{_log_test_block bl}".magenta
-        end
-      end
-      
-      log "                                 test block #{_log_test_block test_block}".magenta
-
-      node.after_stack.each do |stack|
-        stack.each do |bl|
-          log "                                after block #{_log_test_block bl}".magenta
-        end
-      end
-    end
-
-    def log_test_call prefix, &block
-      source_location = block.source_location.join(":").gsub("#{Lizarb::CUR_DIR}/", "")
-      source_location = source_location[0..-1]
-      log "          #{prefix}                                #{source_location}"
-    end
-
-    def log_test_assertion method_name, kaller
-      _inc_assertions
-      prefix = "#{assertions.to_s.rjust 2, "0"} #{_log_test_assertion_tag method_name}"
-
-      source_location = _caller_line_split(kaller[0])[0]
-      source_location = source_location.gsub("#{Lizarb::CUR_DIR}/", "")
-
-      log "             #{prefix} #{source_location}" if log_test_assertion?
-    end
-
-    def _log_test_assertion_tag method_name
-      "#{log_test_assertion_result} #{method_name.to_s.ljust(20).bold.white}"
-    end
-
-    def self._log_test_block test_block
-      test_block.source_location.join(":").gsub("#{Lizarb::CUR_DIR}/", "")
-    end
-
-    def _log_test_block test_block
-      self.class._log_test_block test_block
-    end
-
-    def log_test_assertion_result
-      case @last_result
-      when :todo
-        "  todo".blue
-      when :passed
-        "passed".green
-      when :failed
-        "failed".red
-      else
-        raise "Unknown result: #{@last_result}"
-      end
-    end
-
-    def log_test_assertion_message b, msg
-      if b
-        log "                passed #{msg}".green 
-      else
-        log "                failed #{msg}".red
-      end
-    end
-
-    def _caller_line_split s
-      x = s.split ":in `"
-      x[1] = x[1][0..-2]
-      x
-    end
-
-  end
-
-end

data/lib/liza/test_parts/test_subject_part.rb

@@ -1,22 +0,0 @@
-class Liza::TestSubjectPart < Liza::Part
-
-  insertion do
-    def self.subject_class
-      @subject_class ||=
-        if first_namespace == "Liza"
-          Liza.const_get last_namespace[0..-5]
-        else
-          Object.const_get name[0..-5]
-        end
-    end
-
-    def subject_class
-      self.class.subject_class
-    end
-
-    def subject
-      @subject ||= subject_class.new
-    end
-  end
-
-end

data/lib/liza/test_parts/test_tree_part.rb

@@ -1,92 +0,0 @@
-class Liza::TestTreePart < Liza::Part
-
-  insertion do
-
-    @before_stack = []
-    @after_stack = []
-    
-    def self.before_stack; @before_stack ||= superclass.before_stack.dup end
-    def self.after_stack;  @after_stack  ||= superclass.after_stack.dup end
-    
-    def self.test_node; @test_node ||= test_tree end
-    def self.test_tree; @test_tree ||= Liza::TestTreePart::Extension.new nil, before_stack, after_stack end
-    
-    #
-
-    def self.group *words, &block
-      raise ArgumentError, "No block given" unless block_given?
-      previous = test_node
-      @test_node = test_node.branch_out words
-      instance_exec(&block)
-      @test_node = previous
-    end
-
-    def self.test *words, &block
-      raise ArgumentError, "No block given" unless block_given?
-      test_node.add_test words, &block
-    end
-
-    def self.before &block
-      raise ArgumentError, "No block given" unless block_given?
-      test_node.add_before(&block)
-    end
-
-    def self.after &block
-      raise ArgumentError, "No block given" unless block_given?
-      test_node.add_after(&block)
-    end
-
-  end
-
-  extension do
-    
-    def log *args
-      self.class.solder.log(*args)
-    end
-
-    def log_test_building?
-      Liza::Test.log_test_building?
-    end
-
-    attr_reader :tests, :parent, :children, :before_stack, :after_stack
-
-    def initialize parent, before_stack, after_stack
-      @tests = []
-      initialize_parenting parent
-      initialize_filters before_stack, after_stack
-    end
-
-    def initialize_parenting parent
-      @parent = parent || self
-      @children = []
-      @parent.children << self if @parent != self
-    end
-
-    def initialize_filters before_stack, after_stack
-      @before_top, @after_top = [], []
-      @before_stack = before_stack.push @before_top
-      @after_stack  = after_stack.unshift @after_top
-    end
-
-    def add_before &block
-      log "add_before to ##{object_id} #{block}" if log_test_building?
-      @before_top.push block
-    end
-
-    def add_test words, &block
-      log "add_test to ##{object_id} #{words} #{block}" if log_test_building?
-      tests << [words, block]
-    end
-
-    def add_after &block
-      log "add_after to ##{object_id} #{block}" if log_test_building?
-      @after_top.push block
-    end
-
-    def branch_out words, &block
-      self.class.new self, before_stack.dup, after_stack.dup
-    end
-
-  end
-
-end

data/lib/liza/unit_parts/unit_procedure_part.rb

@@ -1,17 +0,0 @@
-class Liza::UnitProcedurePart < Liza::Part
-
-  insertion do
-    def self.procedure _label, &block
-      catch :procedure, &block
-    end
-
-    def self.proceed val = nil, &block
-      val = yield if val.nil? && block_given?
-      throw :procedure, val
-    end
-
-    def procedure(_label, &block)= self.class.procedure _label, &block
-    def proceed(...)= self.class.proceed(...)
-  end
-
-end

data/lib/liza/unit_parts/unit_procedure_part_test.rb

@@ -1,65 +0,0 @@
-class Liza::UnitProcedurePartTest < Liza::UnitTest
-
-  test :procedure_scopes_and_returns do
-    b = nil
-
-    w =
-      procedure "creates a new scope" do
-        @a = 1
-        b = 2
-        assert true
-
-        proceed if true
-        raise "did not get here"
-      end
-
-    assert assertions > 0
-    assert w.nil?
-
-    x =
-      procedure "asserts old scope is not accessible" do
-        assert instance_variables.include? :@a
-        assert local_variables.include? :b
-
-        assert @a == 1
-        assert b == 2
-
-        proceed 100 if true
-        raise "did not get here"
-      end
-
-    assert x == 100
-
-    y = procedure "asserts proceed calls can be lazy" do
-      proceed do
-        puts "slow operation"
-        200
-      end if true
-      raise "did not get here"
-    end
-    
-    assert y == 200    
-  end
-
-  test :procedure_rescue_and_ensure do
-    procedure "assert ensure works" do
-      @a = 1
-    ensure
-      @a = 2
-    end
-
-    assert @a == 2
-
-    procedure "assert rescue works" do
-      @a = [1]
-      raise "a runtime error!"
-    rescue RuntimeError
-      @a << 2
-    ensure
-      @a << 3
-    end
-
-    assert @a == [1, 2, 3]
-  end
-
-end

data/lib/liza/unit_parts/unit_settings_part.rb

@@ -1,76 +0,0 @@
-class Liza::UnitSettingsPart < Liza::Part
-
-  insertion do
-    def self.settings
-      @settings ||= {}
-    end
-
-    def self.get key
-      return settings[key] if settings.has_key? key
-
-      found = nil
-
-      for klass in ancestors
-        break unless klass.respond_to? :settings
-
-        if klass.settings.has_key? key
-          found = klass.settings[key]
-
-          break
-        end
-      end
-
-      found = settings[key] = found.dup if found.is_a? Enumerable
-
-      found
-    end
-
-    def self.set key, value
-      settings[key] = value
-      value
-    end
-
-    def self.add list, key = nil, value
-      if key
-        fetch(list) { Hash.new }[key] = value
-      else
-        fetch(list) { Set.new } << value
-      end
-    end
-
-    def self.fetch key, &block
-      x = get key
-      x ||= set key, instance_eval(&block)
-      x
-    end
-
-    def settings
-      @settings ||= {}
-    end
-
-    def get key
-      return settings[key] if settings.has_key? key
-
-      self.class.get key
-    end
-
-    def set key, value
-      settings[key] = value
-    end
-
-    def add list, key = nil, value
-      if key
-        fetch(list) { Hash.new }[key] = value
-      else
-        fetch(list) { Set.new } << value
-      end
-    end
-
-    def fetch key, &block
-      x = get key
-      x ||= set key, eval(&block)
-      x
-    end
-  end
-
-end

data/lib/liza/unit_parts/unit_settings_part_test.rb

@@ -1,3 +0,0 @@
-class Liza::UnitSettingsPartTest < Liza::UnitTest
-
-end