lizarb 1.0.3 → 1.0.5

data/lib/dev_system/{dev/controllers/shell → sub/shell/shells}/dir_shell_test.rb

@@ -5,8 +5,7 @@ class DevSystem::DirShellTest < DevSystem::FileShellTest
   end
 
   test :settings do
-    assert subject_class.log_level == :normal
-    assert subject_class.log_color == :green
+    assert_equality subject_class.log_level, 0
   end
 
   #
@@ -23,12 +22,10 @@ class DevSystem::DirShellTest < DevSystem::FileShellTest
 
   test :subject_class, :exist?, true do
     assert subject_class.exist? Dir.pwd
-    assert subject_class.exist? Liza::Shell.source_location_radical
   end
 
   test :subject_class, :exist?, false do
     refute subject_class.exist? "does_not_exist"
-    refute subject_class.exist? Liza::DirShell.source_location_radical
   end
 
   test :subject_class, :size, :raise do
@@ -47,7 +44,6 @@ class DevSystem::DirShellTest < DevSystem::FileShellTest
 
   test :subject_class, :size, true do
     assert subject_class.size(Dir.pwd).positive?
-    assert subject_class.size(Liza::Shell.source_location_radical).positive?
   end
 
   #

data/lib/dev_system/{dev/controllers/shell → sub/shell/shells}/file_shell.rb

@@ -4,14 +4,14 @@ class DevSystem::FileShell < DevSystem::Shell
     raise ArgumentError, "Path is required" if path.nil? || path.to_s.empty?
   end
 
-  def self._raise_if_not_exists path
-    raise ArgumentError, "File does not exist at '#{path}'" unless exist? path
+  def self._raise_if_not_exists path, log_level: self.log_level
+    raise ArgumentError, "File does not exist at '#{path}'" unless exist?(path, log_level: log_level)
   end
 
   #
 
-  def self.exist? path
-    log :normal, "Checking if file exists at '#{path}'"
+  def self.exist? path, log_level: self.log_level
+    log log_level, "Checking if file exists at '#{path}'"
     _raise_if_blank path
 
     File.exist? path

data/lib/dev_system/{dev/controllers/shell → sub/shell/shells}/file_shell_test.rb

@@ -31,8 +31,7 @@ class DevSystem::FileShellTest < DevSystem::ShellTest
   end
 
   test :settings do
-    assert subject_class.log_level == :normal
-    assert subject_class.log_color == :green
+    assert_equality subject_class.log_level, 0
   end
 
   #

data/lib/dev_system/sub/shell/shells/gem_shell.rb

@@ -0,0 +1,21 @@
+class DevSystem::GemShell < DevSystem::Shell
+  
+  # 
+
+  def gemspec
+    Gem::Specification.load "lizarb.gemspec"
+  end
+
+  def gemspecs
+    Dir["*.gemspec"].map { _1.split("/").last.split(".").first }
+  end
+    
+  def gemfile_path
+    Pathname ENV["BUNDLE_GEMFILE"]
+  end
+
+  def gemfile_writable?
+    gemfile_path.to_s.start_with? App.root.to_s
+  end
+
+end

data/lib/dev_system/sub/shell/shells/gem_shell_test.rb

@@ -0,0 +1,28 @@
+class DevSystem::GemShellTest < DevSystem::ShellTest
+  
+  # 
+  
+  test :subject_class, :subject do
+    assert_equality DevSystem::GemShell, subject_class
+    assert_equality DevSystem::GemShell, subject.class
+  end
+
+  test :subject_class, :gemspec do
+    assert_equality subject.gemspec.class, Gem::Specification
+  end
+
+  test :subject_class, :gemspecs do
+    assert_equality subject.gemspecs.class, Array
+  end
+
+  test :subject_class, :gemfile_path do
+    assert_equality subject.gemfile_path.class, Pathname
+    assert subject.gemfile_path.to_s.end_with? "Gemfile"
+  end
+
+  test :subject_class, :gemfile_writable? do
+    c = subject.gemfile_writable?.class
+    assert c == TrueClass or c == FalseClass
+  end
+  
+end

data/lib/dev_system/sub/shell/shells/kernel_shell.rb

@@ -0,0 +1,22 @@
+class DevSystem::KernelShell < DevSystem::Shell
+  
+  # 
+
+  def self.call_backticks(command, log_level: :lower)
+    log log_level, "#{stick command, DevSystem.color} | executing and outputting result"
+    result = `#{command}`
+    puts result if log? log_level
+    result
+  end
+
+  #
+
+  def self.call_system(command, log_level: :normal)
+    log log_level, "#{command} | executing"
+    success = Kernel.system(command)
+    message = success ? (stick :green, "successfully") : (stick :red, "failed")
+    log log_level, "Command executed #{message}"
+    success
+  end
+
+end

