lizarb 1.0.5 → 1.0.6

data/lib/dev_system/subsystems/generator/generator_panel_test.rb

@@ -0,0 +1,86 @@
+class DevSystem::GeneratorPanelTest < Liza::PanelTest
+
+  test :subject_class do
+    assert subject_class == DevSystem::GeneratorPanel
+  end
+
+  test_methods_defined do
+    on_self
+    on_instance \
+      :call,
+      :find,
+      :forward,
+      :inform,
+      :forge,
+      :save
+  end
+  
+  section :forge
+  
+  def forge_with(args)
+    command = SimpleCommand.new
+    command_env = {command: , args: }
+    command.instance_variable_set :@menv, command_env
+    env = subject.forge command_env
+    subject.forge_shortcut env
+    env
+  end
+  
+  test :forge, true do
+    env = forge_with ["system"]
+    assert_equality env[:generator_name_original], "system"
+    assert_equality env[:generator_name], "system"
+    assert_equality env[:generator_action_original], nil
+  end
+  
+  test :forge, true, :action do
+    env = forge_with ["system:install"]
+    assert_equality env[:generator_name_original], "system"
+    assert_equality env[:generator_name], "system"
+    assert_equality env[:generator_action_original], "install"
+  end
+  
+  test :forge, false do
+    env = forge_with ["x"]
+    assert_equality env[:generator_name_original], "x"
+    assert_equality env[:generator_name], "x"
+    assert_equality env[:generator_action_original], nil
+  end
+  
+  test :forge, false, :action do
+    env = forge_with ["x:y"]
+    assert_equality env[:generator_name_original], "x"
+    assert_equality env[:generator_name], "x"
+    assert_equality env[:generator_action_original], "y"
+  end
+
+  test :forge_shortcut do
+    subject.shortcut :s, :system
+    env = {controller: :generator, generator_name_original: "s"}
+    subject.forge_shortcut env
+    assert_equality env[:generator_name], "system"
+
+    env = {controller: :generator, generator_name_original: "zz"}
+    subject.forge_shortcut env
+    assert_equality env[:generator_name], "zz"
+  end
+  
+  section :find
+
+  test :find do
+    env = {controller: :generator, generator_name: :command}
+    subject.find env
+    assert_equality env[:generator_class], CommandGenerator
+
+    env = {controller: :generator, generator_name: :z}
+    subject.find env
+    assert_equality env[:generator_class], NotFoundGenerator
+  end
+
+  test :find_shortcut do
+    env = {controller: :generator, generator_class: CommandGenerator, generator_action_original: "x"}
+    subject.find_shortcut env
+    assert_equality env[:generator_action], "x"
+  end
+
+end

data/lib/dev_system/{sub → subsystems}/generator/generator_test.rb

@@ -9,8 +9,4 @@ class DevSystem::GeneratorTest < Liza::ControllerTest
     on_instance
   end
 
-  test :settings do
-    assert_equality subject_class.log_level, 0
-  end
-
 end

data/lib/dev_system/subsystems/generator/generators/base_generator.rb

