lizarb 1.0.4 → 1.0.5

data/lib/liza/unit_parts/unit_settings_part.rb

@@ -1,6 +1,14 @@
 class Liza::UnitSettingsPart < Liza::Part
 
   insertion do
+    def self.methods_for_settings
+      [:add, :fetch, :get, :set, :settings].sort
+    end
+  
+    def self.instance_methods_for_settings
+      [:add, :fetch, :get, :set, :settings].sort
+    end
+  
     def self.settings
       @settings ||= {}
     end

data/lib/liza/unit_test.rb

@@ -3,13 +3,122 @@ class Liza::UnitTest < Liza::Test
     assert subject_class == Liza::Unit
   end
 
+  #
+
+  def self.test_methods_defined(&block)
+    helper = TestMethodsDefinedHelper.new
+    helper.instance_eval(&block)
+
+    test :subject_class, :methods_defined do
+      a = subject_class.methods_defined
+      b = helper.methods
+      assert_equality a, b, kaller: helper.methods_caller
+    end
+
+    test :subject_class, :instance_methods_defined do
+      a = subject_class.instance_methods_defined
+      b = helper.instance_methods
+      assert_equality a, b, kaller: helper.instance_methods_caller
+    end
+  end
+
+  class TestMethodsDefinedHelper
+    attr_reader :methods, :methods_caller
+    attr_reader :instance_methods, :instance_methods_caller
+
+    def initialize
+      @methods, @instance_methods = [], []
+      @methods_caller, @instance_methods_caller = caller, caller
+    end
+
+    def on_self(*args)
+      @methods = args
+      @methods_caller = caller
+    end
+
+    def on_instance(*args)
+      @instance_methods = args
+      @instance_methods_caller = caller
+    end
+  end
+
+  #
+
+  test :subject_class, :methods_defined do
+    a = \
+      subject_class.methods_defined -
+      subject_class.methods_for_settings -
+      subject_class.methods_for_logging -
+      subject_class.methods_for_rendering
+    b = [
+      :descendants_select,
+      :division,
+      :instance_methods_defined, :instance_methods_for_logging, :instance_methods_for_rendering, :instance_methods_for_settings,
+      :methods_defined, :methods_for_logging, :methods_for_rendering, :methods_for_settings,
+      :namespace,
+      :part,
+      :procedure, :proceed,
+      :reload!,
+      :subclasses_select, :system, :system?,
+      :test_class
+    ]
+    assert_equality a, b
+  end
+
+  test :subject_class, :instance_methods_defined do
+    a = \
+      subject_class.instance_methods_defined -
+      subject_class.instance_methods_for_settings -
+      subject_class.instance_methods_for_logging -
+      subject_class.instance_methods_for_rendering
+    b = [:procedure, :proceed, :reload!, :system]
+    assert_equality a, b
+  end
+
+  test :subject_class, :methods_for_settings do
+    a = subject_class.methods_for_settings
+    b = [:add, :fetch, :get, :set, :settings]
+    assert_equality a, b
+  end
+
+  test :subject_class, :instance_methods_for_settings do
+    a = subject_class.instance_methods_for_settings
+    b = [:add, :fetch, :get, :set, :settings]
+    assert_equality a, b
+  end
+
+  test :subject_class, :methods_for_rendering do
+    a = subject_class.methods_for_rendering
+    b = [:erbs_available, :erbs_defined, :erbs_for, :renderable_formats_for, :renderable_names]
+    assert_equality a, b
+  end
+
+  test :subject_class, :instance_methods_for_rendering do
+    a = subject_class.instance_methods_for_rendering
+    b = [:render, :render!, :render_stack]
+    assert_equality a, b
+  end
+
+  test :subject_class, :methods_for_logging do
+    a = subject_class.methods_for_logging
+    b = [:log, :log?, :log_array, :log_hash, :log_level, :log_level?, :log_levels, :stick, :sticks]
+    assert_equality a, b
+  end
+
+  test :subject_class, :instance_methods_for_logging do
+    a = subject_class.instance_methods_for_logging
+    b = [:log, :log?, :log_array, :log_hash, :log_level, :log_level?, :log_levels, :log_render_convert, :log_render_in, :log_render_out, :stick, :sticks]
+    assert_equality a, b
+  end
+
   test :settings do
-    assert subject_class.get(:log_level) == :normal
-    assert subject_class.get(:log_color) == :white
-    assert subject_class.log_level == :normal
-    assert subject_class.log_color == :white
+    assert_equality subject_class.get(:log_level), 0
+    assert_equality subject_class.log_level, 0
 
