lizarb 1.0.5 → 1.0.6

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

@@ -0,0 +1,113 @@
+class DevSystem::AppShellTest < DevSystem::ShellTest
+
+  test :subject_class do
+    assert_equality subject_class, DevSystem::AppShell
+  end
+
+  test :writable_systems do
+    a = subject_class.writable_systems.keys
+    b = [:dev, :happy, :net, :web, :work, :micro, :desk, :crypto, :media, :art, :deep, :prime, :lab, :eco]
+    assert_equality a, b
+  end
+
+  test :get_writable_domains do
+    expected = {
+      "core"=>"Core",
+      "dev"=>DevSystem,
+      "happy"=>HappySystem,
+      "net"=>NetSystem,
+      "web"=>WebSystem,
+      "work"=>WorkSystem,
+      "micro"=>MicroSystem,
+      "desk"=>DeskSystem,
+      "crypto"=>CryptoSystem,
+      "media"=>MediaSystem,
+      "art"=>ArtSystem,
+      "deep"=>DeepSystem,
+      "prime"=>PrimeSystem,
+      "lab"=>LabSystem,
+      "eco"=>EcoSystem,
+      "app"=>"App"
+    }
+
+    assert_equality subject_class.get_writable_domains, expected
+  end
+
+  test :subject do
+    system_keys = ["dev", "happy", "net", "web", "work", "micro", "desk", "crypto", "media", "art", "deep", "prime", "lab", "eco"]
+    assert_equality subject.consts.keys,           [:top_level, :liza, :systems, :app]
+    assert_equality subject.consts[:top_level],    [Lizarb, App, Liza]
+    assert_equality subject.consts[:liza].keys,    ["unit", "helper_units", "systemic_units", "subsystemic_units", "extra_tests"]
+    assert_equality subject.consts[:systems].keys, system_keys
+    assert_equality subject.consts[:app].keys,     system_keys
+  end
+
+  test :get_liza_categories do
+    assert_equality subject.get_liza_categories.count, 5
+  end
+
+  test :others do
+    assert_no_raise do
+      subject.sorted_units
+      subject.sorted_writable_units
+      subject.sorted_writable_units_in_systems
+    end
+  end
+
+  test :filters do
+    assert_equality subject.filter_history.count, 0
+    
+    c0 = subject.get_units.count
+    subject.filter_by_systems :dev
+    assert_lt subject.get_units.count, c0
+    assert_equality subject.filter_history.count, 1
+
+    c1 = subject.get_units.count
+    subject.filter_by_starting_with "gene"
+    assert_lt subject.get_units.count, c1
+    assert_equality subject.filter_history.count, 2
+
+    subject.undo_filter!
+    assert_equality subject.get_units.count, c1
+    assert_equality subject.filter_history.count, 1
+
+    subject.undo_filter!
+    assert_equality subject.get_units.count, c0
+    assert_equality subject.filter_history.count, 0
+  end
+
+  test :domain, :layer do
+    layers = subject.get_layers_for_core
+    assert_gt layers.count, 0
+    
+    assert_equality layers[0].color, :white
+    assert_equality layers[0].level, 1
+    assert_equality layers[0].name, "top level"
+    assert_equality layers[0].objects.count, 3
+    assert_equality layers[0].path, "lib/"
+
+    #
+
+    layers = subject.get_layers_for_system DevSystem
+    assert_gt layers.count, 0
+
+    assert_equality layers[0].color, :green
+    assert_equality layers[0].level, 1
+    assert_equality layers[0].name, "DevSystem"
+    assert_equality layers[0].objects.count, 4
+    assert_equality layers[0].path, "lib/dev_system"
+
+    #
+    
+    layers = subject.get_layers_for_app
+    assert_gt layers.count, 0
+
+    assert_equality layers[0].color, :green
+    assert_equality layers[0].level, 1
+    assert_equality layers[0].name, "App"
+    assert_equality layers[0].objects.count, 0
+    assert_equality layers[0].path, "app/"
+
+  end
+
+end

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

@@ -4,10 +4,6 @@ class DevSystem::BinShellTest < DevSystem::FileShellTest
     assert subject_class == DevSystem::BinShell
   end
 
-  test :settings do
-    assert_equality subject_class.log_level, 0
-  end
-
   #
 
   test :subject_class, :read, :raise do

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

