lizarb 1.0.3 → 1.0.5

data/lib/liza/base/panel.rb

@@ -1,24 +1,81 @@
 class Liza::Panel < Liza::Unit
-  inherited_explicitly_sets_system
 
-  def self.on_connected box_klass
-    set :box, box_klass
-  end
+  #
+
+  part :panel_rescuer
+
+  #
+
+  set :box, Liza::Box
+  set :controller, Liza::Controller
+
+  #
 
   def self.box
-    get :box
+    system.box
   end
 
   def box
-    self.class.box
+    system.box
+  end
+
+  def self.controller
+    @controller ||= system.const token
+  end
+
+  def controller
+    self.class.controller
+  end
+
+  def self.division
+    controller.division
+  end
+
+  def division
+    controller.division
+  end
+
+  def self.token
+    @token ||= last_namespace.gsub(/Panel$/, '').snakecase.to_sym
+  end
+
+  def self.subsystem
+    controller
   end
 
+  def subsystem
+    controller
+  end
+
+  # color
+
+  def self.color
+    system.color
+  end
+
+  #
+
+  attr_reader :key
+
   def initialize key
     @key = key
     @blocks = []
     @unstarted = true
+    @short = {}
+  end
+
+  #
+
+  def short a, b = nil
+    if b
+      @short[a.to_s] = b.to_s
+    else
+      @short[a.to_s] || a.to_s
+    end
   end
 
+  #
+
   def push block
     @unstarted = true
     @blocks.push block
@@ -28,27 +85,10 @@ class Liza::Panel < Liza::Unit
     return self unless defined? @unstarted
     remove_instance_variable :@unstarted
 
-    @blocks.each { |bl| instance_eval &bl }
+    @blocks.each { |bl| instance_eval(&bl) }
     @blocks.clear
 
     self
   end
-  
-  def 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 = box.to_s
-
-    x = source.size
-    source = source.bold.colorize log_color
-
-    y = source.size
-    source = "#{source}[:#{@key}]".ljust(LOG_JUST+y-x)
-
-    string = "#{source} #{string}"
-    
-    DevBox[:log].call string
-  end
 
 end

data/lib/liza/base/panel_test.rb

@@ -4,11 +4,176 @@ class Liza::PanelTest < Liza::UnitTest
   end
 
   def subject
-    subject_class.new "name"
+    @subject ||= subject_class.new "name"
   end
 
+  test_methods_defined do
+    on_self :box,
+    :color,
+    :controller,
+    :puts,
+    :subsystem,
+    :token
+    on_instance \
+      :box,
+      :controller, :division,
+      :key, :push,
+      :rescue_from, :rescue_from_panel, :rescuers,
+      :short, :started,
+      :subsystem
+  end
+
+  #
+
+  def assert_raises_2 e_class, &block
+    kaller = caller
+    begin
+      block.call
+      assert false, kaller: kaller
+    rescue e_class => e
+      assert true, kaller: kaller
+    rescue Exception => e
+      assert false, kaller: kaller
+    end
+  end
+
+  def refute_raises_2 e_class, &block
+    kaller = caller
+    begin
+      block.call
+      assert true, kaller: kaller
+    rescue e_class => e
+      assert false, kaller: kaller
+    rescue Exception => e
+      assert false, kaller: kaller
+    end
+  end
+
+  #
+
+  test :rescue_from, :validations do
+    assert_raises_2 ArgumentError do
+      subject.rescue_from(Liza)
+    end
+    
+    assert_raises_2 ArgumentError do
+      subject.rescue_from(Liza::Error)
+    end
+    
+    refute_raises_2 ArgumentError do
+      subject.rescue_from(Liza::Error) {  }
+    end
+    
+    refute_raises_2 ArgumentError do
+      subject.rescue_from(Liza::Error, with: Controller)
+    end
+
+    assert_raises_2 ArgumentError do
+      subject.rescue_from(Liza::Error, with: Controller) {  }
+    end
+  end
+
+  test :rescue_from, :rescuers, :rescue_from_panel do
+    assert_equality subject.rescuers, []
+    
+    #
+
+    subject.rescue_from(:command_panel, :parse) {  }
+    actual = subject.rescuers.last
+    
+    #
+
+    assert_equality actual.class, Liza::PanelRescuerPart::Rescuer
+    assert_equality actual[:exception_class], CommandPanel::ParseError
+    assert_equality actual[:with], nil
+    assert_equality actual[:block].class, Proc
+
+    #
+
+    subject.rescue_from(:command_panel, :parse, with: NotFoundCommand)
+    actual = subject.rescuers.last
+    
+    #
+
+    assert_equality actual.class, Liza::PanelRescuerPart::Rescuer
+    assert_equality actual[:exception_class], CommandPanel::ParseError
+    assert_equality actual[:with], DevSystem::NotFoundCommand
+    assert_equality actual[:block], nil
+  end
+
+  test :rescue_from, :rescuers, :_rescue_from_panel_find do
+    assert_equality subject.rescuers, []
+
+    subject.rescue_from(CommandPanel::ParseError, with: NotFoundCommand)
+    original_rescuer = subject.rescuers.last
+
+    assert_equality original_rescuer[:exception_class], CommandPanel::ParseError
+
+    actual = subject._rescue_from_panel_find CommandPanel::ParseError.new
+
+    assert_equality actual.class, Liza::PanelRescuerPart::Rescuer
+    refute_equality actual, original_rescuer
+
+    assert_equality original_rescuer[:exception], nil
+    assert_equality actual[:exception].class, CommandPanel::ParseError
+  end
+
+  test :rescue_from_panel do
+    todo "test this"
+  end
+
+  test :_rescue_from_parse_symbol do
+    actual = subject._rescue_from_parse_symbol(:error)
+    assert_equality Liza::Error, actual
+
+    assert_raises_2 NameError do
+      subject._rescue_from_parse_symbol(:errorx)
+    end
+  end
+
+  test :_rescue_from_parse_symbols do
+    actual = subject._rescue_from_parse_symbols([:command_panel, :parse])
+    assert_equality CommandPanel::ParseError, actual
+
+    actual = subject._rescue_from_parse_symbols([:command_panel, :not_found])
+    assert_equality CommandPanel::NotFoundError, actual
+
+    assert_raises_2 NameError do
+      subject._rescue_from_parse_symbols([:command_panel, :not_foxund])
+    end
+  end
+
+  #
+
   test :settings do
-    assert subject_class.log_level == :normal
-    assert subject_class.log_color == :white
+    assert_equality subject_class.log_level, 0
+  end
+
+  #
+
+  test :short do
+    assert_equality subject.short("m"), "m"
+    assert_equality subject.short("i"), "i"
+    assert_equality subject.short("n"), "n"
+    assert_equality subject.short("s"), "s"
+    assert_equality subject.short("w"), "w"
+    assert_equality subject.short("a"), "a"
+    assert_equality subject.short("n"), "n"
+
+    subject.short :m, :matz
+    subject.short :i, :is
+    subject.short :n, :nice
+    subject.short :s, :so
+    subject.short :w, :we
+    subject.short :a, :are
+
+    assert_equality subject.short("m"), "matz"
+    assert_equality subject.short("i"), "is"
+    assert_equality subject.short("n"), "nice"
+    assert_equality subject.short("s"), "so"
+    assert_equality subject.short("w"), "we"
+    assert_equality subject.short("a"), "are"
+    assert_equality subject.short("n"), "nice"
   end
+
 end

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