lizarb 1.0.4 → 1.0.5

data/lib/liza/base_parts/controller_subsystem_part.rb

@@ -0,0 +1,93 @@
+class Liza::ControllerSubsystemPart < Liza::Part
+  insertion do
+
+    # subsystem
+  
+    def self.subsystem
+      get :subsystem
+    end
+  
+    def self.subsystem?
+      get(:subsystem) == self
+    end
+
+    def self.subsystem! box_klass, panel
+      # FIRST, subsystem settings
+      set :subsystem, self
+      set :box, box_klass
+      set :panel, panel
+
+      # LAST, panel settings
+      panel.settings.each do |k, v|
+        set k, v
+      end  
+    end
+
+    # box and panel
+
+    def self.box
+      get :box
+    end
+
+    def self.panel
+      get :panel
+    end
+
+    def box
+      self.class.box
+    end
+
+    def panel
+      self.class.panel
+    end
+
+    # division
+
+    def self.division
+      get :division
+    end
+  
+    def self.division?
+      get(:division) == self
+    end
+  
+    def self.division!
+      set :division, self
+  
+      camel = last_namespace
+      singular = camel.snakecase.to_sym
+      plural = "#{camel}s".snakecase.to_sym
+      fetch(:singular) { singular }
+      fetch(:plural) { plural }
+    end
+
+    # grammar
+
+    def self.singular
+      case
+      when subsystem? then get :singular
+      when division?  then :"#{token}_#{subsystem.singular}"
+      else                 :"#{token}_#{division.singular}"
+      end
+    end
+  
+    def self.plural
+      case
+      when subsystem? then get :plural
+      when division?  then :"#{token}_#{subsystem.plural}"
+      else                 :"#{token}_#{division.plural}"
+      end
+    end
+    
+    def self.token
+      if subsystem?
+        nil
+      elsif division?
+        last_namespace.gsub(/#{subsystem.last_namespace}$/, '').snakecase.to_sym
+      else
+        last_namespace.gsub(/#{division.last_namespace}$/, '').snakecase.to_sym
+      end
+    end
+  
+  end
+end

data/lib/liza/base_parts/panel_rescuer_part.rb

@@ -0,0 +1,129 @@
+class Liza::PanelRescuerPart < Liza::Part
+  insertion do
+
+    #
+
+    def rescue_from(*args, with: nil, &block)
+      rescuer = Rescuer.new
+
+      raise ArgumentError, "either with: or block is required, but not both" if with && block
+
+      case args.count
+      when 1
+
+        e_class = args[0]
+        e_class = _rescue_from_parse_symbol(e_class) if Symbol === e_class
+
+      when 2
+        
+        e_class = args[0]
+        e_class = _rescue_from_parse_symbols(args) if Symbol === e_class
+      
+      else
+      
+        raise ArgumentError, "wrong number of arguments (given #{args.count}, expected 1..2)"
+      
+      end
+
+      unless e_class
+        msg = "args #{args} parsed to #{e_class} (expected a descendant of Exception)"
+        raise ArgumentError, msg
+      end
+
+      e_class_is_exception = e_class.ancestors.include? Exception
+      unless e_class_is_exception
+        msg = "args #{args} parsed to #{e_class} (expected a descendant of Exception)"
+        raise ArgumentError, msg
+      end
+
+      rescuer[:exception_class] = e_class
+      rescuer[:with] = with
+      rescuer[:block] = block
+
+      if with.nil? && block.nil?
+        puts "rescue_from #{e_class} with: or block: is required".red
+        raise ArgumentError, "with: or block: is required", caller
+      end
+
+      rescuers.push(rescuer)
+    end
+
+    def _rescue_from_parse_symbol(arg)
+      return Liza::Error if arg == :error
+
+      Object.const_get(arg.to_s.camelcase)
+    rescue NameError => e
+      msg = "rescue_from parsed to #{arg.to_s.camelcase} which does not exist"
+      puts msg.red
+      raise e, msg, caller
+    end
+
+    def _rescue_from_parse_symbols(args)
+      namespace = Liza.const(args[0])
+      begin
+        namespace.const_get("#{args[1].to_s.camelcase}Error")
+      rescue NameError => e
+        msg = "rescue_from parsed to #{args[0].to_s.camelcase}::#{args[1].to_s.camelcase}Error which does not exist"
+        puts msg.red
+        raise e, msg, caller
+      end
+    end
+
+    #
+
+    def rescuers
+      @rescuers ||= []
+    end
+
+    #
+
+    def rescue_from_panel(exception, with: )
+      rescuer = _rescue_from_panel_find exception
+      raise exception.class, exception.message, caller[1..-1] unless rescuer
+
+      ret = nil
+
+      log :lower, "rescuer = #{rescuer.inspect}"
+      case with
+      when Array
+        with.push(rescuer)
+        rescuer[:args] = with
+        ret = rescuer.call
+      when Hash
+        with[:rescuer] = rescuer
+        rescuer[:env] = with
+        ret = rescuer.call
+      else
+        raise ArgumentError, "wrong argument type #{with.class} (expected Array or Hash)"
+      end
+
+      ret
+    end
+
+    def _rescue_from_panel_find(exception)
+      rescuer = rescuers.reverse.find { exception.class.ancestors.include? _1[:exception_class] }
+      log :lower, "rescuer = #{rescuer.inspect}"
+      return nil unless rescuer
+      rescuer = rescuer.dup
+      rescuer[:exception] = exception
+      rescuer
+    end
+
+    #
+
+    class Rescuer < Hash
+      def call
+        if self[:block]
+          self[:block].call self
+        elsif self[:env]
+          self[:with].call self[:env]
+        elsif self[:args]
+          self[:with].call self[:args]
+        else
+          raise "not expected"
+        end
+      end
+    end
+
+  end
+end

data/lib/liza/meta/box.rb

@@ -0,0 +1,24 @@
+class Liza::Box < Liza::Unit
+
+  def self.panels
+    fetch(:panels) { {} }
+  end
+
+  def self.[] symbol
+    panels[symbol].started
+  end
+
+  def self.configure name, &block
+    raise ArgumentError, "block required" unless block_given?
+    raise ArgumentError, "Invalid panel: #{name}. Valid panels are: #{system.subs}" unless system.subs.include? name
+
+    panel = panels[name] ||= Liza.const("#{name}_panel").new name
+    panel.push block
+  end
+
+  # color
+
+  def self.color
+    system.color
+  end
+end

data/lib/liza/meta/box_test.rb

@@ -0,0 +1,20 @@
+class Liza::BoxTest < Liza::UnitTest
+  test :subject_class do
+    assert subject_class == Liza::Box
+  end
+
+  test_methods_defined do
+    on_self :[], :color, :configure, :panels, :puts
+    on_instance
+  end
+
+  def assert_sub name, controller_class, panel_class, kaller: caller
+    assert_equality subject_class[name].class, panel_class, kaller: kaller
+    assert_equality panel_class.controller, controller_class, kaller: kaller
+  end
+
+  test :settings do
+    assert_equality subject_class.log_level, 0
+  end
+
+end

data/lib/liza/meta/part_test.rb

@@ -1,6 +1,11 @@
-class Liza::PartTest < Liza::Test
+class Liza::PartTest < Liza::UnitTest
   test :subject_class do
     assert subject_class == Liza::Part
   end
 
+  test_methods_defined do
+    on_self :extension, :insertion
+    on_instance
+  end
+
 end

data/lib/liza/meta/system.rb

@@ -4,15 +4,58 @@ class Liza::System < Liza::Unit
     const_get name.to_s.camelize
   end
 
-  def self.insertion key, &block
-    if block_given?
-      registrar[:"insertion_#{key}"] = block
+  # Ignore this for now.
+  # This feature has been commented out for simplicity purposes.
+  # It injects code into other classes just like Part does. Lizarb connects them
+
+  # def self.insertion key, &block
+  #   if block_given?
+  #     registrar[:"insertion_#{key}"] = block
+  #   else
+  #     registrar[:"insertion_#{key}"]
+  #   end
+  # end
+
+  # def self.registrar
+  #   @registrar ||= {}
+  # end
+
+  #
+
+  def self.subs
+    @subs ||= []
+  end
+
+  def self.subsystems
+    @subsystems ||= subs.map { const _1 }
+  end
+
+  def self.sub name
+    subs << name
+  end
+
+  def self.token
+    @token ||= name.gsub(/System$/, '').snakecase.to_sym
+  end
+
+  def self.box
+    @box ||= self.const_get "#{token}_box".camelize
+  end
+
+  # SYSTEM
+
+  def self.system
+    self
+  end
+  
+  # COLOR
+
+  def self.color color = nil
+    if color
+      @color = color
     else
-      registrar[:"insertion_#{key}"]
+      @color
     end
   end
 
-  def self.registrar
-    @registrar ||= {}
-  end
 end

data/lib/liza/meta/system_test.rb

@@ -3,9 +3,13 @@ class Liza::SystemTest < Liza::UnitTest
     assert subject_class == Liza::System
   end
 
+  test_methods_defined do
+    on_self :box, :color, :const, :sub, :subs, :subsystems, :token
+    on_instance
+  end
+
   test :settings do
-    assert subject_class.log_level == :normal
-    assert subject_class.log_color == :white
+    assert_equality subject_class.log_level, 0
   end
 
 end

data/lib/liza/ruby_tests/app_test.rb

@@ -0,0 +1,39 @@
+class Liza::AppTest < Liza::ObjectTest
+  
+  test :subject_class do
+    assert_equality subject_class, App
+  end
+
+  test :cwd, :root do
+    # returns a Pathname
+    assert_equality App.root.class, Pathname
+
+    # returns a new object each time
+    refute_equality App.cwd.object_id, App.cwd.object_id
+    
+    # returns the same object each time
+    assert_equality App.root.object_id, App.root.object_id
+
+    # the join method creates a new object
+    refute_equality App.root.object_id, App.root.join("lib").object_id
+
+    # matches the current working directory
+    assert_equality App.root, App.cwd
+    Dir.chdir "lib" do
+      refute_equality App.root, App.cwd
+    end
+    assert_equality App.root, App.cwd
+  end
+
+  test :path, :relative_path do
+    # returns a Pathname
+    assert_equality App.path.class, Pathname
+    assert_equality App.relative_path.class, Pathname
+    assert_equality App.relative_path, Pathname("app")
+
+    # App.path starts with App.root
+    assert App.path.to_s.start_with?(App.root.to_s)
+    assert App.path.to_s.end_with?("app")
+  end
+  
+end

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 TerminalCommand.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 TerminalCommand.source_location_radical.end_with? "/lib/dev_system/dev/controllers/command/terminal_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
@@ -77,7 +108,7 @@ class Liza::TestTest < Liza::Test
       if Shell.jruby?
         todo "jruby!"
       else
-        assert_equality instance_variables, [:@test_words, :@before_stack, :@after_stack, :@test_block]
+        assert_equality instance_variables, [:@test_words, :@before_stack, :@after_stack, :@test_block, :@settings]
       end
     end
 
@@ -88,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_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