@@ -0,0 +1,147 @@
+class DevSystem::BaseGenerator < DevSystem::Generator
+
+  section :panel
+
+  def self.call(menv)
+    super
+    
+    generator = new
+    menv[:generator] = generator
+    menv[:command].menv[:generator] = generator
+    generator.call menv
+  end
+
+  #
+
+  attr_reader :menv
+
+  alias env menv
+
+  def call(menv)
+    @menv = menv
+    
+    before
+    method_name = "call_#{action_name}"
+    if respond_to? method_name
+      public_send method_name
+      after
+      return true
+    end
+
+    log "method not found: #{method_name.inspect}"
+
+    raise NoMethodError, "method not found: #{method_name.inspect}", caller 
+  end
+
+  def inform
+    log "not implemented"
+  end
+
+  def save
+    log "not implemented"
+  end
+
+  section :filters
+
+  def before
+    before_default
+    before_input
+  end
+
+  def after
+    #
+  end
+
+  section :helper_methods
+
+  def action_name()= menv[:generator_action]
+
+  section :command
+
+  def args
+    command.args
+  end
+
+  def command
+    menv[:command]
+  end
+
+  #
+
+  def self.get_generator_signatures
+    signatures = []
+    ancestors_until(BaseGenerator).each do |c|
+      signatures +=
+        c.instance_methods_defined.select do |name|
+          name.start_with? "call_"
+        end.map do |name|
+          {
+            name: ( name.to_s.sub("call_", "").sub("default", "") ),
+            description: "# no description",
+          }
+        end
+    end
+    signatures.uniq { _1[:name] }
+  end
+
+  def before_default
+    default_args.each_with_index { |arg, i| set_default_arg i, arg }
+    default_booleans.each { |name, value| set_default_boolean name, value }
+    default_strings.each { |key, value| set_default_string key, value }
+  end
+
+  def self.default_args() = fetch(:default_args) { [] }
+
+  def self.default_booleans() = fetch(:default_booleans) { {} }
+
+  def self.default_strings() = fetch(:default_strings) { {} }
+
+  def self.set_default_arg(index, value) = default_args[index] = value
+
+  def self.set_default_boolean(name, value) = default_booleans[name] = value
+
+  def self.set_default_string(key, value) = default_strings[key] = value
+
+  def default_args() = fetch(:default_args) { [] }
+
+  def default_booleans() = fetch(:default_booleans) { {} }
+
+  def default_strings() = fetch(:default_strings) { {} }
+
+  def set_default_arg(index, value) = command.set_default_arg index, value
+
+  def set_default_boolean(name, value) = command.set_default_boolean name, value
+
+  def set_default_string(key, value) = command.set_default_string key, value
+
+  def before_input
+    input_args.each { |index, block| set_input_arg index, &block }
+    input_booleans.each { |name, block| set_input_boolean name, &block }
+    input_strings.each { |key, block| set_input_string key, &block }
+  end
+
+  def self.input_args() = fetch(:input_args) { {} }
+
+  def self.input_booleans() = fetch(:input_booleans) { {} }
+
+  def self.input_strings() = fetch(:input_strings) { {} }
+
+  def self.set_input_arg(index, &block) = input_args[index] = block
+
+  def self.set_input_boolean(name, &block) = input_booleans[name] = block
+
+  def self.set_input_string(key, &block) = input_strings[key] = block
+
+  def input_args() = fetch(:input_args) { {} }
+
+  def input_booleans() = fetch(:input_booleans) { {} }
+
+  def input_strings() = fetch(:input_strings) { {} }
+
+  def set_input_arg(index, &block) = command.set_input_arg index, &block
+
+  def set_input_boolean(name, &block) = command.set_input_boolean name, &block
+
+  def set_input_string(key, &block) = command.set_input_string key, &block
+
+end

data/lib/dev_system/{sub → subsystems}/generator/generators/base_generator_test.rb

@@ -4,8 +4,7 @@ class DevSystem::BaseGeneratorTest < DevSystem::GeneratorTest
     assert subject_class == DevSystem::BaseGenerator
   end
 
-  test :settings do
-    assert_equality subject_class.log_level, 0
-  end
-
+  test_erbs_defined(
+  )
+  
 end

data/lib/dev_system/subsystems/generator/generators/controller_generator.rb

