lizarb 1.0.4 → 1.0.5

data/lib/liza/safety_parts/test_tree_part.rb

@@ -0,0 +1,87 @@
+class Liza::TestTreePart < Liza::Part
+
+  insertion do
+
+    @before_stack = []
+    @after_stack = []
+    
+    def self.before_stack; @before_stack ||= superclass.before_stack.dup end
+    def self.after_stack;  @after_stack  ||= superclass.after_stack.dup end
+    
+    def self.test_node; @test_node ||= test_tree end
+    def self.test_tree; @test_tree ||= Liza::TestTreePart.new nil, before_stack, after_stack end
+    
+    #
+
+    def self.group *words, &block
+      raise ArgumentError, "No block given" unless block_given?
+      previous = test_node
+      @test_node = test_node.branch_out words
+      instance_exec(&block)
+      @test_node = previous
+    end
+
+    def self.test *words, &block
+      raise ArgumentError, "No block given" unless block_given?
+      test_node.add_test words, &block
+    end
+
+    def self.before &block
+      raise ArgumentError, "No block given" unless block_given?
+      test_node.add_before(&block)
+    end
+
+    def self.after &block
+      raise ArgumentError, "No block given" unless block_given?
+      test_node.add_after(&block)
+    end
+
+  end
+
+  #
+
+  def log_test_building?
+    Liza::Test.log_test_building?
+  end
+
+  attr_reader :tests, :parent, :children, :before_stack, :after_stack
+
+  def initialize parent, before_stack, after_stack
+    @tests = []
+    initialize_parenting parent
+    initialize_filters before_stack, after_stack
+  end
+
+  def initialize_parenting parent
+    @parent = parent || self
+    @children = []
+    @parent.children << self if @parent != self
+  end
+
+  def initialize_filters before_stack, after_stack
+    @before_top, @after_top = [], []
+    @before_stack = before_stack.push @before_top
+    @after_stack  = after_stack.unshift @after_top
+  end
+
+  def add_before &block
+    log "add_before to ##{object_id} #{block}" if log_test_building?
+    @before_top.push block
+  end
+
+  def add_test words, &block
+    log "add_test to ##{object_id} #{words} #{block}" if log_test_building?
+    tests << [words, block]
+  end
+
+  def add_after &block
+    log "add_after to ##{object_id} #{block}" if log_test_building?
+    @after_top.push block
+  end
+
+  def branch_out words, &block
+    self.class.new self, before_stack.dup, after_stack.dup
+  end
+
+
+end

data/lib/liza/unit.rb

@@ -1,9 +1,13 @@
 class Liza::Unit
 
-  # PARTS
+  # ERROR
+  
+  class Error < Liza::Error; end
+
+  # PART
 
-  def self.part key, system: nil
-    App.connect_part self, key, system
+  def self.part key, klass = nil, system: nil
+    Lizarb.connect_part self, key, klass, system
   end
 
   # CONST MISSING
@@ -26,124 +30,70 @@ class Liza::Unit
 
   end
 
-  part :unit_procedure
-  part :unit_settings
-
-  # LOG
-
-  LOG_LEVELS = {
-    :higher => 2,
-    :high   => 1,
-    :normal => 0,
-    :low    => -1,
-    :lower  => -2,
-  }
-
-  set :log_level, :normal
-  set :log_color, :white
+  # PARTS
 
-  # NOTE: improve logs performance and readability
+  part :unit_classes
 
-  LOG_JUST = 60
+  part :unit_logging
 
-  def self.build_log_sidebar_for source, method_key, method_sep, panel_key: nil
-    source = (source.is_a? Class) ? source : source.class
-    source_color = source.log_color
-    source = source.to_s
+  part :unit_methods
 
-    s = source.bold.colorize(source_color)
-    s << "[:#{panel_key}]" if panel_key
-    s << "#{method_sep}#{method_key}"
-    s.ljust(LOG_JUST)
-  end
+  part :unit_procedure
+  
+  class RenderError < Error; end
+  class RendererNotFound < RenderError; end
+  class RenderStackIsFull < RenderError; end
+  class RenderStackIsEmpty < RenderError; end
+  part :unit_renderer
 
-  # NOTE: This code needs to be optimized.
-  def self._log_extract_method_name kaller
-    kaller.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
+  part :unit_settings
 
