lizarb 1.0.3 → 1.0.5

data/lib/app.rb

@@ -1,204 +1,133 @@
-module App
+class App
   class Error < StandardError; end
-  class ModeNotFound < Error; end
-  class SystemNotFound < Error; end
 
   #
 
-  module_function
-
-  def log s
-    puts s.bold
-  end
-
-  def logv s
-    log s if $VERBOSE
+  def self.log s
+    puts s
   end
 
-  # called from "#{APP_DIR}/app"
-  def call argv, &block
-    instance_exec &block
-
-    setup_env
-    setup_bundle
-    setup_liza
-    bundle_systems_app Lizarb::APP_DIR
-
-    check_mode!
-
+  # called from exe/lizarb
+  def self.call argv
+    log "#{$boot_time.diff}s to boot" if defined? $log_boot_high
     puts
-    DevBox[:command].call argv
+    args = argv.dup
+    argv.clear
+    Liza[:DevBox].command args
     puts
   end
 
-  def root
+  def self.cwd
     Pathname Dir.pwd
   end
 
-  def setup_env
-    require "dotenv"
-    Dotenv.load "app.#{mode}.env", "app.env"
-  end
+  @root = cwd
 
-  def setup_bundle
-    require "bundler/setup"
-    Bundler.require :default, *@systems.keys
+  def self.root
+    @root
   end
 
-  def setup_liza
-    require "liza"
-
-    @loaders << loader = Zeitwerk::Loader.new
-    loader.tag = Liza.to_s
-
-    # ORDER MATTERS: IGNORE, COLLAPSE, PUSH
-    loader.collapse "#{Liza.source_location_radical}/**/*"
-    loader.push_dir "#{Liza.source_location_radical}", namespace: Liza
-
-    loader.enable_reloading
-    loader.setup
+  def self.filename
+    root.join "#{$APP}.rb"
   end
 
-  def bundle_systems_app app_dir
-    @systems.keys.each do |k|
-      key = "#{k}_system"
+  # folder
 
-      require_system key
-      klass = Object.const_get key.camelize
-
-      @systems[k] = klass
-    end
-
-    @loaders << loader = Zeitwerk::Loader.new
-
-    @systems.each do |k, klass|
-      # ORDER MATTERS: IGNORE, COLLAPSE, PUSH
-      loader.collapse "#{klass.source_location_radical}/**/*"
-      loader.push_dir "#{klass.source_location_radical}", namespace: klass
-    end
-
-    # ORDER MATTERS: IGNORE, COLLAPSE, PUSH
-    loader.collapse "#{app_dir}/app/**/*"
-    loader.push_dir "#{app_dir}/app" if Dir.exist? "#{app_dir}/app"
-
-    loader.enable_reloading
-    loader.setup
-
-    @systems.each do |k, klass|
-      connect_system k, klass
+  def self.folder folder = nil
+    raise "locked" if @locked
+    if folder
+      @folder = folder
+      @relative_path = Pathname(folder)
+      @path = Pathname("#{Lizarb::APP_DIR}/#{folder}")
+    else
+      @folder
     end
-
-    @systems.freeze
   end
 
-  # loaders
-
-  @loaders = []
-  @mutex = Mutex.new
-
-  def reload &block
-    @mutex.synchronize do
-      @loaders.map &:reload
-      yield if block_given?
-    end
-
-    true
+  def self.path
+    @path
   end
 
-  def eager_load_all
-    Zeitwerk::Loader.eager_load_all
+  def self.relative_path
+    @relative_path or raise "@relative_path not set"
   end
 
   # mode
 
-  @modes = [:code]
-  ENV["LIZA_MODE"] ||= @modes.first.to_s
-  @mode = ENV["LIZA_MODE"].to_sym
-
-  def mode mode = nil
-    return @mode if mode.nil?
-    @modes << mode.to_sym
+  def self.mode mode = nil
+    if mode
+      @mode = mode.to_sym
+    else
+      @mode ||= (ENV["MODE"] || :code).to_sym
+    end
   end
 
-  def check_mode!
-    return if @modes.include? @mode
-    raise ModeNotFound, "LIZA_MODE `#{@mode}` not found in #{@modes}", []
+  def self.coding?
+    mode == :code
   end
 
   # systems
 
   @systems = {}
 
-  def system key
+  def self.system key
     raise "locked" if @locked
     @systems[key] = nil
   end
 
