lizarb 1.0.4 → 1.0.5

data/lib/dev_system/sub/generator/generators/new_generator.rb

@@ -0,0 +1,74 @@
+class DevSystem::NewGenerator < DevSystem::SimpleGenerator
+
+  def call_default
+    args = env[:args]
+    log "args = #{args.inspect}"
+    # setup
+
+    name = args.shift || "app_1"
+
+    from = "#{Lizarb::APP_DIR}/examples/new"
+    log "from: #{from}"
+    to = "#{Dir.pwd}/#{name}"
+
+    return log "Directory #{to.light_green} already exists." if Dir.exist? to
+
+    log "Liza Application initializing at `#{to}`"
+
+    # app
+
+    FileUtils.cp_r from, to, verbose: true
+
+    # extra
+
+    puts
+
+    FileShell.gitkeep "#{to}/lib"
+    FileShell.gitkeep "#{to}/tmp"
+
+    TextShell.write "#{to}/.gitignore", render(:gitignore, format: :gitignore)
+    # TextShell.write "#{to}/Procfile", render(:Procfile, format: :yml)
+    TextShell.write "#{to}/.tool-versions", render(:toolversions, format: :txt)
+
+    FileUtils.cp_r "#{Lizarb::APP_DIR}/README.md",
+                   "#{to}/README.md",
+                   verbose: true
+    # FileUtils.cp_r "#{Lizarb::APP_DIR}/web_files",
+    #                "#{to}/web_files",
+    #                verbose: true
+
+    puts
+
+    KernelShell.call_backticks \
+      "cd #{to}; liza generate gemfile +confirm",
+      log_level: :normal
+
+    KernelShell.call_backticks \
+      "cd #{to}; BUNDLE_GEMFILE=Gemfile bundle install",
+      log_level: :normal
+
+    KernelShell.call_backticks \
+      "cd #{to}; git init -b main; git add .; git commit -m 'lizarb new app_1 (v#{Lizarb::VERSION})'",
+      log_level: :normal
+
+    log "Liza Application initialized at `#{to}`"
+  end
+end
+
+__END__
+
+# view gitignore.gitignore.erb
+# Ignore all files in all subdirectories
+.gitignore
+/.bundle/
+/tmp/
+*.sqlite
+*.rdb
+
+# view toolversions.txt.erb
+ruby <%= RUBY_VERSION %>
+
+# view Procfile.yml.erb
+# HEROKU EXAMPLE
+
+web: MODE=demo bundle exec liza rack h=0.0.0.0 p=$PORT

data/lib/dev_system/sub/generator/generators/new_generator_test.rb

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

data/lib/dev_system/sub/generator/generators/not_found_generator.rb

