lizarb 1.0.5 → 1.0.6

data/lib/liza/unit_parts/unit_logging_part.rb

@@ -1,139 +0,0 @@
-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

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

data/lib/liza/unit_parts/unit_methods_part.rb

@@ -1,35 +0,0 @@
-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

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

data/lib/liza/unit_parts/unit_procedure_part.rb

@@ -1,17 +0,0 @@
-class Liza::UnitProcedurePart < Liza::Part
-
-  insertion do
-    def self.procedure _label = nil, &block
-      catch :procedure, &block
-    end
-
-    def self.proceed val = nil, &block
-      val = yield if val.nil? && block_given?
-      throw :procedure, val
-    end
-
-    def procedure(_label = nil, &block)= self.class.procedure _label, &block
-    def proceed(...)= self.class.proceed(...)
-  end
-
-end

data/lib/liza/unit_parts/unit_procedure_part_test.rb

@@ -1,65 +0,0 @@
-class Liza::UnitProcedurePartTest < Liza::UnitTest
-
-  test :procedure_scopes_and_returns do
-    b = nil
-
-    w =
-      procedure "creates a new scope" do
-        @a = 1
-        b = 2
-        assert true
-
-        proceed if true
-        raise "did not get here"
-      end
-
-    assert assertions > 0
-    assert w.nil?
-
-    x =
-      procedure "asserts old scope is not accessible" do
-        assert instance_variables.include? :@a
-        assert local_variables.include? :b
-
-        assert @a == 1
-        assert b == 2
-
-        proceed 100 if true
-        raise "did not get here"
-      end
-
-    assert x == 100
-
-    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
-    procedure "assert ensure works" do
-      @a = 1
-    ensure
-      @a = 2
-    end
-
-    assert @a == 2
-
-    procedure "assert rescue works" do
-      @a = [1]
-      raise "a runtime error!"
-    rescue RuntimeError
-      @a << 2
-    ensure
-      @a << 3
-    end
-
-    assert @a == [1, 2, 3]
-  end
-
-end

data/lib/liza/unit_parts/unit_renderer_part.rb

@@ -1,171 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,84 +0,0 @@
-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

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

data/lib/lizarb/ruby/class.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-class Class
-
-  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
-
-  def last_namespace
-    name.rpartition('::')[-1]
-  end
-
-end

data/lib/lizarb/ruby/module.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-class Module
-
-  # /path/to/liza.rb
-  def source_location
-    Array Object.const_source_location name
-  end
-
-  # /path/to/liza
-  def source_location_radical
-    source_location[0][0..-4]
-  rescue
-    nil
-  end
-
-end

data/lib/lizarb/ruby/proc.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-class Proc
-  def relative_source
-    absolute_source.gsub "#{Lizarb::APP_DIR}/", ""
-  end
-
-  def absolute_source
-    sl = source_location
-    "#{sl[0]}:#{sl[1]}"
-  end
-end

data/lib/lizarb/ruby/string.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-class String
-  alias lpartition partition
-
-  def camelcase
-    split("_").map { |s| "#{s[0].to_s.upcase}#{s[1..-1]}" }.join("")
-  end
-
-  alias camelize camelcase
-
-  def snakecase
-    gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
-      .gsub(/([a-z\d])([A-Z])/, '\1_\2')
-      .downcase
-  end
-  
-  alias snakefy snakecase
-
-  def rjust_blanks length
-    rjust length, " "
-  end
-
-  def rjust_zeroes length
-    rjust length, "0"
-  end
-
-  def ljust_blanks length
-    ljust length, " "
-  end
-
-  def ljust_zeroes length
-    ljust length, "0"
-  end
-end

data/lib/lizarb/ruby/time.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-class Time
-  def diff digits = 4
-    f = (self.class.now.to_f - to_f).floor(digits)
-    u, d = f.to_s.split "."
-    "#{u}.#{d.ljust digits, "0"}"
-  end
-end