lizarb 1.0.2 → 1.0.3

data/lib/liza/test_parts/test_tree_part.rb

@@ -1,139 +1,137 @@
-module Liza
-  class TestTreePart < Part
+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
 
-    insertion do
+    def self.test *words, &block
+      raise ArgumentError, "No block given" unless block_given?
+      test_node.add_test words, &block
+    end
 
-      @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
+    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
 
-    extension do
-      
-      def log *args
-        self.class.solder.log *args
-      end
+  end
 
-      def log_test_building?
-        Liza::Test.log_test_building?
-      end
+  extension do
+    
+    def log *args
+      self.class.solder.log *args
+    end
 
-      attr_reader :tests, :parent, :children, :before_stack, :after_stack
+    def log_test_building?
+      Liza::Test.log_test_building?
+    end
 
-      def initialize parent, before_stack, after_stack
-        @parent = parent || self
+    attr_reader :tests, :parent, :children, :before_stack, :after_stack
 
-        @children, @tests = [], []
-        @before_top, @after_top = [], []
+    def initialize parent, before_stack, after_stack
+      @parent = parent || self
 
-        @before_stack = before_stack.push @before_top
-        @after_stack  = after_stack.unshift @after_top
+      @children, @tests = [], []
+      @before_top, @after_top = [], []
 
-        @parent.children << self if @parent != self
-      end
+      @before_stack = before_stack.push @before_top
+      @after_stack  = after_stack.unshift @after_top
 
-      def initialize parent, before_stack, after_stack
-        @parent = parent || self
+      @parent.children << self if @parent != self
+    end
 
-        @children, @tests, @before_top, @after_top = [], [], [], []
+    def initialize parent, before_stack, after_stack
+      @parent = parent || self
 
-        @before_stack = before_stack.push @before_top
-        @after_stack  = after_stack.unshift @after_top
+      @children, @tests, @before_top, @after_top = [], [], [], []
 
-        @parent.children << self if @parent != self
-      end
+      @before_stack = before_stack.push @before_top
+      @after_stack  = after_stack.unshift @after_top
 
-      def initialize parent, before_stack, after_stack
-        @parent = parent || self
-        @children, @tests = [], []
-        @parent.children << self if @parent != self
+      @parent.children << self if @parent != self
+    end
 
-        @before_top, @after_top = [], []
-        @before_stack = before_stack.push @before_top
-        @after_stack  = after_stack.unshift @after_top
-      end
+    def initialize parent, before_stack, after_stack
+      @parent = parent || self
+      @children, @tests = [], []
+      @parent.children << self if @parent != self
 
-      def initialize parent, before_stack, after_stack
-        @tests = []
+      @before_top, @after_top = [], []
+      @before_stack = before_stack.push @before_top
+      @after_stack  = after_stack.unshift @after_top
+    end
 
-        @parent = parent || self
-        @children = []
-        @parent.children << self if @parent != self
+    def initialize parent, before_stack, after_stack
+      @tests = []
 
-        @before_top, @after_top = [], []
-        @before_stack = before_stack.push @before_top
-        @after_stack  = after_stack.unshift @after_top
-      end
+      @parent = parent || self
+      @children = []
+      @parent.children << self if @parent != self
 
-      def initialize parent, before_stack, after_stack
-        @tests = []
-        initialize_parenting parent
-        initialize_filters before_stack, after_stack
-      end
+      @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 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,155 @@
-module Liza
-  class Unit
+class Liza::Unit
 
-    # PARTS
+  # PARTS
 
-    def self.part key, system: nil
-      App.connect_part self, key, system
-    end
-
-    part :unit_procedure
+  def self.part key, system: nil
+    App.connect_part self, key, system
+  end
 
-    # SETTINGS
+  def self.const_missing name
+    Liza.const name
+  rescue Liza::ConstNotFound => e
+    raise NameError, "uninitialized constant #{name}", caller[1..], cause: nil
+  end
 
-    def self.settings
-      @settings ||= {}
-    end
+  part :unit_procedure
 