-    assert subject_class.settings == {log_level: :normal, log_color: :white}
+    assert_equality subject_class.settings, {
+      log_level: 0,
+      division: Liza::Controller,
+    }
   end
 
   test :settings_inheritance do
@@ -74,15 +183,4 @@ class Liza::UnitTest < Liza::Test
     assert class_b.get(:hash) == {a: 10, b: 20, c: 30, d: 40}
   end
 
-  test :build_log_sidebar_for do
-    assert_equality "DevSystem::Command:call                       ", build_log_sidebar_for(DevSystem::Command, "call", ":", panel_key: nil)
-    assert_equality "DevSystem::TestCommand#call                   ", build_log_sidebar_for(DevSystem::TestCommand, "call", "#", panel_key: nil)
-    assert_equality "DevBox[:command].call                         ", build_log_sidebar_for(DevBox, "call", ".", panel_key: :command)
-  end
-
-  def build_log_sidebar_for source, method_key, method_sep, panel_key: nil
-    s = subject_class.build_log_sidebar_for source, method_key, method_sep, panel_key: panel_key
-    s.uncolorize
-  end
-
 end

data/lib/liza.rb

@@ -9,7 +9,7 @@ module Liza
   module_function
 
   def log s
-    puts s.bold
+    puts s
   end
 
   #
@@ -33,7 +33,7 @@ module Liza
 
     nil
   rescue NameError
-    log "Liza const #{name} not found!"
+    log "Liza const #{name} not found!" if $VERBOSE
     if Lizarb.ruby_supports_raise_cause?
       raise ConstNotFound, name, cause: nil
     else

data/lib/lizarb/ruby/class.rb

@@ -1,12 +1,19 @@
 # frozen_string_literal: true
 
 class Class
-  public :eval
 
   def descendants
     ObjectSpace.each_object(Class).select { |klass| klass < self }
   end
 
+  def and_descendants
+    ObjectSpace.each_object(Class).select { |klass| klass <= self }
+  end
+  
+  def ancestors_until klass
+    ancestors.take_while { _1 <= klass }
+  end
+
   def first_namespace
     name.rpartition('::')[0]
   end
@@ -14,4 +21,5 @@ class Class
   def last_namespace
     name.rpartition('::')[-1]
   end
+
 end

data/lib/lizarb/ruby/string.rb

@@ -10,7 +10,9 @@ class String
   alias camelize camelcase
 
   def snakecase
-    gsub(/[A-Z\s-]/) { |s, t| "_#{s}" }[1..-1].to_s.downcase
+    gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+      .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+      .downcase
   end
   
   alias snakefy snakecase

data/lib/lizarb/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Lizarb
-  VERSION = "1.0.4"
+  VERSION = "1.0.5"
 end

data/lib/lizarb.rb

@@ -1,5 +1,10 @@
 # frozen_string_literal: true
 
+# This flag allows database connection tests
+# ENV["DBTEST"] ||= "1"
+
+$boot_time = Time.now
+
 require "colorize"
 require "json"
 require "pathname"
@@ -13,12 +18,18 @@ $APP ||= "app"
 module Lizarb
   class Error < StandardError; end
   class ModeNotFound < Error; end
+  class SystemNotFound < Error; end
 
   #
 
-  SPEC    = Gem::Specification.find_by_name("lizarb")
-  GEM_DIR = SPEC.gem_dir
   CUR_DIR = Dir.pwd
+  begin
+    SPEC    = Gem::Specification.find_by_name("lizarb")
+    GEM_DIR = SPEC.gem_dir
+  rescue Gem::MissingSpecError
+    SPEC    = nil
+    GEM_DIR = CUR_DIR
+  end
 
   IS_APP_DIR = File.file? "#{CUR_DIR}/app.rb"
   IS_LIZ_DIR = File.file? "#{CUR_DIR}/lib/lizarb.rb"
@@ -33,11 +44,8 @@ module Lizarb
   module_function
 
   def log s
-    puts s.bold
-  end
-
-  def self.logv s
-    log s if $VERBOSE
+    print "#{$boot_time.diff}s " if defined? $log_boot_low
+    puts s
   end
 
   # Returns Lizarb::VERSION as a Gem::Version
@@ -54,10 +62,6 @@ module Lizarb
     RUBY_ENGINE != "jruby"
   end
 
-  def self.load_all
-    Zeitwerk::Loader.eager_load_all
-  end
-
   # called from exe/lizarb
   def setup
     lookup_and_load_core_ext
@@ -76,31 +80,44 @@ module Lizarb
 
   # called from exe/lizarb
   def call