@@ -0,0 +1,155 @@
+class DevSystem::NotFoundGenerator < DevSystem::SimpleGenerator
+
+  #
+
+  def call_default
+    h3 "Liza is a light application framework written in Ruby 3.3 ❤", color: DevSystem.color
+    h5 "We're optimizing for happiness. Come join us!", color: ColorShell.colors.keys.sample
+    puts
+
+    if App.global?
+      print_global
+    else
+      print_systems
+      print_app
+    end
+  end
+
+  # color helpers
+
+  def color klass
+    return klass unless klass < Liza::Unit
+
+    namespace, _sep, classname = klass.to_s.rpartition('::')
+
+    if namespace.empty?
+      return stick classname, Liza.const(classname).system.color
+    end
+
+    "#{
+      stick namespace, Liza.const(namespace).system.color
+    }::#{
+      stick classname, Liza.const(classname).color
+    }"
+  end
+
+  # print helpers
+
+  def print_class klass, description: nil
+    loc = klass.to_s
+
+    sidebar_length = 50
+    klass.get_generator_signatures.each do |signature|
+      signature.name =
+        signature.name.empty? \
+          ? klass.token.to_s
+          : "#{klass.token}:#{signature.name}"
+      #
+    end.sort_by(&:name).map do |signature|
+      puts [
+        "liza generate #{signature.name}".ljust(sidebar_length),
+        (description or signature.description)
+      ].join ""
+    end
+  end
+  
+  #
+
+  def print_systems
+    h1 "SYSTEMS"
+    AppShell.consts[:systems].each do |system_name, tree_system|
+      system = tree_system["system"][0]
+
+      h4 system
+      tree_system["controllers"].each do |family, klasses|
+        klasses = tree_system["controllers"][family].to_a.select { _1 < Generator }
+        next if klasses.empty?
+
+        h5 "lib/#{system_name}_system/#{family.plural}/", color: system.color
+        klasses.each { print_class _1 }
+      end
+
+      print_system_sub system, system_name, tree_system
+    end
+    puts
+  end
+
+  def print_system_sub system, system_name, tree_system
+    tree_system["subsystems"].each do |subsystem, tree_subsystem|
+      klasses = tree_subsystem["controllers"].values.flatten.select { _1 < Generator }
+      next if klasses.empty?
+
+      tree_subsystem["controllers"].each do |controller_class, klasses|
+        klasses = klasses.select { _1 < Generator }
+        klasses = klasses.reject { _1 == NewGenerator }
+        next if klasses.empty?
+
+        h5 "lib/#{system_name}_system/sub/#{subsystem.singular}/#{controller_class.plural}/", color: system.color
+        klasses.each { print_class _1 }
+      end
+    end
+  end
+
+  def print_app
+    h1 "TEAM CODE AT app/"
+
+    system_name = "dev"
+    tree_system = AppShell.consts[:app]["dev"]
+
+    system = Liza.const "#{system_name}_system"
+    tree_system["controllers"].each do |family, structure|
+      structure.each do |division, klasses|
+        klasses = klasses.select { _1 < Generator }
+        if klasses.any?
+          h5 "app/#{system_name}/#{division.plural}/", color: system.color
+          klasses.each { print_class _1 }
+        end
+      end
+    end
+  end
+
+  def print_global
+    klasses = {
+      # GemfileGenerator => "# no description",
+      # EnvGenerator => "# no description",
+    }
+
+    klasses.each { print_class _1, description: _2 }
+
+    5.times { puts }
+  end
+
+  # typography helpers
+
+  def h1 text
+    puts stick " #{ text } ".center(80, "="), :b
+  end
+
+  def h2 text, color: :white
+    puts stick " #{ text } ".center(80, "-"), :b, color
+  end
+
+  def h3 text, color: :white
+    puts
+    puts stick " #{ text } ".center(80, " "), :b, color
+  end
+
+  def h4 system
+    puts
+    s = system.to_s
+    s1 = s
+    s1 = "#{ color(system) }" if system < Liza::Unit
+    color = system.color rescue :white
+    t = s.rjust(80, " ")
+    t = "#{ stick t, :b, color }"
+    t = t.gsub(s, s1)
+    puts t
+  end
+
+  def h5 text, color: :white
+    puts
+    puts stick text.ljust(80, " "), color
+    puts
+  end
+
+end

data/lib/dev_system/sub/generator/generators/not_found_generator_test.rb

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

data/lib/dev_system/sub/generator/generators/simple_generator.rb

