lizarb 1.0.4 → 1.0.5

data/lib/dev_system/sub/command/command.rb

@@ -0,0 +1,28 @@
+class DevSystem::Command < Liza::Controller
+
+  def self.call args
+    log "args = #{args}"
+    new.call args
+  end
+
+  def call args
+    log "args = #{args}"
+    raise NotImplementedError
+  end
+
+  def self.get_command_signatures
+    signatures = []
+    ancestors_until(Command).each do |c|
+      signatures +=
+        c.methods_defined.select do |name|
+          c.method(name).parameters == [[:req, :args]]
+        end.map do |name|
+          OpenStruct.new({
+            name: ( name == :call ? "" : name.to_s ),
+            description: "# no description",
+          })
+        end
+    end
+    signatures
+  end
+end

data/lib/dev_system/sub/command/command_panel.rb

@@ -0,0 +1,151 @@
+class DevSystem::CommandPanel < Liza::Panel
+  class Error < StandardError; end
+  class ParseError < Error; end
+  class NotFoundError < Error; end
+  class AlreadySet < Error; end
+
+  def call args
+    log :lower, "args = #{args.inspect}"
+
+    return call_not_found args if args.none?
+
+    env = build_env args
+    find env
+    forward env
+    inform env
+  # rescue Exception => e
+  rescue Error => e
+    rescue_from_panel(e, with: env)
+  end
+
+  #
+
+  PARSE_REGEX = /(?<command_given>[A-Za-z0-9_]+)(?::(?<command_class_method>[a-z0-9_]+))?(?:#(?<command_instance_method>[a-z0-9_]+))?(?:\.(?<command_method>[a-z0-9_]+))?/
+
+  # Hash command_name class_method instance_method method
+  def parse string
+    md = string.to_s.match PARSE_REGEX
+    raise ParseError if md.nil?
+
+    env = md.named_captures.map { [_1.to_sym, _2] }.to_h
+    env[:command_arg] = string
+    log :lower, "{#{env.map { ":#{_1}=>#{_2.to_s.inspect}" }.join(", ") }}"
+    env
+  end
+
+  def build_env args
+    env = parse args[0]
+    env[:args] = Array(args[1..-1])
+    env[:command_args] = env[:args].dup
+    env[:command_name] = short env[:command_given]
+    env
+  end
+
+  #
+
+  def find env
+    raise "env[:command_name] is empty #{env}" if env[:command_name].empty?
+    env[:command_class] = Liza.const "#{env[:command_name]}_command"
+  rescue Liza::ConstNotFound
+    raise NotFoundError, "command not found: #{env[:command_name].inspect}"
+  end
+
+  def _find string
+    k = Liza.const "#{string}_command"
+    log :lower, k
+    k
+  rescue Liza::ConstNotFound
+    raise NotFoundError, "command not found: #{string.inspect}"
+  end
+
+  #
+
+  def forward env
+    command_class = env[:command_class]
+    
+    return forward_base_command env if command_class < BaseCommand
+    return forward_command env if command_class < Command
+  end
+
+  def forward_base_command env
+    log :lower,  "forwarding"
+    env[:command_class].call env
+  end
+
+  def forward_command env
+    case
+    when env[:command_class_method]
+      log :lower,  "#{env[:command_class]}.#{env[:command_class_method]}(#{env[:args]})"
+      env[:command_class].public_send env[:command_class_method], env[:args]
+    when env[:command_instance_method]
+      log :lower,  "#{env[:command_class]}.new.#{env[:command_instance_method]}(#{env[:args]})"
+      env[:command_class].new.public_send env[:command_instance_method], env[:args]
+    when env[:command_method]
+      if env[:command_class].respond_to?(env[:command_method])
+        log :lower,  "#{env[:command_class]}.#{env[:command_method]}(#{env[:args]})"
+        env[:command_class].public_send env[:command_method], env[:args]
+      else
+        log :lower,  "#{env[:command_class]}.new.#{env[:command_method]}(#{env[:args]})"
+        env[:command_class].new.public_send env[:command_method], env[:args]
+      end
+    else
+      log :lower,  "#{env[:command_class]}.call(#{env[:args]})"
+      env[:command_class].call env[:args]
+    end
+  end
+
+  #
+
+  def inform env
+    return if env[:simple] == nil
+    return if env[:simple] == [""]
+
+    env[:simple].shift if env[:simple][0] == ""
+
+    puts if log? :higher
+
+    args = [*env[:command_args], *env[:simple]].join(" ")
+
+    log sticks :black, system.color, :b,
+      ["LIZA"],
+      ["HELPS",    :u],
+      ["YOU",      :u, :i],
+      ["REMEMBER", :i] \
+        if log? :higher
+    
+    log stick system.color, "#{ $0.split("/").last } #{ env[:command_arg] } #{ args }" if log? :higher
+  end
+
+  #
+
+  def call_not_found args
+    Liza[:NotFoundCommand].call args
+  end
+
+  #
+
+  def input name = nil
+    return (@input || InputCommand) if name.nil?
+    raise AlreadySet, "input already set to #{@input.inspect}, but trying to set to #{name.inspect}", caller if @input
+    @input = _find "#{name}_input"
+  end
+
+  def pick_one title, options = ["Yes", "No"]
+    if log_level? :highest
+      puts
+      log "Pick One"
+    end
+    # input.pick_one title, options
+    TtyInputCommand.pick_one title, options
+  end
+
+  def pick_many title, options
+    if log_level? :highest
+      puts
+      log "Pick Many"
+    end
+    # input.pick_many title, options
+    TtyInputCommand.multi_select title, options
+  end
+
+end

data/lib/dev_system/sub/command/command_panel_test.rb

@@ -0,0 +1,78 @@
+class DevSystem::CommandPanelTest < Liza::PanelTest
+
+  test :subject_class do
+    assert_equality subject_class, DevSystem::CommandPanel
+  end
+
+  test_methods_defined do
+    on_self
+    on_instance \
+      :build_env,
+      :call, :call_not_found,
+      :find,
+      :forward, :forward_base_command, :forward_command,
+      :inform,
+      :input,
+      :parse,
+      :pick_many, :pick_one
+  end
+
+  test :settings do
+    assert_equality subject_class.log_level, 0
+  end
+
+  test :parse do
+    def parse string
+      OpenStruct.new subject.parse(string)
+    end
+
+    struct = parse "generate"
+    assert_equality struct.command_given, "generate"
+    assert_equality struct.command_class_method, nil
+    assert_equality struct.command_instance_method, nil
+    assert_equality struct.command_method, nil
+
+    struct = parse "generate:install"
+    assert_equality struct.command_given, "generate"
+    assert_equality struct.command_class_method, "install"
+    assert_equality struct.command_instance_method, nil
+    assert_equality struct.command_method, nil
+
+    struct = parse "generate#install"
+    assert_equality struct.command_given, "generate"
+    assert_equality struct.command_class_method, nil
+    assert_equality struct.command_instance_method, "install"
+    assert_equality struct.command_method, nil
+
+    struct = parse "generate.install"
+    assert_equality struct.command_given, "generate"
+    assert_equality struct.command_class_method, nil
+    assert_equality struct.command_instance_method, nil
+    assert_equality struct.command_method, "install"
+
+    struct = parse "two_words"
+    assert_equality struct.command_given, "two_words"
+    assert_equality struct.command_class_method, nil
+    assert_equality struct.command_instance_method, nil
+    assert_equality struct.command_method, nil
+
+    struct = parse "word10"
+    assert_equality struct.command_given, "word10"
+    assert_equality struct.command_class_method, nil
+    assert_equality struct.command_instance_method, nil
+    assert_equality struct.command_method, nil
+  end
+
+  test :find do
+    klass = subject._find "generate"
+    assert_equality DevSystem::GenerateCommand, klass
+
+    begin
+      klass = subject._find "g"
+      assert false
+    rescue CommandPanel::NotFoundError
+      assert true
+    end
+  end
+
+end

data/lib/dev_system/{dev/controllers → sub/command}/command_test.rb

@@ -4,9 +4,13 @@ class DevSystem::CommandTest < Liza::ControllerTest
     assert subject_class == DevSystem::Command
   end
 
+  test_methods_defined do
+    on_self :call, :get_command_signatures
+    on_instance :call
+  end
+
   test :settings do
-    assert subject_class.log_level == :normal
-    assert subject_class.log_color == :green
+    assert_equality subject_class.log_level, 0
   end
 
 end

data/lib/dev_system/sub/command/commands/base_command.rb

@@ -0,0 +1,48 @@
+class DevSystem::BaseCommand < DevSystem::Command
+
+  #
+
+  def self.call(env)
+    log :lower, "env.count is #{env.count}"
+    
+    command = env[:command] = new
+    command.call env
+  end
+
+  #
+
+  attr_reader :env
+
+  def call(env)
+    log :lower, "env.count is #{env.count}"
+    @env = env
+    
+    method_name = env[:command_arg]
+    method_name = method_name.split(":")[1] || :default
+    method_name = "call_#{method_name}"
+    return public_send method_name if respond_to? method_name
+
+    log "method not found: #{method_name.inspect}"
+    raise NoMethodError, "method not found: #{method_name.inspect}"
+  end
+
+  #
+
+  def self.get_command_signatures
+
+    signatures = []
+    ancestors_until(BaseCommand).each do |c|
+      signatures +=
+        c.instance_methods_defined.select do |name|
+          name.start_with? "call_"
+        end.map do |name|
+          OpenStruct.new({
+            name: ( name.to_s.sub("call_", "").sub("default", "") ),
+            description: "# no description",
+          })
+        end
+    end
+    signatures
+  end
+
+end

data/lib/dev_system/sub/command/commands/base_command_test.rb

@@ -0,0 +1,11 @@
+class DevSystem::BaseCommandTest < DevSystem::CommandTest
+
+  test :subject_class do
+    assert_equality subject_class, DevSystem::BaseCommand
+  end
+
+  test :settings do
+    assert_equality subject_class.log_level, 0
+  end
+
+end

data/lib/dev_system/{dev/controllers/terminal/irb_terminal.rb → sub/command/commands/irb_command.rb}

@@ -1,4 +1,4 @@
-class DevSystem::IrbTerminal < DevSystem::Terminal
+class DevSystem::IrbCommand < DevSystem::Command
 
   def self.call args
     log "args = #{args.inspect}"
@@ -11,13 +11,9 @@ class DevSystem::IrbTerminal < DevSystem::Terminal
     irb = IRB::Irb.new(workspace)
     IRB.conf[:MAIN_CONTEXT] = irb.context
 
-    def irb.signal_status(status)
-      super
-    rescue Interrupt
-      IrbTerminal.log "Control-C"
-    end
-
     irb.eval_input
+  rescue Interrupt
+    log "Control-C"
   end
 
 end

data/lib/dev_system/sub/command/commands/irb_command_test.rb

@@ -0,0 +1,11 @@
+class DevSystem::IrbCommandTest < DevSystem::CommandTest
+
+  test :subject_class do
+    assert subject_class == DevSystem::IrbCommand
+  end
+
+  test :settings do
+    assert_equality subject_class.log_level, 0
+  end
+
+end

data/lib/dev_system/sub/command/commands/not_found_command.rb

@@ -0,0 +1,156 @@
+class DevSystem::NotFoundCommand < DevSystem::SimpleCommand
+
+  def call_default
+    h3 "Liza is a light application framework written in Ruby 3.3 ❤", color: DevSystem.color
+    h5 "We're optimizing for happiness. Come join us!", color: ColorShell.colors.keys.sample
+    puts
+
+    if App.global?
+      print_global
+    else
+      print_systems
+      print_app
+    end
+  end
+
+  # color helpers
+
+  def color klass
+    return klass unless klass < Liza::Unit
+
+    namespace, _sep, classname = klass.to_s.rpartition('::')
+
+    if namespace.empty?
+      return stick classname, Liza.const(classname).system.color
+    end
+
+    "#{
+      stick namespace, Liza.const(namespace).system.color
+    }::#{
+      stick classname, Liza.const(classname).color
+    }"
+  end
+
+  # print helpers
+
+  def print_class klass, description: nil
+    loc = klass.to_s
+
+    sidebar_length = 30
+    klass.get_command_signatures.each do |signature|
+      signature.name =
+        signature.name.empty? \
+          ? klass.token.to_s
+          : "#{klass.token}:#{signature.name}"
+      #
+    end.sort_by(&:name).map do |signature|
+      puts [
+        "liza #{signature.name}".ljust(sidebar_length),
+        (description or signature.description)
+      ].join ""
+    end
+  end
+  
+  #
+
+  def print_systems
+    h1 "SYSTEMS"
+    AppShell.consts[:systems].each do |system_name, tree_system|
+      system = tree_system["system"][0]
+
+      h4 system
+      tree_system["controllers"].each do |family, klasses|
+        klasses = tree_system["controllers"][family].to_a.select { _1 < Command }
+        next if klasses.empty?
+
+        h5 "lib/#{system_name}_system/#{family.plural}/", color: system.color
+        klasses.each { print_class _1 }
+      end
+
+      print_system_sub system, system_name, tree_system
+    end
+    puts
+  end
+
+  def print_system_sub system, system_name, tree_system
+    tree_system["subsystems"].each do |subsystem, tree_subsystem|
+      klasses = tree_subsystem["controllers"].values.flatten.select { _1 < Command }
+      next if klasses.empty?
+
+      tree_subsystem["controllers"].each do |controller_class, klasses|
+        klasses = klasses.select { _1 < Command }
+        klasses = klasses.reject { _1 <= InputCommand } # TODO: setting to hide command classes
+        klasses = klasses.reject { _1 == BaseCommand }
+        klasses = klasses.reject { _1 == SimpleCommand }
+        klasses = klasses.reject { _1 == NewCommand }
+        next if klasses.empty?
+
+        h5 "lib/#{system_name}_system/sub/#{subsystem.singular}/#{controller_class.plural}/", color: system.color
+        klasses.each { print_class _1 }
+      end
+    end
+  end
+
+  def print_app
+    h1 "TEAM CODE AT app/"
+
+    system_name = "dev"
+    tree_system = AppShell.consts[:app]["dev"]
+
+    system = Liza.const "#{system_name}_system"
+    tree_system["controllers"].each do |family, structure|
+      structure.each do |division, klasses|
+        klasses = klasses.select { _1 < Command }
+        if klasses.any?
+          h5 "app/#{system_name}/#{division.plural}/", color: system.color
+          klasses.each { print_class _1 }
+        end
+      end
+    end
+  end
+
+  def print_global
+    klasses = {
+      NewCommand => "# Create a new project",
+      NotFoundCommand => "# This command",
+    }
+
+    klasses.each { print_class _1, description: _2 }
+
+    5.times { puts }
+  end
+
+  # typography helpers
+
+  def h1 text
+    puts stick " #{ text } ".center(80, "="), :b
+  end
+
+  def h2 text, color: :white
+    puts stick " #{ text } ".center(80, "-"), :b, color
+  end
+
+  def h3 text, color: :white
+    puts
+    puts stick " #{ text } ".center(80, " "), :b, color
+  end
+
+  def h4 system
+    puts
+    s = system.to_s
+    s1 = s
+    s1 = "#{ color(system) }" if system < Liza::Unit
+    color = system.color rescue :white
+    t = s.rjust(80, " ")
+    t = "#{ stick t, :b, color }"
+    t = t.gsub(s, s1)
+    puts t
+  end
+
+  def h5 text, color: :white
+    puts
+    puts stick text.ljust(80, " "), color
+    puts
+  end
+
+end