@@ -0,0 +1,87 @@
+class DevSystem::ControllerShell < DevSystem::Shell
+
+  #
+  
+  def self.places_for(controller, directory_name: controller.plural)
+    ret = {
+      "app" => "#{App.relative_path}/#{controller.system.token}/#{directory_name}",
+    }
+
+    AppShell.writable_systems.each do |system_key, system|
+      path = system.source_location_radical.sub "#{App.root}/", ""
+      ret[system_key.to_s] = "#{path}/#{directory_name}"
+      system.subs.each do |sub|
+        ret["#{system_key}/#{sub}"] = "#{path}/subsystems/#{sub}/#{directory_name}"
+      end
+    end
+
+    ret
+  end
+
+  def self.places_for_systems(controller_name)
+    ret = {}
+
+    AppShell.writable_systems.each do |system_key, system|
+      path = system.source_location_radical.gsub "#{App.root}/", ""
+      ret[system_key.to_s] = "#{path}/subsystems/#{controller_name}"
+    end
+
+    ret
+  end
+
+  def self.path_for(place, name)
+    system_name, subsystem_name = place.split("/")
+    if system_name == "app"
+      App.directory / "A"
+    elsif subsystem_name
+      App.systems_directory / "B"
+    else
+      App.systems_directory / "#{system_name}_system" / "subsystems" / name
+    end
+  end
+
+  def self.place_for(controller)
+    path = controller.source_location_path
+    system = controller.system
+    if path.include? App.directory.to_s
+      path = path.sub(App.directory.to_s, '')
+      segments = path.split('/')
+      # ["", "dev", "commands", "color_command.rb"]
+      # :app
+      token = segments[3].split("_").last.sub(".rb", "")
+      "app/#{segments[1]}/#{token}"
+    elsif path.include? system.source_location_radical
+      path = path.sub(system.source_location_radical, '')
+      segments = path.split('/')
+      # 3 ["", "commands", "test_command"]
+      # 4 ["", "subsystems", "bench", "bench.rb"]
+      # 5 ["", "subsystems", "bench", "commands", "bench_command.rb"]
+      case segments.count
+      when 3
+        "#{system.token}"
+      when 4, 5
+        token = segments[2]
+        "#{system.token}/#{token}"
+      else
+        raise "unexpected path: #{path} with #{segments.count} segments"
+      end
+    else
+      segments = path.split('/')
+      "other #{segments}"
+    end
+  end
+
+  def self.unit_for(controller)
+    place = place_for(controller)
+    segments = place.split('/')
+    case segments.count
+    when 1
+      Liza.const "#{segments[0]}_system"
+    when 2, 3
+      Liza.const segments.last
+    else
+      raise "unexpected place: #{place}"
+    end
+  end
+
+end

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

@@ -0,0 +1,33 @@
+class DevSystem::ControllerShellTest < DevSystem::ShellTest
+
+  test :subject_class do
+    assert_equality subject_class, DevSystem::ControllerShell
+  end
+
+  test :places_for do
+    places = subject_class.places_for(Shell, directory_name: "shells")
+    assert_equality places.class, Hash
+
+    assert_equality places["app"],           "app/dev/shells"
+    assert_equality places["dev"],           "lib/dev_system/shells"
+    assert_equality places["dev/bench"],     "lib/dev_system/subsystems/bench/shells"
+    assert_equality places["dev/command"],   "lib/dev_system/subsystems/command/shells"
+    assert_equality places["dev/generator"], "lib/dev_system/subsystems/generator/shells"
+    assert_equality places["dev/log"],       "lib/dev_system/subsystems/log/shells"
+    assert_equality places["dev/shell"],     "lib/dev_system/subsystems/shell/shells"
+    assert_equality places["happy"],         "lib/happy_system/shells"
+
+    places = subject_class.places_for(Shell, directory_name: "gem_shells")
+    assert_equality places.class, Hash
+
+    assert_equality places["app"],           "app/dev/gem_shells"
+    assert_equality places["dev"],           "lib/dev_system/gem_shells"
+    assert_equality places["dev/bench"],     "lib/dev_system/subsystems/bench/gem_shells"
+    assert_equality places["dev/command"],   "lib/dev_system/subsystems/command/gem_shells"
+    assert_equality places["dev/generator"], "lib/dev_system/subsystems/generator/gem_shells"
+    assert_equality places["dev/log"],       "lib/dev_system/subsystems/log/gem_shells"
+    assert_equality places["dev/shell"],     "lib/dev_system/subsystems/shell/gem_shells"
+    assert_equality places["happy"],         "lib/happy_system/gem_shells"
+  end
+
+end

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

@@ -12,7 +12,7 @@ class DevSystem::DirShell < DevSystem::FileShell
     log log_level, "Getting size of directory at '#{path}'"
     _raise_if_not_exists path
 
