lizarb 1.0.5 → 1.0.7

data/lib/dev_system/generators/system_generator.rb

@@ -3,68 +3,131 @@ class DevSystem::SystemGenerator < DevSystem::SimpleGenerator
   # liza g system name color=coral
 
   def call_default
-    @name = command.simple_arg_ask_snakecase 0, "What is the name of the system you want to generate?"
-    log "@name = #{@name}"
-
-    @color = command.simple_color :color, string: "#{@name.camelize}System"
-    log "@color = #{@color}"
-
-    append_system_to_app
+    
     create_system
-    create_box
+    create_system_box
+    append_system_to_app
+    create_app_box
+    create_command
+  end
+
+  # liza g system:gemspec name
+  def call_gemspec
+    @rake_version = Gem::Specification.find_by_name("rake").version.to_s
+    create_file "#{gem_name}.gemspec", :gemspec, :rb
   end
 
   private
 
-  def append_system_to_app
-    file = TextFileShell.new App.filename
-    
-    lines = LineShell.extract_wall_of file.old_lines, "  system :"
-    lines << "  system :#{@name}\n"
-    file.new_lines = LineShell.replace_wall_of file.old_lines, "  system :", lines
+  section :name
 
-    add_change file
+  set_input_arg 1 do |default|
+    title = "New systems must have two names:"
+    InputShell.ask title, default: default
+  end
+  
+  def system_name() = @system_name ||= arg_name
+
+  def gem_name() = "#{system_name}_system"
+
+  def arg_name
+    @arg_name ||= begin
+      index = 1
+      name = command.given_args[index]
+      name_words = name.to_s.strip.split("_")
+      # until name.to_s.strip.size.positive?
+      until name_words.count > 1
+        default = nil
+        # prefix "my" if the given a single word
+        default = "my_#{name}" if name_words.count == 1
+        # establish a default name
+        default ||= "my_#{get_random_name}"
+        # hacks the input block
+        value = instance_exec(default, &input_args[index])
+        # hacks the command's args
+        command.env[:simple_args][index] = value
+        # sets name, used by the above `until` loop
+        name = value
+        name_words = name.to_s.strip.split("_")
+      end
+      name
+    end
   end
 
-  def create_system
-    unit    = UnitHelper.new
-    classes = ["#{@name.camelize}System", "Liza::System"]
-    path    = App.root.join("lib/#{@name.snakecase}_system.rb")
-    
-    create_unit unit, classes, path, :system
+  def get_random_name
+    %w[
+    crocodile chameleon gecko snake turtle
+    axolotl salamander tree_frogs toads frogs
+    crow eagle penguin owl hummingbird
+    rhinoceros camel horse zebra hippo
+    bull sheep antelope giraffe elk
+    squirrel beaver capybara rat hamster
+    lion tiger caracal meerkat hyena
+    kangaroo koala tasmanian_devil opossum glider
+    anteater sloth armadillo seacow elephant
+    lemur baboon gibbon capuchin
+    ].sample
   end
+  
+  def color() = @color ||= command.simple_color(:color, string: "#{system_name.camelize}System")
 
-  def create_box
-    unit, test = UnitHelper.new, UnitHelper.new
-    unit_classes = ["#{@name.camelize}System::#{@name.camelize}Box", "Liza::Box"]
-    test_classes = ["#{@name.camelize}System::#{@name.camelize}BoxTest", "Liza::BoxTest"]
-    unit_path = App.root.join("lib/#{@name.snakecase}_system/#{@name.snakecase}_box.rb")
-    test_path = App.root.join("lib/#{@name.snakecase}_system/#{@name.snakecase}_box_test.rb")
+  section :sub_methods
 
-    @class_name = unit_classes[0]
-    test.section :box_test_section_1, caption: ""
-    
-    create_unit unit, unit_classes, unit_path, :unit
-    create_unit test, test_classes, test_path, :unit
+  def append_system_to_app
+    contents = read_file App.filename
+
+    old_lines = contents.split("\n")
+    lines = LineShell.extract_wall_of old_lines, "  system :"
+    lines << "  system :#{system_name}"
+    new_lines = LineShell.replace_wall_of old_lines, "  system :", lines
+
+    contents = new_lines.join("\n")
+    update_file App.filename, contents
   end
 
-end
+  def create_system
+    unit, test = UnitHelper.new, UnitHelper.new
+    unit_classes = ["#{system_name.camelize}System", "Liza::System"]
+    test_classes = ["#{system_name.camelize}System::#{system_name.camelize}SystemTest", "Liza::SystemTest"]
+    unit_path = App.systems_directory / "#{system_name.snakecase}_system.rb"
+    test_path = App.systems_directory / "#{system_name.snakecase}_system" / "#{system_name.snakecase}_system_test.rb"
 