-  def systems
+  def self.systems
     @systems
   end
 
-  def self.require_system key
-    t = Time.now
-    logv "App.system :#{key}"
-    require key
-    logv "App.system :#{key} takes #{t.diff}s"
-  rescue LoadError => e
-    def e.backtrace; []; end
-    raise SystemNotFound, "FILE #{key}.rb not found on $LOAD_PATH", []
-  end
-
-  # parts
+  # settings
 
-  def connect_part part_klass, key, system
-    t = Time.now
-    string = "CONNECTING PART #{part_klass.to_s.rjust 25}.part :#{key}"
-    logv string
-
-    klass = if system.nil?
-              Liza.const "#{key}_part"
-            else
-              Liza.const("#{system}_system")
-                  .const "#{key}_part"
-            end
+  def self.settings
+    @settings ||= {}
+  end
 
-    if klass.insertion
-      part_klass.class_exec &klass.insertion
-    end
+  def self.set key, value
+    settings[key] = value
+  end
 
-    if klass.extension
-      klass.const_set :Extension, Class.new(Liza::PartExtension)
-      klass::Extension.class_exec &klass.extension
-    end
-    logv "#{string} takes #{t.diff}s"
+  def self.get key
+    settings[key]
   end
 
-  # systems
+  # advanced settings
 
-  def connect_system key, system_klass
-    t = Time.now
+  DEFAULT_LOG_LEVEL = 4
 
-    color_system_klass = system_klass.to_s.colorize system_klass.log_color
-    color_key = key.to_s.colorize system_klass.log_color
+  LOG_LEVELS = {
+    :highest => 7,
+    :higher  => 6,
+    :high    => 5,
+    :normal  => 4,
+    :low     => 3,
+    :lower   => 2,
+    :lowest  => 1,
+  }
+  @log_boot = DEFAULT_LOG_LEVEL
+  set :log_level, DEFAULT_LOG_LEVEL
 
-    registrar_index = 0
-    system_klass.registrar.each do |string, target_block|
-      reg_type, _sep, reg_target = string.to_s.lpartition "_"
+  def self.log_boot level = nil
+    return @log_boot if level.nil?
+    level = LOG_LEVELS[level] if level.is_a? Symbol
+    raise Error, "invalid log level `#{level}`", caller unless LOG_LEVELS.values.include? level
 
-      registrar_index += 1
+    @log_boot = level
+  end
 
-      target_klass = Liza.const reg_target
+  def self.log_level level
+    level = LOG_LEVELS[level] if level.is_a? Symbol
+    raise Error, "invalid log level `#{level}`", caller unless LOG_LEVELS.values.include? level
 
-      if reg_type == "insertion"
-        target_klass.class_exec &target_block
-      else
-        raise "TODO: decide and implement system extension"
-      end
+    set :log_level, level
+  end
 
-      log "CONNECTING SYSTEM PART          #{color_system_klass}.#{reg_type} #{target_klass}"
+  # helpers
 
-    end
-    log "CONNECTING SYSTEM - #{t.diff}s for #{color_system_klass} to connect to #{registrar_index} system parts"
+  def self.global?
+    $APP == "app_global"
   end
 
 end

data/lib/art_system/art_box.rb

@@ -0,0 +1,5 @@
+class ArtSystem::ArtBox < Liza::Box
+  
+  #
+
+end

data/lib/art_system/art_box_test.rb

@@ -0,0 +1,8 @@
+class ArtSystem::ArtBoxTest < Liza::BoxTest
+  
+  test :subject_class, :subject do
+    assert_equality ArtSystem::ArtBox, subject_class
+    assert_equality ArtSystem::ArtBox, subject.class
+  end
+
+end

data/lib/art_system.rb

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

data/lib/crypto_system/crypto_box.rb

@@ -0,0 +1,5 @@
+class CryptoSystem::CryptoBox < Liza::Box
+  
+  #
+
+end

data/lib/crypto_system/crypto_box_test.rb

@@ -0,0 +1,8 @@
+class CryptoSystem::CryptoBoxTest < Liza::BoxTest
+  
+  test :subject_class, :subject do
+    assert_equality CryptoSystem::CryptoBox, subject_class
+    assert_equality CryptoSystem::CryptoBox, subject.class
+  end
+
+end

data/lib/crypto_system.rb

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

data/lib/deep_system/deep_box.rb