@@ -0,0 +1,210 @@
+class DevSystem::ControllerGenerator < DevSystem::SimpleGenerator
+
+  section :actions
+
+  # liza g controller
+  
+  def call_default
+    log stick :red, "Did you mean to generate a command instead?"
+  end
+
+  section :creating
+  
+  def create_controller(&block)
+    before_create_controller
+    log "super_controller: #{super_controller}"
+    
+    log "Determining class name..."
+    @class_name = "#{controller_name.camelize}#{super_controller.division.last_namespace}"
+    @class_name = "#{arg_place.split("/").first.camelize}System::#{@class_name}" unless arg_place == "app"
+    log "class_name: #{@class_name}"
+
+    unit, test = UnitHelper.new, UnitHelper.new
+    log "Yielding..."
+    yield unit, test
+
+    log "Determining unit and test classes names..."
+    unit_classes_names = [@class_name, super_controller.to_s]
+    test_classes_names = unit_classes_names.map { "#{_1}Test" }
+    log "unit_classes_names: #{unit_classes_names}"
+    log "test_classes_names: #{test_classes_names}"
+
+    log "Determining unit and test paths..."
+    directory = App.root.join(arg_place_path)
+    unit_path = directory.join("#{controller_name}_#{super_controller.division.singular}.rb")
+    test_path = directory.join("#{controller_name}_#{super_controller.division.singular}_test.rb")
+    log "unit_path: #{unit_path}"
+    log "test_path: #{test_path}"
+
+    log "Adding unit and test..."
+    add_unit unit, unit_classes_names, unit_path
+    add_unit test, test_classes_names, test_path
+
+    unless arg_views_eof?
+      log "Adding views..."
+      arg_action_names.each do |arg|
+        [unit, test].each do |u|
+          u.views.each do |view|
+            view_path = nil
+            view_path = directory.join "#{controller_name}_#{super_controller.division.singular}#{"_test" if u == test}.rb.#{view[:name]}.#{view[:format]}.erb" if arg_views_adjacent?
+            view_path = directory.join "#{controller_name}_#{super_controller.division.singular}#{"_test" if u == test}/#{view[:name]}.#{view[:format]}.erb" if arg_views_nested?
+            add_view u, view, view_path if view_path
+          end
+        end
+      end
+    end
+  end
+ 
+  def before_create_controller
+    # placeholder
+  end
+
+  def super_controller
+    @super_controller ||= Liza.const "#{arg_super}_#{env[:generator_name]}"
+  end
+
+  def controller_name
+    @controller_name ||= begin
+      name = arg_name
+      
+      if arg_place != "app"
+        if arg_prefix
+          name = "#{arg_place.split("/").first}_#{name}"
+        end
+      end
+
+      name
+    end
+  end
+
+  def available_places
+    @available_places ||= begin
+      d = super_controller.division
+      directory_name = arg_division \
+        ? "#{arg_name}_#{d.plural}"
+        : d.plural
+      log "directory_name: #{directory_name}"
+      ControllerShell.places_for(d, directory_name: directory_name)
+    end
+  end
+
+  def requirements_to_add
+    @requirements_to_add ||= begin
+      array = arg_require.to_s.split(",").map(&:strip).reject(&:empty?)
+      array = [] if array == ["none"]
+      array
+    end
+  end
+
+  section :arguments
+
+  def arg_name() = @arg_name ||= (name = command.simple_arg(1) until name.to_s.strip.length.positive?; name)
+
+  def arg_action_names() = @arg_action_names ||= command.simple_args_from_2
+
+  def arg_place() = @arg_place ||= command.simple_string(:place)
+
+  def arg_place_path
+    @arg_place_path ||= begin
+      path = 
+        if available_places.key? arg_place
+          msg = "the place already exists"
+          available_places[arg_place]
+        else
+          msg = "infering the path"
+          system_name, subsystem_name = arg_place.split("/")
+          if subsystem_name.nil?
+            App.systems_directory.join "#{system_name}_system/#{super_controller.division.plural}"
+          else
+            App.systems_directory.join "#{system_name}_system/subsystems/#{subsystem_name}/#{super_controller.division.plural}"
+          end
+        end
+      log "#{msg}. #{path}"
+      path
+    end
+  end
+
+  def arg_require() = @arg_require ||= command.simple_string(:require)
+    
+  def arg_division() = @arg_division ||= command.simple_boolean(:division)
+
+  def arg_prefix() = @arg_prefix ||= command.simple_boolean(:prefix)
+
+  def arg_super() = @arg_super ||= command.simple_string(:super)
+
+  section :defaults_and_inputs
+
+  def self.set_default_ask(ask)= before_instance_call :set_default_ask, ask
+
+  def self.set_default_super(zuper)= before_instance_call :set_default_super, zuper
+  
+  def self.set_default_prefix(prefix)= before_instance_call :set_default_prefix, prefix
+
+  def self.set_default_division(division)= before_instance_call :set_default_division, division
+
+  def self.set_default_require(string)= before_instance_call :set_default_require, string
+  
+  def set_default_ask(ask)
+    command.set_default_boolean :ask, ask
+  end
+
+  def set_default_prefix(prefix)
+    command.set_default_boolean :prefix, prefix
+  end
+
+  def set_default_super(zuper)
+    command.set_default_string :super, zuper
+    log stick :white, :red, "Checking if class exists... #{arg_super}_#{env[:generator_name]}"
+    Liza.const "#{zuper}_#{env[:generator_name]}"
+  end
+
+  def set_default_division(division)
+    command.set_default_boolean :division, division
+  end
+
+  def set_default_require(string)
+    command.set_default_string :require, string    
+  end
+
+  set_input_arg 1 do |default|
+    title = "Name your new #{env[:generator].super_controller.last_namespace}:"
+    x = InputShell.ask title, default: default
+    redo if x.to_s.strip.empty?
+    x
+  end
+  
+  set_input_boolean :division do |default|
+    title = "Create a new division?"
+    InputShell.yes? title, default: !!default
+  end
+
+  set_input_boolean :prefix do |default|
+    title = "Do you want to prefix your controllers with their system names?"
+    InputShell.yes? title, default: !!default
+  end
+
+  set_input_string :place do |default|
+    available_places = env[:generator].available_places
+    place = nil
+    place = available_places.keys[0] if available_places.count == 1
+    place ||= begin
+      options = available_places.map do |place, path|
+        [
+          "#{place.ljust 30} path: #{path}",
+          place
+        ]
+      end.to_h
+      InputShell.pick_one "Where should the controller be placed?", options
+    end
+    place
+  end
+
+  set_input_string :require do |default|
+    title = "Want to require any gems? (comma separated)"
+    InputShell.ask title, default: default
+  end
+
+  set_default_division false
+  set_default_require "none"
+
+end