-    def self.get key
-      return settings[key] if settings.has_key? key
+  # SETTINGS
 
-      found = nil
+  def self.settings
+    @settings ||= {}
+  end
 
-      for klass in ancestors
-        break unless klass.respond_to? :settings
+  def self.get key
+    return settings[key] if settings.has_key? key
 
-        if klass.settings.has_key? key
-          found = klass.settings[key]
+    found = nil
 
-          break
-        end
-      end
+    for klass in ancestors
+      break unless klass.respond_to? :settings
 
-      found = settings[key] = found.dup if found.is_a? Enumerable
+      if klass.settings.has_key? key
+        found = klass.settings[key]
 
-      found
+        break
+      end
     end
 
-    def self.set key, value
-      settings[key] = value
-      value
-    end
+    found = settings[key] = found.dup if found.is_a? Enumerable
 
-    def self.add list, key = nil, value
-      if key
-        fetch(list) { Hash.new }[key] = value
-      else
-        fetch(list) { Set.new } << value
-      end
-    end
+    found
+  end
 
-    def self.fetch key, &block
-      x = get key
-      x ||= set key, instance_eval(&block)
-      x
-    end
+  def self.set key, value
+    settings[key] = value
+    value
+  end
 
-    def settings
-      @settings ||= {}
+  def self.add list, key = nil, value
+    if key
+      fetch(list) { Hash.new }[key] = value
+    else
+      fetch(list) { Set.new } << value
     end
+  end
 
-    def get key
-      return settings[key] if settings.has_key? key
+  def self.fetch key, &block
+    x = get key
+    x ||= set key, instance_eval(&block)
+    x
+  end
 
-      self.class.get key
-    end
+  def settings
+    @settings ||= {}
+  end
 
-    def set key, value
-      settings[key] = value
-    end
+  def get key
+    return settings[key] if settings.has_key? key
 
-    def add list, key = nil, value
-      if key
-        fetch(list) { Hash.new }[key] = value
-      else
-        fetch(list) { Set.new } << value
-      end
-    end
+    self.class.get key
+  end
 
-    def fetch key, &block
-      x = get key
-      x ||= set key, eval(&block)
-      x
+  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
 
-    # LOG
+  def fetch key, &block
+    x = get key
+    x ||= set key, eval(&block)
+    x
+  end
 
-    LOG_LEVELS = {
-      :higher => 2,
-      :high   => 1,
-      :normal => 0,
-      :low    => -1,
-      :lower  => -2,
-    }
+  # LOG
 
-    set :log_level, :normal
-    set :log_color, :white
+  LOG_LEVELS = {
+    :higher => 2,
+    :high   => 1,
+    :normal => 0,
+    :low    => -1,
+    :lower  => -2,
+  }
 
-    #
+  set :log_level, :normal
+  set :log_color, :white
 
-    LOG_JUST = 40
+  #
 
-    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
+  LOG_JUST = 40
 
-      source = (self.is_a? Class) ? self : self.class
-      source = source.to_s.ljust(LOG_JUST).bold.colorize(source.log_color)
+  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
 
-      string = "#{source} #{string}"
+    source = (self.is_a? Class) ? self : self.class
+    source = source.to_s.ljust(LOG_JUST).bold.colorize(source.log_color)
 
-      DevBox.logs.call string
-    end
+    string = "#{source} #{string}"
 
-    def self.log_level
-      get(:log_level) || :normal
-    end
+    DevBox[:log].call string
+  end
 
-    def self.log_level? log_level = :normal
-      # TODO
-      true
-    end
+  def self.log_level
+    get(:log_level) || :normal
+  end
 
-    def self.log_color
-      (get(:system) || self).get :log_color
-    end
+  def self.log_level? log_level = :normal
+    # TODO
+    true
+  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_color
+    (get(:system) || self).get :log_color
+  end
 
-    # SYSTEM
+  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.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_test.rb

