lizarb 1.0.4 → 1.0.6

data/lib/dev_system/subsystems/shell/shells/gemspec_shell.rb

@@ -0,0 +1,21 @@
+class DevSystem::GemspecShell < 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/subsystems/shell/shells/gemspec_shell_test.rb

@@ -0,0 +1,28 @@
+class DevSystem::GemspecShellTest < DevSystem::ShellTest
+  
+  # 
+  
+  test :subject_class, :subject do
+    assert_equality DevSystem::GemspecShell, subject_class
+    assert_equality DevSystem::GemspecShell, 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/subsystems/shell/shells/kernel_shell.rb

@@ -0,0 +1,26 @@
+class DevSystem::KernelShell < DevSystem::Shell
+  
+  # 
+
+  def self.call_backticks(command, log_level: :normal)
+    t = Time.now
+    log log_level, "#{stick command, DevSystem.color} | returns a string | executing..."
+    result = Kernel.send :`, command
+  ensure
+    log log_level, "#{t.diff}s | executed with an output of #{"#{result.size} bytes" if result}#{result.inspect unless result} |"
+    puts result if log? log_level
+  end
+
+  #
+
+  def self.call_system(command, log_level: :normal)
+    t = Time.now
+    log log_level, "#{command} | returns a boolean | executing..."
+    success = Kernel.system(command)
+    success
+  ensure
+    message = success ? (stick :green, "successfully") : (stick :red, "failed")
+    log log_level, "#{t.diff}s | #{message}"
+  end
+
+end

data/lib/dev_system/subsystems/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/subsystems/shell/shells/line_diff_shell.rb

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

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

@@ -0,0 +1,7 @@
+class DevSystem::LineDiffShellTest < DevSystem::ShellTest
+
+  test :subject_class do
+    assert_equality subject_class, DevSystem::LineDiffShell
+  end
+
+end

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

@@ -0,0 +1,104 @@
+class DevSystem::LineShell < DevSystem::Shell
+
+  section :wall_of
+
+  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
+
+  section :between
+
+  def self.extract_between(lines, range)
+    ret = []
+
+    state = nil
+    lines.each do |line|
+      if state == :entered_region
+        if line.start_with? range.max
+          break
+        else
+          ret << line
+        end
+      else
+        if line.start_with? range.min
+          state = :entered_region
+        end
+      end
+    end
+
+    ret
+  end
+
+  def self.replace_between(lines, range, with, stop_at="__END__")
+    ret = []
+
+    state = nil
+    ignoring = false
+    lines.each do |line|
+      if state == :entered_region
+        if line.start_with? range.max
+          ret += with
+          state = nil
+        end
+      else
+        if line.start_with? range.min
+          state = :entered_region
+          ret << line
+        end
+      end unless ignoring
+
+      ret << line unless state == :entered_region
+      ignoring = true if line.start_with? stop_at
+    end
+
+    ret
+  end
+  
+end

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

@@ -0,0 +1,102 @@
+class DevSystem::LineShellTest < DevSystem::ShellTest
+
+  test :subject_class do
+    assert_equality subject_class, DevSystem::LineShell
+  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
+
+  group do
+    before do
+      @lines = get_wall_lines
+    end
+
+    #
+
+    test :subject_class, :extract_between do
+      expected_lines = ["bbb 444", "bbb 555", "bbb 666"]
+      range = "aaa 333".."ccc 777"
+
+      extracted_lines = subject_class.extract_between(@lines, range)
+      assert_equality extracted_lines, expected_lines
+    end
+
+    #
+
+    test :subject_class, :replace_between do
+      expected_lines = [
+        "aaa 111",
+        "aaa 222",
+        "aaa 333",
+        "new line 1",
+        "new line 2",
+        "ccc 777",
+        "ccc 888",
+        "ccc 999"
+      ]
+      range = "aaa 333".."ccc 777"
+      new_content = ["new line 1", "new line 2"]
+
+      replaced_lines = subject_class.replace_between(@lines, range, new_content)
+      assert_equality replaced_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/subsystems/shell/shells/main_shell.rb

@@ -0,0 +1,29 @@
+# DevSystem::MainShell is a functional wrapper for advanced use cases related to main.
+class DevSystem::MainShell < DevSystem::Shell
+
+  def self.main
+    $main
+  end
+
+  def self.easy!
+    easy_constants!
+    easy_log!
+  end
+
+  def self.easy_constants!
+    puts
+    log "Object.const_missing now delegates to Liza.const_missing"
+    puts
+    proc = Liza.method(:const_missing)
+    main.define_singleton_method :const_missing, &proc
+  end
+
+  def self.easy_log!
+    m = main
+    def m.log(...)=       DevSystem::MainShell.log(...)
+    def m.log_array(...)= DevSystem::MainShell.log_array(...)
+    def m.log_hash(...)=  DevSystem::MainShell.log_hash(...)
+    def m.stick(...)=     DevSystem::MainShell.stick(...)
+  end
+  
+end

data/lib/dev_system/subsystems/shell/shells/main_shell_test.rb

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

data/lib/dev_system/subsystems/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/subsystems/shell/shells/method_shell_test.rb

@@ -0,0 +1,30 @@
+class DevSystem::MethodShellTest < DevSystem::ShellTest
+
+  test :subject_class do
+    assert_equality subject_class, DevSystem::MethodShell
+  end
+
+  #
+
+  test :subject, false do
+    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 BaseGenerator, :call
+    assert_equality subject.method, BaseGenerator.method(:call)
+
+    assert_equality subject.object, BaseGenerator
+    assert_equality subject.method_name, :call
+
+    assert_equality subject.line, "def self.call(menv)"
+    assert_equality subject.line_location, "lib/dev_system/subsystems/generator/generators/base_generator.rb:5"
+
+    assert subject.signature_has_single_parameter_named? :menv
+    refute subject.signature_has_single_parameter_named? :wrong
+  end
+
+end

data/lib/dev_system/subsystems/shell/shells/signal_shell.rb

@@ -0,0 +1,53 @@
+class DevSystem::SignalShell < DevSystem::Shell
+
+  # {"EXIT"=>0, "INT"=>2, "ILL"=>4, ...}
+  def self.list
+    ::Signal.list.sort_by { _2 }.to_h
+  end
+
+  def self.trap(signal, &block)
+    Trap.find(signal).push block
+
+    true
+  end
+
+  def self.traps() = @traps ||= {}
+
+  def self.trap_interrupt(&block)
+    trap("INT", &block)
+  end
+
+  def self.trap_kill(&block)
+    trap("KILL", &block)
+  end
+
+  class Trap
+    
+    def self.find(signal)
+      @traps ||= {}
+      @traps[signal] ||= new(signal)
+    end
+
+    def initialize(signal)
+      @blocks = []
+      ::Signal.trap(signal) do
+        puts "\nSignal.trap(#{signal.inspect})"
+        puts "# Control-C pressed. #{@blocks.count} blocks to run..." if signal == "INT"
+        call
+        if signal == "INT"
+          puts "# Exiting with status 1..."
+          exit 1
+        end
+      end
+    end
+
+    def push (block) = @blocks.push block
+
+    def call
+      @blocks.each do |block|
+        block.call
+      end
+    end
+  end
+
+end

data/lib/dev_system/subsystems/shell/shells/signal_shell_test.rb

@@ -0,0 +1,28 @@
+class DevSystem::SignalShellTest < DevSystem::ShellTest
+
+  section :subject
+
+  test :subject_class, :subject do
+    assert_equality subject_class, DevSystem::SignalShell
+    assert_equality subject.class, DevSystem::SignalShell
+  end
+
+  test :list do
+    assert_equality subject_class.list, expected_linux_list if Shell.linux?
+    assert_equality subject_class.list, expected_mac_list if Shell.mac?
+    assert_equality subject_class.list, expected_windows_list if Shell.windows?
+  end
+
+  def expected_linux_list
+    {"EXIT"=>0, "HUP"=>1, "INT"=>2, "QUIT"=>3, "ILL"=>4, "TRAP"=>5, "ABRT"=>6, "IOT"=>6, "BUS"=>7, "FPE"=>8, "KILL"=>9, "USR1"=>10, "SEGV"=>11, "USR2"=>12, "PIPE"=>13, "ALRM"=>14, "TERM"=>15, "CLD"=>17, "CHLD"=>17, "CONT"=>18, "STOP"=>19, "TSTP"=>20, "TTIN"=>21, "TTOU"=>22, "URG"=>23, "XCPU"=>24, "XFSZ"=>25, "VTALRM"=>26, "PROF"=>27, "WINCH"=>28, "IO"=>29, "POLL"=>29, "PWR"=>30, "SYS"=>31}
+  end
+
+  def expected_mac_list
+    {"EXIT"=>0, "HUP"=>1, "INT"=>2, "QUIT"=>3, "ILL"=>4, "TRAP"=>5, "ABRT"=>6, "IOT"=>6, "EMT"=>7, "FPE"=>8, "KILL"=>9, "BUS"=>10, "SEGV"=>11, "SYS"=>12, "PIPE"=>13, "ALRM"=>14, "TERM"=>15, "URG"=>16, "STOP"=>17, "TSTP"=>18, "CONT"=>19, "CHLD"=>20, "CLD"=>20, "TTIN"=>21, "TTOU"=>22, "IO"=>23, "XCPU"=>24, "XFSZ"=>25, "VTALRM"=>26, "PROF"=>27, "WINCH"=>28, "INFO"=>29, "USR1"=>30, "USR2"=>31}
+  end
+
+  def expected_windows_list
+    {"EXIT"=>0, "INT"=>2, "ILL"=>4, "FPE"=>8, "KILL"=>9, "SEGV"=>11, "TERM"=>15, "ABRT"=>22}
+  end
+
+end

data/lib/dev_system/subsystems/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/subsystems/shell/shells/text_file_shell_test.rb

@@ -0,0 +1,7 @@
+class DevSystem::TextFileShellTest < DevSystem::FileShellTest
+
+  test :subject_class do
+    assert_equality subject_class, DevSystem::TextFileShell
+  end
+
+end

data/lib/dev_system/subsystems/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 :high, (stick :light_green, newline.strip)
+          state = :done
+        end
+        
+        out.write(line)
+        log :high, (stick :onyx, line.strip)
+      end
+    end
+  end
+
+end

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

@@ -4,11 +4,6 @@ class DevSystem::TextShellTest < DevSystem::FileShellTest
     assert subject_class == DevSystem::TextShell
   end
 
-  test :settings do
-    assert subject_class.log_level == :normal
-    assert subject_class.log_color == :green
-  end
-
   #
 
   test :subject_class, :read, true do

data/lib/dev_system/subsystems/shell/soft_shells/soft_shell.rb

@@ -0,0 +1,4 @@
+class DevSystem::SoftShell < DevSystem::Shell
+  division!
+
+end

data/lib/dev_system/subsystems/shell/soft_shells/soft_shell_test.rb

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

data/lib/dev_system/subsystems/shell/view_shells/logo_view_shell.rb

@@ -0,0 +1,12 @@
+class DevSystem::LogoViewShell < DevSystem::ViewShell
+
+  def self.get_svg
+    new.get_svg
+  end
+
+  def get_svg
+    @pallet = ["#005623", "#4fa63e", "#348b35"]
+    render :logo, format: :svg
+  end
+
+end