@@ -0,0 +1,5 @@
+class DeepSystem::DeepBox < Liza::Box
+  
+  #
+
+end

data/lib/deep_system/deep_box_test.rb

@@ -0,0 +1,8 @@
+class DeepSystem::DeepBoxTest < Liza::BoxTest
+  
+  test :subject_class, :subject do
+    assert_equality DeepSystem::DeepBox, subject_class
+    assert_equality DeepSystem::DeepBox, subject.class
+  end
+
+end

data/lib/deep_system.rb

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

data/lib/desk_system/commands/glimmer_command.rb

@@ -0,0 +1,26 @@
+class DeskSystem::GlimmerCommand < DevSystem::SimpleCommand
+  
+  # liza glimmer
+
+  def call_default
+    call_examples
+  end
+
+  # liza glimmer:examples
+
+  def call_examples
+    log stick :b, system.color, "Glimmer is a free Ruby Desktop Development Cross-Platform Native GUI Library!"
+    log [
+      (stick :b, "Learn more at "),
+      (stick :b, system.color, "https://github.com/AndyObtiva/glimmer-dsl-libui")
+    ]
+    
+    puts
+    log "args = #{env[:args].inspect}"
+    # require "glimmer-dsl-libui"
+    require "examples/meta_example"
+    
+    log "done at #{Time.now}"
+  end
+  
+end

data/lib/desk_system/commands/glimmer_command_test.rb

@@ -0,0 +1,10 @@
+class DeskSystem::GlimmerCommandTest < DevSystem::SimpleCommandTest
+  
+  # 
+
+  test :subject_class, :subject do
+    assert_equality DeskSystem::GlimmerCommand, subject_class
+    assert_equality DeskSystem::GlimmerCommand, subject.class
+  end
+  
+end

data/lib/desk_system/desk_box.rb

@@ -0,0 +1,5 @@
+class DeskSystem::DeskBox < Liza::Box
+  
+  #
+
+end

data/lib/desk_system/desk_box_test.rb

@@ -0,0 +1,8 @@
+class DeskSystem::DeskBoxTest < Liza::BoxTest
+  
+  test :subject_class, :subject do
+    assert_equality DeskSystem::DeskBox, subject_class
+    assert_equality DeskSystem::DeskBox, subject.class
+  end
+
+end

data/lib/desk_system.rb

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

data/lib/dev_system/{dev/controllers/command → commands}/test_command.rb

@@ -1,13 +1,15 @@
 class DevSystem::TestCommand < DevSystem::Command
 
   def self.call args
-    log :higher, "Called #{self} with args #{args}"
-
-    App.eager_load_all
+    log "args = #{args.inspect}"
 
     now = Time.now
     test_classes = Liza::Test.descendants
 
+    if args.any?
+      test_classes = test_classes.select { |tc| args.any? { tc.source_location_radical.snakecase.include? _1.snakecase } }
+    end
+
     _call_silence_base_units
     
     if Lizarb::IS_APP_DIR
@@ -44,11 +46,11 @@ class DevSystem::TestCommand < DevSystem::Command
     proc_namespaced = proc { |tc| tc.name.include? "::" }
     proc_liza = proc { |tc| tc.name[0..3] == "Liza" }
 
-    tc_app        = test_classes.reject &proc_namespaced
-    tc_namespaced = test_classes.select &proc_namespaced
+    tc_app        = test_classes.reject(&proc_namespaced)
+    tc_namespaced = test_classes.select(&proc_namespaced)
 
-    tc_liza   = tc_namespaced.select &proc_liza
-    tc_system = tc_namespaced.reject &proc_liza
+    tc_liza   = tc_namespaced.select(&proc_liza)
+    tc_system = tc_namespaced.reject(&proc_liza)
 
     tc_app.sort_by! &:source_location
     tc_liza.sort_by! &:source_location
@@ -63,7 +65,12 @@ class DevSystem::TestCommand < DevSystem::Command
     end
   end
 
+
   def self._call_counting test_classes
+    puts
+    Liza.log ""
+    Liza.log stick :b, " TEST TOTALS ".center(140, "-")
+    Liza.log ""
     puts
     totals = Hash.new { 0 }
     last_namespace = nil
@@ -75,11 +82,32 @@ class DevSystem::TestCommand < DevSystem::Command
       test_class.totals.each do |k, v|
         totals[k] += v.size
       end
