lizarb 1.0.3 → 1.0.5

data/lib/liza/ruby_tests/class_test.rb

@@ -0,0 +1,20 @@
+class Liza::ClassTest < Liza::ObjectTest
+  
+  test :subject_class do
+    assert_equality subject_class, Class
+  end
+
+  test :ancestors_until do
+    assert_equality [Object],  Object.ancestors_until(BasicObject)
+    assert_equality [Integer], Integer.ancestors_until(Object)
+    assert_equality [Symbol],  Symbol.ancestors_until(Object)
+    assert_equality [String],  String.ancestors_until(Object)
+    assert_equality [Array],   Array.ancestors_until(Object)
+    assert_equality [Hash],    Hash.ancestors_until(Object)
+
+    assert_equality [IrbCommand, Command],  IrbCommand.ancestors_until(Command)
+    assert_equality [PryCommand, Command],  PryCommand.ancestors_until(Command)
+    assert_equality [TestCommand, Command], TestCommand.ancestors_until(Command)
+  end
+
+end

data/lib/liza/ruby_tests/module_test.rb

@@ -1,4 +1,4 @@
-class Liza::ModuleTest < Liza::RubyTest
+class Liza::ModuleTest < Liza::ObjectTest
   
   test :subject_class do
     assert subject_class == Module
@@ -8,14 +8,14 @@ class Liza::ModuleTest < Liza::RubyTest
     assert Object.source_location == []
 
     assert Liza::Command.source_location[1] == 1
-    assert AppCommand.source_location[1] == 1
+    assert IrbCommand.source_location[1] == 1
   end
 
   test :source_location_radical do
     assert Object.source_location_radical == nil
 
-    assert Liza::Command.source_location_radical.end_with? "/lib/dev_system/dev/controllers/command"
-    assert AppCommand.source_location_radical.end_with? "/app/dev/commands/app_command"
+    assert Liza::Command.source_location_radical.end_with? "/lib/dev_system/sub/command/command"
+    assert IrbCommand.source_location_radical.end_with? "/lib/dev_system/sub/command/commands/irb_command"
   end
 
 end

data/lib/liza/{ruby_test.rb → ruby_tests/object_test.rb}

@@ -1,4 +1,4 @@
-class Liza::RubyTest < Liza::Test
+class Liza::ObjectTest < Liza::Test
 
   def self.subject_class
     @subject_class ||= Object.const_get last_namespace[0..-5]

data/lib/liza/ruby_tests/string_test.rb

@@ -1,4 +1,4 @@
-class Liza::StringTest < Liza::RubyTest
+class Liza::StringTest < Liza::ObjectTest
   
   test :subject_class do
     assert subject_class == String
@@ -38,6 +38,8 @@ class Liza::StringTest < Liza::RubyTest
     assert "ab"    == "Ab".snakecase
     assert "ab_c"  == "AbC".snakecase
     assert "ab_cd" == "AbCd".snakecase
+    assert "ab"    == "ab".snakecase
+    assert "cd"    == "cd".snakecase
   end
 
   test :rjust_blanks do

data/lib/liza/{test → safety}/test.rb

@@ -7,4 +7,13 @@ class Liza::Test < Liza::Unit
   part :test_subject
   part :test_tree
 
+  def self.subsystem
+    subject_class.subsystem
+  end
+
+  # color
+
+  def self.color
+    subject_class.color
+  end
 end

data/lib/liza/{test → safety}/test_test.rb

@@ -1,9 +1,40 @@
 
-class Liza::TestTest < Liza::Test
+class Liza::TestTest < Liza::UnitTest
 
   test :settings do
-    assert subject_class.log_level == :normal
-    assert subject_class.log_color == :white
+    assert_equality subject_class.log_level, 0
+  end
+
+  test_methods_defined do
+    on_self \
+      :after, :after_stack,
+      :before, :before_stack,
+      :call, :color,
+      :group,
+      :log_test_building, :log_test_building?,
+      :subject_class,
+      :subsystem,
+      :test, :test_node, :test_tree,
+      :totals
+    on_instance \
+      :assert, :assert!,
+      :assert_equality, :assert_equality!,
+      :assert_raises, :assert_raises!,
+      :assertions, :assertions=,
+      :call,
+      :critical,
+      :division,
+      :group,
+      :log_test_assertion, :log_test_assertion?,
+      :log_test_assertion_message, :log_test_assertion_message?,
+      :log_test_assertion_result, :log_test_building?,
+      :log_test_call, :log_test_call_block?, :log_test_call_rescue,
+      :refute, :refute!,
+      :refute_equality, :refute_equality!,
+      :refute_raises, :refute_raises!,
+      :subject, :subject_class,
+      :test_words,
+      :todo
   end
 
   group :basics do
