lizarb 1.0.4 → 1.0.6

data/lib/dev_system/generators/subsystem_generator.rb

@@ -0,0 +1,187 @@
+class DevSystem::SubsystemGenerator < DevSystem::SimpleGenerator
+
+  section :actions
+
+  # liza g subsystem name
+  def call_default
+    name = arg_name
+
+    if App.systems.values.map(&:subs).flatten.map(&:to_s).include? name
+      log stick :red, :white, :b, "controller and panel #{name} already exist"
+      return
+    end
+
+    add_sub_to_system
+    add_panel_to_box
+    create_controller_panel
+    create_command
+    create_generator
+  end
+
+  section :submethods
+
+  def add_sub_to_system
+    contents = read_file system_path
+    old_lines = contents.split("\n")
+
+    lines = LineShell.extract_between old_lines, "class ".."end"
+    lines << "  panel :#{subsystem_name}"
+    lines = LineShell.replace_between old_lines, "class ".."end", lines
+
+    contents = lines.join("\n")
+    update_file system_path, contents
+  end
+
+  def add_panel_to_box
+    path = App.systems_directory / "#{system_name}_system/#{system_name}_box.rb"
+    contents = read_file path
+    contents = _add_panel_to_box path, contents, "preconfigure"
+    update_file path, contents
+
+    path = App.directory / "#{system_name}_box.rb"
+    
+    contents = read_file path
+    return if contents.empty?
+    contents = _add_panel_to_box path, contents, "configure"
+    update_file path, contents
+  end
+
+  def _add_panel_to_box path, contents, verb
+    a = contents.split("\n")
+    a = a.map { _1.strip }
+    a = a.select { _1.start_with? "  #{verb} :" }
+
+    # contents
+
+    old_lines = contents.split("\n")
+
+    generic_panel_line = "  #{verb} :"
+
+    new_lines = [
+      "  #{verb} :#{subsystem_name} do",
+      "    # #{subsystem_name.camelcase}Panel.instance gives you read-access to this instance",
+      "  end",
+      "",
+    ]
+
+    lines = LineShell.extract_between old_lines, "class ".."end"
+    if a.count == 0
+      lines += new_lines
+    else
+      panel_lines = LineShell.extract_wall_of lines, generic_panel_line
+      panel_lines += new_lines
+      panel_lines = panel_lines.sort
+      lines = LineShell.replace_wall_of lines, generic_panel_line, panel_lines
+    end
+
+    lines = LineShell.replace_between old_lines, "class ".."end", lines
+
+    lines.join("\n")
+  end
+
+  def create_controller_panel
+    class_name = "#{system_name.to_s.camelize}System::#{subsystem_name.to_s.camelize}"
+
+    # build
+
+    controller      = UnitHelper.new
+    controller_test = UnitHelper.new
+    panel           = UnitHelper.new
+    panel_test      = UnitHelper.new
+
+    controller.section        name: :subsystem, render_key: :section_controller,      format: :rb
+    controller_test.section   name: :subject,   render_key: :section_controller_test
+    panel.section             name: :subsystem, render_key: :section_panel,           format: :rb
+    panel_test.section        name: :subject,   render_key: :section_panel_test
+
+    controller_class_names      = ["#{class_name}",          "Liza::Controller"]
+    controller_test_class_names = ["#{class_name}Test",      "Liza::ControllerTest"]
+    panel_class_names           = ["#{class_name}Panel",     "Liza::Panel"]
+    panel_test_class_names      = ["#{class_name}PanelTest", "Liza::PanelTest"]
+
+    controller_path      = subsystem_path / "#{subsystem_name}.rb"
+    controller_test_path = subsystem_path / "#{subsystem_name}_test.rb"
+    panel_path           = subsystem_path / "#{subsystem_name}_panel.rb"
+    panel_test_path      = subsystem_path / "#{subsystem_name}_panel_test.rb"
+
+    # render and add
+
+    _create_controller_panel_unit(
+      controller,
+      controller_class_names,
+      controller_path
+    )
+    
+    _create_controller_panel_unit(
+      controller_test,
+      controller_test_class_names,
+      controller_test_path
+    )
+    
+    _create_controller_panel_unit(
+      panel,
+      panel_class_names,
+      panel_path
+    )
+    
+    _create_controller_panel_unit(
+      panel_test,
+      panel_test_class_names,
+      panel_test_path
+    )
+  end
+
+  def _create_controller_panel_unit(unit, class_names, path)
+    log "Adding unit..."
+    log "unit: #{unit.inspect}"
+    log "class_names: #{class_names}"
+    log "path: #{path.inspect}"
+
+    add_unit unit, class_names, path
+  end
+
+  def create_command
+    generate "command", subsystem_name, "place=#{system_name}/#{subsystem_name}", "-prefix"
+  end
+
+  def create_generator
+    generate "generator:controller", subsystem_name, "place=#{system_name}/#{subsystem_name}", "-prefix"
+  end
+
+  section :helpers
+
+  def arg_name() = @arg_name ||= (name = command.simple_arg(1) until name.to_s.strip.length.positive?; name)
+
+  def system_name() = arg_place
+  
+  def system_path() = @system_path ||= (App.systems_directory / "#{system_name}_system.rb")
+  
+  def subsystem_name() = arg_name
+
+  def subsystem_path() = @subsystem_path ||= (App.root / arg_place_path)
+  
+  def available_places() = @available_places ||= ControllerShell.places_for_systems(arg_name)
+
+  def arg_place_system() = App.systems[arg_place.to_sym]
+
+  def arg_place() = @arg_place ||= command.simple_string(:place)
+
+  def arg_place_path() = @arg_place_path ||= ControllerShell.path_for(arg_place, arg_name)
+  
+  set_input_string :place do |default|
+    available_places = env[:generator].available_places
+    place = nil
+    place = available_places.keys[0] if available_places.count == 1
+    place ||= begin
+      options = available_places.map do |place, path|
+        [
+          "#{place.ljust 30} path: #{path}",
+          place
+        ]
+      end.to_h
+      InputShell.pick_one "Where should the controller be placed?", options
+    end
+    place
+  end
+
+end

