lizarb 1.0.5 → 1.0.6

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

@@ -1,185 +0,0 @@
-class DevSystem::AppShell < DevSystem::Shell
-
-  #
-  
-  def self.writable_systems
-    root = App.root.to_s
-    App.systems.select { _2.source_location_radical.start_with? root }
-  end
-
-  #
-
-  def self.consts
-    @instance ||= new
-    @instance.consts
-  end
-
-  attr_reader :consts
-
-  def initialize
-    liza_classes = self.class.liza_classes
-    liza_categories = self.class.liza_categories
-    h = @consts = {}
-    h[:top_level]  = [Lizarb, App, Liza]
-    h[:liza]       = self.class.liza_classes_structured
-    h[:systems]    = self.class.system_classes_structured
-    h[:app]        = self.class.object_classes_structured
-  end
-
-  #
-
-  def self.liza_classes
-    Lizarb.loaders[0].__to_unload.keys.map { Object.const_get _1 }
-  end
-
-  def self.implementation_classes
-    Lizarb.loaders[1].__to_unload.keys.map { Object.const_get _1 }
-  end
-
-  #
-
-  def self.system_classes
-    implementation_classes.reject { _1.namespace == Object }
-  end
-
-  def self.object_classes
-    implementation_classes.select { _1.namespace == Object }
-  end
-
-  #
-
-  def self.liza_categories
-    ["unit", "base", "safety", "meta", "ruby_tests"]
-  end
-
-  #
-
-  def self.liza_classes_structured
-    ret = {}
-    liza_classes = self.liza_classes
-
-    ret["unit"] =
-      liza_classes
-        .select { _1.source_location_radical.include? "/liza/unit" }
-        .sort_by { _1.to_s }
-
-    ret["base"] =
-      liza_classes
-        .select { _1.source_location_radical.include? "/liza/base" }
-        .sort_by { _1.to_s }
-
-    ret["safety"] =
-      liza_classes
-        .select { _1.source_location_radical.include? "/liza/safety" }
-        .sort_by { _1.to_s }
-
-    ret["meta"] =
-      liza_classes
-        .select { _1.source_location_radical.include? "/liza/meta" }
-        .sort_by { _1.to_s }
-
-    ret["ruby_tests"] =
-      liza_classes
-        .select { _1.source_location_radical.include? "/liza/ruby_tests" }
-        .sort_by { _1.to_s }
-
-    raise "not all categories are filled" if liza_categories != ret.select { _2.any? }.keys
-
-    ret
-  end
-
-  def self.system_classes_structured
-    ret = {}
-    system_classes = self.system_classes
-
-    App.systems.each do |system_name, system|
-      tree = ret[system_name.to_s] = {}
-
-      array = system_classes.select { _1.system == system }
-
-      tree["system"]      = [system]
-      tree["box"]         = [system.box, system.box.test_class]
-      tree["controllers"] = {}
-      tree["subsystems"]  = {}
-
-      array.delete system
-      array.delete system.box
-      array.delete system.box.test_class
-      
-      system.subsystems.each do |subsystem|
-        tree["subsystems"][subsystem] = {}
-        tree["subsystems"][subsystem]["panel"] = [subsystem.panel.class, subsystem.panel.class.test_class]
-        tree["subsystems"][subsystem]["controller"] = [subsystem, subsystem.test_class]
-        tree["subsystems"][subsystem]["controllers"] = {}
-
-        array.delete subsystem.panel.class
-        array.delete subsystem.panel.class.test_class
-        array.delete subsystem
-        array.delete subsystem.test_class
-      end
-
-      array.each do |klass|
-        radical = klass.source_location_radical
-
-        if radical.include? "/#{system_name}_system/sub"
-          name = radical.split("_system/sub/").last.split("/").first
-          subsystem = system.const name
-          klasses = tree["subsystems"][subsystem]["controllers"][klass.division] ||= []
-        else
-          klasses = tree["controllers"][klass.division] ||= []
-        end
-
-        klasses << klass
-      end
-
-    end
-
-    ret.each do |system_name, tree|
-      tree["subsystems"].each do |subsystem_name, subsystem_tree|
-        subsystem_tree["controllers"].each do |division, controllers|
-          controllers.sort_by! &:to_s
-        end
-      end
-      tree["controllers"].each do |division, controllers|
-        controllers.sort_by! &:to_s
-      end
-    end
-
-    ret
-  end
-
-  def self.object_classes_structured
-    ret = {}
-    object_classes = self.object_classes.sort_by { _1.source_location_radical }
-
-    App.systems.each do |system_name, system|
-      tree = ret[system_name.to_s] = {}
-
-      a = object_classes.select { _1.system == system }
-      
-      tree["box"] = []
-      box = Liza.const "#{system_name}_box"
-      if box.namespace == Object
-        tree["box"] << box
-        a.delete box
-      end
-
-      tree["controllers"] = {}
-
-      a.each do |klass|
-        tree["controllers"][klass.subsystem] ||= {}
-        tree["controllers"][klass.subsystem][klass.division] ||= []
-        tree["controllers"][klass.subsystem][klass.division] << klass
-      end
-
-      system.subsystems.each do |subsystem|
-        tree["controllers"][subsystem]&.each do |division, klasses|
-          klasses.sort_by! &:to_s
-        end
-      end
-    end
-
-    ret
-  end
-
-end

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