@@ -1,79 +1,77 @@
-module Liza
-  class UnitTest < Test
-    test :subject_class do
-      assert subject_class == Liza::Unit
-    end
+class Liza::UnitTest < Liza::Test
+  test :subject_class do
+    assert subject_class == Liza::Unit
+  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 subject_class.settings == {log_level: :normal, log_color: :white}
+  end
+
+  test :settings_inheritance do
+    class_a = Class.new(subject_class) do
+      set :number, 1
+
+      add :default, 10
+      add :default, 20
 
-    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
+      set :array, []
+      add :array, 10
+      add :array, 20
 
-      assert subject_class.settings == {log_level: :normal, log_color: :white}
+      add :hash, :a, 10
+      add :hash, :b, 20
     end
 
-    test :settings_inheritance do
-      class_a = Class.new(subject_class) do
-        set :number, 1
-
-        add :default, 10
-        add :default, 20
-
-        set :array, []
-        add :array, 10
-        add :array, 20
-
-        add :hash, :a, 10
-        add :hash, :b, 20
-      end
-
-      assert class_a.settings == {
-        number: 1,
-        default: Set[10, 20],
-        array: [10, 20],
-        hash: {a: 10, b: 20}
-      }
-
-      assert class_a.get(:default) == Set[10, 20]
-      assert class_a.get(:array) == [10, 20]
-      assert class_a.get(:hash) == {a: 10, b: 20}
-
-      class_b = Class.new(class_a) do
-        set :string, "a"
-
-        add :default, 30
-        add :default, 40
-
-        add :array, 30
-        add :array, 40
-
-        add :hash, :c, 30
-        add :hash, :d, 40
-      end
-
-      assert class_a.settings == {
-        number: 1,
-        default: Set[10, 20],
-        array: [10, 20],
-        hash: {a: 10, b: 20}
-      }
-
-      assert class_a.get(:default) == Set[10, 20]
-      assert class_a.get(:array) == [10, 20]
-      assert class_a.get(:hash) == {a: 10, b: 20}
-
-      assert class_b.settings == {
-        string: "a",
-        default: Set[10, 20, 30, 40],
-        array: [10, 20, 30, 40],
-        hash: {a: 10, b: 20, c: 30, d: 40}
-      }
-
-      assert class_b.get(:default) == Set[10, 20, 30, 40]
-      assert class_b.get(:array) == [10, 20, 30, 40]
-      assert class_b.get(:hash) == {a: 10, b: 20, c: 30, d: 40}
+    assert class_a.settings == {
+      number: 1,
+      default: Set[10, 20],
+      array: [10, 20],
+      hash: {a: 10, b: 20}
+    }
+
+    assert class_a.get(:default) == Set[10, 20]
+    assert class_a.get(:array) == [10, 20]
+    assert class_a.get(:hash) == {a: 10, b: 20}
+
+    class_b = Class.new(class_a) do
+      set :string, "a"
+
+      add :default, 30
+      add :default, 40
+
+      add :array, 30
+      add :array, 40
+
+      add :hash, :c, 30
+      add :hash, :d, 40
     end
 
+    assert class_a.settings == {
+      number: 1,
+      default: Set[10, 20],
+      array: [10, 20],
+      hash: {a: 10, b: 20}
+    }
+
+    assert class_a.get(:default) == Set[10, 20]
+    assert class_a.get(:array) == [10, 20]
+    assert class_a.get(:hash) == {a: 10, b: 20}
+
+    assert class_b.settings == {
+      string: "a",
+      default: Set[10, 20, 30, 40],
+      array: [10, 20, 30, 40],
+      hash: {a: 10, b: 20, c: 30, d: 40}
+    }
+
+    assert class_b.get(:default) == Set[10, 20, 30, 40]
+    assert class_b.get(:array) == [10, 20, 30, 40]
+    assert class_b.get(:hash) == {a: 10, b: 20, c: 30, d: 40}
   end
+
 end

data/lib/lizarb/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Lizarb
-  VERSION = "1.0.2"
+  VERSION = "1.0.3"
 end