-    raise "there's something wrong with kaller"
-  end
+  # TEST
 
-  def _log_extract_method_name kaller
-    self.class._log_extract_method_name kaller
+  def self.test_class
+    @test_class ||=
+      if first_namespace == "Liza"
+        Liza.const_get "#{last_namespace}Test"
+      else
+        Object.const_get "#{name}Test"
+      end
   end
 
-  def self.log log_level = :normal, string, kaller: caller
-    raise "invalid log_level `#{log_level}`" unless LOG_LEVELS.keys.include? log_level
-    return unless log_level? log_level
+  # CONTROLLER
 
-    method_key = _log_extract_method_name kaller
-    source = Liza::Unit.build_log_sidebar_for self, method_key, ":"
-
-    DevBox[:log].call "#{source} #{string}"
+  def self.division
+    Liza::Controller
   end
 
-  def log log_level = :normal, string, kaller: caller
-    raise "invalid log_level `#{log_level}`" unless LOG_LEVELS.keys.include? log_level
-    return unless log_level? log_level
-
-    method_key = _log_extract_method_name kaller
+  # SYSTEM
 
-    case self
-    when Liza::Panel
-      source = Liza::Unit.build_log_sidebar_for box, method_key, ".", panel_key: @key
-    when Liza::UnitTest
-      source = Liza::Unit.build_log_sidebar_for self, " ", " "
+  def self.system
+    if name&.include? "::"
+      return System if first_namespace == "Liza"
+      Object.const_get first_namespace
     else
-      source = Liza::Unit.build_log_sidebar_for self, method_key, "#"
+      superclass.system
     end
-
-    DevBox[:log].call "#{source} #{string}"
   end
 
-  #
-
-  def self.log_level
-    get(:log_level) || :normal
-  end
-
-  def self.log_level? log_level = :normal
-    # TODO
-    true
-  end
+  singleton_class.send :public, :system
 
-  def self.log_color
-    (get(:system) || self).get :log_color
+  def system
+    self.class.system
   end
 
-  def self.log?(log_level = :normal)= log_level? log_level
-  def log_level(...)= self.class.log_level(...)
-  def log?(...)= self.class.log?(...)
-  def log_level?(...)= self.class.log_level?(...)
-  def log_color(...)= self.class.log_color(...)
-
-  # SYSTEM
-
-  def self.inherited_explicitly_sets_system
+  public :system
 
-    def self.inherited sub
-      super
-
-      return unless sub.name.to_s.include? "::"
-
-      system = Object.const_get sub.first_namespace
-
-      sub.set :system, system
-    end
+  #
 
+  App.settings.each do |k, v|
+    set k, v
   end
-
+  set :division, Liza::Controller
+  
 end
+
+__END__
+
+# view render.txt.erb
+<%= render if render_stack.any? -%>

data/lib/liza/unit_parts/unit_classes_part.rb

@@ -0,0 +1,37 @@
+class Liza::UnitClassesPart < Liza::Part
+
+  insertion do
+    
+    def self.subclasses_select system:
+      subclasses.select { _1.system? system }
+    end
+
+    def self.descendants_select system:
+      descendants.select { _1.system? system }
+    end
+
+    def self.namespace
+      return @namespace if defined? @namespace
+
+      @namespace ||= Object unless to_s.include? "::"
+      @namespace ||= Liza if to_s.start_with? "Liza::"
+      @namespace ||= system
+      @namespace
+    end
+
+    def self.system? system
+      system = Liza.const "#{system}_system" if system.is_a? Symbol
+      system == get(:system)
+    end
+
+    def self.reload!
+      Lizarb.reload
+    end
+
+    def reload!
+      Lizarb.reload
+    end
+
+  end
+
+end

data/lib/liza/unit_parts/unit_classes_part_test.rb

@@ -0,0 +1,3 @@
+class Liza::UnitClassesPartTest < Liza::UnitTest
+
+end

data/lib/liza/unit_parts/unit_logging_part.rb