-__END__
+    log stick system.color, "Creating system: #{system_name}"
 
-# view system.rb.erb
-class <%= @class_names[0] %> < <%= @class_names[1] %>
-  class Error < Liza::Error; end
-  
-  #
+    unit.section name: :default, render_key: :section_system_default
+    unit.section name: :info, render_key: :section_system_info
+    test.section name: :systemic, render_key: :section_system_test
 
-  color :<%= @color %>
+    add_unit unit, unit_classes, unit_path
+    add_unit test, test_classes, test_path
+  end
 
-end
+  def create_system_box
+    unit, test = UnitHelper.new, UnitHelper.new
+    unit_classes = ["#{system_name.camelize}System::#{system_name.camelize}Box", "Liza::Box"]
+    test_classes = ["#{system_name.camelize}System::#{system_name.camelize}BoxTest", "Liza::BoxTest"]
+    unit_path = App.systems_directory / "#{system_name.snakecase}_system" / "#{system_name.snakecase}_box.rb"
+    test_path = App.systems_directory / "#{system_name.snakecase}_system" / "#{system_name.snakecase}_box_test.rb"
 
-# view box_test_section_1.rb.erb
+    unit.section name: :preconfiguration, render_key: :section_system_box_settings
+    test.section name: :systemic, render_key: :section_system_box_test
 
-  test :subject_class, :subject do
-    assert_equality <%= @class_name %>, subject_class
-    assert_equality <%= @class_name %>, subject.class
+    add_unit unit, unit_classes, unit_path
+    add_unit test, test_classes, test_path
   end
+
+  def create_app_box
+    unit = UnitHelper.new
+    classes = ["#{system_name.camelize}Box", "#{system_name.camelize}System::#{system_name.camelize}Box"]
+    path = App.directory / "#{system_name.snakecase}_box.rb"
+    
+    unit.section name: :configuration, render_key: :section_app_box_settings
+
+    add_unit unit, classes, path
+  end
+
+  def create_command
+    generate %w[command -prefix], system_name, "place=#{system_name}"
+  end
+
+end

data/lib/dev_system/generators/system_generator.rb.gemspec.rb.erb

@@ -0,0 +1,36 @@
+# view gemspec.rb.erb
+# frozen_string_literal: true
+
+Gem::Specification.new do |spec|
+  spec.name = <%= gem_name.inspect %>
+  spec.version = "1.0.0"
+  spec.authors = "Your Name"
+  spec.email = "your@email.com"
+
+  spec.summary = "Write a short summary, because RubyGems requires one."
+  spec.description = "Write a longer description or delete this line."
+  spec.homepage = "https://<%= gem_name %>.github.io"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.1.0"
+
+  spec.metadata = {
+    "homepage_uri"    => "https://github.com/<%= gem_name %>/<%= gem_name %>",
+    "changelog_uri"   => "https://github.com/<%= gem_name %>/<%= gem_name %>/blob/main/CHANGELOG.md",
+    "source_code_uri" => "https://github.com/<%= gem_name %>/<%= gem_name %>",
+    "bug_tracker_uri" => "https://github.com/<%= gem_name %>/<%= gem_name %>/issues"
+  }
+
+  # Specify which files should be added to the gem when it is released.
+  spec.files = Dir.glob("lib/<%= gem_name %>*/**/*")
+  # spec.bindir = "bin"
+  # spec.executables = [""]
+  spec.require_paths = ["lib"]
+
+  # runtime dependencies
+
+  spec.add_dependency "lizarb", ">= <%= Lizarb::VERSION %>"
+
+  # development dependencies
+
+  spec.add_development_dependency "rake", "~> <%= @rake_version %>"
+end

data/lib/dev_system/generators/system_generator.rb.section_app_box_settings.rb.erb

@@ -0,0 +1,4 @@
+# view section_app_box_settings.rb.erb
+
+  # set :min_x, 0
+  # set :max_x, 100

data/lib/dev_system/generators/system_generator.rb.section_system_box_settings.rb.erb

@@ -0,0 +1,4 @@
+# view section_system_box_settings.rb.erb
+
+  set :min_x, 0
+  set :max_x, 100

data/lib/dev_system/generators/system_generator.rb.section_system_box_test.rb.erb

@@ -0,0 +1,12 @@
+# view section_system_box_test.rb.erb
+
+  test :subject_class do
+    assert_equality subject_class, <%= @class_name[0..-5] %>
+  end
+
+  test_sections(
+  )
+
+  test :settings do
+    assert_equality subject_class.log_level, 4
+  end

