lizarb 1.0.2 → 1.0.4

data/lib/liza/unit_test.rb

@@ -1,79 +1,88 @@
-module Liza
-  class UnitTest < Test
-    test :subject_class do
-      assert subject_class == Liza::Unit
-    end
+class Liza::UnitTest < Liza::Test
+  test :subject_class do
+    assert subject_class == Liza::Unit
+  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 subject_class.settings == {log_level: :normal, log_color: :white}
+  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
+  test :settings_inheritance do
+    class_a = Class.new(subject_class) do
+      set :number, 1
 
-      assert subject_class.settings == {log_level: :normal, log_color: :white}
+      add :default, 10
+      add :default, 20
+
+      set :array, []
+      add :array, 10
+      add :array, 20
+
+      add :hash, :a, 10
+      add :hash, :b, 20
     end
 
-    test :settings_inheritance do
-      class_a = Class.new(subject_class) do
-        set :number, 1
-
-        add :default, 10
-        add :default, 20
-
-        set :array, []
-        add :array, 10
-        add :array, 20
-
-        add :hash, :a, 10
-        add :hash, :b, 20
-      end
-
-      assert class_a.settings == {
-        number: 1,
-        default: Set[10, 20],
-        array: [10, 20],
-        hash: {a: 10, b: 20}
-      }
-
-      assert class_a.get(:default) == Set[10, 20]
-      assert class_a.get(:array) == [10, 20]
-      assert class_a.get(:hash) == {a: 10, b: 20}
-
-      class_b = Class.new(class_a) do
-        set :string, "a"
-
-        add :default, 30
-        add :default, 40
-
-        add :array, 30
-        add :array, 40
-
-        add :hash, :c, 30
-        add :hash, :d, 40
-      end
-
-      assert class_a.settings == {
-        number: 1,
-        default: Set[10, 20],
-        array: [10, 20],
-        hash: {a: 10, b: 20}
-      }
-
-      assert class_a.get(:default) == Set[10, 20]
-      assert class_a.get(:array) == [10, 20]
-      assert class_a.get(:hash) == {a: 10, b: 20}
-
-      assert class_b.settings == {
-        string: "a",
-        default: Set[10, 20, 30, 40],
-        array: [10, 20, 30, 40],
-        hash: {a: 10, b: 20, c: 30, d: 40}
-      }
-
-      assert class_b.get(:default) == Set[10, 20, 30, 40]
-      assert class_b.get(:array) == [10, 20, 30, 40]
-      assert class_b.get(:hash) == {a: 10, b: 20, c: 30, d: 40}
+    assert class_a.settings == {
+      number: 1,
+      default: Set[10, 20],
+      array: [10, 20],
+      hash: {a: 10, b: 20}
+    }
+
+    assert class_a.get(:default) == Set[10, 20]
+    assert class_a.get(:array) == [10, 20]
+    assert class_a.get(:hash) == {a: 10, b: 20}
+
+    class_b = Class.new(class_a) do
+      set :string, "a"
+
+      add :default, 30
+      add :default, 40
+
+      add :array, 30
+      add :array, 40
+
+      add :hash, :c, 30
+      add :hash, :d, 40
     end
 
+    assert class_a.settings == {
+      number: 1,
+      default: Set[10, 20],
+      array: [10, 20],
+      hash: {a: 10, b: 20}
+    }
+
+    assert class_a.get(:default) == Set[10, 20]
+    assert class_a.get(:array) == [10, 20]
+    assert class_a.get(:hash) == {a: 10, b: 20}
+
+    assert class_b.settings == {
+      string: "a",
+      default: Set[10, 20, 30, 40],
+      array: [10, 20, 30, 40],
+      hash: {a: 10, b: 20, c: 30, d: 40}
+    }
+
+    assert class_b.get(:default) == Set[10, 20, 30, 40]
+    assert class_b.get(:array) == [10, 20, 30, 40]
+    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.2"
+  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

data/lib/net_system/dev/net_command.rb