@@ -0,0 +1,139 @@
+class Liza::UnitLoggingPart < Liza::Part
+
+  insertion do
+    
+    # LOG
+
+    def self.log_levels()=App::LOG_LEVELS
+    def log_levels()= App::LOG_LEVELS
+  
+    def self.log log_level = App::DEFAULT_LOG_LEVEL, object, kaller: caller
+      log_level = log_levels[log_level] if log_level.is_a? Symbol
+      raise "invalid log_level `#{log_level}`" unless log_levels.values.include? log_level
+      return unless log_level? log_level
+  
+      env = {}
+      env[:type] = :log
+      env[:unit] = self
+      env[:unit_class] = self
+      env[:message_log_level] = log_level
+      env[:unit_log_level] = self.log_level
+      env[:caller] = kaller
+      env[:object] = object
+  
+      DevBox[:log].call env
+    end
+  
+    def log log_level = App::DEFAULT_LOG_LEVEL, object, kaller: caller
+      log_level = log_levels[log_level] if log_level.is_a? Symbol
+      raise "invalid log_level `#{log_level}`" unless log_levels.values.include? log_level
+      return unless log_level? log_level
+  
+      env = {}
+      env[:type] = :log
+      env[:unit] = self
+      env[:unit_class] = self.class
+      env[:message_log_level] = log_level
+      env[:unit_log_level] = self.log_level
+      env[:caller] = kaller
+      env[:object] = object
+  
+      DevBox[:log].call env
+    end
+  
+    def self.stick *args
+      StickLog.new *args
+    end
+  
+    def stick *args
+      StickLog.new *args
+    end
+  
+    def self.sticks *args
+      StickLog.bundle *args
+    end
+  
+    def sticks *args
+      StickLog.bundle *args
+    end
+  
+    #
+  
+    def self.log_level new_value = nil
+      if new_value
+        new_value = log_levels[new_value] if new_value.is_a? Symbol
+        raise "invalid log_level `#{new_value}`" unless log_levels.values.include? new_value
+        set :log_level, new_value
+      else
+        get :log_level
+      end
+    end
+  
+    def log_level new_value = nil
+      if new_value
+        new_value = log_levels[new_value] if new_value.is_a? Symbol
+        raise "invalid log_level `#{new_value}`" unless log_levels.values.include? new_value
+        set :log_level, new_value
+      else
+        get :log_level
+      end
+    end
+
+    #
+  
+    def self.log_hash log_level = :normal, hash, prefix: "", kaller: caller[1..-1]
+      prefix = prefix.to_s
+      size = hash.keys.map(&:to_s).map(&:size).max
+      
+      hash.each do |k,v|
+        log log_level, "#{prefix}#{k.to_s.ljust size} = #{v.to_s.inspect}", kaller: kaller
+      end
+    end
+  
+    def log_hash log_level = :normal, hash, prefix: "", kaller: caller[1..-1]
+      prefix = prefix.to_s
+      size = hash.keys.map(&:to_s).map(&:size).max
+      
+      hash.each do |k,v|
+        log log_level, "#{prefix}#{k.to_s.ljust size} = #{v.to_s.inspect}", kaller: kaller
+      end
+    end
+
+    #
+  
+    def self.log_array log_level = :normal, array, prefix: "", kaller: caller[1..-1]
+      prefix = prefix.to_s
+      size = array.size.to_s.size+1
+      
+      array.each.with_index do |v, i|
+        log log_level, "#{prefix}#{i.to_s.ljust size} = #{v.inspect}", kaller: kaller
+      end
+    end
+  
+    def log_array log_level = :normal, array, prefix: "", kaller: caller[1..-1]
+      prefix = prefix.to_s
+      size = array.size.to_s.size+1
+      
+      array.each.with_index do |v, i|
+        log log_level, "#{prefix}#{i.to_s.ljust size} = #{v.inspect}", kaller: kaller
+      end
+    end
+  
+    #
+  
+    def self.log?(log_level = App::DEFAULT_LOG_LEVEL)= log_level? log_level
+    def log?(...)= log_level? log_level
+  
+    def self.log_level? log_level = App::DEFAULT_LOG_LEVEL
+      log_level = log_levels[log_level] if log_level.is_a? Symbol
+      log_level >= self.log_level
+    end
+  
+    def log_level? log_level = App::DEFAULT_LOG_LEVEL
+      log_level = log_levels[log_level] if log_level.is_a? Symbol
+      log_level >= self.log_level
+    end
+  
+  end
+
+end