data/lib/dev_system/subsystems/generator/generators/controller_generator.rb.unit.rb.erb

@@ -0,0 +1,18 @@
+# view unit.rb.erb
+class <%= @class_names[0] %> < <%= @class_names[1] %>
+<% if not @class_name.end_with?("Test") -%>
+<% if arg_division -%>
+  division!
+<% end %>
+<% if requirements_to_add.any? -%>
+  # Liza lazily requires gems required in Controllers
+<% requirements_to_add.each do |requirement| -%>
+  require "<%= requirement %>"
+<% end -%>
+<% end -%>
+<% end -%>
+<% @current_unit.sections.each do |section| %>
+<%= "  section #{section[:name].inspect}" %>
+<%= section[:content] -%>
+<% end %>
+end

data/lib/dev_system/subsystems/generator/generators/controller_generator_test.rb

@@ -0,0 +1,48 @@
+class DevSystem::ControllerGeneratorTest < DevSystem::SimpleGeneratorTest
+  
+  test :subject_class, :subject do
+    assert_equality subject_class, DevSystem::ControllerGenerator
+    assert_equality subject.class, DevSystem::ControllerGenerator
+  end
+
+  test_erbs_defined(
+    "unit.rb.erb"
+  )
+
+  test :before_instance_calls, :before_instance_call do
+    assert_equality subject_class.before_instance_calls, [
+      [:set_default_views, ["none"], nil],
+      [:set_default_division, [false], nil],
+      [:set_default_require, ["none"], nil]
+    ]
+    assert_equality subject_class_subject.before_instance_calls, [
+      [:set_default_views, ["none"], nil],
+      [:set_default_division, [false], nil],
+      [:set_default_require, ["none"], nil]
+    ]
+
+    subject_class_subject.set_default_super "base"
+    subject_class_subject.set_default_division false
+    subject_class_subject.set_default_views "eof"
+    subject_class_subject.before_instance_call :foo, "bar", "baz"
+
+    assert_equality! subject_class.before_instance_calls, [
+      [:set_default_views, ["none"], nil],
+      [:set_default_division, [false], nil],
+      [:set_default_require, ["none"], nil]
+    ]
+    assert_equality subject_class_subject.before_instance_calls, [
+      [:set_default_views, ["none"], nil],
+      [:set_default_division, [false], nil],
+      [:set_default_require, ["none"], nil],
+      # new values below
+      [:set_default_super, ["base"], nil],
+      [:set_default_division, [false], nil],
+      [:set_default_views, ["eof"], nil],
+      [:foo, ["bar", "baz"], nil]
+    ]
+  end
+
+  def subject_class_subject() = @subject_class_subject ||= Class.new(subject_class)
+
+end

data/lib/dev_system/subsystems/generator/generators/generator_generator.rb

@@ -0,0 +1,58 @@
+class DevSystem::GeneratorGenerator < DevSystem::ControllerGenerator
+
+  section :default
+  
+  def arg_action_names()= @arg_action_names ||= ["default", *super]
+
+  set_default_views "adjacent"
+
+  set_default_string :format, "txt"
+  set_input_string :format do |default|
+    InputShell.ask "What format?", default: default
+  end
+
+  section :actions
+  
+  # liza g generator name place=app 
+
+  def call_default
+    call_simple
+  end
+
+  # liza g generator:controller
+
+  def call_controller
+    set_default_super "controller"
+    set_default_require ""
+
+    create_controller do |unit, test|
+      format = command.simple_string :format
+      unit.section name: :actions, render_key: :section_controller_actions, format: format
+
+      arg_action_names.each do |action_name|
+        unit.view name: "section_#{action_name}_actions", render_key: :view_controller_actions, format: :rb
+        unit.view name: "view_#{action_name}", render_key: :view_controller_views, render_format: :txt, format: format
+      end
+
+      test.section name: :subject
+    end
+  end
+
+  # liza g generator:simple format=txt
+
+  def call_simple
+    set_default_super "simple"
+    set_default_require ""
+
+    create_controller do |unit, test|
+      format = command.simple_string :format
+      unit.section name: :actions, render_key: :section_simple_actions, format: format
+      test.section name: :subject
+
+      arg_action_names.each do |action_name|
+        unit.view name: action_name, render_key: :view_simple, render_format: "txt", format: format
+      end
+    end
+  end
+
+end

