lizarb 1.0.2 → 1.0.4

data/lib/liza/test_parts/test_tree_part.rb

@@ -1,139 +1,92 @@
-module Liza
-  class TestTreePart < 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::Extension.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
-
+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::Extension.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
 
-    extension do
-      
-      def log *args
-        self.class.solder.log *args
-      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
-        @parent = parent || self
-
-        @children, @tests = [], []
-        @before_top, @after_top = [], []
-
-        @before_stack = before_stack.push @before_top
-        @after_stack  = after_stack.unshift @after_top
-
-        @parent.children << self if @parent != self
-      end
-
-      def initialize parent, before_stack, after_stack
-        @parent = parent || self
-
-        @children, @tests, @before_top, @after_top = [], [], [], []
-
-        @before_stack = before_stack.push @before_top
-        @after_stack  = after_stack.unshift @after_top
-
-        @parent.children << self if @parent != self
-      end
+    def self.test *words, &block
+      raise ArgumentError, "No block given" unless block_given?
+      test_node.add_test words, &block
+    end
 
-      def initialize parent, before_stack, after_stack
-        @parent = parent || self
-        @children, @tests = [], []
-        @parent.children << self if @parent != self
+    def self.before &block
+      raise ArgumentError, "No block given" unless block_given?
+      test_node.add_before(&block)
+    end
 
-        @before_top, @after_top = [], []
-        @before_stack = before_stack.push @before_top
-        @after_stack  = after_stack.unshift @after_top
-      end
+    def self.after &block
+      raise ArgumentError, "No block given" unless block_given?
+      test_node.add_after(&block)
+    end
 
-      def initialize parent, before_stack, after_stack
-        @tests = []
+  end
 
-        @parent = parent || self
-        @children = []
-        @parent.children << self if @parent != self
+  extension do
+    
+    def log *args
+      self.class.solder.log(*args)
+    end
 
-        @before_top, @after_top = [], []
-        @before_stack = before_stack.push @before_top
-        @after_stack  = after_stack.unshift @after_top
-      end
+    def log_test_building?
+      Liza::Test.log_test_building?
+    end
 
-      def initialize parent, before_stack, after_stack
-        @tests = []
-        initialize_parenting parent
-        initialize_filters before_stack, after_stack
-      end
+    attr_reader :tests, :parent, :children, :before_stack, :after_stack
 
-      def initialize_parenting parent
-        @parent = parent || self
-        @children = []
-        @parent.children << self if @parent != self
-      end
+    def initialize parent, before_stack, after_stack
+      @tests = []
+      initialize_parenting parent
+      initialize_filters before_stack, after_stack
+    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 initialize_parenting parent
+      @parent = parent || self
+      @children = []
+      @parent.children << self if @parent != self
+    end
 
-      def add_before &block
-        log "add_before to ##{object_id} #{block}" if log_test_building?
-        @before_top.push block
-      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_test words, &block
-        log "add_test to ##{object_id} #{words} #{block}" if log_test_building?
-        tests << [words, block]
-      end
+    def add_before &block
+      log "add_before to ##{object_id} #{block}" if log_test_building?
+      @before_top.push block
+    end
 
-      def add_after &block
-        log "add_after to ##{object_id} #{block}" if log_test_building?
-        @after_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 branch_out words, &block
-        self.class.new self, before_stack.dup, after_stack.dup
-      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
+
 end

data/lib/liza/unit.rb

@@ -1,151 +1,149 @@
-module Liza
-  class Unit
+class Liza::Unit
 
-    # PARTS
+  # PARTS
 
-    def self.part key, system: nil
-      App.connect_part self, key, system
-    end
+  def self.part key, system: nil
+    App.connect_part self, key, system
+  end
 
-    part :unit_procedure
+  # CONST MISSING
 
-    # SETTINGS
+  if Lizarb.ruby_supports_raise_cause?
 
-    def self.settings
-      @settings ||= {}
+    def self.const_missing name
+      Liza.const name
+    rescue Liza::ConstNotFound
+      raise NameError, "uninitialized constant #{name}", caller[1..], cause: nil
     end
 
-    def self.get key
-      return settings[key] if settings.has_key? key
+  else
 
-      found = nil
+    def self.const_missing name
+      Liza.const name
+    rescue Liza::ConstNotFound
+      raise NameError, "uninitialized constant #{name}", caller[1..]
+    end
 
-      for klass in ancestors
-        break unless klass.respond_to? :settings
+  end
 
