lizarb 1.0.5 → 1.0.7

data/lib/dev_system/subsystems/command/generators/command_generator.rb.section_simple_actions.rb.erb

@@ -0,0 +1,21 @@
+# view section_simple_actions.rb.erb
+<% arg_action_names.each do |action_name| %>
+  # liza <%= controller_name %><%= ":#{action_name}" if action_name != "default" %> s1 s2 s3 +b1 +b2 -b3 -b4 k1=v1 k2=v2
+  def call_<%= action_name %>
+    color = :<%= ColorShell.colors.keys.sample %>
+    log stick :b, color, "I just think Ruby is the Best for coding!"
+<% 1.upto 3 do -%>
+    sleep <%= random_sleep_float %>
+<% end -%>
+<% arg_action_names.each do |arg| -%>
+<%= "    call_#{arg}" if arg != "default" %>
+<% end if action_name == "default" -%>
+<% unless arg_views_none? %>
+    text = render :<%= action_name %>, format: :txt
+    puts stick :b, color, text.strip
+<% end -%>
+  rescue => e
+    log "rescued from (#{e.class}) #{e.message}"
+    binding.irb
+  end
+<% end -%>

data/lib/dev_system/subsystems/command/generators/command_generator.rb.section_simple_filters.rb.erb

@@ -0,0 +1,25 @@
+# view section_simple_filters.rb.erb
+
+  def before
+    super
+    @t = Time.now
+    log "simple_args     #{ simple_args }"
+    log "simple_booleans #{ simple_booleans }"
+    log "simple_strings  #{ simple_strings }"
+  end
+  
+  def after
+    super
+    log "#{ time_diff @t }s | done"
+  end
+<% if @should_add_rescue_from -%>
+
+  def rescue_from(e)
+    log stick :red, "Exception raised during action #{action_name}: (#{e.class}) #{e.message}"
+    puts "--- e.backtrace ---"
+    puts e.backtrace
+    puts "---"
+    menv[:exception] = e
+    # binding.irb
+  end
+<% end -%>

data/lib/dev_system/subsystems/command/generators/command_generator.rb.view_simple.txt.erb

@@ -0,0 +1,2 @@
+# view view_simple.txt.erb
+This text was rendered by an instance of <%%= self.class %> at <%%= Time.now %>

data/lib/dev_system/subsystems/command/generators/command_generator_test.rb

@@ -0,0 +1,15 @@
+class DevSystem::CommandGeneratorTest < DevSystem::SimpleGeneratorTest
+
+  test :subject_class do
+    assert_equality subject_class, DevSystem::CommandGenerator
+    assert_equality subject.class, DevSystem::CommandGenerator
+  end
+
+  test_erbs_defined(
+    "section_base.rb.erb",
+    "section_simple_actions.rb.erb",
+    "section_simple_filters.rb.erb",
+    "view_simple.txt.erb"
+  )
+
+end

data/lib/dev_system/subsystems/command/parts/command_shortcut_part.rb

@@ -0,0 +1,58 @@
+class DevSystem::CommandShortcutPart < Liza::Part
+
+  insertion :controller do
+    def self.shortcuts() = @shortcuts ||= {}
+
+    def self.shortcut(a, b = nil)
+      if b
+        shortcuts[a.to_s] = b.to_s
+      else
+        shortcuts[a.to_s] || a.to_s
+      end
+    end
+  end
+
+  insertion :panel do
+    def shortcuts() = @shortcuts ||= {}
+
+    def shortcut(a, b = nil)
+      if b
+        shortcuts[a.to_s] = b.to_s
+      else
+        shortcuts[a.to_s] || a.to_s
+      end
+    end
+
+    # called by the panel {#call} method after {#forge}
+    def forge_shortcut(env)
+      c = env[:controller] 
+      env[:"#{c}_name"] = shortcut env[:"#{c}_name_original"] || ""
+      log :high, "#{ "#{c}_name is".ljust_blanks 53 }#{env[:"#{c}_name"]}"
+    end
+
+    # called by the panel {#call} method after {#forge_shortcut}
+    def find(env)
+      c = env[:controller] 
+      raise Liza::ConstNotFound if env[:"#{c}_name"].to_s.empty?
+      env[:"#{c}_class"] = Liza.const "#{env[:"#{c}_name"]}_#{c}"
+    rescue Liza::ConstNotFound
+      env[:"#{c}_class"] = Liza.const "not_found_#{c}"
+    ensure
+      log :high, "#{ "#{c}_class is".ljust_blanks 53 }#{env[:"#{c}_class"]}"
+    end
+  
+    # called by the panel {#call} method after {#find}
+    def find_shortcut(env)
+      c = env[:controller] 
+      env[:"#{c}_action"] ||= env[:"#{c}_class"].shortcut env[:"#{c}_action_original"] || "default"
+      log :high, "#{ "#{c}_name:#{c}_action is".ljust_blanks 53 }#{env[:"#{c}_name"]}:#{env[:"#{c}_action"]}"
+    end
+
+    # called by the panel {#call} method after {#find_shortcut}
+    def forward(env)
+      log :high, "forwarding"
+      env[:"#{env[:controller]}_class"].call env
+    end
+  end
+
+end

