lizarb 1.0.3 → 1.0.4

data/lib/dev_system/dev/controllers/generators/controller_generator.rb

@@ -0,0 +1,97 @@
+class DevSystem::ControllerGenerator < DevSystem::Generator
+
+  def self.call args
+    log "args = #{args.inspect}"
+    new.generate_app_controller(*args)
+  end
+
+  def generate_app_controller system_name, controller_name, folder, name
+    log "(#{system_name.inspect}, #{controller_name.inspect}, #{folder.inspect}, #{name.inspect})"
+
+    @name = name
+    @panels = []
+
+    filename = "app/#{system_name}/#{folder}/#{name}_#{controller_name}.rb"
+    content = render "controller.rb"
+    TextShell.write filename, content
+
+    filename = "app/#{system_name}/#{folder}/#{name}_#{controller_name}_test.rb"
+    content = render "controller_test.rb"
+    TextShell.write filename, content
+  end
+
+  #
+
+  def self.install args
+    log "args = #{args.inspect}"
+
+    system_name = get(:system).name.snakecase.gsub "_system", ""
+    controller_name = last_namespace.snakecase.gsub "_generator", ""
+
+    new.instance_exec do
+      log "#install_app_panel"
+
+      @filename = "app/#{system_name}_box.rb"
+      @system_name = system_name
+      @controller_name = controller_name
+      @panels = {}
+
+      install_write_box unless FileShell.exist? @filename
+      install_read_box
+      install_insert_panel
+      install_write_box
+    end
+  end
+
+  # helper methods
+
+  def install_write_box
+    @content = render "app_box.rb"
+    TextShell.write @filename, "#{@content.strip}\n"
+  end
+
+  def install_read_box
+    @content ||= TextShell.read @filename
+
+    cursor = nil
+    @content.split("\n").each do |line|
+      md = line.match(/^  configure :(.*) do$/)
+      if md
+        cursor = md[1]
+        @panels[cursor] = {lines: []}
+      elsif line =~ /^  end$/
+        cursor = nil
+      else
+        next unless cursor
+        @panels[cursor][:lines] << line
+      end
+    end
+  end
+
+  def install_insert_panel
+    lines = render("install_insert_panel.rb").split("\n").reject(&:empty?)
+    @panels[@controller_name] = {lines: lines}
+    @panels = @panels.sort_by(&:first)
+  end
+
+end
+
+__END__
+
+# view app_box.rb.erb
+
+class <%= @system_name.camelcase %>Box < Liza::<%= @system_name.camelcase %>Box
+
+<% @panels.each do |key, panel| -%>
+  configure :<%= key %> do
+<% panel[:lines].each do |line| -%>
+<%= line %>
+<%   end -%>
+  end
+
+<% end -%>
+end
+
+# view install_insert_panel.rb.erb
+
+    #

data/lib/dev_system/dev/controllers/generators/controller_generator_test.rb

@@ -0,0 +1,12 @@
+class DevSystem::ControllerGeneratorTest < DevSystem::GeneratorTest
+
+  test :subject_class do
+    assert subject_class == DevSystem::ControllerGenerator
+  end
+
+  test :settings do
+    assert subject_class.log_level == :normal
+    assert subject_class.log_color == :green
+  end
+
+end

data/lib/dev_system/dev/controllers/generators/generator_generator/template.rb.erb

@@ -4,6 +4,6 @@ end
 
 __END__
 
-# text.txt.erb
+# view text.txt.erb
 Called <%%%= self %>.<%%%= __method__ %>
 @args: <%%%= @args %>

data/lib/dev_system/dev/controllers/generators/new_generator.rb