@@ -0,0 +1,257 @@
+class DevSystem::SimpleGenerator < DevSystem::BaseGenerator
+
+  #
+
+  def inform
+    log :highest, "informing #{changes.count} changes"
+
+    changes.each do |change|
+      puts_line
+
+      action = "updating"
+      action = "creating" if change.old_lines.empty?
+      # action = "deleting" if change.new_lines.empty? # not implemented
+
+      diff = {
+        "+": (change.new_lines - change.old_lines).count,
+        "-": (change.old_lines - change.new_lines).count,
+      }
+
+      bit = diff.map { "#{_1}#{_2}" }.join(" ")
+      relative = Pathname(change.path).relative_path_from(App.root)
+      string = "#{action.ljust 8} | #{"#{bit}".rjust 8} lines | #{relative}"
+      log :highest, string
+
+      if log_level? :high
+        puts relative
+        LineDiffShell.log_diff(change.old_lines, change.new_lines) if diff.values.sum.positive?
+      end
+    end 
+  end
+
+  #
+
+  def save
+    puts_line
+    diff = {
+      "+": changes.map { _1.new_lines.count }.sum,
+      "-": changes.map { _1.old_lines.count }.sum,
+    }
+    log "saving #{changes.count} files changed: #{diff[:"+"]} insertions(+), #{diff[:"-"]} deletions(-)"
+
+    if env[:args].include? "+confirm"
+      answers = changes
+    else
+      choices = changes.map { |i| [i.relative_path.to_s, i] }.to_h
+      answers = box.pick_many "Approve all changes?", choices
+    end
+
+    #
+
+    puts_line
+    diff = {
+      "+": answers.map { _1.new_lines.count }.sum,
+      "-": answers.map { _1.old_lines.count }.sum,
+    }
+    log "saving #{answers.count} files changed: #{diff[:"+"]} insertions(+), #{diff[:"-"]} deletions(-)"
+
+    answers.each do |change|
+      if change.old_lines == change.new_lines
+        log "skipping #{change.path}"
+      else
+        log "writing #{change.path}"
+        TextShell.write change.path, change.new_lines.join(""), log_level: :lower
+      end
+    end
+  end
+
+  # changes
+
+  def changes
+    @changes ||= []
+  end
+
+  def last_change
+    @last_change
+  end
+
+  def add_change change
+    log :lower, "#{change.class}"
+    @last_change = change
+    changes << change
+    self
+  end
+
+  # create_file
+
+  def create_file name, template, format
+    path = App.root.join name
+    file = TextFileShell.new path
+
+    new_lines = render! template, format: format
+    file.new_lines = new_lines.strip.split("\n").map { "#{_1}\n" }
+
+    add_change file
+  end
+
+  # create_unit
+  
+  def create_unit unit, class_names, path, template = :unit
+    unit.sections.each do |section|
+      @current_section = section
+      section[:content] = render! section[:name], format: :rb
+    end
+    unit.views.each do |view|
+      @current_view = view
+      view[:content] = render! view[:name], format: view[:format]
+    end
+    @sections = unit.sections
+    @views = unit.views
+    @class_names = class_names
+
+    file = TextFileShell.new path
+    file.new_lines = render! template, format: :rb
+    file.new_lines = file.new_lines.split("\n").map { "#{_1}\n" }
+    add_change file
+  end
+
+  # helper classes
+
+  class UnitHelper
+    def section name, section = {}
+      sections << section
+      section[:name] = name
+    end
+
+    def view name, view = {}
+      views << view
+      view[:name] = name
+      view[:key] ||= name
+      view[:format] ||= :rb
+    end
+
+    def sections
+      @sections ||= []
+    end
+
+    def views
+      @views ||= []
+    end
+  end
+
+  #
+
+  def copy_examples controller
+    puts
+    log controller.to_s
+    singular = controller.singular
+    plural = controller.plural
+    sys = controller.system.token
+    
+    [
+      Lizarb::GEM_DIR,
+      Lizarb::APP_DIR,
+    ].uniq.each do |dir|
+      FileShell.directory? "#{dir}/examples/#{singular}" or next
+      copy_files "#{dir}/examples/#{singular}/app/#{sys}/#{plural}", "#{App.folder}/#{sys}/#{plural}"
+    end
+  end
+
+  #
+
+  def copy_files from_folder, to_folder
+    from_pattern = "#{from_folder}/**/*"
+    log "from_pattern = #{from_pattern}"
+
+    from_files = Dir[from_pattern]
+    log "from_files"
+    log_array from_files
+    puts
+
+    from_files.each do |source|
+      next if File.directory? source
+
+      target = source.sub(from_folder, to_folder)
+      copy_file source, target
+    end
+  end
+
+  def copy_file source, target
+    path = App.root.join target
+    file = TextFileShell.new path
+    file.new_lines = TextShell.read_lines source
+    add_change file
+  end
+
+  #
+
+  def name!
+    @name = command.simple_arg_ask_snakecase 0, "Name your new #{@controller_class.last_namespace}:"
+    log "@name = #{@name.inspect}"
+  end
+
+  #
+
+  def place!
+    places = ControllerShell.places_for(@controller_class)
+    @place = places.keys[0] if places.count == 1
+    @place ||= command.simple_controller_placement :place, places
+    @path = places[@place]
+    log "@place, @path = #{@place.inspect}, #{@path.inspect}"
+  end
+
+  # create_controller
+
+  def create_controller(name, controller, place, path, ancestor: controller, &block)
+    unit, test = UnitHelper.new, UnitHelper.new
+
+    @class_name = "#{name.camelize}#{controller.last_namespace}"
+    @class_name = "#{place.split("/").first.camelize}System::#{@class_name}" unless place == "app"
+
+    unit_classes = [@class_name, ancestor.to_s]
+    test_classes = unit_classes.map { "#{_1}Test" }
+
+    unit_path = App.root.join(path).join("#{name}_#{controller.division.singular}.rb")
+    test_path = App.root.join(path).join("#{name}_#{controller.division.singular}_test.rb")
+
+    # decorate
+
+    yield unit, test
+
+    # create
+
+    create_unit unit, unit_classes, unit_path
+    create_unit test, test_classes, test_path
+
+    log "done"
+  end
+
+  # helper methods
+
+  def puts_line
+    puts "-" * 120
+  end
+
+end
+
+__END__
+
+# view unit.rb.erb
+class <%= @class_names[0] %> < <%= @class_names[1] %>
+  <% @sections.each do |section| %>
+  # <%= section[:caption] %>
+<%= section[:content] -%>
+  <% end -%>
+
+end
+<% if @views.any? -%>
+
+<%= "__END__" %>
+
+<% @views.each do |view| -%>
+<%= "#" -%> view <%= view[:key] %>.<%= view[:format] %>.erb
+
+<%= view[:content] -%>
+
+<% end -%>
+<% end -%>