-    Pathname.new(path).children.inject(0) { |sum, f| sum + f.size }
+    Pathname(path).children.inject(0) { |sum, f| sum + f.size }
   end
 
   # CUSTOM
@@ -21,7 +21,7 @@ class DevSystem::DirShell < DevSystem::FileShell
     log log_level, "Creating directory at '#{path}'"
     _raise_if_blank path
 
-    Pathname.new(path).mkpath
+    Pathname(path).mkpath
   end
 
 end

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

@@ -4,10 +4,6 @@ class DevSystem::DirShellTest < DevSystem::FileShellTest
     assert subject_class == DevSystem::DirShell
   end
 
-  test :settings do
-    assert_equality subject_class.log_level, 0
-  end
-
   #
 
   test :subject_class, :exist?, :raise do

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

@@ -0,0 +1,19 @@
+class DevSystem::EnvShell < DevSystem::Shell
+
+  define_error :mandatory do |args|
+    "Mandatory Environment Variable Not Found: #{args[0]}. Your .env files are: #{App.env_vars}"
+  end
+
+  def self.key?(key)
+    ENV.key? key
+  end
+
+  def self.optional(key, default = nil)
+    ENV[key] || default
+  end
+
+  def self.mandatory(key)
+    ENV[key] or raise_error :mandatory, key, kaller: caller
+  end
+
+end

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

@@ -0,0 +1,27 @@
+class DevSystem::EnvShellTest < DevSystem::ShellTest
+
+  section :subject
+
+  test :subject_class, :subject do
+    assert_equality subject_class, DevSystem::EnvShell
+    assert_equality subject.class, DevSystem::EnvShell
+  end
+
+  test :optional do
+    refute_equality nil, (subject_class.optional "BUNDLE_GEMFILE")
+    refute_equality nil, (subject_class.optional "BUNDLE_GEMFILE", nil)
+    assert_equality nil, (subject_class.optional "THIS_ENV_VAR_DOES_NOT_EXIST")
+    assert_equality "A", (subject_class.optional "THIS_ENV_VAR_DOES_NOT_EXIST", "A")
+  end
+
+  test :mandatory do
+    refute_equality nil, (subject_class.mandatory "BUNDLE_GEMFILE")
+    assert_raises(
+      DevSystem::EnvShell::MandatoryError,
+      "Mandatory Environment Variable Not Found: THIS_ENV_VAR_DOES_NOT_EXIST. Your .env files are: []"
+      ) do
+      subject_class.mandatory "THIS_ENV_VAR_DOES_NOT_EXIST"
+    end
+  end
+
+end

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

