lizarb 1.0.5 → 1.0.6

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

@@ -2,40 +2,71 @@
 class Liza::TestTest < Liza::UnitTest
 
   test :settings do
-    assert_equality subject_class.log_level, 0
+    assert_equality subject_class.log_level, 4
   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
+  test_sections({
+    assertion_totals: {
+      constants: [],
+      class_methods: [:totals, :_assertion_todo, :_assertion_passed, :_assertion_failed, :_assertion_errored],
+      instance_methods: [:assertions=, :assertions, :_inc_assertions]
+    },
+    assertion: {
+      constants: [],
+      class_methods: [],
+      instance_methods: [:todo, :_groups, :group]
+    },
+    assertion_basic: {
+      constants: [],
+      class_methods: [],
+      instance_methods: [:assert, :refute, :assert!, :refute!, :critical]
+    },
+    assertion_equality: {
+      constants: [],
+      class_methods: [],
+      instance_methods: [:assert_equality, :refute_equality, :assert_equality!, :refute_equality!]
+    },
+    assertion_raises: {
+      constants: [],
+      class_methods: [],
+      instance_methods: [:assert_raises, :refute_raises, :assert_raises!, :refute_raises!]
+    },
+    no_raise: {
+      constants: [],
+      class_methods: [],
+      instance_methods: [:assert_no_raise, :assert_no_raise!, :refute_no_raise, :refute_no_raise!]
+    },
+    assertions_arythmetic:{
+      constants: [],
+      class_methods: [],
+      instance_methods: [:assert_gt, :refute_gt, :assert_lt, :refute_lt]
+    },
+    dsl: {
+      constants: [],
+      class_methods: [:call],
+      instance_methods: [:test_words, :initialize, :call]
+    },
+    log: {
+     constants: [:LOG_BUILDING, :LOG_ASSERTION, :LOG_ASSERTION_MESSAGE, :LOG_CALL_BLOCK],
+     class_methods: [:division, :log_test_building?, :log_test_building, :_log_test_block],
+     instance_methods: [:division, :log_test_building?, :log_test_assertion?, :log_test_assertion_message?, :log_test_call_block?, :log_test_call_rescue, :log_test_call, :log_test_assertion, :_log_test_assertion_tag, :_log_test_block, :log_test_assertion_result, :log_test_assertion_message, :_caller_line_split]
+    },
+    subject: {
+      constants: [],
+      class_methods: [:subject_class, :system],
+      instance_methods: [:subject_class, :subject, :system]
+    },
+    tree: {
+      constants: [:Tree],
+      class_methods: [:before_stack, :after_stack, :test_node, :test_tree, :group, :test, :before, :after],
+      instance_methods: []
+    },
+    default: {
+      constants: [],
+      class_methods: [:subsystem, :color],
+      instance_methods: []
+    }
+  })
 
   group :basics do
     test :truths do
@@ -119,14 +150,14 @@ class Liza::TestTest < Liza::UnitTest
 
   group :tree do
     test :test_tree do
-      assert_equality self.class.test_tree.class, Liza::TestTreePart
+      assert_equality self.class.test_tree.class, Liza::Test::Tree
       assert_equality self.class.test_tree, self.class.test_tree.parent
       
-      assert_equality 4, self.class.test_tree.tests.count
+      assert_equality 3, self.class.test_tree.tests.count
       assert_equality 5, self.class.test_tree.children.count
 
       a = self.class.test_tree.tests.map(&:first).flatten
-      b = [:settings, :subject_class, :methods_defined, :subject_class, :instance_methods_defined, :instance_groups]
+      b = [:settings, :sections, :instance_groups]
       assert_equality a, b
     end
   end

data/lib/liza/subsystemic_units/controller.rb

