lizarb 1.0.3 → 1.0.4

data/lib/liza/unit.rb

@@ -6,86 +6,28 @@ class Liza::Unit
     App.connect_part self, key, system
   end
 
-  def self.const_missing name
-    Liza.const name
-  rescue Liza::ConstNotFound => e
-    raise NameError, "uninitialized constant #{name}", caller[1..], cause: nil
-  end
-
-  part :unit_procedure
-
-  # SETTINGS
-
-  def self.settings
-    @settings ||= {}
-  end
-
-  def self.get key
-    return settings[key] if settings.has_key? key
+  # CONST MISSING
 
-    found = nil
+  if Lizarb.ruby_supports_raise_cause?
 
-    for klass in ancestors
-      break unless klass.respond_to? :settings
-
-      if klass.settings.has_key? key
-        found = klass.settings[key]
-
-        break
-      end
+    def self.const_missing name
+      Liza.const name
+    rescue Liza::ConstNotFound
+      raise NameError, "uninitialized constant #{name}", caller[1..], cause: nil
     end
 
-    found = settings[key] = found.dup if found.is_a? Enumerable
-
-    found
-  end
-
-  def self.set key, value
-    settings[key] = value
-    value
-  end
+  else
 
-  def self.add list, key = nil, value
-    if key
-      fetch(list) { Hash.new }[key] = value
-    else
-      fetch(list) { Set.new } << value
+    def self.const_missing name
+      Liza.const name
+    rescue Liza::ConstNotFound
+      raise NameError, "uninitialized constant #{name}", caller[1..]
     end
-  end
-
-  def self.fetch key, &block
-    x = get key
-    x ||= set key, instance_eval(&block)
-    x
-  end
-
-  def settings
-    @settings ||= {}
-  end
 
-  def get key
-    return settings[key] if settings.has_key? key
-
-    self.class.get key
-  end
-
-  def set key, value
-    settings[key] = value
   end
 
-  def add list, key = nil, value
-    if key
-      fetch(list) { Hash.new }[key] = value
-    else
-      fetch(list) { Set.new } << value
-    end
-  end
-
-  def fetch key, &block
-    x = get key
-    x ||= set key, eval(&block)
-    x
-  end
+  part :unit_procedure
+  part :unit_settings
 
   # LOG
 
@@ -100,22 +42,75 @@ class Liza::Unit
   set :log_level, :normal
   set :log_color, :white
 