data/lib/liza/unit_parts/unit_logging_part_test.rb

@@ -0,0 +1,3 @@
+class Liza::UnitLoggingPartTest < Liza::UnitTest
+
+end

data/lib/liza/unit_parts/unit_methods_part.rb

@@ -0,0 +1,35 @@
+class Liza::UnitMethodsPart < Liza::Part
+
+  insertion do
+    def self.methods_defined
+      a = methods - superclass.methods
+      a.reject! { _1.to_s[0] == "_" }
+      a.sort!
+    end
+
+    def self.instance_methods_defined
+      a = instance_methods - superclass.instance_methods
+      a.reject! { _1.to_s[0] == "_" }
+      a.sort!
+    end
+
+    def self.methods_for_rendering
+      methods_defined.select { _1[0..5] == "render" || _1[0..2] == "erb" }.sort
+    end
+
+    def self.instance_methods_for_rendering
+      instance_methods_defined.select { _1[0..5] == "render" || _1[0..2] == "erb" }.sort
+    end
+
+    def self.methods_for_logging
+      array = methods_defined.select { _1[0..2] == "log" }.sort
+      [*array, :stick, :sticks]
+    end
+
+    def self.instance_methods_for_logging
+      array = instance_methods_defined.select { _1[0..2] == "log" }.sort
+      [*array, :stick, :sticks]
+    end
+  end
+
+end

data/lib/liza/unit_parts/unit_methods_part_test.rb

@@ -0,0 +1,3 @@
+class Liza::UnitMethodsPartTest < Liza::UnitTest
+
+end

data/lib/liza/unit_parts/unit_procedure_part.rb

@@ -1,7 +1,7 @@
 class Liza::UnitProcedurePart < Liza::Part
 
   insertion do
-    def self.procedure _label, &block
+    def self.procedure _label = nil, &block
       catch :procedure, &block
     end
 
@@ -10,7 +10,7 @@ class Liza::UnitProcedurePart < Liza::Part
       throw :procedure, val
     end
 
-    def procedure(_label, &block)= self.class.procedure _label, &block
+    def procedure(_label = nil, &block)= self.class.procedure _label, &block
     def proceed(...)= self.class.proceed(...)
   end
 

data/lib/liza/unit_parts/unit_renderer_part.rb