@@ -0,0 +1,168 @@
+class DevSystem::ErbShell < DevSystem::Shell
+
+  # https://docs.ruby-lang.org/en/3.2/ERB.html
+  Kernel.require "erb"
+
+  def self.load(path_radical)
+    LERB.load path_radical
+  end
+
+  $LERB_VERBOSE = ENV["LERB_VERBOSE"]
+
+  class LERB < ERB
+    class Error < StandardError; end
+    class BuildError < Error; end
+    class ExecutionError < Error; end
+  
+    # output
+  
+    def self.puts string=nil
+      super if $LERB_VERBOSE
+    end
+  
+    # loaders
+  
+    DEFAULT_KEY = "inline.txt.erb"
+  
+    def self.load path_radical
+      erbs = []
+  
+      "#{path_radical}.rb".tap do |filename|
+        _load erbs, filename, :eof
+      end
+  
+      Dir.glob("#{path_radical}.rb.*.erb").each do |filename|
+        _load erbs, filename, :adjacent
+      end
+  
+      Dir.glob("#{path_radical}/*.*.erb").each do |filename|
+        _load erbs, filename, :nested
+      end
+  
+      #
+  
+      puts "#{erbs.size} erbs"
+      erbs.each do |h|
+        puts "key: #{h.key}"
+      end
+  
+      erbs
+    end
+  
+    def self._load erbs, filename, views_type
+      is_eof = views_type == :eof
+      is_adjacent = views_type == :adjacent
+      is_nested = views_type == :nested
+
+      is_erb = filename.end_with? ".erb"
+      is_ignoring_ruby = is_eof
+      is_accepting_views = is_eof || is_adjacent
+      
+      puts
+      puts "LERB filename: #{filename}"
+      puts Liza::Unit.stick :red, "LERB views_type: :#{views_type}"
+      
+      puts "LERB is_eof: #{is_eof}"
+      puts "LERB is_adjacent: #{is_adjacent}"
+      puts "LERB is_nested: #{is_nested}"
+      puts "LERB is_erb: #{is_erb}"
+      puts "LERB is_ignoring_ruby: #{is_ignoring_ruby}"
+      puts "LERB is_accepting_views: #{is_accepting_views}"
+  
+      current_lineno = 0
+      current_content = ""
+      current_key = DEFAULT_KEY
+  
+      if is_nested
+        current_key = filename.split("/").last.split(".")[-3..-1].join(".")
+        puts "LERB declare: #{current_key} | because nested"
+      end
+  
+      File.readlines(filename).each.with_index do |line, lineno|
+        is_line_end = line == "__END__\n"
+  
+        # stop ignoring ruby lines if line is __END__
+        # move to next line if ignoring ruby lines
+  
+        if is_ignoring_ruby
+          puts "LERB ignore: #{lineno}: #{line[0..-2]}"
+          if is_line_end
+            is_ignoring_ruby = false
+            is_accepting_views = true
+            current_lineno = lineno + 1
+            puts "LERB declare: #{current_key} | current" if current_key
+          end
+          next
+        end
+  
+        if is_accepting_views && line[0..6] == "# view "
+          _load_into erbs, filename, current_lineno, current_key, current_content
+          current_key = line[7..-1].strip
+          current_lineno = lineno + 1
+          current_content = ""
+          puts "LERB declare: #{current_key} | #{lineno}: #{line[0..-2]}"
+        else
+          current_content += line
+          puts "LERB keeping: #{lineno}: #{line[0..-2]}"
+        end
+  
+        if is_line_end
+          puts "LERB warning: #{lineno}: #{line[0..-2]} found! No longer accepting views"
+          is_accepting_views = false
+        end
+      end
+  
+      _load_into erbs, filename, current_lineno, current_key, current_content
+  
+      erbs
+    end
+  
+    def self._load_into erbs, filename, lineno, key, content
+      return unless key
+      return unless key.end_with? "erb"
+      return if content.strip.empty?
+  
+      content += "\n" if content[-1] != "\n"
+  
+      erbs.push new filename, lineno, key, content
+    end
+  
+    # format
+  
+    TAG_FORMATS = %w|xml html|
+  
+    def tags?
+      TAG_FORMATS.include? format
+    end
+  
+    # constructor
+  
+    TRIM_MODE = "<>-"
+  
+    attr_reader :key, :name, :format
+  
+    def initialize filename, lineno, key, content
+      segments = key.split("/").last.split(".")
+      name, format = segments[0..1]
+  
+      if format.gsub(/[^a-z0-9]/, "") != format
+        raise BuildError, "key '#{key}' has an invalid format '#{format}'"
+      end
+  
+      super content, trim_mode: TRIM_MODE
+      self.filename, self.lineno, @key, @name, @format = filename, lineno, key, name, format
+    end
+  
+    # result
+  
+    def result the_binding, receiver=:unset
+      super the_binding
+    rescue NameError => e
+      raise unless e.receiver == receiver
+      message = "ERB template for a #{e.receiver.class} instance could not find method '#{e.name}'"
+      raise ExecutionError, message, [e.backtrace[0]]
+    end
+  end
+  
+
+end

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

@@ -0,0 +1,10 @@
+class DevSystem::ErbShellTest < DevSystem::ShellTest
+
+
+
+  test :subject_class, :subject do
+    assert_equality DevSystem::ErbShell, subject_class
+    assert_equality DevSystem::ErbShell, subject.class
+  end
+
+end

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

