lizarb 1.0.5 → 1.0.6

data/lib/liza/base/panel_test.rb

@@ -1,179 +0,0 @@
-class Liza::PanelTest < Liza::UnitTest
-  test :subject_class do
-    assert subject_class == Liza::Panel
-  end
-
-  def subject
-    @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_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

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

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

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

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

@@ -1,17 +0,0 @@
-class Liza::Part < Liza::Unit
-  def self.insertion &block
-    if block_given?
-      @insertion = block
-    else
-      @insertion
-    end
-  end
-
-  def self.extension &block
-    if block_given?
-      @extension = block
-    else
-      @extension
-    end
-  end
-end

data/lib/liza/meta/part_test.rb

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

@@ -1,61 +0,0 @@
-class Liza::System < Liza::Unit
-
-  def self.const name
-    const_get name.to_s.camelize
-  end
-
-  # 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
-      @color
-    end
-  end
-
-end

data/lib/liza/meta/system_test.rb

@@ -1,15 +0,0 @@
-class Liza::SystemTest < Liza::UnitTest
-  test :subject_class do
-    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_equality subject_class.log_level, 0
-  end
-
-end

data/lib/liza/ruby_tests/class_test.rb

@@ -1,20 +0,0 @@
-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,21 +0,0 @@
-class Liza::ModuleTest < Liza::ObjectTest
-  
-  test :subject_class do
-    assert subject_class == Module
-  end
-
-  test :source_location do
-    assert Object.source_location == []
-
-    assert Liza::Command.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/sub/command/command"
-    assert IrbCommand.source_location_radical.end_with? "/lib/dev_system/sub/command/commands/irb_command"
-  end
-
-end

data/lib/liza/safety/test.rb

@@ -1,19 +0,0 @@
-class Liza::Test < Liza::Unit
-
-  part :test_assertions
-  part :test_assertions_advanced
-  part :test_dsl
-  part :test_log
-  part :test_subject
-  part :test_tree
-
-  def self.subsystem
-    subject_class.subsystem
-  end
-
-  # color
-
-  def self.color
-    subject_class.color
-  end
-end