data/lib/dev_system/generators/system_generator.rb.section_system_default.rb.erb

@@ -0,0 +1,3 @@
+# view section_system_default.rb.erb
+
+  color :<%= color %>

data/lib/dev_system/generators/system_generator.rb.section_system_info.rb.erb

@@ -0,0 +1,3 @@
+# view section_system_info.rb.erb
+
+  #

data/lib/dev_system/generators/system_generator.rb.system_test.rb.erb

@@ -0,0 +1,5 @@
+# view section_system_test.rb.erb
+
+  test :subject_class do
+    assert_equality subject_class, <%= @class_name[0..-5] %>
+  end

data/lib/dev_system/generators/system_generator.rb.unit.rb.erb

@@ -0,0 +1,7 @@
+# view unit.rb.erb
+class <%= @class_names[0] %> < <%= @class_names[1] %>
+<% @current_unit.sections.each do |section| %>
+<%= "  section #{section[:name].inspect}" %>
+<%= section[:content] -%>
+<% end %>
+end

data/lib/dev_system/generators/system_generator_test.rb

@@ -4,8 +4,15 @@ class DevSystem::SystemGeneratorTest < DevSystem::SimpleGeneratorTest
     assert subject_class == DevSystem::SystemGenerator
   end
 
-  test :settings do
-    assert_equality subject_class.log_level, 0
-  end
+  test_erbs_defined(
+    "gemspec.rb.erb",
+    "section_app_box_settings.rb.erb",
+    "section_system_box_settings.rb.erb",
+    "section_system_box_test.rb.erb",
+    "section_system_default.rb.erb",
+    "section_system_info.rb.erb",
+    "section_system_test.rb.erb",
+    "unit.rb.erb"
+  )
 
 end

data/lib/dev_system/shells/unit_shell.rb

@@ -0,0 +1,40 @@
+class DevSystem::UnitShell < DevSystem::Shell
+
+  # Returns a flattened array of all subunits for a given unit.
+  # 
+  # @param unit [Object] The unit to retrieve subunits for.
+  # @return [Array] A flattened array of subunits.
+  def self.subunits_flat(unit)
+    ret = []
+    
+    rec = get_subunits_recursive(unit)
+    while rec.is_a? Hash
+      rec.each do |subunit, next_subs|
+        ret << subunit
+        rec = next_subs
+      end
+    end
+    ret += rec
+
+    ret
+  end
+
+  # Recursively retrieves subunits for a given unit and caches the result.
+  # 
+  # @param unit [Object] The unit to retrieve subunits for.
+  # @return [Array, Hash] An array or hash of subunits.
+  def self.get_subunits_recursive(unit)
+    subs = unit.subunits
+    return [] if subs.empty?
+    h = subs.map do |subunit|
+      next_subs = get_subunits_recursive(subunit)
+      [subunit, next_subs]
+    end.to_h
+    if h.values.all?(&:empty?)
+      h.keys
+    else
+      h
+    end
+  end
+
+end

data/lib/dev_system/shells/unit_shell_test.rb

@@ -0,0 +1,24 @@
+class DevSystem::UnitShellTest < DevSystem::ShellTest
+
+  section :subject
+
+  test :subject_class, :subject do
+    assert_equality subject_class, DevSystem::UnitShell
+    assert_equality subject.class, DevSystem::UnitShell
+  end
+
+  test :get_subunits_recursive do
+    actual = subject_class.get_subunits_recursive(Unit).keys.map(&:to_s).sort
+    expected = %w[Liza::System Liza::Box Liza::Panel Liza::Test Liza::Controller Liza::Part].sort
+    assert_equality actual, expected
+
+    actual = subject_class.get_subunits_recursive(Liza::System).map(&:to_s).sort
+    expected = %w[DevSystem HappySystem NetSystem WebSystem WorkSystem MicroSystem DeskSystem CryptoSystem MediaSystem ArtSystem DeepSystem PrimeSystem LabSystem EcoSystem].sort
+    assert_equality actual, expected
+
+    actual = subject_class.get_subunits_recursive(DevSystem::DevBox).map(&:to_s).sort
+    expected = %w[DevBox].sort
+    assert_equality actual, expected
+  end
+
+end

data/lib/dev_system/shells/zeitwerk_shell.rb