@@ -0,0 +1,221 @@
+class Liza::Controller < Liza::Unit
+
+  section :subsystem
+
+  def self.on_connected
+    token = self.last_namespace.snakecase.to_sym
+    subsystem! system.box, token
+    division!
+  end
+
+  def self.inherited klass
+    super
+
+    klass.on_connected if klass.superclass == Liza::Controller
+  end
+
+  # color
+
+  def self.color
+    return :white if self == Liza::Controller
+    return system.color if subsystem?
+    subsystem.color
+  end
+
+  def self.sh(s)
+    KernelShell.call_system s
+  end
+
+  def sh(s)
+    KernelShell.call_system s
+  end
+
+  def self.`(s)
+    KernelShell.call_backticks s
+  end
+
+  def `(s)
+    KernelShell.call_backticks s
+  end
+
+  # subsystem
+
+  def self.subsystem_token
+    get :subsystem_token
+  end
+
+  def self.subsystem
+    get :subsystem
+  end
+
+  def self.subsystem?
+    get(:subsystem) == self
+  end
+
+  def self.subsystem! box_klass, token
+    # FIRST, subsystem settings
+    panel = box_klass[token]
+    set :subsystem_token, token
+    set :subsystem, self
+    set :box, box_klass
+    set :panel, panel
+
+    # LAST, panel settings
+    panel.settings.each do |k, v|
+      next if settings.key? k
+      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
+
+  section :divisionable
+
+  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
+
+  section :grammarable
+
+  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
+
+  section :callable
+
+  def self.call(env)
+    log :higher, "env.count is #{env.count}" unless self <= DevSystem::Log
+
+    requirements.each do
+      log :normal, "require '#{_1}'" unless self <= DevSystem::Log
+      Kernel.require _1
+    end.clear
+
+    true
+  end
+
+  section :requirable
+
+  # This gem will be lazily required
+  def self.require(gem_name)
+    log :higher, "lazy require '#{gem_name}'" unless self <= DevSystem::Log
+    requirements << gem_name
+  end
+
+  def self.requirements()= @requirements ||= fetch(:requirements) { [] }
+
+  section :attributable
+
+  def self.attr_reader(*names)
+    names.each do |name|
+      define_method name do
+        log :highest, "@#{name} reads #{instance_variable_get("@#{name}").inspect}" unless name == :menv
+        instance_variable_get "@#{name}"
+      end
+    end
+  end
+
+  def self.attr_writer(*names)
+    names.each do |name|
+      define_method "#{name}=" do |value|
+        log :higher, "@#{name} writes #{value.inspect}" unless name == :menv
+        instance_variable_set "@#{name}", value
+      end
+    end
+  end
+
+  def self.attr_accessor(*names)
+    attr_reader(*names)
+    attr_writer(*names)
+  end
+
+  def attrs
+    instance_variables.map do |ivar|
+      [ivar, instance_variable_get(ivar)]
+    end.to_h
+  end
+
+  section :environmentable
+
+  def self.menv_reader(*names)
+    names.each do |name|
+      define_method name do
+        log :highest, "env[:#{name}] reads #{env[name].inspect}", method_name: 'menv_reader'
+        raise "env is nil!" unless env
+        env[name]
+      end
+    end
+  end
+  
+  def self.menv_writer(*names)
+    names.each do |name|
+      define_method "#{name}=" do |value|
+        log :higher, "env[:#{name}] writes #{value.inspect}", method_name: 'menv_writer'
+        raise "env is nil!" unless env
+        env[name] = value
+      end
+    end
+  end
+  
+  def self.menv_accessor(*names)
+    menv_reader(*names)
+    menv_writer(*names)
+  end
+  
+  attr_accessor :menv
+  
+  section :default
+
+end

data/lib/liza/subsystemic_units/controller_test.rb

