lizarb 1.0.0 → 1.0.2

data/lib/liza/test_parts/test_dsl_part.rb

@@ -1,122 +1,70 @@
 module Liza
   class TestDslPart < Part
     insertion do
-      def self.test *words, &block
-        Liza.log "#{inspect}.test #{words}, &block"
-        block_given? || raise(ArgumentError, "No block given")
-
-        key = [
-          block.source_location,
-          'b',
-          context.befores.flatten.map(&:source_location),
-          'a',
-          context.afters.flatten.map(&:source_location),
-        ].flatten.join("-")
-
-        key.gsub! Lizarb::CUR_DIR, ""
-
-        instances[key] ||= new  words,
-                                context.befores.flatten.uniq,
-                                context.afters.flatten.uniq,
-                                &block
-      end
-
-      def self.instances
-        @instances ||= {}
-      end
 
       def self.call class_index, class_count
         counter_class = "#{class_index.to_s.rjust 3, "0"}/#{class_count.to_s.rjust 3, "0"}"
 
-        puts "- #{counter_class} #{self} (#{instances.size} tests)".cyan
+        log "+ #{counter_class} #{self} class".bold.white
+
+        array = [test_tree]
+        while array.any?
+          node = array.pop
+          i = 0
 
-        instances.values.each_with_index do |instance, i|
-          counter_instance = "#{(i+=1).to_s.rjust 2, '0'}/#{instances.size.to_s.rjust 2, '0'}"
-          label = instance.words_as_label
+          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]
 
-          puts "  #{ counter_class } #{ counter_instance } (#{ label })".light_cyan
+            log "  #{ counter_class } #{ counter_instance } #{ label.ljust(27)} #{_log_test_block test_block}"
 
-          instance.call
+            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
 
-      #
+      end
 
-      attr_reader :words
+      attr_reader :test_words
 
-      def initialize words, befores, afters, &block
-        @words, @befores, @afters, @block = words, befores, afters, block
+      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
-          @befores.each do |bl|
-            _call_log "B&", &bl
-            instance_exec &bl
+          @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 = @block
-          _call_log " &", &bl
+          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
 
-          @afters.each do |bl|
-            _call_log "A&", &bl
-            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
-        _rescue_log e
+        log_test_call_rescue e
       ensure
         puts
       end
 
-      def words_as_label
-        label = words.to_s
-        label = label[1..-2] if label.start_with? "["
-        label = label[1..-2] if label.start_with? "{"
-        label
-      end
-
-      def _rescue_log e
-        prefix = "error"
-
-        kaller = e.backtrace
-
-        source_location = _caller_line_split(kaller[0])[0]
-        source_location = source_location.gsub("#{Lizarb::CUR_DIR}/", "")
-
-        log "                      #{prefix}  #{source_location}"
-
-        puts "Exception!".red
-        puts e.class.to_s.red
-        puts e.message.red
-        puts
-        puts e.backtrace.join("\n").red
-      end
-
-      def _call_log prefix, &block
-        source_location = block.source_location.join(":").gsub("#{Lizarb::CUR_DIR}/", "")
-        source_location = source_location[0..-1]
-        log "          #{prefix}                 #{source_location}"
-      end
-
-      def _assertion_log method_name, kaller
-        _inc_assertions
-        method_name = method_name.to_s.ljust 6
-        prefix = "#{assertions} #{method_name} #{@last_result}"
-
-        source_location = _caller_line_split(kaller[0])[0]
-        source_location = source_location.gsub("#{Lizarb::CUR_DIR}/", "")
-
-        log "             #{prefix} #{source_location}"
-      end
-
-      def _caller_line_split s
-        x = s.split ":in `"
-        x[1] = x[1][0..-2]
-        x
-      end
     end
   end
 end

data/lib/liza/test_parts/test_log_part.rb

@@ -0,0 +1,124 @@
+module Liza
+  class TestLogPart < 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
+end

data/lib/liza/test_parts/test_subject_part.rb

@@ -3,7 +3,12 @@ module Liza
 
     insertion do
       def self.subject_class
-        @subject_class ||= Liza::const name[0..-5]
+        @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

data/lib/liza/test_parts/test_tree_part.rb