data/lib/dev_system/subsystems/generator/generators/generator_generator.rb.section_controller_actions.rb.erb

@@ -0,0 +1,23 @@
+# view section_controller_actions.rb.erb
+
+  # set_default_views "none"
+  # set_default_views "eof"
+  # set_default_views "adjacent"
+  # set_default_views "nested"
+
+<% arg_action_names.each do |action_name| %>
+  # liza g <%= controller_name %><%= ":#{action_name}" if action_name != "default" %> name action_1 action_2 action_3
+  def call_<%= action_name %>
+    set_default_super "<%= action_name if action_name != "default" %>"
+
+    create_controller do |unit, test|
+      unit.section name: :actions, render_key: :section_<%= action_name %>_actions
+
+      arg_action_names.each do |action_name|
+        unit.view name: action_name, render_key: :view_<%= action_name %>, format: :<%= @current_section[:format] %>
+      end unless arg_views_none?
+
+      test.section name: :subject
+    end
+  end
+<% end %>

data/lib/dev_system/subsystems/generator/generators/generator_generator.rb.section_simple_actions.rb.erb

@@ -0,0 +1,19 @@
+# view section_simple_actions.rb.erb
+<% arg_action_names.each do |action_name| -%>
+
+  # liza g <%= controller_name %><%= ":#{action_name}" if action_name != "default" %> name
+  def call_<%= action_name %>
+    fname = arg_name
+
+    create_file "<%= @controller_name %><%= "_#{action_name}" if action_name != "default" %>_#{fname}.<%= @current_section[:format] %>", :<%= action_name %>, :<%= @current_section[:format] %>
+  end
+
+<% end -%>
+
+  def arg_name
+    # @arg_name ||= (name = command.simple_arg(1) until name.to_s.strip.length.positive?; name)
+    @arg_name ||= begin
+      name = command.simple_arg(1) until name.to_s.strip.length.positive?
+      name
+    end
+  end

data/lib/dev_system/subsystems/generator/generators/generator_generator.rb.view_controller_actions.rb.erb

@@ -0,0 +1,11 @@
+# view view_controller_actions.rb.erb
+
+<% arg_action_names.each do |action_name| %>
+  # <%= controller_name.camelcase %>.call action: :<%= action_name %>
+  # liza <%= controller_name %><%= ":#{action_name}" if action_name != "default" %> name action_1 action_2 action_3
+  def self.call_<%= action_name %>
+    # your code here
+    call(action: :<%= action_name %>)
+    # your code here
+  end
+<% end %>

data/lib/dev_system/subsystems/generator/generators/generator_generator.rb.view_controller_views.txt.erb

@@ -0,0 +1,2 @@
+# view view_controller_views.txt.erb
+yyy

data/lib/dev_system/subsystems/generator/generators/generator_generator.rb.view_simple.txt.erb

@@ -0,0 +1,2 @@
+# view view_simple.txt.erb
+This file was automatically generated by <%%= self.class %> at <%%= Time.now %>

data/lib/dev_system/subsystems/generator/generators/generator_generator_test.rb

@@ -0,0 +1,16 @@
+class DevSystem::GeneratorGeneratorTest < Liza::SimpleGeneratorTest
+
+  test :subject_class do
+    assert_equality subject_class, DevSystem::GeneratorGenerator
+    assert_equality subject.class, DevSystem::GeneratorGenerator
+  end
+
+  test_erbs_defined(
+    "section_controller_actions.rb.erb",
+    "section_simple_actions.rb.erb",
+    "view_controller_actions.rb.erb",
+    "view_controller_views.txt.erb",
+    "view_simple.txt.erb"
+  )
+
+end

data/lib/dev_system/subsystems/generator/generators/install_generator.rb

@@ -0,0 +1,9 @@
+class DevSystem::InstallGenerator < DevSystem::SimpleGenerator
+  
+  # liza g install
+  
+  def call_default
+    log stick :red, "Not implemented yet"
+  end
+
+end

data/lib/dev_system/subsystems/generator/generators/install_generator_test.rb

@@ -0,0 +1,8 @@
+class DevSystem::InstallGeneratorTest < DevSystem::SimpleGeneratorTest
+  
+  test :subject_class, :subject do
+    assert_equality DevSystem::InstallGenerator, subject_class
+    assert_equality DevSystem::InstallGenerator, subject.class
+  end
+  
+end