-      Liza.log "  #{"#{test_class}.totals".ljust 60} #{test_class.totals.map { |k, v| [k, v.size] }.to_h}"
+      size = 60 - test_class.subject_class.to_s.size
+      Liza.log "#{_color_unit test_class.subject_class}#{".totals".ljust size} #{test_class.totals.map { |k, v| [k, v.size] }.to_h}"
     end
     puts
-    Liza.log "  #{"Total".ljust 60} #{totals}"
+    Liza.log "#{"Total".ljust 60} #{totals}"
     puts
   end
 
+  def self._color_unit klass
+    return klass.to_s unless klass < Liza::Unit
+    return klass.to_s if klass.superclass == Liza::Unit
+
+    ret = ""
+    namespace, _sep, classname = klass.name.rpartition('::')
+    unless namespace.empty?
+      system_color = klass.system.color
+      ret << stick(namespace, system_color, :b).to_s
+      ret << "::"
+    end
+
+    klass = klass.division if klass.is_a? Liza::Controller
+    unit_color = nil
+    unit_color = klass.system.color
+
+    ret << stick(classname, unit_color).to_s
+    ret
+  end
+
 end

data/lib/dev_system/{dev/controllers/command → commands}/test_command_test.rb

@@ -5,8 +5,7 @@ class DevSystem::TestCommandTest < DevSystem::CommandTest
   end
 
   test :settings do
-    assert subject_class.log_level == :normal
-    assert subject_class.log_color == :green
+    assert_equality subject_class.log_level, 0
   end
 
 end

data/lib/dev_system/dev_box.rb

@@ -0,0 +1,79 @@
+class DevSystem::DevBox < Liza::Box
+
+  # Preconfigure your bench panel
+  
+  configure :bench do
+    # 
+  end
+
+  # Preconfigure your command panel
+  
+  configure :command do
+    # 
+    rescue_from CommandPanel::NotFoundError, with: NotFoundCommand
+  end
+
+  def self.command(...)
+    self[:command].call(...)
+  end
+
+  def self.input
+    self[:command].input
+  end
+  
+  def self.pick_one(...)
+    self[:command].pick_one(...)
+  end
+  
+  def self.pick_many(...)
+    self[:command].pick_many(...)
+  end
+  
+  # Preconfigure your generator panel
+  
+  configure :generator do
+    # 
+    rescue_from GeneratorPanel::NotFoundError, with: NotFoundGenerator
+  end
+
+  # Preconfigure your log panel
+
+  configure :log do
+    # 
+  end
+
+  # Preconfigure your shell panel
+
+  configure :shell do
+    # 
+  end
+
+  def self.formatters
+    self[:shell].formatters
+  end
+
+  def self.converters
+    self[:shell].converters
+  end
+
+  def self.converters_to
+    self[:shell].converters_to
+  end
+
+  def self.format(...)
+    self[:shell].format(...)
+  end
+
+  def self.format?(...)
+    self[:shell].format?(...)
+  end
+
+  def self.convert(...)
+    self[:shell].convert(...)
+  end
+
+  def self.convert?(...)
+    self[:shell].convert?(...)
+  end
+
+end

data/lib/dev_system/dev_box_test.rb

@@ -0,0 +1,33 @@
+class DevSystem::DevBoxTest < Liza::BoxTest
+
+  test :subject_class do
+    assert subject_class == DevSystem::DevBox
+  end
+
+  test_methods_defined do
+    on_self \
+      :command,
+      :convert, :convert?, :converters, :converters_to,
+      :format, :format?, :formatters,
+      :input,
+      :pick_many, :pick_one
+    on_instance
+  end
+
+  test :settings do
+    assert_equality subject_class.log_level, 0
+  end
+
+  test :subsystems do
+    a = subject_class.panels.keys
+    b = [:bench, :command, :generator, :log, :shell]
+    assert_equality a, b
+    
+    assert_sub :bench,     DevSystem::Bench,     DevSystem::BenchPanel
+    assert_sub :command,   DevSystem::Command,   DevSystem::CommandPanel
+    assert_sub :generator, DevSystem::Generator, DevSystem::GeneratorPanel
+    assert_sub :log,       DevSystem::Log,       DevSystem::LogPanel
+    assert_sub :shell,     DevSystem::Shell,     DevSystem::ShellPanel
+  end
+
+end