@@ -74,7 +105,11 @@ class Liza::TestTest < Liza::Test
   
   group :instance_variables do
     test :instance_variables do
-      assert_equality instance_variables, [:@test_words, :@before_stack, :@after_stack, :@test_block]
+      if Shell.jruby?
+        todo "jruby!"
+      else
+        assert_equality instance_variables, [:@test_words, :@before_stack, :@after_stack, :@test_block, :@settings]
+      end
     end
 
     test :test_block do
@@ -84,13 +119,15 @@ class Liza::TestTest < Liza::Test
 
   group :tree do
     test :test_tree do
-      assert_equality self.class.test_tree.class, Liza::TestTreePart::Extension
+      assert_equality self.class.test_tree.class, Liza::TestTreePart
       assert_equality self.class.test_tree, self.class.test_tree.parent
       
-      assert_equality 2, self.class.test_tree.tests.count
+      assert_equality 4, self.class.test_tree.tests.count
       assert_equality 5, self.class.test_tree.children.count
 
-      assert_equality self.class.test_tree.tests.map(&:first).flatten, [:settings, :instance_groups]
+      a = self.class.test_tree.tests.map(&:first).flatten
+      b = [:settings, :subject_class, :methods_defined, :subject_class, :instance_methods_defined, :instance_groups]
+      assert_equality a, b
     end
   end
 

data/lib/liza/{test_parts → safety_parts}/test_assertions_advanced_part.rb

@@ -16,7 +16,7 @@ class Liza::TestAssertionsAdvancedPart < Liza::Part
       log_test_assertion __method__, kaller if _groups.empty?
 
       if log_test_assertion_message?
-        msg ||= "#{__method__} #{a}, #{b} (== equality)"
+        msg ||= "#{__method__} #{a.inspect}, #{b.inspect} (== equality)"
         log_test_assertion_message ret, msg
       end
 

data/lib/liza/{test_parts → safety_parts}/test_assertions_part.rb

@@ -56,7 +56,7 @@ class Liza::TestAssertionsPart < Liza::Part
       block_given? || raise(ArgumentError, "No block given")
 
       _groups << block
-      instance_exec &block
+      instance_exec(&block)
       _groups.pop
 
       kaller ||= caller

data/lib/liza/{test_parts → safety_parts}/test_dsl_part.rb

@@ -40,20 +40,20 @@ class Liza::TestDslPart < Liza::Part
           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
+            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
+        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
+            instance_exec(&bl)
           end
         end
       end

data/lib/liza/{test_parts → safety_parts}/test_log_part.rb

@@ -7,6 +7,26 @@ class Liza::TestLogPart < Liza::Part
     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

data/lib/liza/{test_parts → safety_parts}/test_subject_part.rb

@@ -17,6 +17,16 @@ class Liza::TestSubjectPart < Liza::Part
     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

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

@@ -1,155 +1,99 @@
 class Liza::Unit
 
-  # PARTS
-
-  def self.part key, system: nil
-    App.connect_part self, key, system
-  end
-
-  def self.const_missing name
-    Liza.const name
-  rescue Liza::ConstNotFound => e
-    raise NameError, "uninitialized constant #{name}", caller[1..], cause: nil
-  end
-
-  part :unit_procedure
+  # ERROR
+  
+  class Error < Liza::Error; end
 
-  # SETTINGS
+  # PART
 
-  def self.settings
-    @settings ||= {}
+  def self.part key, klass = nil, system: nil
+    Lizarb.connect_part self, key, klass, system
   end
 
-  def self.get key
-    return settings[key] if settings.has_key? key
+  # CONST MISSING
 
-    found = nil
+  if Lizarb.ruby_supports_raise_cause?
 