@@ -1,26 +0,0 @@
-class DevSystem::AppShellTest < DevSystem::ShellTest
-
-  test :subject_class do
-    assert_equality subject_class, DevSystem::AppShell
-  end
-
-  test :settings do
-    assert_equality subject_class.log_level, 0
-  end
-
-  test :writable_systems do
-    a = subject_class.writable_systems.keys
-    b = [:dev, :happy, :net, :web, :work, :micro, :desk, :crypto, :art, :deep, :lab]
-    assert_equality a, b
-  end
-
-  test :subject do
-    system_keys = ["dev", "happy", "net", "web", "work", "micro", "desk", "crypto", "art", "deep", "lab"]
-    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", "base", "safety", "meta", "ruby_tests"]
-    assert_equality subject.consts[:systems].keys, system_keys
-    assert_equality subject.consts[:app].keys,     system_keys
-  end
-
-end

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

@@ -1,20 +0,0 @@
-class DevSystem::ControllerShell < DevSystem::Shell
-
-  #
-  
-  def self.places_for(controller)
-    ret = {
-      "app" => "#{App.relative_path}/#{controller.system.token}/#{controller.plural}",
-    }
-
-    AppShell.writable_systems.each do |system_key, system|
-      ret[system_key.to_s] = "lib/#{system_key}_system/#{controller.plural}"
-      system.subs.each do |sub|
-        ret["#{system_key}/#{sub}"] = "lib/#{system_key}_system/sub/#{sub}/#{controller.plural}"
-      end
-    end
-
-    ret
-  end
-
-end

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

@@ -1,16 +0,0 @@
-class DevSystem::ControllerShellTest < DevSystem::ShellTest
-
-  test :subject_class do
-    assert_equality subject_class, DevSystem::ControllerShell
-  end
-
-  test :settings do
-    assert_equality subject_class.log_level, 0
-  end
-
-  test :places_for do
-    places = subject_class.places_for(Shell)
-    assert_equality places.class, Hash
-  end
-
-end

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

@@ -1,59 +0,0 @@
-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 :normal, "Getting size of file at '#{path}'"
-    _raise_if_not_exists path
-
-    File.size path
-  end
-
-  #
-
-  def self.directory? path
-    log :normal, "Checking if '#{path}' is a directory"
-    _raise_if_blank path
-
-    File.directory? path
-  end
-
-  def self.file? path
-    log :normal, "Checking if '#{path}' is a file"
-    _raise_if_blank path
-
-    File.file? path
-  end
-
-  #
-
-  def self.touch path
-    log :normal, "Touching '#{path}'"
-    _raise_if_blank path
-
-    dir = File.dirname(path)
-    DevSystem::DirShell.create dir
-
-    FileUtils.touch path
-  end
-
-  def self.gitkeep path
-    touch "#{path}/.gitkeep"
-  end
-
-end

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