@@ -0,0 +1,171 @@
+class Liza::UnitRendererPart < Liza::Part
+
+  RENDER_STACK_IS_EMPTY_MESSAGE = <<~STRING
+You called render without ERB keys,
+but the render stack is empty.
+Did you forget to add ERB keys?
+  STRING
+
+  RENDER_STACK_IS_FULL_MESSAGE = <<~STRING
+You called render with too many ERB keys.
+Did you accidentally fall into an infinite loop?
+  STRING
+
+  insertion do
+    def render! *keys, format: nil
+      render *keys, format: format, allow_missing: false
+    end
+
+    def render *keys, format: nil, allow_missing: true
+      format = @render_format ||= @format if format.nil?
+      raise "@render_format or @format must be set, or format keyword-argument must be given" if format.nil?
+      @render_format = format = format.to_sym
+
+      log_rendering = log_level? :low
+      
+      if keys.any?
+        log_render_in keys, kaller: caller if log_rendering
+
+        erbs = self.class.erbs_for format, keys, allow_missing: allow_missing
+        erbs.to_a.reverse.each do |key, erb|
+          if true
+            t = Time.now
+            s = erb.result binding, self
+            log_render_out "#{erb.name}.#{erb.format}", s.length, t.diff, kaller: caller if log_rendering
+          end
+          
+          if DevBox.convert? erb.format
+            t = Time.now
+            s = DevBox.convert erb.format, s
+            log_render_convert "#{erb.name}.#{format}", s.length, t.diff, kaller: caller if log_rendering
+          end
+  
+          render_stack.push s
+
+          raise RenderStackIsFull RENDER_STACK_IS_FULL_MESSAGE, caller if render_stack.size > 10
+        end
+  
+        render_stack.pop
+      elsif render_stack.any?
+        render_stack.pop
+      else
+        raise RenderStackIsEmpty, RENDER_STACK_IS_EMPTY_MESSAGE, caller
+      end
+    end
+
+    def render_stack
+      @render_stack ||= []
+    end
+
+    def log_render_in keys, kaller: 
+      if render_stack.any?
+        log "render → #{keys.join " "}", kaller: kaller
+      else
+        log "render #{"→ " * keys.size}#{keys.join " "}", kaller: kaller
+      end
+    end
+
+    def log_render_out key, length, t, kaller: 
+      if render_stack.any?
+        log "render #{"← #{key}".ljust_blanks 25} #{length.to_s.rjust_blanks 4} characters in #{t}s", kaller: kaller
+      else
+        log "render #{"← #{key}".ljust_blanks 25} #{length.to_s.rjust_blanks 4} characters in #{t}s", kaller: kaller
+      end
+    end
+
+    def log_render_convert key, length, t, kaller: 
+      log "convert  #{"#{key}".ljust_blanks 23} #{length.to_s.rjust_blanks 4} characters in #{t}s", kaller: kaller
+    end
+
+    # class level methods
+
+    def self.erbs_defined
+      @erbs_defined ||= LERB.load(self.source_location_radical)
+    end
+
+    def self.erbs_available ref = Liza::Unit
+      @erbs_available ||= begin
+        h = {}
+
+        ancestors.take_while do |ancestor|
+          ancestor != ref
+        end.reverse.each do |ancestor|
+          ancestor.erbs_defined.each do |erb|
+            h[erb.key] = erb
+          end
+        end
+
+        h.values
+      end
+    end
+
+    def self.renderable_names
+      erbs_available.map(&:name).uniq
+    end
+
+    def self.renderable_formats_for name_string
+      erbs_available.select { _1.name == name_string }
+    end
+
+    def self.erbs_for format, names, allow_missing:
+      @erbs_for ||= {}
+      k = "#{format}-#{names.join("-")}"
+      @erbs_for[k] ||= _erbs_for format, names, allow_missing:
+    end
+
+    def self._erbs_for format, names, allow_missing:
+      ret = {}
+
+      log_erb = log_level? :lower
+
+      converters = DevBox.converters_to[format] || []
+      converters_from = converters.map { _1[:from] }
+      format_with_converters_from = [format, *converters_from]
+      log "names #{names.join(" ").green} | formats #{format_with_converters_from.join(" ").green}" if log_erb
+
+      names.each do |name|
+        name_string = name.to_s
+        log "      #{name_string}#{".*.erb # filtering name  "} #{renderable_names.join(" ")}".light_black if log_erb
+        
+        name_candidates = renderable_formats_for name_string
+        if name_candidates.none?
+
+          if allow_missing
+            log "      #{name_string}.#{format}.erb not found, but allow_missing: true".light_yellow if log_erb
+            found = Liza::Unit.erbs_defined.first
+          else
+            log "    #{name}.#{format}.erb not found, and allow_missing: false".red
+            raise RendererNotFound, "ERB #{name}.#{format}.erb not found"
+          end
+
+        else
+
+          log "      #{name_string}#{".*.erb # filtering format "}#{name_candidates.map(&:format).join(" ")}".light_black if log_erb
+
+          found = name_candidates.find do |erb|
+            erb_format_sym = erb.format.to_sym
+            format_with_converters_from.include? erb_format_sym
+          end
+
+          if found
+            log "      #{found.key} found".green if log_erb
+          else
+            if allow_missing
+              log "    #{name}.#{format}.erb not found, but allow_missing: true".light_yellow if log_erb
+              found = Liza::Unit.erbs_defined.first
+            else
+              log "    #{name}.#{format}.erb not found, and allow_missing: false".red
+              raise RendererNotFound, "ERB #{name}.#{format}.erb not found"
+            end
+          end
+
+        end
+
+        ret[name] = found
+      end
+
+      ret
+    end
+  end
+
+end

data/lib/liza/unit_parts/unit_renderer_part_test.rb

@@ -0,0 +1,15 @@
+class Liza::UnitRendererPartTest < Liza::UnitTest
+
+  test :erbs_defined do
+    erbs_defined = Unit.erbs_defined.map(&:key)
+    expected = ["render.txt.erb"]
+    assert_equality erbs_defined, expected
+  end
+
+  test :erbs_available do
+    erbs_available = Unit.erbs_available.map(&:key)
+    expected = []
+    assert_equality erbs_available, expected
+  end
+
+end