lizarb 1.0.5 → 1.0.6

data/lib/liza/safety_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.inspect}, #{b.inspect} (== 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/safety_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/safety_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/safety_parts/test_log_part.rb

@@ -1,142 +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.system
-      subject_class.system
-    rescue
-      Liza::System
-    end
-
-    def system
-      self.class.system
-    end
-
-    def self.division
-      subject_class.division
-    rescue
-      Liza::Controller
-    end
-
-    def division
-      self.class.division
-    end
-
-    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/safety_parts/test_subject_part.rb

@@ -1,32 +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
-
-    def self.system
-      subject_class.system
-    rescue
-      System
-    end
-
-    def system
-      self.class.system
-    end
-  end
-
-end

data/lib/liza/safety_parts/test_tree_part.rb

@@ -1,87 +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.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
-
-  #
-
-  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

data/lib/liza/unit_parts/unit_classes_part.rb

@@ -1,37 +0,0 @@
-class Liza::UnitClassesPart < Liza::Part
-
-  insertion do
-    
-    def self.subclasses_select system:
-      subclasses.select { _1.system? system }
-    end
-
-    def self.descendants_select system:
-      descendants.select { _1.system? system }
-    end
-
-    def self.namespace
-      return @namespace if defined? @namespace
-
-      @namespace ||= Object unless to_s.include? "::"
-      @namespace ||= Liza if to_s.start_with? "Liza::"
-      @namespace ||= system
-      @namespace
-    end
-
-    def self.system? system
-      system = Liza.const "#{system}_system" if system.is_a? Symbol
-      system == get(:system)
-    end
-
-    def self.reload!
-      Lizarb.reload
-    end
-
-    def reload!
-      Lizarb.reload
-    end
-
-  end
-
-end

data/lib/liza/unit_parts/unit_classes_part_test.rb

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