@@ -0,0 +1,62 @@
+class Liza::ControllerTest < Liza::UnitTest
+  test :subject_class do
+    assert subject_class == Liza::Controller
+  end
+
+  test_sections(
+    :subsystem=>{
+      :constants=>[],
+      :class_methods=>[:on_connected, :inherited, :color, :sh, :`, :subsystem_token, :subsystem, :subsystem?, :subsystem!, :box, :panel],
+      :instance_methods=>[:sh, :`, :box, :panel]
+    },
+    :divisionable=>{
+      :constants=>[],
+      :class_methods=>[:division, :division?, :division!],
+      :instance_methods=>[]
+    },
+    :grammarable=>{
+      :constants=>[],
+      :class_methods=>[:singular, :plural, :token],
+      :instance_methods=>[]
+    },
+    :callable=>{
+      :constants=>[],
+      :class_methods=>[:call],
+      :instance_methods=>[]
+    },
+    :requirable=>{
+      :constants=>[],
+      :class_methods=>[:require, :requirements],
+      :instance_methods=>[]
+    },
+    :attributable=>{
+      :constants=>[],
+      :class_methods=>[:attr_reader, :attr_writer, :attr_accessor],
+      :instance_methods=>[:attrs]
+    },
+    :environmentable=>{
+      :constants=>[],
+      :class_methods=>[:menv_reader, :menv_writer, :menv_accessor],
+      :instance_methods=>[:menv, :menv=]
+    },
+    :default=>{
+      # this is because tests mock this class
+      :constants=>[],
+      :class_methods=>[:log, :puts],
+      :instance_methods=>[:log, :puts]
+    }
+  )
+
+  test :erbs_defined do
+    erbs_defined = subject_class.erbs_defined.map(&:key)
+    expected = []
+    assert_equality erbs_defined, expected
+  end
+
+  test :erbs_available do
+    erbs_available = subject_class.erbs_available.map(&:key)
+    expected = []
+    assert_equality erbs_available, expected
+  end
+
+end

data/lib/liza/{base → subsystemic_units}/panel.rb

@@ -1,16 +1,19 @@
 class Liza::Panel < Liza::Unit
 
-  #
-
-  part :panel_rescuer
-
-  #
+  section :subsystem
 
   set :box, Liza::Box
   set :controller, Liza::Controller
 
   #
 
+  def self.instance
+    x = self
+    x = x.ancestors.take_while { _1.last_namespace == x.last_namespace }.last
+    x = x.last_namespace.to_s.sub('Panel', '').snakecase.to_sym
+    box.configuration[x]
+  end
+
   def self.box
     system.box
   end
@@ -61,17 +64,6 @@ class Liza::Panel < Liza::Unit
     @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
 
   #

data/lib/liza/subsystemic_units/panel_test.rb

@@ -0,0 +1,22 @@
+class Liza::PanelTest < Liza::UnitTest
+  test :subject_class do
+    assert subject_class == Liza::Panel
+  end
+
+  def subject
+    @subject ||= subject_class.new "name"
+  end
+
+  test_sections(
+    :subsystem=>{
+      :constants=>[],
+      :class_methods=>[:instance, :box, :controller, :division, :token, :subsystem, :color, :log, :puts],
+      :instance_methods=>[:box, :controller, :division, :subsystem, :key, :initialize, :push, :started, :log, :puts]
+    }
+  )
+  
+  test :instance do
+    assert_equality BenchPanel.instance, DevBox.panels[:bench]
+  end
+
+end

data/lib/liza/systemic_units/box.rb