@@ -0,0 +1,117 @@
+class DevSystem::NewGenerator < DevSystem::Generator
+  def self.call(args)
+    log "args = #{args.inspect}"
+    new.call args
+  end
+
+  def call(args)
+    log "args = #{args.inspect}"
+    # setup
+
+    name = args.shift || "app_1"
+
+    from = "#{Lizarb::APP_DIR}/app_new"
+    to = name
+
+    return log "Directory #{to.light_green} already exists." if Dir.exist? to
+
+    log "Liza Application initializing at `#{to}`"
+
+    # init
+
+    DirShell.create to
+
+    # app
+
+    FileUtils.cp_r from, "#{to}/app", verbose: true
+    FileUtils.cp_r "#{from}.rb", "#{to}/app.rb", verbose: true
+
+    # extra
+
+    puts
+
+    FileShell.gitkeep "#{to}/lib"
+    FileShell.gitkeep "#{to}/tmp"
+
+    TextShell.write "#{to}/.gitignore", render("hidden.gitignore")
+    TextShell.write "#{to}/Gemfile", render("Gemfile.rb")
+    # TextShell.write "#{to}/Procfile", render("Procfile.yml")
+    TextShell.write "#{to}/.tool-versions", render("toolversions.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
+    @env_name = nil
+    TextShell.write "#{to}/app.env",      render("env.env")
+    @env_name = :code
+    TextShell.write "#{to}/app.code.env", render("env.env")
+    @env_name = :demo
+    TextShell.write "#{to}/app.demo.env", render("env.env")
+
+    puts
+
+    `cd #{to}; git init -b main; git add .; git commit -m "lizarb new app_1 (v#{Lizarb::VERSION})"`
+
+    log "Liza Application initialized at `#{to}`"
+  end
+end
+
+__END__
+
+# view hidden.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
+
+# view Gemfile.rb.erb
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+group :default do
+  gem "lizarb", "~> <%= Lizarb::VERSION %>"
+  # gem "lizarb", github: "rubyonrails-brasil/lizarb"
+end
+
+group :dev do
+  # gems you only want to load if DevSystem is loaded
+  # gem "pry", "~> 0.14.1"
+end
+
+# view env.env.erb
+#
+<% if @env_name == :code -%>
+# ENV VARIABLES FOR MODE=code (default)
+#
+# MODE=code lizarb commands
+# lizarb commands
+<% elsif @env_name == :demo -%>
+# ENV VARIABLES FOR MODE=demo
+#
+# MODE=demo lizarb commands
+<% else -%>
+# ENV VARIABLES FOR ALL MODES
+#
+# MODE=code lizarb commands
+# MODE=demo lizarb commands
+# lizarb commands
+<% end -%>
+#
+
+# app variables
+
+# dev variables

data/lib/dev_system/dev/controllers/generators/new_generator_test.rb

@@ -0,0 +1,12 @@
+class DevSystem::NewGeneratorTest < DevSystem::GeneratorTest
+
+  test :subject_class do
+    assert subject_class == DevSystem::NewGenerator
+  end
+
+  test :settings do
+    assert subject_class.log_level == :normal
+    assert subject_class.log_color == :green
+  end
+
+end

data/lib/dev_system/dev/controllers/generators/not_found_generator.rb

@@ -3,25 +3,37 @@ class DevSystem::NotFoundGenerator < DevSystem::Generator
   def self.call args
     # 1. LOG
 
-    log :higher, "Called #{self}.#{__method__} with args #{args}"
+    log "args = #{args.inspect}"
     puts
 
     # 2. FIND generators
 
-    App.eager_load_all
+    App.load_all
     generators = Liza::Generator.descendants
+    generators -= ignored_generators
 
-    log "Liza comes with #{generators.count} generators you can use."
-    puts
+    # 3. LIST generators
+
+    keys = generators.map { _1.last_namespace.snakecase[0..-11] }.uniq.sort
 
+    log "Liza comes with #{keys.count} generators you can use."
     log "Here they are:"
     puts
 
-    # 3. LIST generators
+    keys.each do
+      log "liza generate #{_1}"
+    end
+  end
 
-    keys = generators.map { |k| k.last_namespace.snakecase[0..-11] }.sort
-    keys.reject! { |s| s == "not_found" }
-    keys.each { |s| log "liza generate #{s}" }
+  def self.ignored_generators
+    [
+      self,
+      DevSystem::NotFoundGenerator,
+      DevSystem::NewGenerator,
+      DevSystem::ControllerGenerator,
+      DevSystem::RecordGenerator,
+      DevSystem::RequestGenerator,
+    ].uniq.compact
   end
 
 end

data/{app/dev → lib/dev_system/dev/controllers}/generators/record_generator.rb

@@ -1,4 +1,4 @@
-class RecordGenerator < Liza::Generator
+class DevSystem::RecordGenerator < DevSystem::Generator
   main_dsl
 
   FOLDER = "app/net/records"

data/lib/dev_system/dev/controllers/generators/record_generator_test.rb

@@ -0,0 +1,12 @@
+class DevSystem::RecordGeneratorTest < DevSystem::GeneratorTest
+
+  test :subject_class do
+    assert subject_class == DevSystem::RecordGenerator
+  end
+
+  test :settings do
+    assert subject_class.log_level == :normal
+    assert subject_class.log_color == :green
+  end
+
+end

data/{app/dev → lib/dev_system/dev/controllers}/generators/request_generator.rb

@@ -1,4 +1,4 @@
-class RequestGenerator < Liza::Generator
+class DevSystem::RequestGenerator < DevSystem::Generator
   main_dsl
 
   FOLDER = "app/web/requests"
@@ -23,7 +23,7 @@ class #{name.camelize}Request < Liza::Request
 
   def self.call env
     path = env["REQUEST_PATH"]
-    log :higher, "Called \#{self}.\#{__method__} with path \#{path}"
+    log "args = #{args.inspect}"
 
     #
 

data/lib/dev_system/dev/controllers/generators/request_generator_test.rb

@@ -0,0 +1,12 @@
+class DevSystem::RequestGeneratorTest < DevSystem::GeneratorTest
+
+  test :subject_class do
+    assert subject_class == DevSystem::RequestGenerator
+  end
+
+  test :settings do
+    assert subject_class.log_level == :normal
+    assert subject_class.log_color == :green
+  end
+
+end

data/lib/dev_system/dev/controllers/log.rb

@@ -0,0 +1,3 @@
+class DevSystem::Log < Liza::Controller
+
+end

data/{app/dev/generators/request_generator_test.rb → lib/dev_system/dev/controllers/log_test.rb}

@@ -1,7 +1,7 @@
-class RequestGeneratorTest < Liza::GeneratorTest
+class DevSystem::LogTest < Liza::ControllerTest
 
   test :subject_class do
-    assert subject_class == RequestGenerator
+    assert subject_class == DevSystem::Log
   end
 
   test :settings do

data/lib/dev_system/dev/controllers/shell.rb

@@ -28,4 +28,26 @@ class DevSystem::Shell < Liza::Controller
     :unix
   end
 
+  # Return the current Ruby engine as a symbol
+  def self.engine
+    return :jruby if jruby?
+    return :ruby  if ruby?
+    :unknown
+  end
+
+  # Check if the current Ruby engine is JRuby
+  def self.jruby?
+    @jruby || RUBY_ENGINE == "jruby"
+  end
+
+  # Check if the current Ruby engine is MRI
+  def self.ruby?
+    @ruby || RUBY_ENGINE == "ruby"
+  end
+
+  # Return the current Ruby version as a Gem::Version
+  def self.ruby_version
+    Lizarb.ruby_version
+  end
+
 end

data/lib/dev_system/dev/controllers/shell_test.rb

@@ -43,4 +43,29 @@ class DevSystem::ShellTest < Liza::ControllerTest
     subject_class.instance_variable_set(:@mac, original)
   end
 
+  #
+
+  test :subject_class, :ruby? do
+    original = subject_class.ruby?
+    subject_class.instance_variable_set(:@ruby, true)
+    assert subject_class.ruby?
+  ensure
+    subject_class.instance_variable_set(:@ruby, original)
+  end
+
+  test :subject_class, :jruby? do
+    original = subject_class.jruby?
+    subject_class.instance_variable_set(:@jruby, true)
+    assert subject_class.jruby?
+  ensure
+    subject_class.instance_variable_set(:@jruby, original)
+  end
+
+  #
+
+  test :subject_class, :ruby_version do
+    assert subject_class.ruby_version.class == Gem::Version
+  end
+
+
 end

data/lib/dev_system/dev/controllers/terminal/irb_terminal.rb

@@ -1,7 +1,7 @@
 class DevSystem::IrbTerminal < DevSystem::Terminal
 
   def self.call args
-    log :higher, "Called #{self}.#{__method__} with args #{args}"
+    log "args = #{args.inspect}"
 
     # https://github.com/ruby/ruby/blob/master/lib/irb.rb
     require "irb"
@@ -11,6 +11,12 @@ class DevSystem::IrbTerminal < DevSystem::Terminal
     irb = IRB::Irb.new(workspace)
     IRB.conf[:MAIN_CONTEXT] = irb.context
 
+    def irb.signal_status(status)
+      super
+    rescue Interrupt
+      IrbTerminal.log "Control-C"
+    end
+
     irb.eval_input
   end
 

data/lib/dev_system/dev/controllers/terminal/pry_terminal.rb

@@ -1,7 +1,7 @@
 class DevSystem::PryTerminal < DevSystem::Terminal
 
   def self.call args
-    log :higher, "Called #{self}.#{__method__} with args #{args}"
+    log "args = #{args.inspect}"
 
     require "pry"
     Pry.start

data/lib/dev_system/dev/dev_box.rb

@@ -1,39 +1,33 @@
 class DevSystem::DevBox < Liza::Box
 
-  # Set up your bench panel per the DSL in http://guides.lizarb.org/panels/bench.html
-  panel :bench do
+  # Configure your bench panel per the DSL in http://guides.lizarb.org/panels/bench.html
+  configure :bench do
     # set :log_level, ENV["dev.bench.log_level"]
   end
 
-  # Set up your command panel per the DSL in http://guides.lizarb.org/panels/command.html
-  panel :command do
+  # Configure your command panel per the DSL in http://guides.lizarb.org/panels/command.html
+  configure :command do
     # set :log_level, ENV["dev.command.log_level"]
   end
 
-  # Set up your generator panel per the DSL in http://guides.lizarb.org/panels/generator.html
-  panel :generator do
+  # Configure your generator panel per the DSL in http://guides.lizarb.org/panels/generator.html
+  configure :generator do
     # set :log_level, ENV["dev.generator.log_level"]
   end
 
-  # Set up your command panel per the DSL in http://guides.lizarb.org/panels/log.html
-  panel :log do
+  # Configure your command panel per the DSL in http://guides.lizarb.org/panels/log.html
+  configure :log do
     # set :log_level, ENV["dev.log.log_level"]
   end
 
-  # Set up your shell panel per the DSL in http://guides.lizarb.org/panels/shell.html
-  panel :shell do
+  # Configure your shell panel per the DSL in http://guides.lizarb.org/panels/shell.html
+  configure :shell do
     # set :log_level, ENV["dev.shell.log_level"]
   end
 
-  # Set up your terminal panel per the DSL in http://guides.lizarb.org/panels/terminal.html
-  panel :terminal do
+  # Configure your terminal panel per the DSL in http://guides.lizarb.org/panels/terminal.html
+  configure :terminal do
     # set :log_level, ENV["dev.terminal.log_level"]
   end
 
-  has_controller :bench, :bench
-  has_controller :command, :command
-  has_controller :generator, :generator
-  # has_controller :log, :log
-  has_controller :shell, :shell
-  has_controller :terminal, :terminal
 end

data/lib/dev_system/dev/panels/command_panel.rb

@@ -1,28 +1,71 @@
 class DevSystem::CommandPanel < Liza::Panel
+  class Error < StandardError; end
+  class ParseError < Error; end
 
   def call args
-    # 1. LOG
+    log "args = #{args.inspect}" if get :log_details
 
-    log "call #{args}"
+    return call_not_found args if args.none?
 
-    # 2. FIND command
+    struct = parse args[0]
+    struct.command = short struct.command
+    command = find struct.command
 
-    return call_not_found args if args.none?
+    case
+    when struct.class_method
+      _call_log "#{command}.#{struct.class_method}(#{args[1..-1]})"
+      command.public_send struct.class_method, args[1..-1]
+    when struct.instance_method
+      _call_log "#{command}.new.#{struct.instance_method}(#{args[1..-1]})"
+      command.new.public_send struct.instance_method, args[1..-1]
+    when struct.method
+      if command.respond_to?(struct.method)
+        _call_log "#{command}.#{struct.method}(#{args[1..-1]})"
+        command.public_send struct.method, args[1..-1]
+      else
+        _call_log "#{command}.new.#{struct.method}(#{args[1..-1]})"
+        command.new.public_send struct.method, args[1..-1]
+      end
+    else
+      _call_log "#{command}.call(#{args[1..-1]})"
+      command.call args[1..-1]
+    end
+  rescue ParseError
+    call_not_found args
+  end
+
+  def _call_log string
+    log "#{string}" if get :log_details
+  end
 
-    command = args[0]
+  #
 
-    log({command:})
+  PARSE_REGEX = /(?<command>[A-Za-z_]+)(?::(?<class_method>[a-z_]+))?(?:#(?<instance_method>[a-z_]+))?(?:\.(?<method>[a-z_]+))?/
 
-    command_klass = Liza.const "#{command}_command"
+  # OpenStruct command class_method instance_method method
+  def parse string
+    md = string.to_s.match PARSE_REGEX
+    raise ParseError if md.nil?
+    hash = md.named_captures
+    log "{#{hash.map { ":#{_1}=>#{_2.to_s.inspect}" }.join(", ") }}" if get :log_details
+    OpenStruct.new hash
+  end
 
-    # 3. CALL
+  #
 
-    command_klass.call args[1..-1]
+  def find string
+    k = Liza.const "#{string}_command"
   rescue Liza::ConstNotFound
-    call_not_found args
+    k = Liza::NotFoundCommand
+  ensure
+    log k.to_s if get :log_details
+    k
   end
 
+  #
+
   def call_not_found args
-    Liza::NotFoundCommand.call args
+    Liza[:NotFoundCommand].call args
   end
+
 end

data/lib/dev_system/dev/panels/command_panel_test.rb

@@ -1,21 +1,46 @@
 class DevSystem::CommandPanelTest < Liza::PanelTest
 
   test :subject_class do
-    assert subject_class == DevSystem::CommandPanel
+    assert_equality subject_class, DevSystem::CommandPanel
   end
 
   test :settings do
-    assert subject_class.log_level == :normal
-    assert subject_class.log_color == :green
+    assert_equality subject_class.log_level, :normal
+    assert_equality subject_class.log_color, :green
   end
 
-  test :call do
-    begin
-      subject.call ["echo", 1, 2, 3]
-      assert false
-    rescue RuntimeError => e
-      assert e.message == "[1, 2, 3]"
-    end
+  test :parse do
+    struct = subject.parse "generate"
+    assert_equality struct.command, "generate"
+    assert_equality struct.class_method, nil
+    assert_equality struct.instance_method, nil
+    assert_equality struct.method, nil
+
+    struct = subject.parse "generate:install"
+    assert_equality struct.command, "generate"
+    assert_equality struct.class_method, "install"
+    assert_equality struct.instance_method, nil
+    assert_equality struct.method, nil
+
+    struct = subject.parse "generate#install"
+    assert_equality struct.command, "generate"
+    assert_equality struct.class_method, nil
+    assert_equality struct.instance_method, "install"
+    assert_equality struct.method, nil
+
+    struct = subject.parse "generate.install"
+    assert_equality struct.command, "generate"
+    assert_equality struct.class_method, nil
+    assert_equality struct.instance_method, nil
+    assert_equality struct.method, "install"
+  end
+
+  test :find do
+    klass = subject.find "generate"
+    assert_equality DevSystem::GenerateCommand, klass
+
+    klass = subject.find "g"
+    assert_equality DevSystem::NotFoundCommand, klass
   end
 
 end