lizarb 1.0.3 → 1.0.5

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/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.3"
+  VERSION = "1.0.5"
 end

data/lib/lizarb.rb

@@ -1,77 +1,452 @@
 # frozen_string_literal: true
 
+# This flag allows database connection tests
+# ENV["DBTEST"] ||= "1"
+
+$boot_time = Time.now
+
 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
+  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"
+  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
 
   def log s
-    puts s.bold
+    print "#{$boot_time.diff}s " if defined? $log_boot_low
+    puts s
+  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
 
   # 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
+    require "bundler/setup"
 
-    require "#{APP_DIR}/app"
+    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
 
-    versions = {ruby: RUBY_VERSION, bundler: Bundler::VERSION, zeitwerk: Zeitwerk::VERSION, lizarb: VERSION}
-    bugs = SPEC.metadata["bug_tracker_uri"]
-    puts versions.to_s.green
-    puts "Report bugs at #{bugs}"
+    lookup_and_set_mode
+    lookup_and_load_settings
+    require_liza_and_systems
+    connect_systems
   end
 
-  # called from "#{APP_DIR}/app"
-  def bundle
-    require "bundler/setup"
-    Bundler.require :default
+  # called from exe/lizarb
+  def exit
+    exit_messages if defined? $log_boot_normal
+    super 0
+  end
+
+  def exit_messages
+    info = {
+      ruby: RUBY_VERSION,
+      bundler: Bundler::VERSION,
+      zeitwerk: Zeitwerk::VERSION,
+      lizarb: VERSION,
+      app: $APP,
+      mode: App.mode,
+      log_boot: App.log_boot,
+      log_level: App.get(:log_level),
+    }
+    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
+
+  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
+
+    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"
+
+    log "#{self} setting BUNDLE_GEMFILE to #{gemfile}" if $VERBOSE
+    ENV["BUNDLE_GEMFILE"] = gemfile
+  end
+
+  # app phase
+
+  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
+
+    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
+
+  # call phase
+
+  def lookup_and_set_mode
+    log "  Lizarb.#{__method__}" if defined? $log_boot_low
+
+    $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
+    log "  Lizarb.#{__method__}" if defined? $log_boot_low
+    files = ["#{$APP}.#{$mode}.env", "#{$APP}.env"]
+    require "dotenv"
+    Dotenv.load(*files)
+  end
+
+  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"
+
+    # 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
+
+    # 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
+
+    # bundle each System gem
 
-    bundle_liza
+    Bundler.require :systems
 
-    check_mode!
+    # 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"
+
+      require_system key
+      klass = Object.const_get key.camelize
+
+      App.systems[k] = klass
+    end
+
+    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
+
+    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.path
+    if app_dir
+      log "      Application Directory: #{app_dir}" if defined? $log_boot_lowest
+      list = Dir["#{app_dir}/*"].to_set
+    end
+
+    if app_dir.nil? || list.empty?
+      log "      Application Directory is empty" if defined? $log_boot_lowest
+    else
+      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
+          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
+          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|
+        log "      Ignoring   #{file}" if $log_boot_lowest
+        loader.ignore file
+      end
+
+      to_collapse.each do |path|
+        log "      Collapsing #{path}" if $log_boot_lowest
+        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
+
+    log "    Zeitwerk loaders eager load" if defined? $log_boot_lowest
+    loaders.map &:eager_load
   end
 
-  # setup
+  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
 
-  def setup_core_ext
-    pattern =
-      IS_LIZ_DIR  ? "lib/lizarb/ruby/*.rb"
-                  : "#{GEM_DIR}/lib/lizarb/ruby/*.rb"
+  # systems
 
-    Dir[pattern].each &method(:load)
+  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 setup_gemfile
-    ENV["BUNDLE_GEMFILE"] =
-      IS_APP_DIR  ? "#{CUR_DIR}/Gemfile"
-                  : "#{GEM_DIR}/exe/Gemfile"
+  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
 
-  # threads
+  # thread management
 
   def thread_object_id
     Thread.current.object_id

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

data/lib/net_system/{net/controllers → sub/client}/client_test.rb

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

data/lib/net_system/sub/client/generators/client_generator.rb

@@ -0,0 +1,88 @@
+class NetSystem::ClientGenerator < DevSystem::SimpleGenerator
+  
+  # liza g client name place=app
+
+  def call_default
+    @controller_class = Client
+
+    name!
+    place!
+
+    create_controller @name, @controller_class, @place, @path do |unit, test|
+      unit.section :controller_section_1
+      test.section :controller_test_section_1
+    end
+  end
+  
+  # liza g client:examples
+  
+  def call_examples
+    copy_examples Client
+  end
+  
+end
+
+__END__
+
+# view controller_section_1.rb.erb
+
+  def self.ruby_news
+    new.call "https://www.ruby-lang.org/en/feeds/news.rss"
+  end
+
+  def self.ruby_weekly
+    new.call "https://cprss.s3.amazonaws.com/rubyweekly.com.xml"
+  end
+
+  #
+
+  def call url
+    t = Time.now
+    body = http_get url
+    hash = xml_to_hash body
+    log "rss channel title: #{ hash.dig :rss, :channel, :title }"
+    hash
+  ensure
+    log "#{t.diff}s to request #{url}"
+    hash
+  end
+
+  #
+
+  def http_get url
+    require "net/http"
+    request_uri = URI(url)
+    log "GET #{request_uri}"
+    Net::HTTP.get(request_uri)
+  end
+
+  def xml_to_hash string
+    # https://github.com/savonrb/nori
+    gem "nori"
+    gem "rexml"
+    require "nori"
+    require "rexml"
+    log "parsing using Nori and REXML"
+    Nori.new(:parser => :rexml).parse string
+  end
+
+# view controller_test_section_1.rb.erb
+
+  test :subject_class, :subject do
+    assert_equality <%= @class_name %>, subject_class
+    assert_equality <%= @class_name %>, subject.class
+  end
+
+  test :subject_class, :ruby_news do
+    hash = subject_class.ruby_news
+    a = hash.dig("rss", "channel", "title")
+    b = "Ruby News"
+    assert_equality a, b
+  end
+
+  test :subject_class, :ruby_weekly do
+    hash = subject_class.ruby_weekly
+    a = hash.dig("rss", "channel", "title")
+    b = "Ruby Weekly"
+    assert_equality a, b
+  end

data/lib/net_system/sub/client/generators/client_generator_test.rb

@@ -0,0 +1,10 @@
+class NetSystem::ClientGeneratorTest < DevSystem::SimpleGeneratorTest
+  
+  # 
+
+  test :subject_class, :subject do
+    assert_equality NetSystem::ClientGenerator, subject_class
+    assert_equality NetSystem::ClientGenerator, subject.class
+  end
+  
+end