data/lib/dev_system/sub/generator/generators/simple_generator_test.rb

@@ -0,0 +1,38 @@
+class DevSystem::SimpleGeneratorTest < DevSystem::GeneratorTest
+
+  test :subject_class do
+    assert subject_class == DevSystem::SimpleGenerator
+  end
+
+  test :settings do
+    assert_equality subject_class.log_level, 0
+  end
+
+  # helper methods
+
+  def call_with(name, coil, placement, superklass, path)
+    env = {}
+    env[:name] = name.to_s
+    env[:generator_coil] = coil.to_s
+    env[:placement] = placement
+    env[:superclass] = superklass
+    env[:path] = path
+
+    subject.call env
+  end
+
+  def assert_change_count count, kaller: nil
+    kaller ||= caller
+    assert_equality subject.changes.count, count, kaller: kaller
+  end
+
+  def assert_change index, path, lines_count, first_line, kaller: nil
+    kaller ||= caller
+    unless assert subject.changes[index].path.to_s.end_with?(path), kaller: kaller
+      puts stick :red, "#{subject.changes[index].path.inspect} does not end with #{path.inspect}"
+    end
+    assert_equality subject.changes[index].new_lines.count, lines_count, kaller: kaller
+    assert_equality subject.changes[index].new_lines[0].strip, first_line, kaller: kaller
+  end
+
+end

data/lib/dev_system/sub/log/commands/log_command.rb