data/lib/dev_system/subsystems/command/parts/command_shortcut_part_test.rb

@@ -0,0 +1,6 @@
+class DevSystem::CommandShortcutPartTest < Liza::PartTest
+
+  test :subject_class do
+    assert_equality subject_class, DevSystem::CommandShortcutPart
+  end
+end

data/lib/dev_system/subsystems/command/shells/color_shell.rb

@@ -0,0 +1,60 @@
+class DevSystem::ColorShell < DevSystem::Shell
+
+  #
+
+  def self.parse color
+    return colors[color] if colors.has_key? color
+
+    return rgb_from_int(color) if color.is_a? Integer
+    return rgb_from_str(color) if color.is_a? String
+    
+    color
+  end
+  
+  # Colors
+
+  def self.colors
+    PalletShell.colors
+  end
+
+  # 
+
+  def self.rgb_from_int hex
+    raise "Invalid type: #{hex.class}" unless hex.is_a? Integer
+    raise "Invalid hex color: #{hex}" unless 0 <= hex && hex <= 0xffffff
+    
+    r = (hex >> 16) & 0xff
+    g = (hex >> 8) & 0xff
+    b = hex & 0xff
+    [r, g, b]
+  end
+
+  def self.rgb_from_str hex
+    raise "Invalid type: #{hex.class}" unless hex.is_a? String
+    raise "Invalid hex color: #{hex}" unless hex =~ /^#?[0-9a-fA-F]{6}$/
+
+    hex = hex[1..-1] if hex[0] == "#"
+    rgb_from_int hex.to_i(16)
+  end
+
+  def self.rgb_to_str rgb
+    raise "Invalid type: #{rgb.class}" unless rgb.is_a? Array
+    raise "Invalid rgb color: #{rgb}" unless rgb.length == 3 && rgb.all? {|x| 0 <= x && x <= 0xff}
+
+    r, g, b = rgb
+    "##{"%02x" % r}#{"%02x" % g}#{"%02x" % b}"
+  end
+
+  def initialize(color)
+    @rgb = self.class.parse color
+  end
+
+  def to_s
+    @string ||= self.class.rgb_to_str @rgb
+  end
+
+  def to_rgb
+    @rgb
+  end
+
+end

data/lib/dev_system/{sub/shell → subsystems/command}/shells/color_shell_test.rb

@@ -4,7 +4,7 @@ class DevSystem::ColorShellTest < DevSystem::ShellTest
 
   test :subject_class, :subject do
     assert_equality DevSystem::ColorShell, subject_class
-    assert_equality DevSystem::ColorShell, subject.class
+    # assert_equality DevSystem::ColorShell, subject.class
   end
 
   test :subject_class, :rgb_from_int do
@@ -19,9 +19,4 @@ class DevSystem::ColorShellTest < DevSystem::ShellTest
     assert_equality [255, 0, 0], subject_class.rgb_from_str("#ff0000")
   end
 
-  test :subject_class, :colors do
-    assert_equality 245,     subject_class.colors.count
-    assert_equality [Array], subject_class.colors.map(&:class).uniq
-  end
-  
 end

data/lib/dev_system/subsystems/command/shells/input_shell.rb