data/lib/dev_system/generators/subsystem_generator.rb.section_controller.rb.erb

@@ -0,0 +1,8 @@
+# view section_controller.rb.erb
+
+  def self.call(env)
+    super
+    log stick :b, "TODO: Build a great DSL!"
+    log "env"
+    log env
+  end

data/lib/dev_system/generators/subsystem_generator.rb.section_controller_test.rb.erb

@@ -0,0 +1,18 @@
+# view section_controller_test.rb.erb
+
+  test :subject_class, :subject do
+    assert_equality subject_class, <%= @class_name[0..-5] %>
+    assert_equality subject.class, <%= @class_name[0..-5] %>
+  end
+
+  test_sections(
+    :subsystem=>{
+      :constants=>[],
+      :class_methods=>[:call],
+      :instance_methods=>[]
+    }
+  )
+
+  test :settings do
+    assert_equality subject_class.log_level, 4
+  end

data/lib/dev_system/generators/subsystem_generator.rb.section_panel.rb.erb

@@ -0,0 +1,19 @@
+# view section_panel.rb.erb
+
+  define_error(:not_found) do |args|
+    "<%= subsystem_name %> not found: #{args[0].inspect}"
+  end
+
+  def call(other_env)
+    log "not implemented"
+  #   log "forging"
+  #   env = { other_env: }
+
+  #   log "finding"
+  #   k = Liza.const "#{other_env[:<%= subsystem_name %>]}_<%= subsystem_name %>"
+    
+  #   log "forwarding"
+  #   k.call env
+  # rescue Liza::ConstNotFound
+  #   raise_error :not_found, string
+  end

data/lib/dev_system/generators/subsystem_generator.rb.section_panel_test.rb.erb

@@ -0,0 +1,18 @@
+# view section_panel_test.rb.erb
+
+  test :subject_class, :subject do
+    assert_equality subject_class, <%= @class_name[0..-5] %>
+    assert_equality subject.class, <%= @class_name[0..-5] %>
+  end
+
+  test_sections(
+    :subsystem=>{
+      :constants=>[],
+      :class_methods=>[],
+      :instance_methods=>[:call]
+    }
+  )
+
+  test :settings do
+    assert_equality subject.log_level, 4
+  end

data/lib/dev_system/generators/subsystem_generator_test.rb

@@ -0,0 +1,17 @@
+class DevSystem::SubsystemGeneratorTest < DevSystem::SimpleGeneratorTest
+
+  section :subject
+
+  test :subject_class, :subject do
+    assert_equality subject_class, DevSystem::SubsystemGenerator
+    assert_equality subject.class, DevSystem::SubsystemGenerator
+  end
+
+  test_erbs_defined(
+    "section_controller.rb.erb",
+    "section_controller_test.rb.erb",
+    "section_panel.rb.erb",
+    "section_panel_test.rb.erb"
+  )
+
+end

data/lib/dev_system/generators/system_generator.rb

@@ -0,0 +1,117 @@
+class DevSystem::SystemGenerator < DevSystem::SimpleGenerator
+
+  # liza g system name color=coral
+
+  def call_default
+    
+    create_system
+    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
+
+  section :name
+
+  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
+      name = nil
+      index = 1
+      until name.to_s.strip.size.positive?
+        name = command.given_args[index]
+        if name.to_s.strip.split("_").count < 2
+          # establish a default name
+          username = ENV['USER'] || ENV['USERNAME']
+          name = username if name.to_s.strip.size.zero?
+          default = "#{username}_#{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
+        end
+      end
+      name
+    end
+  end
+  
+  def color() = @color ||= command.simple_color(:color, string: "#{system_name.camelize}System")
+
+  section :sub_methods
+
+  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
+
+  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"
+
+    log stick system.color, "Creating system: #{system_name}"
+
+    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
+
+    add_unit unit, unit_classes, unit_path
+    add_unit test, test_classes, test_path
+  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"
+
+    unit.section name: :preconfiguration, render_key: :section_system_box_settings
+    test.section name: :systemic, render_key: :section_system_box_test
+
+    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

@@ -0,0 +1,18 @@
+class DevSystem::SystemGeneratorTest < DevSystem::SimpleGeneratorTest
+
+  test :subject_class do
+    assert subject_class == DevSystem::SystemGenerator
+  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/subsystems/bench/bench.rb

@@ -0,0 +1,9 @@
+class DevSystem::Bench < Liza::Controller
+  
+  #
+
+  set :plural,   :benches
+
+  part :command_shortcut, :controller
+
+end