@@ -0,0 +1,130 @@
+class DevSystem::FileShell < DevSystem::Shell
+
+  def self._raise_if_blank path
+    raise ArgumentError, "Path is required" if path.nil? || path.to_s.empty?
+  end
+
+  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_level: self.log_level
+    log log_level, "Checking if file exists at '#{path}'"
+    _raise_if_blank path
+
+    File.exist? path
+  end
+
+  def self.size path, log_level: self.log_level
+    log log_level, "Getting size of file at '#{path}'"
+    _raise_if_not_exists path
+
+    File.size path
+  end
+
+  # category
+
+  def self.directory? path, log_level: self.log_level
+    log log_level, "Checking if '#{path}' is a directory"
+    _raise_if_blank path
+
+    File.directory? path
+  end
+
+  def self.file? path, log_level: self.log_level
+    log log_level, "Checking if '#{path}' is a file"
+    _raise_if_blank path
+
+    File.file? path
+  end
+
+  def self.symbolic_link? path, log_level: self.log_level
+    log log_level, "Checking if '#{path}' is a symbolic link"
+    _raise_if_blank path
+
+    File.symlink? path
+  end
+
+  def self.category_for path, log_level: self.log_level
+    log log_level, "Getting category for '#{path}'"
+    _raise_if_blank path
+
+    return :directory     if directory?     path, log_level: :highest
+    return :file          if file?          path, log_level: :highest
+    return :symbolic_link if symbolic_link? path, log_level: :highest
+  end
+
+  #
+
+  def self.touch path, log_level: self.log_level
+    log log_level, "Touching '#{path}'"
+    _raise_if_blank path
+
+    dir = File.dirname(path)
+    DevSystem::DirShell.create dir
+
+    File.open(path, "w").close
+
+    true
+  end
+
+  def self.gitkeep path
+    touch "#{path}/.gitkeep"
+  end
+
+  # read
+
+  def self.read_binary(path, log_level: self.log_level)
+    # TODO: move all code from BinShell to this file
+    BinShell.read path
+  end
+
+  def self.read_text(path, log_level: self.log_level)
+    # TODO: move all code from TextShell to this file
+    TextShell.read path, log_level:
+  end
+
+  # write
+
+  def self.write_binary(path, content, create_dir: nil, log_level: self.log_level)
+    # TODO: move all code from BinShell to this file
+    BinShell.write path, content, create_dir:
+  end
+
+  def self.write_text(path, content, create_dir: nil, log_level: self.log_level)
+    # TODO: move all code from TextShell to this file
+    TextShell.write path, content, create_dir:, log_level:
+  end
+
+  def self.copy(source, destination, log_level: self.log_level)
+    log log_level, "Copying '#{source}' to '#{destination}'"
+    source = Pathname(source)
+    destination = Pathname(destination)
+    _raise_if_blank source
+    _raise_if_blank destination
+  
+    if source.directory?
+      destination.mkpath
+      source.each_child do |child|
+        copy(child, destination.join(child.basename))
+      end
+    else
+      destination.dirname.mkpath # Ensure the destination directory exists
+      File.open(destination, "wb") do |dest_file|
+        File.open(source, "rb") do |src_file|
+          dest_file.write(src_file.read)
+        end
+      end
+    end
+  end
+
+  def self.remove(path, log_level: self.log_level)
+    log log_level, "Removing '#{path}'"
+    _raise_if_blank path
+
+    File.delete path
+  end
+
+end

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

@@ -10,7 +10,7 @@ class DevSystem::FileShellTest < DevSystem::ShellTest
       time = Time.now.strftime "%Y%m%d_%H%M%S"
       random = SecureRandom.hex 4
       ret = Pathname.new(Dir.pwd).join "tmp/test_#{App.mode}_#{name}_#{time}_#{random}"
-      FileUtils.mkdir_p ret
+      Pathname(ret).mkpath
       log "Created tmp_dir: #{ret}"
       ret
     end
@@ -19,7 +19,8 @@ class DevSystem::FileShellTest < DevSystem::ShellTest
   after do
     # NOTE: @tmp_dir does not create a new directory for each test
     if @tmp_dir
-      FileUtils.rm_rf @tmp_dir
+      Pathname(@tmp_dir).rmtree
+
       log "Removed tmp_dir: #{@tmp_dir}"
     end
   end
@@ -30,10 +31,6 @@ class DevSystem::FileShellTest < DevSystem::ShellTest
     assert subject_class == DevSystem::FileShell
   end
 
-  test :settings do
-    assert_equality subject_class.log_level, 0
-  end
-
   #
 
   test :subject_class, :exist?, :true do

data/lib/dev_system/{sub/shell/shells/gem_shell.rb → subsystems/shell/shells/gemspec_shell.rb}

@@ -1,4 +1,4 @@
-class DevSystem::GemShell < DevSystem::Shell
+class DevSystem::GemspecShell < DevSystem::Shell
   
   # 
 

data/lib/dev_system/{sub/shell/shells/gem_shell_test.rb → subsystems/shell/shells/gemspec_shell_test.rb}

@@ -1,10 +1,10 @@
-class DevSystem::GemShellTest < DevSystem::ShellTest
+class DevSystem::GemspecShellTest < DevSystem::ShellTest
   
   # 
   
   test :subject_class, :subject do
-    assert_equality DevSystem::GemShell, subject_class
-    assert_equality DevSystem::GemShell, subject.class
+    assert_equality DevSystem::GemspecShell, subject_class
+    assert_equality DevSystem::GemspecShell, subject.class
   end
 
   test :subject_class, :gemspec do