data/lib/dev_system/sub/command/commands/not_found_command_test.rb

@@ -0,0 +1,11 @@
+class DevSystem::NotFoundCommandTest < DevSystem::SimpleCommandTest
+
+  test :subject_class do
+    assert subject_class == DevSystem::NotFoundCommand
+  end
+
+  test :settings do
+    assert_equality subject_class.log_level, 0
+  end
+
+end

data/lib/dev_system/{dev/controllers/terminal/pry_terminal.rb → sub/command/commands/pry_command.rb}

@@ -1,9 +1,9 @@
-class DevSystem::PryTerminal < DevSystem::Terminal
+class DevSystem::PryCommand < DevSystem::Command
 
   def self.call args
+    require "pry"
     log "args = #{args.inspect}"
 
-    require "pry"
     Pry.start
   end
 

data/lib/dev_system/sub/command/commands/pry_command_test.rb

@@ -0,0 +1,11 @@
+class DevSystem::PryCommandTest < DevSystem::CommandTest
+
+  test :subject_class do
+    assert subject_class == DevSystem::PryCommand
+  end
+
+  test :settings do
+    assert_equality subject_class.log_level, 0
+  end
+
+end

data/lib/dev_system/sub/command/commands/simple_command.rb

@@ -0,0 +1,143 @@
+class DevSystem::SimpleCommand < DevSystem::BaseCommand
+
+  #
+
+  def call(env)
+    env[:simple] = [""]
+    super
+  end
+
+  #
+
+  def log_simple_remember
+    log :lower, "env[:remember] is now #{stick system.color, (env[:simple].join " ")}", kaller: caller
+  end
+  
+  # 
+
+  # key=value
+  def simple_string(key, &block)
+    string = env[:args].find { _1.start_with? "#{key}=" }.to_s.sub("#{key}=", "")
+    return string unless string.empty?
+
+    value = yield.to_s.split(" ")[0]
+    log :high, value.inspect
+
+    env[:simple] << "#{key}=#{value}"
+
+    log_simple_remember
+
+    value
+  end
+
+  #
+
+  # key=value
+  def simple_color(key, string: "I LOVE RUBY")
+    simple_string key do
+      TtyInputCommand.pick_color string: string
+    end.to_sym.tap do |color|
+      log :high, color.inspect
+    end
+  end
+
+  #
+
+  # key=value
+  def simple_controller_placement(key, places)
+    simple_string key do
+      options = places.map do |place, path|
+        [
+          "#{place.ljust 30} path: #{path}",
+          place
+        ]
+      end.to_h
+      TtyInputCommand.pick_one "Where should the controller be placed?", options
+    end.tap do |place|
+      log :high, place.inspect
+    end
+  end
+
+  #
+
+  # arg0 arg1 arg2
+  def simple_args
+    env[:args]
+      .reject { _1.start_with? "+" }
+      .reject { _1.start_with? "-" }
+      .reject { _1.include? "=" }
+  end
+
+  # arg0 arg1 arg2
+  def simple_arg(index, &block)
+    string = env[:args][index]
+    return string if string
+
+    value = yield
+    value = "" if value.nil?
+    value = value.inspect if value.include? " "
+    log :high, value.inspect
+
+    string = env[:simple][0]
+    string << " " unless string.empty?
+    string << value
+
+    log_simple_remember
+
+    value
+  end
+
+  #
+
+  # arg0 arg1 arg2
+  def simple_arg_ask(index, title)
+    simple_arg index do
+      TtyInputCommand.prompt.ask(title)
+    end
+  end
+
+  #
+
+  # arg0 arg1 arg2
+  def simple_arg_ask_snakecase(index, title)
+    simple_arg index do
+      TtyInputCommand.prompt.ask(title) do |q|
+        q.required true
+        q.validate /^[a-zA-Z_]*$/
+      end.snakecase
+    end
+  end
+
+  #
+
+  # +key -key
+  def simple_boolean_yes(key, title)
+    simple_boolean key do
+      TtyInputCommand.prompt.yes? title
+    end
+  end
+
+  # +key -key
+  def simple_boolean_no(key, title)
+    simple_boolean key do
+      TtyInputCommand.prompt.no? title
+    end
+  end
+
+  # +key -key
+  def simple_boolean(key, &block)
+    return true  if env[:args].find { _1 == "+#{key}" }
+    return false if env[:args].find { _1 == "-#{key}" }
+
+    value = yield
+    log :high, value.inspect
+
+    env[:simple] << "+#{key}" if TrueClass === value
+    env[:simple] << "-#{key}" if FalseClass === value
+
+    log_simple_remember
+
+    value
+  end
+
+end