@@ -0,0 +1,95 @@
+class DevSystem::InputShell < DevSystem::Shell
+
+  def self.ask(...)
+    prompt.ask(...)
+  rescue Exception => e
+    rescue_input_interrupt e
+  end
+
+  def self.select(...)
+    prompt.select(...)
+  rescue Exception => e
+    rescue_input_interrupt e
+  end
+
+  def self.yes?(...)
+    prompt.yes?(...)
+  rescue Exception => e
+    rescue_input_interrupt e
+  end
+
+  def self.pick_one title, options = ["Yes", "No"], default: nil
+    prompt.select title, options, filter: true, show_help: :always, per_page: 20, default: default
+  rescue Exception => e
+    rescue_input_interrupt e
+  end
+
+  def self.pick_color title = "Pick a color", string: nil
+    options = ColorShell.colors.map { [(stick _2, "#{string} # #{_1}", :b), _1] }.to_h
+
+    prompt.select \
+      title,
+      options,
+      filter: true, show_help: :always, per_page: 28
+  rescue Exception => e
+    rescue_input_interrupt e
+  end
+
+  def self.pick_log_level(title = "Which log level?", default: )
+    choices = {
+      "lowest"  => 1,
+      "lower"   => 2,
+      "low"     => 3,
+      "normal"  => 4,
+      "high"    => 5,
+      "higher"  => 6,
+      "highest" => 7,
+    }
+    answer = pick_one title, choices.keys, default: default
+    choices[answer]
+  end
+
+  def self.pick_writeable_domains(title)
+    domains = AppShell.get_writable_domains
+    pick_domains title, domains: domains
+  end
+
+  def self.pick_domains(domains, default, title)
+    choices = domains.map do
+      color = _2.color rescue :white
+      [(stick color, _2.to_s).to_s, _1]
+    end.to_h
+    multi_select title, choices, selected: default
+  end
+
+  def self.multi_select title, choices, selected: :all
+    raise ArgumentError, "choices must be a hash", caller unless choices.is_a? Hash
+    return choices if choices.empty?
+    
+    default = 1..choices.count if selected == :all
+    default = [] if selected == :none
+    default = selected.map { choices.values.index(_1) + 1 } if selected.is_a? Array
+
+    options = {
+      enum: ")",
+      per_page: 30,
+      help: "(space to select, enter to finish)",
+      show_help: :always,
+      default: default
+    }
+    prompt.multi_select title, choices, options
+  rescue Exception => e
+    rescue_input_interrupt e
+  end
+
+  section :delegations
+
+  def self.rescue_input_interrupt(e)
+    TtyPromptGemShell.rescue_input_interrupt e
+  end
+
+  def self.prompt
+    TtyPromptGemShell.prompt
+  end
+
+end

data/lib/dev_system/subsystems/command/shells/input_shell_test.rb

@@ -0,0 +1,11 @@
+class DevSystem::InputShellTest < DevSystem::ShellTest
+
+  section :subject
+
+  test :subject_class, :subject do
+    assert_equality subject_class, DevSystem::InputShell
+    assert_equality subject.class, DevSystem::InputShell
+  end
+
+end
+

data/lib/dev_system/{sub/shell/shells/color_shell.rb → subsystems/command/shells/pallet_shell.rb}

@@ -1,17 +1,4 @@
-class DevSystem::ColorShell < DevSystem::Shell
-
-  #
-
-  def self.parse color
-    return colors[color] if colors.has_key? color
-
-    return rgb_from_int(color) if color.is_a? Integer
-    return rgb_from_str(color) if color.is_a? String
-    
-    color
-  end
-  
-  # Colors
+class DevSystem::PalletShell < DevSystem::Shell
 
   @@colors = {}
 
@@ -19,39 +6,18 @@ class DevSystem::ColorShell < DevSystem::Shell
     @@colors
   end
 
-  def self.add k, v
-    v = @@colors[v] if v.is_a? Symbol
-    v = rgb_from_int v if v.is_a? Integer
-    v = rgb_from_str v if v.is_a? String
-    @@colors[k] = v
+  def self.find(k)
+    return k if k.class.name == ColorShell.name
+    ret = nil
+    ret   = @@colors[k]
+    ret ||= @@colors.values.find { k == _1.to_s } if k.is_a? String
+    ret ||= @@colors.values.find { k == _1.to_rgb } if k.is_a? Array
+    ret ||  raise("Unknown color: #{k.inspect}")
+    ret
   end
 
-  # 
-
-  def self.rgb_from_int hex
-    raise "Invalid type: #{hex.class}" unless hex.is_a? Integer
-    raise "Invalid hex color: #{hex}" unless 0 <= hex && hex <= 0xffffff
-    
-    r = (hex >> 16) & 0xff
-    g = (hex >> 8) & 0xff
-    b = hex & 0xff
-    [r, g, b]
-  end
-
-  def self.rgb_from_str hex
-    raise "Invalid type: #{hex.class}" unless hex.is_a? String
-    raise "Invalid hex color: #{hex}" unless hex =~ /^#?[0-9a-fA-F]{6}$/
-
-    hex = hex[1..-1] if hex[0] == "#"
-    rgb_from_int hex.to_i(16)
-  end
-
-  def self.rgb_to_str rgb
-    raise "Invalid type: #{rgb.class}" unless rgb.is_a? Array
-    raise "Invalid rgb color: #{rgb}" unless rgb.length == 3 && rgb.all? {|x| 0 <= x && x <= 0xff}
-
-    r, g, b = rgb
-    "##{"%02x" % r}#{"%02x" % g}#{"%02x" % b}"
+  def self.add k, v
+    @@colors[k] = ColorShell.new v
   end
 
   # Standard ANSI Colors:
@@ -385,5 +351,4 @@ class DevSystem::ColorShell < DevSystem::Shell
   add :lighter_pink,  0xff3399
   add :lightest_pink, 0xff66b2
 
-
 end

data/lib/dev_system/subsystems/command/shells/pallet_shell_test.rb

@@ -0,0 +1,15 @@
+class DevSystem::PalletShellTest < DevSystem::ShellTest
+
+  section :subject
+
+  test :subject_class, :subject do
+    assert_equality subject_class, DevSystem::PalletShell
+    assert_equality subject.class, DevSystem::PalletShell
+  end
+
+  test :subject_class, :colors do
+    assert_equality 245,     subject_class.colors.count
+    assert_equality [Array], subject_class.colors.map(&:class).uniq
+  end
+  
+end

data/lib/dev_system/subsystems/command/shells/typography_shell.rb

@@ -0,0 +1,33 @@
+class DevSystem::TypographyShell < DevSystem::Shell
+
+  def self.h1(text, color, length: 100)
+    stick color, " #{ text } ".center(length, "=")
+  end
+
+  def self.h2(text, color, length: 100)
+    stick color, " #{ text } ".center(length, "-")
+  end
+
+  def self.h3(text, color, length: 100)
+    stick color, " #{ text } ".center(length, " ")
+  end
+
+  def self.color_class klass
+    return klass.to_s unless klass < Liza::Unit
+    return klass.to_s if klass.superclass == Liza::Unit
+
+    namespace, _sep, classname = klass.to_s.rpartition('::')
+
+    return stick classname, klass.system.color if namespace.empty?
+    return stick klass.to_s, :white if namespace == "Liza"
+    
+    ns = Liza.const(namespace)
+
+    "#{
+      stick namespace, ns.system.color
+    }::#{
+      stick classname, klass.color
+    }"
+  end
+
+end

data/lib/dev_system/subsystems/command/shells/typography_shell_test.rb

@@ -0,0 +1,10 @@
+class DevSystem::TypographyShellTest < DevSystem::ShellTest
+
+  section :subject
+
+  test :subject_class, :subject do
+    assert_equality subject_class, DevSystem::TypographyShell
+    assert_equality subject.class, DevSystem::TypographyShell
+  end
+
+end

data/lib/dev_system/subsystems/generator/commands/generate_command.rb

@@ -0,0 +1,46 @@
+class DevSystem::GenerateCommand < DevSystem::SimpleCommand
+
+  shortcut :r, :remove
+  shortcut :u, :uninstall
+  shortcut :i, :install
+  shortcut :m, :move
+  shortcut :o, :overwrite
+
+  def before
+    super
+    log "simple_args     #{ simple_args }"
+    log "simple_booleans #{ simple_booleans }"
+    log "simple_strings  #{ simple_strings }"
+  end
+
+  # liza generate
+  def call_default
+    DevBox.generate env
+  end
+
+  # liza generate:remove
+  def call_remove
+    DevBox.command ["generate", "remove", *args]
+  end
+
+  # liza generate:uninstall
+  def call_uninstall
+    DevBox.command ["generate", "uninstall", *args]
+  end
+
+  # liza generate:install
+  def call_install
+    DevBox.command ["generate", "install", *args]
+  end
+
+  # liza generate:move
+  def call_move
+    DevBox.command ["generate", "move", *args]
+  end
+
+  # liza generate:overwrite
+  def call_overwrite
+    DevBox.command ["generate", "overwrite", *args]
+  end
+
+end

data/lib/dev_system/{sub → subsystems}/generator/commands/generate_command_test.rb

@@ -4,8 +4,4 @@ class DevSystem::GenerateCommandTest < DevSystem::SimpleCommandTest
     assert subject_class == DevSystem::GenerateCommand
   end
 
-  test :settings do
-    assert_equality subject_class.log_level, 0
-  end
-
 end

data/lib/dev_system/subsystems/generator/commands/new_command.rb