+    require "bundler/setup"
+
+    level = App.log_boot
+    is_lowest = level == -3
+    App::LOG_LEVELS.each do |k, v|
+      puts "$log_boot_#{k} = #{v >= level}" if level == -3
+      eval "$log_boot_#{k} = true" if v >= level
+    end
+    log "LizaRB v#{Lizarb.version}                                                                                                      https://lizarb.org" if defined? $log_boot_higher
+    log "#{self}.#{__method__}" if defined? $log_boot_low
+
     lookup_and_set_mode
-    lookup_and_require_dependencies
     lookup_and_load_settings
-    require_liza_and_bundle_systems
+    require_liza_and_systems
+    connect_systems
   end
 
   # called from exe/lizarb
-  def exit verbose: $VERBOSE
-    exit_messages if verbose
+  def exit
+    exit_messages if defined? $log_boot_normal
     super 0
   end
 
   def exit_messages
-    versions = {
+    info = {
       ruby: RUBY_VERSION,
       bundler: Bundler::VERSION,
       zeitwerk: Zeitwerk::VERSION,
       lizarb: VERSION,
       app: $APP,
-      mode: $MODE
+      mode: App.mode,
+      log_boot: App.log_boot,
+      log_level: App.get(:log_level),
     }
-    bugs = SPEC.metadata["bug_tracker_uri"]
-    puts versions.to_s.green
-    puts "Report bugs at #{bugs}"
-    puts "Fork us on Github at #{bugs}/fork"
+    github = "https://github.com/lizarb/lizarb"
+    puts info.to_s
+    puts "Report bugs at #{github}/issues"
+    puts "Fork us on Github at #{github}/fork"
   end
 
   # setup phase
@@ -164,35 +181,34 @@ module Lizarb
   # call phase
 
   def lookup_and_set_mode
-    raise ModeNotFound, "App #{$APP} has no modes" if App.modes.empty?
-
-    mode = ENV["MODE"]
-    mode ||= App.modes.first
-    mode = mode.to_sym
-
-    raise ModeNotFound, "MODE `#{mode}` is not included in #{App.modes}" unless App.modes.include? mode
+    log "  Lizarb.#{__method__}" if defined? $log_boot_low
 
-    log "#{self}.#{__method__} #{mode.inspect}" if $VERBOSE
-    $MODE = mode
-  end
-
-  def lookup_and_require_dependencies
-    require "bundler/setup"
-    Bundler.require :default, *App.systems.keys
+    $mode = App.mode
+    log "    $mode = #{$mode.inspect}" if defined? $log_boot_lower
+    $coding = App.coding?
+    log "    $coding enabled because $mode == :code | A bit slower for debugging purposes" if $coding && defined? $log_boot_lower
   end
 
   def lookup_and_load_settings
-    files = ["#{$APP}.#{$MODE}.env", "#{$APP}.env"]
+    log "  Lizarb.#{__method__}" if defined? $log_boot_low
+    files = ["#{$APP}.#{$mode}.env", "#{$APP}.env"]
     require "dotenv"
     Dotenv.load(*files)
   end
 
-  def require_liza_and_bundle_systems
+  def require_liza_and_systems
+    log "  Lizarb.#{__method__}" if defined? $log_boot_low
+
+    log "    require Zeitwerk and Liza" if defined? $log_boot_lower
+
     require "zeitwerk"
     require "liza"
 
-    # App.loaders[0] first loads Liza, then each System class
-    App.loaders << loader = Zeitwerk::Loader.new
+    # loaders[0] first loads Liza, then each System class
+
+    log "    Zeitwerk loaders [0] first loads Liza, then each System class" if defined? $log_boot_lower
+
+    loaders << loader = Zeitwerk::Loader.new
     loader.tag = Liza.to_s
 
     # collapse Liza paths
@@ -206,19 +222,27 @@ module Lizarb
     loader.enable_reloading
     loader.setup
 
+    # bundle each System gem
+
+    Bundler.require :systems
+
     # load each System class
 
+    log "      App.systems is Hash containing all system classes" if defined? $log_boot_lowest
     App.systems.keys.each do |k|
       key = "#{k}_system"
 
-      App.require_system key
+      require_system key
       klass = Object.const_get key.camelize
 
       App.systems[k] = klass
     end
 
-    # App.loaders[1] first loads each System, then the App
-    App.loaders << loader = Zeitwerk::Loader.new
+    App.systems.freeze
+
+    # loaders[1] first loads each System, then the App
+    log "    Zeitwerk loaders [1] first loads each System, then the App" if defined? $log_boot_lower
+    loaders << loader = Zeitwerk::Loader.new
 
     # collapse each System paths
 
@@ -230,46 +254,55 @@ module Lizarb
 
     # cherrypick App paths
 
-    app_dir = "#{APP_DIR}/#{$APP}"
-    logv "Lizarb app loader #{app_dir}".on_cyan
-    list = Dir["#{app_dir}/*"].to_set
-    logv "Lizarb app loader lists #{list.count} entries to review".on_cyan
+    app_dir = App.path
+    if app_dir
+      log "      Application Directory: #{app_dir}" if defined? $log_boot_lowest
+      list = Dir["#{app_dir}/*"].to_set
+    end
 
-    if list.empty?
-      logv "no #{app_dir} found".red
+    if app_dir.nil? || list.empty?
+      log "      Application Directory is empty" if defined? $log_boot_lowest
     else
-      logv "Lizarb app loader found #{app_dir}\t\tCollapsing #{app_dir}/*".on_cyan
+      log "      Application Directory found #{list.count} items to collapse" if defined? $log_boot_lowest
 
       to_collapse = []
 
       App.systems.each do |k, klass|
+        next if klass.subs.empty?
         box_dir  = "#{app_dir}/#{k}"
         box_file = "#{box_dir}_box.rb"
 
         if !list.include? box_file
-          logv "Lizarb app loader missd #{box_file}".on_light_black
+          log "        Missd box file    #{box_file}! Generating it"
+
+          File.write box_file, <<-RUBY
+class #{k.to_s.camelize}Box < #{k.to_s.camelize}System::#{k.to_s.camelize}Box
+
+end
+          RUBY
+        end
+
+        log "        Found box file    #{box_file}" if defined? $log_boot_lowest
+        to_collapse << box_file
+
+        if !list.include? box_dir
+          log "        Missd controllers #{box_dir}" if defined? $log_boot_lowest
         else
-          logv "Lizarb app loader found #{box_file}\t\tto_collapse!".on_cyan
-          to_collapse << box_file
-
-          if !list.include? box_dir
-            logv "Lizarb app loader missd #{box_dir}".on_light_black
-          else
-            logv "Lizarb app loader found #{box_dir}\t\tto_collapse!".on_cyan
-            to_collapse << box_dir
-          end
+          log "        Found controllers #{box_dir}" if defined? $log_boot_lowest
+          to_collapse << box_dir
         end
+
       end
 
       # ORDER MATTERS: IGNORE, COLLAPSE, PUSH
       to_ignore = list - to_collapse
       to_ignore.each do |file|
-        logv "Lizarb app loader missd #{file}\t\tSkipping this one".on_light_black
+        log "      Ignoring   #{file}" if $log_boot_lowest
         loader.ignore file
       end
 
       to_collapse.each do |path|
-        logv "Lizarb app loader collapsing #{path}".on_cyan
+        log "      Collapsing #{path}" if $log_boot_lowest
         if path.end_with? ".rb"
           loader.collapse path
         else
@@ -288,11 +321,129 @@ module Lizarb
 
     # App connects to systems
 
-    App.systems.each do |k, klass|
-      App.connect_system k, klass
+    log "    Zeitwerk loaders eager load" if defined? $log_boot_lowest
+    loaders.map &:eager_load
+  end
+
+  def connect_systems
+    log "  Lizarb.#{__method__} (#{App.systems.count})" if defined? $log_boot_low
+    App.systems.each do |system_key, system_class|
+      connect_system system_key, system_class
+      connect_box system_key, system_class
     end
+  end
 
-    App.systems.freeze
+  # systems
+
+  def require_system key
+    log "        require '#{key}'" if defined? $log_boot_lowest
+    require key
+  rescue LoadError => e
+    def e.backtrace; []; end
+    raise SystemNotFound, "FILE #{key}.rb not found on $LOAD_PATH", []
+  end
+
+  def connect_system key, system_class
+    t = Time.now
+    puts if defined? $log_boot_low
+
+    system_class.color DevSystem::ColorShell.parse system_class.color unless system_class.color.is_a? Array
+
+    color_system_class = Liza::Unit.stick(system_class.color, system_class.name).to_s
+
+    log "CONNECTING SYSTEM                     #{color_system_class}" if defined? $log_boot_low
+    
+    # Ignore this for now.
+    # This feature has been commented out for simplicity purposes.
+    # It injects code into other classes just like Part does. System defines them
+
+    # index = 0
+    # system_class.registrar.each do |string, target_block|
+    #   reg_type, _sep, reg_target = string.to_s.lpartition "_"
+
+    #   index += 1
+
+    #   target_klass = Liza.const reg_target
+
+    #   if reg_type == "insertion"
+    #     target_klass.class_exec(&target_block)
+    #   else
+    #     raise "TODO: decide and implement system extension"
+    #   end
+    #   log "CONNECTING SYSTEM-PART                #{color_system_class}.#{reg_type.to_s.ljust 11} to #{target_klass.to_s.ljust 30} at #{target_block.source_location * ":"}  " if defined? $log_boot_low
+    # end
+
+    # pad = 21-system_class.name.size
+    # log "CONNECTED  SYSTEM         #{t.diff}s for #{color_system_class}#{"".ljust pad} to connect to #{index} system parts" if defined? $log_boot_normal
+  end
+
+  def connect_box key, system_class
+    t = Time.now
+
+    box_class = system_class.box
+    color_box_class = Liza::Unit.stick(system_class.color, box_class.name).to_s
+
+    log "CONNECTING BOX                        #{color_box_class}" if defined? $log_boot_low
+    index = 0
+    # system_class.subs.keys.each do |sub_key|
+    system_class.subs.each do |sub_key|
+      panel_class_name      = "#{sub_key}_panel".camelize
+      controller_class_name = sub_key.to_s.camelize
+
+      index += 1
+      pad = 30-box_class.name.size-sub_key.to_s.size
+      log "CONNECTED  BOX TO PANEL               #{"#{color_box_class}[:#{sub_key}]"}#{"".ljust pad} is an instance of #{panel_class_name.ljust_blanks 20} and it configures #{controller_class_name}" if defined? $log_boot_low
+    end
+
+    log "CONNECTED  BOX            #{t.diff}s" if defined? $log_boot_low
+  end
+
+  # parts
+
+  def connect_part unit_class, key, part_class, system
+    if defined? $log_boot_lowest
+      t = Time.now
+      string = "      #{unit_class}.part :#{key}"
+      log string
+    end
+
+    part_class ||= if system.nil?
+                Liza.const "#{key}_part"
+              else
+                Liza.const("#{system}_system")
+                    .const "#{key}_part"
+              end
+
+    if part_class.insertion
+      unit_class.class_exec(&part_class.insertion)
+    end
+
+    if part_class.extension
+      part_class.const_set :Extension, Class.new(Liza::PartExtension)
+      part_class::Extension.class_exec(&part_class.extension)
+    end
+
+    if defined? $log_boot_lowest
+      log "      ."
+    end
+  end
+
+  # loaders
+
+  @loaders = []
+  @mutex = Mutex.new
+
+  def loaders
+    @loaders
+  end
+
+  def reload &block
+    @mutex.synchronize do
+      loaders.map &:reload
+      yield if block_given?
+    end
+
+    true
   end
 
   # thread management

data/lib/micro_system/micro_box.rb

@@ -0,0 +1,5 @@
+class MicroSystem::MicroBox < Liza::Box
+
+  #
+  
+end

data/lib/micro_system/micro_box_test.rb

@@ -0,0 +1,8 @@
+class MicroSystem::MicroBoxTest < Liza::BoxTest
+  
+  test :subject_class, :subject do
+    assert_equality MicroSystem::MicroBox, subject_class
+    assert_equality MicroSystem::MicroBox, subject.class
+  end
+
+end

data/lib/micro_system.rb

@@ -0,0 +1,8 @@
+class MicroSystem < Liza::System
+  class Error < Liza::Error; end
+
+  #
+
+  color :red
+
+end

data/lib/net_system/net_box.rb

@@ -0,0 +1,21 @@
+class NetSystem::NetBox < Liza::Box
+
+  # Preconfigure your client panel
+  
+  configure :client do
+    #
+  end
+
+  # Preconfigure your database panel
+
+  configure :database do
+    #
+  end
+
+  # Preconfigure your record panel
+
+  configure :record do
+    #
+  end
+  
+end

data/lib/net_system/{net/net_box_test.rb → net_box_test.rb}

@@ -5,8 +5,7 @@ class NetSystem::NetBoxTest < Liza::BoxTest
   end
 
   test :settings do
-    assert subject_class.log_level == :normal
-    assert subject_class.log_color == :red
+    assert_equality subject_class.log_level, 0
   end
 
   test :panels do

data/lib/net_system/{net/panels → sub/client}/client_panel_test.rb

@@ -5,8 +5,7 @@ class NetSystem::ClientPanelTest < Liza::PanelTest
   end
 
   test :settings do
-    assert subject_class.log_level == :normal
-    assert subject_class.log_color == :red
+    assert_equality subject_class.log_level, 0
   end
 
   # test :call do