@@ -0,0 +1,82 @@
+class Liza::Box < Liza::Unit
+
+  def self.panels
+    fetch(:panels) { {} }
+  end
+
+  def self.[] symbol
+    configuration.panels[symbol].started
+  end
+
+  section :two_boxes
+
+  # Returns the Preconfiguration Box.
+  # (The Box in the systems directory)
+  # DevSystem::DevBox, HappySystem::HappyBox, etc.
+  # @return [Liza::Box]
+  def self.preconfiguration
+    @preconfiguration ||= last_namespace == name ? self.superclass : self
+  end
+
+  # Returns the Configuration Box.
+  # (The Box in the app directory)
+  # DevBox, HappyBox, etc.
+  # @return [Liza::Box]
+  def self.configuration
+    @configuration ||= begin
+      last_namespace == name ? self : const_get(last_namespace)
+    rescue NameError
+      self
+    end
+  end
+
+  # Preconfigure from the Preconfiguration Box at lib/my_system/my_box.rb
+  # @param name [Symbol]
+  # @param block [Proc] This block will only be loaded when configuration is requested.
+  def self.preconfigure(name, &block)= configure(name, &block)
+
+  # Configure from the Configuration Box at app/my_box.rb
+  # @param name [Symbol]
+  # @param block [Proc] This block will only be loaded when configuration is requested.
+  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
+
+  section :forwarding
+
+  def self.forward panel_key, method_name=nil
+    case method_name
+    when NilClass
+      method_name = :call
+      box_method_name = panel_key
+    when Symbol
+      box_method_name = method_name
+    when Hash
+      box_method_name = method_name.keys.first
+      method_name = method_name.values.first
+    else
+      raise ArgumentError, "Invalid method_name: #{method_name.inspect}. Expecting Symbol or Hash."
+    end
+    
+    define_singleton_method box_method_name do |*args, **kwargs|
+      self[panel_key].send method_name, *args, **kwargs
+    end
+  end
+
+  def self.color
+    system.color
+  end
+
+end
+
+__END__
+
+# view default.rb.erb
+<% token = system.token.to_s.capitalize -%>
+class <%= token %>Box < <%= token %>System::<%= token %>Box
+
+end

data/lib/liza/systemic_units/box_test.rb

@@ -0,0 +1,36 @@
+class Liza::BoxTest < Liza::UnitTest
+  test :subject_class do
+    assert subject_class == Liza::Box
+  end
+
+  test_sections(
+    :default=>{
+      :constants=>[],
+      :class_methods=>[:panels, :[]],
+      :instance_methods=>[]
+    },
+    :two_boxes=>{
+      :constants=>[],
+      :class_methods=>[:preconfiguration, :configuration, :preconfigure, :configure],
+      :instance_methods=>[]
+    },
+    :forwarding=>{
+      :constants=>[],
+      :class_methods=>[:forward, :color, :log, :puts],
+      :instance_methods=>[:log, :puts]
+    },
+  )
+
+  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 :preconfiguration, :configuration do
+    assert_equality ::DevBox.preconfiguration, ::DevSystem::DevBox
+    assert_equality ::DevBox.configuration, ::DevBox
+    assert_equality ::DevSystem::DevBox.preconfiguration, ::DevSystem::DevBox
+    assert_equality ::DevSystem::DevBox.configuration, ::DevBox
+  end
+
+end

data/lib/liza/systemic_units/system.rb

@@ -0,0 +1,52 @@
+class Liza::System < Liza::Unit
+
+  def self.const name
+    const_get name.to_s.camelize
+  end
+
+  #
+
+  def self.subs
+    @subs ||= []
+  end
+
+  def self.subsystems
+    return @subsystems if @subsystems
+    ret = subs.map { [_1, const(_1)] }.to_h
+    @subsystems = ret unless App.coding?
+    ret
+  end
+
+  # Adds a subsystem to the system
+  def self.panel name
+    subs << name
+  end
+
+  def self.token
+    @token ||= name.gsub(/System$/, '').snakecase.to_sym
+  end
+
+  def self.box
+    return @box if @box
+    ret = const "#{token}_box"
+    @box = ret unless App.coding?
+    ret
+  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/systemic_units/system_test.rb

@@ -0,0 +1,14 @@
+class Liza::SystemTest < Liza::UnitTest
+  test :subject_class do
+    assert subject_class == Liza::System
+  end
+
+  test_sections(
+    :default=>{
+      :constants=>[],
+      :class_methods=>[:const, :subs, :subsystems, :panel, :token, :box, :system, :color, :log, :puts],
+      :instance_methods=>[:log, :puts]
+    }
+  )
+
+end