@@ -0,0 +1,33 @@
+class DevSystem::NewCommand < DevSystem::SimpleCommand
+
+  # liza new [name]
+
+  def call_default
+    call_project
+  end
+
+  # liza new:project [name]
+
+  def call_project
+    DevBox.command ["generate", "new:project", *args]
+  end
+
+  # liza new:script [name]
+
+  def call_script
+    DevBox.command ["generate", "new:script", *args]
+  end
+
+  # liza new:script_dependent [name]
+  
+  def call_script_dependent
+    DevBox.command ["generate", "new:script_dependent", *args]
+  end
+
+  # liza new:script_independent [name]
+  
+  def call_script_independent
+    DevBox.command ["generate", "new:script_independent", *args]
+  end
+
+end

data/lib/dev_system/subsystems/generator/commands/new_command_test.rb

@@ -0,0 +1,12 @@
+class DevSystem::NewCommandTest < DevSystem::SimpleCommandTest
+
+  test :subject_class do
+    assert subject_class == DevSystem::NewCommand
+  end
+
+  test_methods_defined do
+    on_self
+    on_instance :call_default, :call_project, :call_script, :call_script_dependent, :call_script_independent
+  end
+  
+end

data/lib/dev_system/{sub/shell/shells/line_diff_shell.rb → subsystems/generator/gem_shells/difflcs_gem_shell.rb}

@@ -1,26 +1,28 @@
-class DevSystem::LineDiffShell < DevSystem::Shell
+class DevSystem::DifflcsGemShell < DevSystem::GemShell
+  require "diff/lcs"
+  # gem "diff-lcs"
 
-  # 
+  def self.get_diffs(a, b)
+    call({})
+    Diff::LCS.diff(a, b)
+  end
 
   def self.log_diff(a, b)
-    require "diff/lcs"
-
-    # Compute the diff
-    diffs = Diff::LCS.diff(a, b)
+    diffs = get_diffs(a, b)
     puts
     # Output the diff in a format similar to git diff
     diffs.each do |diff|
       diff.each do |change|
         # If it's a deletion (present in old but not in new)
         if change.action == "-"
-          puts "- #{change.element.chomp.red}"
+          puts "- #{stick change.element.chomp, :light_red}"
         # If it's an addition (present in new but not in old)
         elsif change.action == "+"
-          puts "+ #{change.element.chomp.green}"
+          puts "+ #{stick change.element.chomp, :light_green}"
         end
       end
     end
     puts
   end
-  
+
 end

data/lib/dev_system/subsystems/generator/gem_shells/difflcs_gem_shell_test.rb

@@ -0,0 +1,10 @@
+class DevSystem::DifflcsGemShellTest < DevSystem::GemShellTest
+
+  section :subject
+
+  test :subject_class, :subject do
+    assert_equality subject_class, DevSystem::DifflcsGemShell
+    assert_equality subject.class, DevSystem::DifflcsGemShell
+  end
+
+end

data/lib/dev_system/subsystems/generator/generator.rb

@@ -0,0 +1,7 @@
+class DevSystem::Generator < Liza::Controller
+
+  def self.get_generator_signatures()= []
+
+  part :command_shortcut, :controller
+
+end

data/lib/dev_system/subsystems/generator/generator_panel.rb

@@ -0,0 +1,51 @@
+class DevSystem::GeneratorPanel < Liza::Panel
+  
+  part :command_shortcut, :panel
+
+  section :default
+  
+  def call(command_menv)
+    menv = forge command_menv
+    forge_shortcut menv
+    find menv
+    find_shortcut menv
+    forward menv
+    inform menv
+    save menv
+  end
+
+  #
+  
+  def forge command_menv
+    command = command_menv[:command]
+    generator_name_original, generator_action_original = command.args.first.to_s.split(":")
+
+    menv = { controller: :generator, command:, generator_name_original:, generator_action_original: }
+
+    log :high, "generator_name_original:generator_action_original is #{generator_name_original}:#{generator_action_original}"
+    menv
+  end
+  
+  #
+
+  def inform menv
+    if log_level? :high
+      puts
+      log "menv.count is #{menv.count}"
+    end
+    menv[:generator] or return log :higher, "not implemented"
+    menv[:generator].inform
+  end
+
+  #
+
+  def save menv
+    if log_level? :high
+      puts
+      log "menv.count is #{menv.count}"
+    end
+    menv[:generator] or return log :higher, "not implemented"
+    menv[:generator].save
+  end
+
+end