lizarb 1.0.3 → 1.0.5

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_procedure_part_test.rb

@@ -7,7 +7,6 @@ class Liza::UnitProcedurePartTest < Liza::UnitTest
       procedure "creates a new scope" do
         @a = 1
         b = 2
-        c = 3
         assert true
 
         proceed if true
@@ -21,7 +20,6 @@ class Liza::UnitProcedurePartTest < Liza::UnitTest
       procedure "asserts old scope is not accessible" do
         assert instance_variables.include? :@a
         assert local_variables.include? :b
-        refute local_variables.include? :c
 
         assert @a == 1
         assert b == 2
@@ -32,13 +30,15 @@ class Liza::UnitProcedurePartTest < Liza::UnitTest
 
     assert x == 100
 
-    y =
-      procedure "asserts proceed calls can be lazy" do
-        proceed { "slow operation"; 200 } if true
-        raise "did not get here"
-      end
-
-    assert y == 200
+    y = procedure "asserts proceed calls can be lazy" do
+      proceed do
+        puts "slow operation"
+        200
+      end if true
+      raise "did not get here"
+    end
+    
+    assert y == 200    
   end
 
   test :procedure_rescue_and_ensure do

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

data/lib/liza/unit_parts/unit_settings_part.rb

@@ -0,0 +1,84 @@
+class Liza::UnitSettingsPart < Liza::Part
+
+  insertion do
+    def self.methods_for_settings
+      [:add, :fetch, :get, :set, :settings].sort
+    end
+  
+    def self.instance_methods_for_settings
+      [:add, :fetch, :get, :set, :settings].sort
+    end
+  
+    def self.settings
+      @settings ||= {}
+    end
+
+    def self.get key
+      return settings[key] if settings.has_key? key
+
+      found = nil
+
+      for klass in ancestors
+        break unless klass.respond_to? :settings
+
+        if klass.settings.has_key? key
+          found = klass.settings[key]
+
+          break
+        end
+      end
+
+      found = settings[key] = found.dup if found.is_a? Enumerable
+
+      found
+    end
+
+    def self.set key, value
+      settings[key] = value
+      value
+    end
+
+    def self.add list, key = nil, value
+      if key
+        fetch(list) { Hash.new }[key] = value
+      else
+        fetch(list) { Set.new } << value
+      end
+    end
+
+    def self.fetch key, &block
+      x = get key
+      x ||= set key, instance_eval(&block)
+      x
+    end
+
+    def settings
+      @settings ||= {}
+    end
+
+    def get key
+      return settings[key] if settings.has_key? key
+
+      self.class.get key
+    end
+
+    def set key, value
+      settings[key] = value
+    end
+
+    def add list, key = nil, value
+      if key
+        fetch(list) { Hash.new }[key] = value
+      else
+        fetch(list) { Set.new } << value
+      end
+    end
+
+    def fetch key, &block
+      x = get key
+      x ||= set key, eval(&block)
+      x
+    end
+  end
+
+end

data/lib/liza/unit_parts/unit_settings_part_test.rb

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

data/lib/liza/unit_test.rb

@@ -3,13 +3,122 @@ class Liza::UnitTest < Liza::Test
     assert subject_class == Liza::Unit
   end
 