@@ -1,22 +0,0 @@
-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/line_shell.rb

@@ -1,56 +0,0 @@
-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/method_shell_test.rb

@@ -1,34 +0,0 @@
-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/happy_system/sub/axo/generators/axo_generator_test.rb

@@ -1,11 +0,0 @@
-class HappySystem::AxoGeneratorTest < DevSystem::SimpleGeneratorTest
-
-  test :subject_class do
-    assert subject_class == HappySystem::AxoGenerator
-  end
-
-  test :settings do
-    assert_equality subject_class.log_level, 0
-  end
-
-end

data/lib/lerb.rb

@@ -1,152 +0,0 @@
-# frozen_string_literal: true
-
-# https://docs.ruby-lang.org/en/3.2/ERB.html
-require "erb"
-
-$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
-    end
-
-    Dir.glob("#{path_radical}.*.erb").each do |filename|
-      _load erbs, filename
-    end
-
-    Dir.glob("#{path_radical}/*.*.erb").each do |filename|
-      _load erbs, filename
-    end
-
-    #
-
-    puts "#{erbs.size} erbs".on_red
-    erbs.each do |h|
-      puts "key: #{h.key}".on_green
-    end
-
-    erbs
-  end
-
-  def self._load erbs, filename
-    is_erb = filename.end_with? ".erb"
-    is_ignoring_ruby = !is_erb
-    is_accepting_views = false
-    
-    puts
-    puts "LERB filename: #{filename}".on_red
-    
-    puts "LERB is_erb: #{is_erb}".on_red
-    puts "LERB is_ignoring_ruby: #{is_ignoring_ruby}".on_red
-    puts "LERB is_accepting_views: #{is_accepting_views}".on_red
-
-    current_lineno = 0
-    current_content = ""
-    current_key = is_erb ? filename.split("/").last : DEFAULT_KEY
-
-    if current_key
-      puts "LERB declare: #{current_key} | because not erb".green
-    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]}".light_black
-        if is_line_end
-          is_ignoring_ruby = false
-          is_accepting_views = true
-          current_lineno = lineno + 1
-          puts "LERB declare: #{current_key} | current".green 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]}".green
-      else
-        current_content += line
-        puts "LERB keeping: #{lineno}: #{line[0..-2]}".bold.white
-      end
-
-      if is_line_end
-        puts "LERB warning: #{lineno}: #{line[0..-2]} found! No longer accepting views".light_yellow
-        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

data/lib/liza/base/controller.rb

@@ -1,26 +0,0 @@
-class Liza::Controller < Liza::Unit
-
-  part :controller_subsystem
-
-  def self.on_connected
-    token = self.last_namespace.snakecase.to_sym
-    panel = system.const("#{token}_panel").new name
-
-    subsystem! system.box, panel
-    division!
-  end
-
-  def self.inherited klass
-    super
-
-    klass.on_connected if klass.superclass == Liza::Controller
-  end
-
-  # color
-
-  def self.color
-    return system.color if subsystem?
-    subsystem.color
-  end
-
-end

data/lib/liza/base/controller_test.rb

@@ -1,36 +0,0 @@
-class Liza::ControllerTest < Liza::UnitTest
-  test :subject_class do
-    assert subject_class == Liza::Controller
-  end
-
-  test_methods_defined do
-    on_self :box, \
-      :color,
-      :division!, :division?,
-      :inherited,
-      :on_connected,
-      :panel, :plural,
-      :puts,
-      :singular,
-      :subsystem, :subsystem!, :subsystem?,
-      :token
-    on_instance :box, :panel
-  end
-
-  test :erbs_defined do
-    erbs_defined = subject_class.erbs_defined.map(&:key)
-    expected = []
-    assert_equality erbs_defined, expected
-  end
-
-  test :erbs_available do
-    erbs_available = subject_class.erbs_available.map(&:key)
-    expected = []
-    assert_equality erbs_available, expected
-  end
-
-  test :settings do
-    assert_equality subject_class.log_level, 0
-  end
-
-end