data/lib/dev_system/sub/shell/shells/kernel_shell_test.rb

@@ -0,0 +1,10 @@
+class DevSystem::KernelShellTest < DevSystem::ShellTest
+  
+  # 
+  
+  test :subject_class, :subject do
+    assert_equality DevSystem::KernelShell, subject_class
+    assert_equality DevSystem::KernelShell, subject.class
+  end
+
+end

data/lib/dev_system/sub/shell/shells/line_diff_shell.rb

@@ -0,0 +1,26 @@
+class DevSystem::LineDiffShell < DevSystem::Shell
+
+  # 
+
+  def self.log_diff(a, b)
+    require "diff/lcs"
+
+    # Compute the diff
+    diffs = Diff::LCS.diff(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}"
+        # If it's an addition (present in new but not in old)
+        elsif change.action == "+"
+          puts "+ #{change.element.chomp.green}"
+        end
+      end
+    end
+    puts
+  end
+  
+end

data/lib/dev_system/sub/shell/shells/line_diff_shell_test.rb

@@ -0,0 +1,11 @@
+class DevSystem::LineDiffShellTest < DevSystem::ShellTest
+
+  test :subject_class do
+    assert_equality subject_class, DevSystem::LineDiffShell
+  end
+
+  test :settings do
+    assert_equality subject_class.log_level, 0
+  end
+
+end

data/lib/dev_system/sub/shell/shells/line_shell.rb

@@ -0,0 +1,56 @@
+class DevSystem::LineShell < DevSystem::Shell
+
+  #
+
+  def self.extract_wall_of(lines, string)
+    ret = []
+
+    state = nil
+    lines.each do |line|
+      if state == :entered_region
+        if line.start_with? string
+          ret << line
+        else
+          break
+        end
+      else
+        if line.start_with? string
+          state = :entered_region
+          ret << line
+        end
+      end
+    end
+
+    ret
+  end
+
+  #
+
+  def self.replace_wall_of(lines, string, with)
+    ret = []
+    
+    state = nil
+    lines.each do |line|
+
+      if state == :entered_region
+        if line.start_with? string
+          #
+        else
+          ret << line
+          state = nil
+        end
+      else
+        if line.start_with? string
+          ret += with
+          state = :entered_region
+        else
+          ret << line
+        end
+      end
+
+    end
+
+    ret
+  end
+  
+end

data/lib/dev_system/sub/shell/shells/line_shell_test.rb

@@ -0,0 +1,70 @@
+class DevSystem::LineShellTest < DevSystem::ShellTest
+
+  test :subject_class do
+    assert_equality subject_class, DevSystem::LineShell
+  end
+
+  test :settings do
+    assert_equality subject_class.log_level, 0
+  end
+
+  #
+
+  def get_wall_lines
+    lines = render!(:wall, format: :txt).split("\n")
+    assert_equality lines.count, 9, kaller: caller
+    lines
+  end
+
+  group do
+    before do
+      @lines = get_wall_lines
+    end
+
+    #
+
+    test :subject_class, :extract_wall_of do
+      expected_lines = render!(:wall_extract_wall_of, format: :txt).split("\n")
+  
+      new_lines = subject_class.extract_wall_of @lines, "bbb"
+      assert_equality new_lines, expected_lines
+    end
+  
+    #
+  
+    test :subject_class, :replace_wall_of do
+      expected_lines = render!(:wall_replace_wall_of, format: :txt).split("\n")
+  
+      new_lines = subject_class.replace_wall_of @lines, "bbb", ["bbb 123"]
+      assert_equality new_lines, expected_lines
+    end
+  end
+
+end
+
+__END__
+
+# view wall.txt.erb
+aaa 111
+aaa 222
+aaa 333
+bbb 444
+bbb 555
+bbb 666
+ccc 777
+ccc 888
+ccc 999
+
+# view wall_extract_wall_of.txt.erb
+bbb 444
+bbb 555
+bbb 666
+
+# view wall_replace_wall_of.txt.erb
+aaa 111
+aaa 222
+aaa 333
+bbb 123
+ccc 777
+ccc 888
+ccc 999

data/lib/dev_system/sub/shell/shells/method_shell.rb