@@ -0,0 +1,11 @@
+class DevSystem::LogCommand < DevSystem::Command
+
+  def self.call args
+    log :lower, "args = #{args}"
+
+    DevBox[:log].handlers.each do |key, log_class|
+      log "handler #{key} maps to #{log_class}"
+    end
+  end
+
+end

data/lib/dev_system/sub/log/commands/log_command_test.rb

@@ -0,0 +1,11 @@
+class DevSystem::LogCommandTest < DevSystem::CommandTest
+
+  test :subject_class do
+    assert_equality subject_class, DevSystem::LogCommand
+  end
+
+  test :settings do
+    assert_equality subject_class.log_level, 0
+  end
+
+end

data/lib/dev_system/sub/log/generators/log_generator.rb

@@ -0,0 +1,54 @@
+class DevSystem::LogGenerator < DevSystem::SimpleGenerator
+  
+  # liza g log name place=app
+
+  def call_default
+    @controller_class = Log
+
+    name!
+    place!
+    append_handler_to_log_panel
+
+    create_controller @name, @controller_class, @place, @path do |unit, test|
+      unit.section :controller_section_1
+      test.section :controller_test_section_1
+    end
+  end
+
+  def append_handler_to_log_panel
+    file = TextFileShell.new App.path.join("dev_box.rb")
+    
+    lines = LineShell.extract_wall_of file.old_lines, "    handler :"
+    lines << "    handler :#{@name}\n"
+    file.new_lines = LineShell.replace_wall_of file.old_lines, "    handler :", lines
+
+    add_change file
+  end
+
+  # liza g log:examples
+
+  def call_examples
+    # TODO: append once per example
+    @name = "logger"
+    append_handler_to_log_panel
+    #
+    copy_examples Log
+  end
+
+end
+
+__END__
+
+# view controller_section_1.rb.erb
+
+  # TODO: https://rubyapi.org/3.1/o/logger
+  def self.call(env)
+    # as of version <%= Lizarb::VERSION %>, OutputLog has been the only controller explored
+  end
+
+# view controller_test_section_1.rb.erb
+
+  test :subject_class, :subject do
+    assert_equality <%= @class_name %>, subject_class
+    assert_equality <%= @class_name %>, subject.class
+  end

data/lib/dev_system/sub/log/generators/log_generator_test.rb

@@ -0,0 +1,10 @@
+class DevSystem::LogGeneratorTest < DevSystem::SimpleGeneratorTest
+
+  #
+  
+  test :subject do
+    assert_equality DevSystem::LogGenerator, subject_class
+    assert_equality DevSystem::LogGenerator, subject.class
+  end
+  
+end

data/lib/dev_system/sub/log/log_panel.rb

@@ -0,0 +1,47 @@
+class DevSystem::LogPanel < Liza::Panel
+
+  def call env
+    env[:instance] ||= env[:unit_class] != env[:unit]
+    env[:method_name] ||= method_name_for env
+
+    # The unit determines the smallest log level it wants to log
+    # Therefore, a message of lower log level will not be logged
+    return if env[:message_log_level] < env[:unit_log_level]
+
+    handlers.values.each do |handler|
+      handler.call env
+    rescue Exception => e
+      log "#{e.class} #{e.message.inspect} on #{e.backtrace[0]}".yellow
+    end
+  end
+
+  def handler key
+    handlers[key] ||= Liza.const("#{key}_log")
+  end
+
+  def handlers
+    @handlers ||= {}
+  end
+
+  # NOTE: improve logs performance and readability
+
+  def method_name_for env
+    env[:caller].each do |s|
+      t = s.match(/`(.*)'/)[1]
+
+      next if t.include? " in <class:"
+      return t.split(" ").last if t.include? " in "
+
+      next if t == "log"
+      next if t == "each"
+      next if t == "map"
+      next if t == "with_index"
+      next if t == "instance_exec"
+      next if t.start_with? "_"
+      return t
+    end
+
+    raise "there's something wrong with kaller"
+  end
+
+end