-        if klass.settings.has_key? key
-          found = klass.settings[key]
+  part :unit_procedure
+  part :unit_settings
 
-          break
-        end
-      end
+  # LOG
 
-      found = settings[key] = found.dup if found.is_a? Enumerable
+  LOG_LEVELS = {
+    :higher => 2,
+    :high   => 1,
+    :normal => 0,
+    :low    => -1,
+    :lower  => -2,
+  }
 
-      found
-    end
+  set :log_level, :normal
+  set :log_color, :white
 
-    def self.set key, value
-      settings[key] = value
-      value
-    end
+  # NOTE: improve logs performance and readability
 
-    def self.add list, key = nil, value
-      if key
-        fetch(list) { Hash.new }[key] = value
-      else
-        fetch(list) { Set.new } << value
-      end
-    end
+  LOG_JUST = 60
 
-    def self.fetch key, &block
-      x = get key
-      x ||= set key, instance_eval(&block)
-      x
-    end
+  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
 
-    def settings
-      @settings ||= {}
-    end
-
-    def get key
-      return settings[key] if settings.has_key? key
-
-      self.class.get key
-    end
+    s = source.bold.colorize(source_color)
+    s << "[:#{panel_key}]" if panel_key
+    s << "#{method_sep}#{method_key}"
+    s.ljust(LOG_JUST)
+  end
 
-    def set key, value
-      settings[key] = value
-    end
+  # NOTE: This code needs to be optimized.
+  def self._log_extract_method_name kaller
+    kaller.each do |s|
+      t = s.match(/`(.*)'/)[1]
 
-    def add list, key = nil, value
-      if key
-        fetch(list) { Hash.new }[key] = value
-      else
-        fetch(list) { Set.new } << value
-      end
+      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
 
-    def fetch key, &block
-      x = get key
-      x ||= set key, eval(&block)
-      x
-    end
-
-    # LOG
-
-    LOG_LEVELS = {
-      :higher => 2,
-      :high   => 1,
-      :normal => 0,
-      :low    => -1,
-      :lower  => -2,
-    }
+    raise "there's something wrong with kaller"
+  end
 
-    set :log_level, :normal
-    set :log_color, :white
+  def _log_extract_method_name kaller
+    self.class._log_extract_method_name kaller
+  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
 
-    LOG_JUST = 40
+    method_key = _log_extract_method_name kaller
+    source = Liza::Unit.build_log_sidebar_for self, method_key, ":"
 
-    def self.log log_level = :normal, string
-      raise "invalid log_level `#{log_level}`" unless LOG_LEVELS.keys.include? log_level
-      return unless log_level? log_level
+    DevBox[:log].call "#{source} #{string}"
+  end
 
-      source = (self.is_a? Class) ? self : self.class
-      source = source.to_s.ljust(LOG_JUST).bold.colorize(source.log_color)
+  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
 
-      string = "#{source} #{string}"
+    method_key = _log_extract_method_name kaller
 
-      DevBox.logs.call string
+    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, " ", " "
+    else
+      source = Liza::Unit.build_log_sidebar_for self, method_key, "#"
     end
 
-    def self.log_level
-      get(:log_level) || :normal
-    end
+    DevBox[:log].call "#{source} #{string}"
+  end
 
-    def self.log_level? log_level = :normal
-      # TODO
-      true
-    end
+  #
 
-    def self.log_color
-      (get(:system) || self).get :log_color
-    end
+  def self.log_level
+    get(:log_level) || :normal
+  end
 
-    def self.log?(log_level = :normal)= log_level? log_level
-    def log(...)= self.class.log(...)
-    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(...)
+  def self.log_level? log_level = :normal
+    # TODO
+    true
+  end
 
-    # SYSTEM
+  def self.log_color
+    (get(:system) || self).get :log_color
+  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(...)
 
-    def self.inherited_explicitly_sets_system
+  # SYSTEM
 
-      def self.inherited sub
-        super
+  def self.inherited_explicitly_sets_system
 
-        return unless sub.name.to_s.include? "::"
+    def self.inherited sub
+      super
 
-        system = Object.const_get sub.first_namespace
+      return unless sub.name.to_s.include? "::"
 
-        sub.set :system, system
-      end
+      system = Object.const_get sub.first_namespace
 
+      sub.set :system, system
     end
 
   end
+
 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_settings_part.rb

@@ -0,0 +1,76 @@
+class Liza::UnitSettingsPart < Liza::Part
+
+  insertion do
+    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