@@ -0,0 +1,52 @@
+class DevSystem::MethodShell < DevSystem::Shell
+  class NotFoundError < Error; end
+
+  #
+
+  def self.signature_has_single_parameter_named?(object, method_name, arg_name)
+    return false unless object.respond_to? method_name
+    new(object, method_name).signature_has_single_parameter_named?(arg_name)
+  end
+
+  #
+
+  attr_reader :object, :method_name
+
+  def initialize(object, method_name)
+    super()
+    @object = object
+    @method_name = method_name
+    
+    @method = object.method method_name
+  rescue NameError
+    raise NotFoundError, "method not found: #{method_name.inspect}", caller
+  end
+
+  #
+  
+  def method(sym=nil)
+    return super if sym
+    @method
+  end
+
+  #
+
+  def line
+    @line ||= File.readlines(@method.source_location[0])[@method.source_location[1] - 1].strip
+  end
+
+  def line_location
+    @line_location ||= begin
+      path = @method.source_location[0].gsub(App.root.to_s, "")[1..-1]
+      line_number = @method.source_location[1]
+      "#{path}:#{line_number}"
+    end
+  end
+
+  #
+
+  def signature_has_single_parameter_named?(name)
+    @method.parameters == [[:req, name]]
+  end
+
+end

data/lib/dev_system/sub/shell/shells/method_shell_test.rb

@@ -0,0 +1,34 @@
+class DevSystem::MethodShellTest < DevSystem::ShellTest
+
+  test :subject_class do
+    assert_equality subject_class, DevSystem::MethodShell
+  end
+
+  test :settings do
+    assert_equality subject_class.log_level, 0
+  end
+
+  #
+
+  test :subject, false do
+    subject = subject_class.new FileShell, :abc
+    assert false
+  rescue DevSystem::MethodShell::NotFoundError
+    assert true
+  end
+
+  test :subject, :method, :line, :line_location, :signature_has_single_parameter_named? do
+    subject = subject_class.new FileShell, :touch
+    assert_equality subject.method, FileShell.method(:touch)
+
+    assert_equality subject.object, FileShell
+    assert_equality subject.method_name, :touch
+
+    assert_equality subject.line, "def self.touch path"
+    assert_equality subject.line_location, "lib/dev_system/sub/shell/shells/file_shell.rb:45"
+
+    assert subject.signature_has_single_parameter_named? :path
+    refute subject.signature_has_single_parameter_named? :wrong
+  end
+
+end

data/lib/dev_system/sub/shell/shells/text_file_shell.rb

@@ -0,0 +1,14 @@
+class DevSystem::TextFileShell < DevSystem::FileShell
+
+  #
+
+  attr_reader :old_lines, :relative_path, :path
+  attr_accessor :new_lines
+
+  def initialize(path)
+    @path = Pathname(path)
+    @relative_path = Pathname(path).relative_path_from(App.root)
+    @old_lines = TextShell.read_lines path
+  end
+
+end

data/lib/dev_system/sub/shell/shells/text_file_shell_test.rb

@@ -0,0 +1,11 @@
+class DevSystem::TextFileShellTest < DevSystem::FileShellTest
+
+  test :subject_class do
+    assert_equality subject_class, DevSystem::TextFileShell
+  end
+
+  test :settings do
+    assert_equality subject_class.log_level, 0
+  end
+
+end

data/lib/dev_system/sub/shell/shells/text_shell.rb

@@ -0,0 +1,65 @@
+class DevSystem::TextShell < DevSystem::FileShell
+
+  #
+    
+  set :create_dir, true
+  
+  def self.write path, content, create_dir: nil, log_level: self.log_level
+    log log_level, "Writing #{content.to_s.size} characters (#{content.encoding}) to #{path}"
+    _raise_if_blank path
+
+    create_dir = get :create_dir if create_dir.nil?
+    DevSystem::DirShell.create File.dirname(path), log_level: log_level if create_dir
+
+    File.write path, content
+  end
+
+  #
+  
+  def self.read path, log_level: self.log_level
+    log log_level, "Reading #{path}"
+    _raise_if_blank path
+    _raise_if_not_exists path, log_level: log_level
+
+    File.read path
+  end
+
+  def self.read_lines path, log_level: self.log_level
+    log log_level, "Reading lines from #{path}"
+    return [] unless exist? path
+
+    File.readlines path
+  end
+
+  def self.read_lines! path, log_level: self.log_level
+    log log_level, "Reading lines from #{path}"
+    _raise_if_blank path
+    _raise_if_not_exists path
+
+    File.readlines path
+  end
+
+  #
+
+  def self.append_line_after_last_including(path:, newline:, after:)
+    log "Appending to #{path}"
+    state = nil
+    lines = File.readlines(path)
+    File.open(path, "w") do |out|
+      lines.each do |line|
+        state = :entered_systems_region if state == nil && line =~ after
+        state = :left_systems_region if state == :entered_systems_region && line !~ after
+        
+        if state == :left_systems_region
+          out.write("#{newline}\n")
+          log :low, newline.strip.green
+          state = :done
+        end
+        
+        out.write(line)
+        log :low, line.strip.light_black
+      end
+    end
+  end
+
+end