@@ -1,24 +1,22 @@
-class NetSystem
-  class NetCommand < Liza::Command
+class NetSystem::NetCommand < Liza::Command
 
-    def self.call args
-      log :higher, "Called #{self} with args #{args}"
+  def self.call args
+    log "args = #{args.inspect}"
 
-      ruby_time   = Time.now
-      redis_time  = ::NetBox.databases.redis.now
-      sqlite_time = ::NetBox.databases.sqlite.now
-      # redis_time  = ::RedisDb.current.now
-      # sqlite_time = ::SqliteDb.current.now
+    ruby_time   = Time.now
+    redis_time  = NetBox[:database].redis.new.now
+    sqlite_time = NetBox[:database].sqlite.new.now
+    # redis_time  = ::RedisDb.current.now
+    # sqlite_time = ::SqliteDb.current.now
 
-      puts <<-OUTPUT.bold
 
-          Time for Ruby:    #{ruby_time.to_s.light_red}
-          Time for Redis:   #{redis_time.to_s.light_red}
-          Time for Sqlite:  #{sqlite_time.to_s.light_red}
-
-      OUTPUT
-      Liza::DevCommand.call []
-    end
+    log "Time for Ruby:    #{_red ruby_time}".bold
+    log "Time for Redis:   #{_red redis_time}".bold
+    log "Time for Sqlite:  #{_red sqlite_time}".bold
+  end
 
+  def self._red s
+    s.to_s.light_red
   end
+
 end

data/lib/net_system/net/controllers/client/redis_client.rb

@@ -1,28 +1,26 @@
-class NetSystem
-  class RedisClient < Client
+class NetSystem::RedisClient < NetSystem::Client
 
-    # https://redis.io/
-    # https://github.com/redis/redis-rb
-    def initialize *args
-      args = [url: Liza.const(:net_box).clients.get(:redis_url)] if args.empty?
-      log "Connecting to #{args}"
-      @conn = Redis.new *args
-    end
-
-    attr_reader :conn
+  # https://redis.io/
+  # https://github.com/redis/redis-rb
+  def initialize *args
+    args = [url: NetBox[:client].get(:redis_url)] if args.empty?
+    log "Connecting to #{args}"
+    @conn = Redis.new(*args)
+  end
 
-    def call cmd_name, *args
-      t = Time.now
-      result = @conn.send cmd_name, *args
+  attr_reader :conn
 
-      result
-    ensure
-      log "#{t.diff}s | #{cmd_name} | #{args}"
-    end
+  def call cmd_name, *args
+    t = Time.now
+    result = @conn.send cmd_name, *args
 
-    def now
-      call :time
-    end
+    result
+  ensure
+    log "#{t.diff}s | #{cmd_name} | #{args}"
+  end
 
+  def now
+    call :time
   end
+
 end

data/lib/net_system/net/controllers/client/redis_client_test.rb

@@ -1,29 +1,27 @@
-class NetSystem
-  class RedisClientTest < ClientTest
+class NetSystem::RedisClientTest < NetSystem::ClientTest
 
-    def subject
-      @subject ||= subject_class.new
-    end
-
-    test :subject_class do
-      assert subject_class == Liza::RedisClient
-    end
+  def subject
+    @subject ||= subject_class.new
+  end
 
-    test :subject do
-      assert subject.conn.class == Redis
-    end
+  test :subject_class do
+    assert subject_class == NetSystem::RedisClient
+  end
 
-    test :call do
-      result = subject.call :keys
-      assert result.class == Array
-      assert result.count == 0
-    end
+  test :subject do
+    assert subject.conn.class == Redis
+  end
 
-    test :now do
-      result = subject.now
-      assert result.class == Array
-      assert result.map(&:class) == [Integer, Integer]
-    end
+  test :call do
+    result = subject.call :keys
+    assert result.class == Array
+    assert result.count == 0
+  end
 
+  test :now do
+    result = subject.now
+    assert result.class == Array
+    assert result.map(&:class) == [Integer, Integer]
   end
+
 end