-  #
+  # NOTE: improve logs performance and readability
+
+  LOG_JUST = 60
+
+  def self.build_log_sidebar_for source, method_key, method_sep, panel_key: nil
+    source = (source.is_a? Class) ? source : source.class
+    source_color = source.log_color
+    source = source.to_s
+
+    s = source.bold.colorize(source_color)
+    s << "[:#{panel_key}]" if panel_key
+    s << "#{method_sep}#{method_key}"
+    s.ljust(LOG_JUST)
+  end
+
+  # NOTE: This code needs to be optimized.
+  def self._log_extract_method_name kaller
+    kaller.each do |s|
+      t = s.match(/`(.*)'/)[1]
+
+      next if t.include? " in <class:"
+      return t.split(" ").last if t.include? " in "
+      
+      next if t == "log"
+      next if t == "each"
+      next if t == "map"
+      next if t == "with_index"
+      next if t == "instance_exec"
+      next if t.start_with? "_"
+      return t
+    end
+
+    raise "there's something wrong with kaller"
+  end
+
+  def _log_extract_method_name kaller
+    self.class._log_extract_method_name kaller
+  end
+
+  def self.log log_level = :normal, string, kaller: caller
+    raise "invalid log_level `#{log_level}`" unless LOG_LEVELS.keys.include? log_level
+    return unless log_level? log_level
 
-  LOG_JUST = 40
+    method_key = _log_extract_method_name kaller
+    source = Liza::Unit.build_log_sidebar_for self, method_key, ":"
 
-  def self.log log_level = :normal, string
+    DevBox[:log].call "#{source} #{string}"
+  end
+
+  def log log_level = :normal, string, kaller: caller
     raise "invalid log_level `#{log_level}`" unless LOG_LEVELS.keys.include? log_level
     return unless log_level? log_level
 
-    source = (self.is_a? Class) ? self : self.class
-    source = source.to_s.ljust(LOG_JUST).bold.colorize(source.log_color)
+    method_key = _log_extract_method_name kaller
 
-    string = "#{source} #{string}"
+    case self
+    when Liza::Panel
+      source = Liza::Unit.build_log_sidebar_for box, method_key, ".", panel_key: @key
+    when Liza::UnitTest
+      source = Liza::Unit.build_log_sidebar_for self, " ", " "
+    else
+      source = Liza::Unit.build_log_sidebar_for self, method_key, "#"
+    end
 
-    DevBox[:log].call string
+    DevBox[:log].call "#{source} #{string}"
   end
 
+  #
+
   def self.log_level
     get(:log_level) || :normal
   end
@@ -130,7 +125,6 @@ class Liza::Unit
   end
 
   def self.log?(log_level = :normal)= log_level? log_level
-  def log(...)= self.class.log(...)
   def log_level(...)= self.class.log_level(...)
   def log?(...)= self.class.log?(...)
   def log_level?(...)= self.class.log_level?(...)

data/lib/liza/unit_parts/unit_procedure_part_test.rb

@@ -7,7 +7,6 @@ class Liza::UnitProcedurePartTest < Liza::UnitTest
       procedure "creates a new scope" do
         @a = 1
         b = 2
-        c = 3
         assert true
 
         proceed if true
@@ -21,7 +20,6 @@ class Liza::UnitProcedurePartTest < Liza::UnitTest
       procedure "asserts old scope is not accessible" do
         assert instance_variables.include? :@a
         assert local_variables.include? :b
-        refute local_variables.include? :c
 
         assert @a == 1
         assert b == 2
@@ -32,13 +30,15 @@ class Liza::UnitProcedurePartTest < Liza::UnitTest
 
     assert x == 100
 
-    y =
-      procedure "asserts proceed calls can be lazy" do
-        proceed { "slow operation"; 200 } if true
-        raise "did not get here"
-      end
-
-    assert y == 200
+    y = procedure "asserts proceed calls can be lazy" do
+      proceed do
+        puts "slow operation"
+        200
+      end if true
+      raise "did not get here"
+    end
+    
+    assert y == 200    
   end
 
   test :procedure_rescue_and_ensure do

data/lib/liza/unit_parts/unit_settings_part.rb

@@ -0,0 +1,76 @@
+class Liza::UnitSettingsPart < Liza::Part
+
+  insertion do
+    def self.settings
+      @settings ||= {}
+    end
+
+    def self.get key
+      return settings[key] if settings.has_key? key
+
+      found = nil
+
+      for klass in ancestors
+        break unless klass.respond_to? :settings
+
+        if klass.settings.has_key? key
+          found = klass.settings[key]
+
+          break
+        end
+      end
+
+      found = settings[key] = found.dup if found.is_a? Enumerable
+
+      found
+    end
+
+    def self.set key, value
+      settings[key] = value
+      value
+    end
+
+    def self.add list, key = nil, value
+      if key
+        fetch(list) { Hash.new }[key] = value
+      else
+        fetch(list) { Set.new } << value
+      end
+    end
+
+    def self.fetch key, &block
+      x = get key
+      x ||= set key, instance_eval(&block)
+      x
+    end
+
+    def settings
+      @settings ||= {}
+    end
+
+    def get key
+      return settings[key] if settings.has_key? key
+
+      self.class.get key
+    end
+
+    def set key, value
+      settings[key] = value
+    end
+
+    def add list, key = nil, value
+      if key
+        fetch(list) { Hash.new }[key] = value
+      else
+        fetch(list) { Set.new } << value
+      end
+    end
+
+    def fetch key, &block
+      x = get key
+      x ||= set key, eval(&block)
+      x
+    end
+  end
+
+end

data/lib/liza/unit_parts/unit_settings_part_test.rb

@@ -0,0 +1,3 @@
+class Liza::UnitSettingsPartTest < Liza::UnitTest
+
+end

data/lib/liza/unit_test.rb

@@ -74,4 +74,15 @@ 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

@@ -14,6 +14,10 @@ module Liza
 
   #
 
+  def [] name
+    const name
+  end
+
   # Checks Object, each system, then Liza for Liza::Unit classes
   def const name
     name = name.to_s.camelize.to_sym
@@ -29,7 +33,12 @@ module Liza
 
     nil
   rescue NameError
-    raise ConstNotFound, name
+    log "Liza const #{name} not found!"
+    if Lizarb.ruby_supports_raise_cause?
+      raise ConstNotFound, name, cause: nil
+    else
+      raise ConstNotFound, name, []
+    end
   end
 
   # Checks each system, then Liza for Liza::Unit classes

data/lib/lizarb/ruby/module.rb

@@ -4,7 +4,7 @@ class Module
 
   # /path/to/liza.rb
   def source_location
-    Object.const_source_location name
+    Array Object.const_source_location name
   end
 
   # /path/to/liza

data/lib/lizarb/version.rb

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

data/lib/lizarb.rb

@@ -3,13 +3,16 @@
 require "colorize"
 require "json"
 require "pathname"
-require "zeitwerk"
+require "fileutils"
 require "lerb"
 
 require_relative "lizarb/version"
 
+$APP ||= "app"
+
 module Lizarb
   class Error < StandardError; end
+  class ModeNotFound < Error; end
 
   #
 
@@ -19,9 +22,12 @@ module Lizarb
 
   IS_APP_DIR = File.file? "#{CUR_DIR}/app.rb"
   IS_LIZ_DIR = File.file? "#{CUR_DIR}/lib/lizarb.rb"
+  IS_GEM_DIR = File.file? "#{CUR_DIR}/lizarb.gemspec"
 
   APP_DIR = IS_APP_DIR ? CUR_DIR : GEM_DIR
 
+  $APP = "app_global" if not IS_APP_DIR
+
   #
 
   module_function
@@ -30,48 +36,266 @@ module Lizarb
     puts s.bold
   end
 
+  def self.logv s
+    log s if $VERBOSE
+  end
+
+  # Returns Lizarb::VERSION as a Gem::Version
+  def version
+    @version ||= Gem::Version.new VERSION
+  end
+
+  # Returns RUBY_VERSION as a Gem::Version
+  def ruby_version
+    @ruby_version ||= Gem::Version.new RUBY_VERSION
+  end
+
+  def ruby_supports_raise_cause?
+    RUBY_ENGINE != "jruby"
+  end
+
+  def self.load_all
+    Zeitwerk::Loader.eager_load_all
+  end
+
   # called from exe/lizarb
-  def call
+  def setup
+    lookup_and_load_core_ext
+    lookup_and_set_gemfile
+  end
+
+  # called from exe/lizarb
+  def app &block
     require "app"
+    if block_given?
+      App.class_exec(&block)
+    else
+      lookup_and_require_app
+    end
+  end
 
-    setup_core_ext
-    setup_gemfile
+  # called from exe/lizarb
+  def call
+    lookup_and_set_mode
+    lookup_and_require_dependencies
+    lookup_and_load_settings
+    require_liza_and_bundle_systems
+  end
 
-    require "#{APP_DIR}/app"
+  # called from exe/lizarb
+  def exit verbose: $VERBOSE
+    exit_messages if verbose
+    super 0
+  end
 
-    versions = {ruby: RUBY_VERSION, bundler: Bundler::VERSION, zeitwerk: Zeitwerk::VERSION, lizarb: VERSION}
+  def exit_messages
+    versions = {
+      ruby: RUBY_VERSION,
+      bundler: Bundler::VERSION,
+      zeitwerk: Zeitwerk::VERSION,
+      lizarb: VERSION,
+      app: $APP,
+      mode: $MODE
+    }
     bugs = SPEC.metadata["bug_tracker_uri"]
     puts versions.to_s.green
     puts "Report bugs at #{bugs}"
+    puts "Fork us on Github at #{bugs}/fork"
   end
 
-  # called from "#{APP_DIR}/app"
-  def bundle
-    require "bundler/setup"
-    Bundler.require :default
+  # setup phase
+
+  def lookup_and_load_core_ext
+    files =
+      if IS_GEM_DIR
+        Dir["#{CUR_DIR}/lib/lizarb/ruby/*.rb"]
+      else
+        Dir["#{GEM_DIR}/lib/lizarb/ruby/*.rb"] + Dir["#{CUR_DIR}/lib/lizarb/ruby/*.rb"]
+      end
+
+    files.each do |file_name|
+      log "#{self} loading #{file_name}" if $VERBOSE
+      load file_name
+    end
+  end
+
+  def lookup_and_set_gemfile
+    gemfile = nil
 
-    bundle_liza
+    finder = \
+      proc do |file_name|
+        log "#{self}.#{__method__} #{file_name}" if $VERBOSE
+        if File.file? file_name
+          file_name
+        else
+          false
+        end
+      end
+
+    gemfile ||= finder.call "#{CUR_DIR}/#{$APP}.gemfile.rb"
+    gemfile ||= finder.call "#{GEM_DIR}/#{$APP}.gemfile.rb" unless IS_GEM_DIR
+    gemfile ||= finder.call "#{CUR_DIR}/Gemfile"
+    gemfile ||= finder.call "#{GEM_DIR}/app_global.gemfile.rb"
 
-    check_mode!
+    log "#{self} setting BUNDLE_GEMFILE to #{gemfile}" if $VERBOSE
+    ENV["BUNDLE_GEMFILE"] = gemfile
   end
 
-  # setup
+  # app phase
 
-  def setup_core_ext
-    pattern =
-      IS_LIZ_DIR  ? "lib/lizarb/ruby/*.rb"
-                  : "#{GEM_DIR}/lib/lizarb/ruby/*.rb"
+  def lookup_and_require_app
+    finder = \
+      proc do |lib_name, file_name|
+        log "#{self} checking if #{file_name} exists" if $VERBOSE
+        if File.file? "#{file_name}"
+          require lib_name
+          true
+        else
+          false
+        end
+      end
 
-    Dir[pattern].each &method(:load)
+    return if finder.call "#{CUR_DIR}/#{$APP}", "#{CUR_DIR}/#{$APP}.rb"
+    return if finder.call "#{GEM_DIR}/#{$APP}", "#{GEM_DIR}/#{$APP}.rb"
+
+    raise Error, "Could not find #{$APP}.rb in #{CUR_DIR} or #{GEM_DIR}"
   end
 
-  def setup_gemfile
-    ENV["BUNDLE_GEMFILE"] =
-      IS_APP_DIR  ? "#{CUR_DIR}/Gemfile"
-                  : "#{GEM_DIR}/exe/Gemfile"
+  # 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 "#{self}.#{__method__} #{mode.inspect}" if $VERBOSE
+    $MODE = mode
+  end
+
+  def lookup_and_require_dependencies
+    require "bundler/setup"
+    Bundler.require :default, *App.systems.keys
+  end
+
+  def lookup_and_load_settings
+    files = ["#{$APP}.#{$MODE}.env", "#{$APP}.env"]
+    require "dotenv"
+    Dotenv.load(*files)
+  end
+
+  def require_liza_and_bundle_systems
+    require "zeitwerk"
+    require "liza"
+
+    # App.loaders[0] first loads Liza, then each System class
+    App.loaders << loader = Zeitwerk::Loader.new
+    loader.tag = Liza.to_s
+
+    # collapse Liza paths
+
+    # ORDER MATTERS: IGNORE, COLLAPSE, PUSH
+    loader.collapse "#{Liza.source_location_radical}/**/*"
+    loader.push_dir "#{Liza.source_location_radical}", namespace: Liza
+
+    # loader setup
+
+    loader.enable_reloading
+    loader.setup
+
+    # load each System class
+
+    App.systems.keys.each do |k|
+      key = "#{k}_system"
+
+      App.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
+
+    # collapse each System paths
+
+    App.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
+
+    # 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
+
+    if list.empty?
+      logv "no #{app_dir} found".red
+    else
+      logv "Lizarb app loader found #{app_dir}\t\tCollapsing #{app_dir}/*".on_cyan
+
+      to_collapse = []
+
+      App.systems.each do |k, klass|
+        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
+        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
+        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
+        loader.ignore file
+      end
+
+      to_collapse.each do |path|
+        logv "Lizarb app loader collapsing #{path}".on_cyan
+        if path.end_with? ".rb"
+          loader.collapse path
+        else
+          loader.collapse "#{path}/**/*"
+        end
+      end
+      loader.collapse "#{app_dir}/*"
+
+      loader.push_dir app_dir, namespace: Object
+    end
+
+    # loader setup
+
+    loader.enable_reloading
+    loader.setup
+
+    # App connects to systems
+
+    App.systems.each do |k, klass|
+      App.connect_system k, klass
+    end
+
+    App.systems.freeze
   end
 
-  # threads
+  # thread management
 
   def thread_object_id
     Thread.current.object_id