+  #
+
+  def self.test_methods_defined(&block)
+    helper = TestMethodsDefinedHelper.new
+    helper.instance_eval(&block)
+
+    test :subject_class, :methods_defined do
+      a = subject_class.methods_defined
+      b = helper.methods
+      assert_equality a, b, kaller: helper.methods_caller
+    end
+
+    test :subject_class, :instance_methods_defined do
+      a = subject_class.instance_methods_defined
+      b = helper.instance_methods
+      assert_equality a, b, kaller: helper.instance_methods_caller
+    end
+  end
+
+  class TestMethodsDefinedHelper
+    attr_reader :methods, :methods_caller
+    attr_reader :instance_methods, :instance_methods_caller
+
+    def initialize
+      @methods, @instance_methods = [], []
+      @methods_caller, @instance_methods_caller = caller, caller
+    end
+
+    def on_self(*args)
+      @methods = args
+      @methods_caller = caller
+    end
+
+    def on_instance(*args)
+      @instance_methods = args
+      @instance_methods_caller = caller
+    end
+  end
+
+  #
+
+  test :subject_class, :methods_defined do
+    a = \
+      subject_class.methods_defined -
+      subject_class.methods_for_settings -
+      subject_class.methods_for_logging -
+      subject_class.methods_for_rendering
+    b = [
+      :descendants_select,
+      :division,
+      :instance_methods_defined, :instance_methods_for_logging, :instance_methods_for_rendering, :instance_methods_for_settings,
+      :methods_defined, :methods_for_logging, :methods_for_rendering, :methods_for_settings,
+      :namespace,
+      :part,
+      :procedure, :proceed,
+      :reload!,
+      :subclasses_select, :system, :system?,
+      :test_class
+    ]
+    assert_equality a, b
+  end
+
+  test :subject_class, :instance_methods_defined do
+    a = \
+      subject_class.instance_methods_defined -
+      subject_class.instance_methods_for_settings -
+      subject_class.instance_methods_for_logging -
+      subject_class.instance_methods_for_rendering
+    b = [:procedure, :proceed, :reload!, :system]
+    assert_equality a, b
+  end
+
+  test :subject_class, :methods_for_settings do
+    a = subject_class.methods_for_settings
+    b = [:add, :fetch, :get, :set, :settings]
+    assert_equality a, b
+  end
+
+  test :subject_class, :instance_methods_for_settings do
+    a = subject_class.instance_methods_for_settings
+    b = [:add, :fetch, :get, :set, :settings]
+    assert_equality a, b
+  end
+
+  test :subject_class, :methods_for_rendering do
+    a = subject_class.methods_for_rendering
+    b = [:erbs_available, :erbs_defined, :erbs_for, :renderable_formats_for, :renderable_names]
+    assert_equality a, b
+  end
+
+  test :subject_class, :instance_methods_for_rendering do
+    a = subject_class.instance_methods_for_rendering
+    b = [:render, :render!, :render_stack]
+    assert_equality a, b
+  end
+
+  test :subject_class, :methods_for_logging do
+    a = subject_class.methods_for_logging
+    b = [:log, :log?, :log_array, :log_hash, :log_level, :log_level?, :log_levels, :stick, :sticks]
+    assert_equality a, b
+  end
+
+  test :subject_class, :instance_methods_for_logging do
+    a = subject_class.instance_methods_for_logging
+    b = [:log, :log?, :log_array, :log_hash, :log_level, :log_level?, :log_levels, :log_render_convert, :log_render_in, :log_render_out, :stick, :sticks]
+    assert_equality a, b
+  end
+
   test :settings do
-    assert subject_class.get(:log_level) == :normal
-    assert subject_class.get(:log_color) == :white
-    assert subject_class.log_level == :normal
-    assert subject_class.log_color == :white
+    assert_equality subject_class.get(:log_level), 0
+    assert_equality subject_class.log_level, 0
 
-    assert subject_class.settings == {log_level: :normal, log_color: :white}
+    assert_equality subject_class.settings, {
+      log_level: 0,
+      division: Liza::Controller,
+    }
   end
 
   test :settings_inheritance do

data/lib/liza.rb

@@ -9,11 +9,15 @@ module Liza
   module_function
 
   def log s
-    puts s.bold
+    puts s
   end
 
   #
 
+  def [] name
+    const name
+  end
+
   # Checks Object, each system, then Liza for Liza::Unit classes
   def const name
     name = name.to_s.camelize.to_sym
@@ -29,7 +33,12 @@ module Liza
 
     nil
   rescue NameError
-    raise ConstNotFound, name
+    log "Liza const #{name} not found!" if $VERBOSE
+    if Lizarb.ruby_supports_raise_cause?
+      raise ConstNotFound, name, cause: nil
+    else
+      raise ConstNotFound, name, []
+    end
   end
 
   # Checks each system, then Liza for Liza::Unit classes

data/lib/lizarb/ruby/class.rb

@@ -1,12 +1,19 @@
 # frozen_string_literal: true
 
 class Class
-  public :eval
 
   def descendants
     ObjectSpace.each_object(Class).select { |klass| klass < self }
   end
 
+  def and_descendants
+    ObjectSpace.each_object(Class).select { |klass| klass <= self }
+  end
+  
+  def ancestors_until klass
+    ancestors.take_while { _1 <= klass }
+  end
+
   def first_namespace
     name.rpartition('::')[0]
   end
@@ -14,4 +21,5 @@ class Class
   def last_namespace
     name.rpartition('::')[-1]
   end
+
 end