-    for klass in ancestors
-      break unless klass.respond_to? :settings
+    def self.const_missing name
+      Liza.const name
+    rescue Liza::ConstNotFound
+      raise NameError, "uninitialized constant #{name}", caller[1..], cause: nil
+    end
 
-      if klass.settings.has_key? key
-        found = klass.settings[key]
+  else
 
-        break
-      end
+    def self.const_missing name
+      Liza.const name
+    rescue Liza::ConstNotFound
+      raise NameError, "uninitialized constant #{name}", caller[1..]
     end
 
-    found = settings[key] = found.dup if found.is_a? Enumerable
-
-    found
   end
 
-  def self.set key, value
-    settings[key] = value
-    value
-  end
+  # PARTS
 
-  def self.add list, key = nil, value
-    if key
-      fetch(list) { Hash.new }[key] = value
-    else
-      fetch(list) { Set.new } << value
-    end
-  end
+  part :unit_classes
 
-  def self.fetch key, &block
-    x = get key
-    x ||= set key, instance_eval(&block)
-    x
-  end
+  part :unit_logging
+
+  part :unit_methods
 
-  def settings
-    @settings ||= {}
+  part :unit_procedure
+  
+  class RenderError < Error; end
+  class RendererNotFound < RenderError; end
+  class RenderStackIsFull < RenderError; end
+  class RenderStackIsEmpty < RenderError; end
+  part :unit_renderer
+
+  part :unit_settings
+
+  # TEST
+
+  def self.test_class
+    @test_class ||=
+      if first_namespace == "Liza"
+        Liza.const_get "#{last_namespace}Test"
+      else
+        Object.const_get "#{name}Test"
+      end
   end
 
-  def get key
-    return settings[key] if settings.has_key? key
+  # CONTROLLER
 
-    self.class.get key
+  def self.division
+    Liza::Controller
   end
 
-  def set key, value
-    settings[key] = value
-  end
+  # SYSTEM
 
-  def add list, key = nil, value
-    if key
-      fetch(list) { Hash.new }[key] = value
+  def self.system
+    if name&.include? "::"
+      return System if first_namespace == "Liza"
+      Object.const_get first_namespace
     else
-      fetch(list) { Set.new } << value
+      superclass.system
     end
   end
 
-  def fetch key, &block
-    x = get key
-    x ||= set key, eval(&block)
-    x
-  end
-
-  # LOG
+  singleton_class.send :public, :system
 
-  LOG_LEVELS = {
-    :higher => 2,
-    :high   => 1,
-    :normal => 0,
-    :low    => -1,
-    :lower  => -2,
-  }
-
-  set :log_level, :normal
-  set :log_color, :white
-
-  #
-
-  LOG_JUST = 40
-
-  def self.log log_level = :normal, string
-    raise "invalid log_level `#{log_level}`" unless LOG_LEVELS.keys.include? log_level
-    return unless log_level? log_level
-
-    source = (self.is_a? Class) ? self : self.class
-    source = source.to_s.ljust(LOG_JUST).bold.colorize(source.log_color)
-
-    string = "#{source} #{string}"
-
-    DevBox[:log].call string
+  def system
+    self.class.system
   end
 
-  def self.log_level
-    get(:log_level) || :normal
-  end
+  public :system
 
-  def self.log_level? log_level = :normal
-    # TODO
-    true
-  end
+  #
 
-  def self.log_color
-    (get(:system) || self).get :log_color
+  App.settings.each do |k, v|
+    set k, v
   end
+  set :division, Liza::Controller
+  
+end
 
-  def self.log?(log_level = :normal)= log_level? log_level
-  def log(...)= self.class.log(...)
-  def log_level(...)= self.class.log_level(...)
-  def log?(...)= self.class.log?(...)
-  def log_level?(...)= self.class.log_level?(...)
-  def log_color(...)= self.class.log_color(...)
-
-  # SYSTEM
-
-  def self.inherited_explicitly_sets_system
-
-    def self.inherited sub
-      super
-
-      return unless sub.name.to_s.include? "::"
-
-      system = Object.const_get sub.first_namespace
-
-      sub.set :system, system
-    end
+__END__
 
-  end
-
-end
+# view render.txt.erb
+<%= render if render_stack.any? -%>

data/lib/liza/unit_parts/unit_classes_part.rb

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

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