data/lib/dev_system/{dev/controllers/shell → sub/shell/shells}/text_shell_test.rb

@@ -5,8 +5,7 @@ class DevSystem::TextShellTest < DevSystem::FileShellTest
   end
 
   test :settings do
-    assert subject_class.log_level == :normal
-    assert subject_class.log_color == :green
+    assert_equality subject_class.log_level, 0
   end
 
   #

data/lib/dev_system.rb

@@ -1,8 +1,14 @@
 class DevSystem < Liza::System
-  class Error < Liza::Error; end
+  class Error < Error; end
 
   #
 
-  set :log_color, :green
+  color :light_green
 
+  sub :bench
+  sub :command
+  sub :generator
+  sub :log
+  sub :shell
+  
 end

data/lib/happy_system/happy_box.rb

@@ -0,0 +1,9 @@
+class HappySystem::HappyBox < Liza::Box
+
+  # Preconfigure your axo panel
+
+  configure :axo do
+    # 
+  end
+
+end

data/lib/happy_system/happy_box_test.rb

@@ -0,0 +1,24 @@
+class HappySystem::HappyBoxTest < Liza::BoxTest
+
+  test :subject_class do
+    assert subject_class == HappySystem::HappyBox
+  end
+
+  test_methods_defined do
+    on_self
+    on_instance
+  end
+
+  test :settings do
+    assert_equality subject_class.log_level, 0
+  end
+
+  test :panels do
+    a = subject_class.panels.keys
+    b = [:axo]
+    assert_equality a, b
+    
+    assert_sub :axo, HappySystem::Axo, HappySystem::AxoPanel
+  end
+
+end

data/lib/happy_system/sub/axo/axo.rb

@@ -0,0 +1,10 @@
+class HappySystem::Axo < Liza::Controller
+
+  def self.call(env)
+    log :low, "env.count is #{env.count}"
+    new.tap { _1.env = env }.call(env[:args])
+  end
+
+  attr_accessor :env
+
+end

data/lib/happy_system/sub/axo/axo_panel.rb

@@ -0,0 +1,9 @@
+class HappySystem::AxoPanel < Liza::Panel
+
+  def call(env)
+    log :low, "env.count is #{env.count}"
+    env[:args] = Array env[:args][1..-1]
+    env[:axo].call env
+  end
+
+end

data/lib/happy_system/sub/axo/axo_panel_test.rb

@@ -0,0 +1,16 @@
+class HappySystem::AxoPanelTest < Liza::PanelTest
+
+  test :subject_class do
+    assert subject_class == HappySystem::AxoPanel
+  end
+
+  test_methods_defined do
+    on_self
+    on_instance :call
+  end
+
+  test :settings do
+    assert_equality subject_class.log_level, 0
+  end
+  
+end

data/lib/happy_system/sub/axo/axo_test.rb

@@ -0,0 +1,16 @@
+class HappySystem::AxoTest < Liza::ControllerTest
+
+  test :subject_class do
+    assert subject_class == HappySystem::Axo
+  end
+
+  test_methods_defined do
+    on_self :call
+    on_instance :env, :env=
+  end
+
+  test :settings do
+    assert_equality subject_class.log_level, 0
+  end
+
+end

data/lib/happy_system/sub/axo/commands/axo_command.rb

@@ -0,0 +1,40 @@
+class HappySystem::AxoCommand < DevSystem::SimpleCommand
+  
+  #
+
+  def call_default
+    find!
+
+    env[:axo] = @axo
+    HappyBox[:axo].call(env)
+
+    log "done at #{Time.now}"
+  end
+
+  def find!
+    @name = simple_args[0]
+
+    if @name
+      @axo = Liza.const "#{@name}_axo"
+      return
+    end
+
+    @axo = pick_axo
+    @name = @axo.last_namespace.snakecase
+  ensure
+    log :high, "@name = #{@name}"
+    log :high, "@axo = #{@axo}"
+  end
+
+  def pick_axo
+    axos = Axo.descendants
+    options = axos.sort_by(&:last_namespace).map do |axo|
+      [
+        "#{axo.last_namespace.snakecase.ljust 30} - #{axo} - #{(axo.get :description) || "No description."}",
+        axo
+      ]
+    end.to_h
+    TtyInputCommand.pick_one "Pick an Axolotl ASCII Animation to run", options
+  end
+
+end

data/lib/happy_system/sub/axo/commands/axo_command_test.rb

@@ -0,0 +1,8 @@
+class HappySystem::AxoCommandTest < DevSystem::SimpleCommandTest
+  
+  test :subject_class, :subject do
+    assert_equality HappySystem::AxoCommand, subject_class
+    assert_equality HappySystem::AxoCommand, subject.class
+  end
+
+end