@@ -0,0 +1,94 @@
+class DevSystem::ZeitwerkShell < DevSystem::Shell
+
+  def self.get_units_in_core
+    get_core_mappings.values.map(&:get)
+  end
+
+  def self.get_units_in_systems
+    ret = {}
+
+    App.systems.each do |key, system|
+      ret[key] = get_units_in_system(system)
+    end
+    
+    ret
+  end
+
+  def self.get_units_in_system(system)
+    s = system.source_location_radical
+    ret = get_main_mappings
+    ret = ret.select { _1.start_with? s }
+    ret.values.map(&:get)
+  end
+
+  def self.get_units_in_app
+    s = App.directory.to_s
+    ret = get_main_mappings
+    ret = ret.select { _1.start_with? s }
+    ret.values.map(&:get)
+  end
+
+  def self.get_core_mappings
+    ret = {}
+
+    core_loader.__autoloads.each do |path, reference|
+      ret[path] = reference
+    end
+    core_loader.__to_unload.each do |name, (path, reference)|
+      ret[path] = reference
+    end
+
+    ret
+  end
+
+  def self.get_main_mappings
+    ret = {}
+
+    main_loader.__autoloads.each do |path, reference|
+      ret[path] = reference
+    end
+    main_loader.__to_unload.each do |name, (path, reference)|
+      ret[path] = reference
+    end
+
+    ret
+  end
+
+  def self.get_unit_in_system(system, name)
+    cname = name.to_s.camelcase.to_sym
+    mappings = get_mappings_in_system(system)
+    references = mappings.values.select { _1.cname == cname }
+    references.first.get
+  rescue NoMethodError
+    nil
+  end
+
+  def self.get_unit_in_app(name)
+    cname = name.to_s.camelcase.to_sym
+    mappings = get_mappings_in_app
+    references = mappings.values.select { _1.cname == cname }
+    references.first.get
+  rescue NoMethodError
+    nil
+  end
+
+
+  def self.get_mappings_in_system(system)
+    s = system.source_location_radical
+    ret = get_main_mappings
+    ret = ret.select { _1.start_with? s }
+    ret
+  end
+
+  def self.get_mappings_in_app
+    s = App.directory.to_s
+    ret = get_main_mappings
+    ret = ret.select { _1.start_with? s }
+    ret
+  end
+
+  def self.core_loader() = Lizarb.loaders[0]
+  
+  def self.main_loader() = Lizarb.loaders[1]
+  
+end

data/lib/dev_system/shells/zeitwerk_shell_test.rb

@@ -0,0 +1,14 @@
+class DevSystem::ZeitwerkShellTest < DevSystem::ShellTest
+
+  section :subject
+
+  test :subject_class, :subject do
+    assert_equality subject_class, DevSystem::ZeitwerkShell
+    assert_equality subject.class, DevSystem::ZeitwerkShell
+  end
+
+  test :get_units_in_core do
+    assert_equality subject_class.get_units_in_core.count, 22
+  end
+
+end

data/lib/dev_system/{sub → subsystems}/bench/bench.rb

@@ -4,4 +4,6 @@ class DevSystem::Bench < Liza::Controller
 
   set :plural,   :benches
 
+  part :command_shortcut, :controller
+
 end

data/lib/dev_system/subsystems/bench/bench_panel.rb

@@ -0,0 +1,31 @@
+class DevSystem::BenchPanel < Liza::Panel
+
+  define_error(:not_found) do |args|
+    "bench not found: #{args[0].inspect}"
+  end
+
+  part :command_shortcut, :panel
+
+  section :default
+
+  def call(command_env)
+    env = forge command_env
+    forge_shortcut env
+    find env
+    find_shortcut env
+    forward env
+  end
+
+  #
+  
+  def forge(command_env)
+    command = command_env[:command]
+    bench_name_original, bench_action_original = command.args.first.to_s.split(":")
+
+    env = { controller: :bench, command:, bench_name_original:, bench_action_original: }
+
+    log :high, "bench_name:bench_action_original is                  #{bench_name_original}:#{bench_action_original}"
+    env
+  end
+
+end

data/lib/dev_system/subsystems/bench/bench_panel_test.rb