@@ -0,0 +1,139 @@
+module Liza
+  class TestTreePart < 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
+        @parent = parent || self
+
+        @children, @tests = [], []
+        @before_top, @after_top = [], []
+
+        @before_stack = before_stack.push @before_top
+        @after_stack  = after_stack.unshift @after_top
+
+        @parent.children << self if @parent != self
+      end
+
+      def initialize parent, before_stack, after_stack
+        @parent = parent || self
+
+        @children, @tests, @before_top, @after_top = [], [], [], []
+
+        @before_stack = before_stack.push @before_top
+        @after_stack  = after_stack.unshift @after_top
+
+        @parent.children << self if @parent != self
+      end
+
+      def initialize parent, before_stack, after_stack
+        @parent = parent || self
+        @children, @tests = [], []
+        @parent.children << self if @parent != self
+
+        @before_top, @after_top = [], []
+        @before_stack = before_stack.push @before_top
+        @after_stack  = after_stack.unshift @after_top
+      end
+
+      def initialize parent, before_stack, after_stack
+        @tests = []
+
+        @parent = parent || self
+        @children = []
+        @parent.children << self if @parent != self
+
+        @before_top, @after_top = [], []
+        @before_stack = before_stack.push @before_top
+        @after_stack  = after_stack.unshift @after_top
+      end
+
+      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
+end

data/lib/liza/unit.rb

@@ -7,6 +7,8 @@ module Liza
       App.connect_part self, key, system
     end
 
+    part :unit_procedure
+
     # SETTINGS
 
     def self.settings

data/lib/liza/unit_parts/unit_procedure_part.rb

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,65 @@
+class Liza::UnitProcedurePartTest < Liza::UnitTest
+
+  test :procedure_scopes_and_returns do
+    b = nil
+
+    w =
+      procedure "creates a new scope" do
+        @a = 1
+        b = 2
+        c = 3
+        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
+        refute local_variables.include? :c
+
+        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 { "slow operation"; 200 } 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.rb

@@ -2,6 +2,7 @@
 
 module Liza
   class Error < StandardError; end
+  class ConstNotFound < Error; end
 
   #
 
@@ -13,22 +14,54 @@ module Liza
 
   #
 
-  # After checking the top-level namespace, looks up the Liza namespace
+  # Checks Object, each system, then Liza for Liza::Unit classes
   def const name
-    name = name.to_s.camelize
+    name = name.to_s.camelize.to_sym
 
-    return Object.const_get name if Object.const_defined? name
+    k = const_check_object name
+    return k if k
 
-    const_get name
+    k = const_check_systems name
+    return k if k
+
+    k = const_get name
+    return k if k
+
+    nil
+  rescue NameError
+    raise ConstNotFound, name
   end
 
-  # constants missing from Liza will be looked up in all systems
+  # Checks each system, then Liza for Liza::Unit classes
   def const_missing name
+    k = const_check_systems name
+    return k if k
+
+    super
+  end
+
+  def const_check_object name
+    return if not Object.const_defined? name
+    kk = Object.const_get name
+    return kk if is_unit? kk
+
+    nil
+  end
+
+  def const_check_systems name
+    App.systems.frozen? or return nil
+
     for k in App.systems.values.reverse
-      return k.const_get(name) if k.const_defined? name
+      next if not k.const_defined? name.to_sym
+      kk = k.const(name) if k.constants.include? name
+      return kk if is_unit? kk
     end
 
-    super
+    nil
+  end
+
+  def is_unit? kk
+    kk && kk < Liza::Unit
   end
 
 end

data/lib/lizarb/ruby/class.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 class Class
+  public :eval
+
   def descendants
     ObjectSpace.each_object(Class).select { |klass| klass < self }
   end

data/lib/lizarb/ruby/module.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class Module
+
+  # /path/to/liza.rb
+  def source_location
+    Object.const_source_location name
+  end
+
+  # /path/to/liza
+  def source_location_radical
+    source_location[0][0..-4]
+  rescue
+    nil
+  end
+
+end

data/lib/lizarb/ruby/proc.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+class Proc
+  def relative_source
+    absolute_source.gsub "#{Lizarb::APP_DIR}/", ""
+  end
+
+  def absolute_source
+    sl = source_location
+    "#{sl[0]}:#{sl[1]}"
+  end
+end

data/lib/lizarb/ruby/string.rb

@@ -3,7 +3,31 @@
 class String
   alias lpartition partition
 
-  def camelize
-    split("_").map { |s| "#{s[0].upcase}#{s[1..-1]}" }.join("")
+  def camelcase
+    split("_").map { |s| "#{s[0].to_s.upcase}#{s[1..-1]}" }.join("")
+  end
+
+  alias camelize camelcase
+
+  def snakecase
+    gsub(/[A-Z\s-]/) { |s, t| "_#{s}" }[1..-1].to_s.downcase
+  end
+  
+  alias snakefy snakecase
+
+  def rjust_blanks length
+    rjust length, " "
+  end
+
+  def rjust_zeroes length
+    rjust length, "0"
+  end
+
+  def ljust_blanks length
+    ljust length, " "
+  end
+
+  def ljust_zeroes length
+    ljust length, "0"
   end
 end

data/lib/lizarb/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Lizarb
-  VERSION = "1.0.0"
+  VERSION = "1.0.2"
 end