@@ -0,0 +1,55 @@
+class DevSystem::BenchPanelTest < Liza::PanelTest
+
+  test :subject_class do
+    assert subject_class == DevSystem::BenchPanel
+  end
+
+  test_methods_defined do
+    on_self
+    on_instance \
+      :call,
+      :find,
+      :forward,
+      :forge
+  end
+
+  section :forge
+  
+  def forge_with(args)
+    command = SimpleCommand.new
+    command_menv = {command: , args: }
+    command.instance_variable_set :@menv, command_menv
+    menv = subject.forge command_menv
+    subject.forge_shortcut menv
+    menv
+  end
+  
+  test :forge, true do
+    menv = forge_with ["objects"]
+    assert_equality menv[:bench_name_original], "objects"
+    assert_equality menv[:bench_name], "objects"
+    assert_equality menv[:bench_action_original], nil
+  end
+  
+  test :forge, true, :action do
+    menv = forge_with ["objects:quadratic"]
+    assert_equality menv[:bench_name_original], "objects"
+    assert_equality menv[:bench_name], "objects"
+    assert_equality menv[:bench_action_original], "quadratic"
+  end
+  
+  test :forge, false do
+    menv = forge_with ["x"]
+    assert_equality menv[:bench_name_original], "x"
+    assert_equality menv[:bench_name], "x"
+    assert_equality menv[:bench_action_original], nil
+  end
+  
+  test :forge, false, :action do
+    menv = forge_with ["x:y"]
+    assert_equality menv[:bench_name_original], "x"
+    assert_equality menv[:bench_name], "x"
+    assert_equality menv[:bench_action_original], "y"
+  end
+
+end

data/lib/dev_system/{sub → subsystems}/bench/bench_test.rb

@@ -10,8 +10,6 @@ class DevSystem::BenchTest < Liza::ControllerTest
   end
 
   test :settings do
-    assert_equality subject_class.log_level, 0
-
     assert_equality subject_class.token, nil
     assert_equality subject_class.singular, :bench
     assert_equality subject_class.plural, :benches

data/lib/dev_system/subsystems/bench/benches/not_found_bench.rb

@@ -0,0 +1,73 @@
+class DevSystem::NotFoundBench < DevSystem::Bench
+
+  def self.call env
+    new.call env
+  end
+
+  def call env
+    app_shell = AppShell.new
+    app_shell.filter_by_unit Bench
+
+    app_shell.filter_out_units SortedBench if defined? SortedBench
+    failed_name = env[:bench_name_original]
+    app_shell.filter_by_name_including failed_name if failed_name
+
+    outputs(app_shell, failed_name)
+  end
+
+  section :helpers
+
+  def outputs(app_shell, failed_name)
+    domains = app_shell.get_domains.reject(&:empty?)
+    log "domains: #{domains.count}"
+    puts
+
+    if domains.empty?
+      log stick :black, :green, "No results found for '#{failed_name}'"
+      app_shell.undo_filter!
+      domains = app_shell.get_domains
+    end
+
+    domains.each do |domain|
+      next if domain.empty?
+
+      if log? :normal
+        puts typo.h1 domain.name.snakecase.upcase, domain.color
+      end
+
+      puts
+      domain.layers.each do |layer|
+        next if layer.objects.empty?
+
+        if log? :normal
+          m = "h#{layer.level}"
+          name = layer.level==1 ? domain.name.to_s.upcase : layer.name.to_s
+          puts typo.send m, name, layer.color unless layer.level==3
+
+          puts stick layer.color, layer.path
+          puts
+        end
+
+        layer.objects.each { print_class _1 }
+        puts
+      end
+    end
+  end
+
+  def print_class klass, description: nil
+    return if [NotFoundBench].include? klass
+
+    sidebar_length = Log.panel.sidebar_size
+    signature = {}
+    signature[:name] = klass.token.to_s
+    signature[:description] = "no description"
+
+    puts [
+      "liza bench #{signature[:name]}".ljust(sidebar_length),
+      (description or signature[:description])
+    ].join ""
+  end
+
+  def typo () = TypographyShell
+
+end

data/lib/dev_system/subsystems/bench/benches/not_found_bench_test.rb

@@ -0,0 +1,7 @@
+class DevSystem::NotFoundBenchTest < DevSystem::BenchTest
+
+  test :subject_class do
+    assert subject_class == DevSystem::NotFoundBench
+  end
+
+end

data/lib/dev_system/subsystems/bench/commands/bench_command.rb

@@ -0,0 +1,21 @@
+class DevSystem::BenchCommand < DevSystem::SimpleCommand
+
+  def before
+    super
+    log "simple_args     #{ simple_args }"
+    log "simple_booleans #{ simple_booleans }"
+    log "simple_strings  #{ simple_strings }"
+  end
+
+  # liza bench NAME
+  def call_default
+    log :higher, "env.count is #{env.count}"
+    DevBox.bench env
+  end
+
+  # liza bench:controllers
+  def call_controllers
+    log "not implemented yet"
+  end
+
+end

data/lib/dev_system/subsystems/bench/commands/bench_command_test.rb

@@ -0,0 +1,7 @@
+class DevSystem::BenchCommandTest < DevSystem::SimpleCommandTest
+
+  test :subject_class do
+    assert subject_class == DevSystem::BenchCommand
+  end
+
+end