lizarb 1.0.1 → 1.0.3

data/lib/liza/unit.rb

@@ -1,149 +1,155 @@
-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
 
-    # 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 set key, value
+    settings[key] = value
+  end
 
-    def fetch key, &block
-      x = get key
-      x ||= set key, eval(&block)
-      x
+  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_parts/unit_procedure_part.rb

@@ -0,0 +1,17 @@
+class Liza::UnitProcedurePart < Liza::Part
+
+  insertion do
+    def self.procedure _label, &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, &block)= self.class.procedure _label, &block
+    def proceed(...)= self.class.proceed(...)
+  end
+
+end

data/lib/liza/unit_parts/unit_procedure_part_test.rb

@@ -0,0 +1,65 @@
+class Liza::UnitProcedurePartTest < Liza::UnitTest
+
+  test :procedure_scopes_and_returns do
+    b = nil
+
+    w =
+      procedure "creates a new scope" do
+        @a = 1
+        b = 2
+        c = 3
+        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
+        refute local_variables.include? :c
+
+        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 { "slow operation"; 200 } 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_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/liza.rb

@@ -2,6 +2,7 @@
 
 module Liza
   class Error < StandardError; end
+  class ConstNotFound < Error; end
 
   #
 
@@ -27,6 +28,8 @@ module Liza
     return k if k
 
     nil
+  rescue NameError
+    raise ConstNotFound, name
   end
 
   # Checks each system, then Liza for Liza::Unit classes
@@ -46,6 +49,8 @@ module Liza
   end
 
   def const_check_systems name
+    App.systems.frozen? or return nil
+
     for k in App.systems.values.reverse
       next if not k.const_defined? name.to_sym
       kk = k.const(name) if k.constants.include? name

data/lib/lizarb/ruby/module.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class Module
+
+  # /path/to/liza.rb
+  def source_location
+    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/string.rb

@@ -3,10 +3,18 @@
 class String
   alias lpartition partition
 
-  def camelize
-    split("_").map { |s| "#{s[0].upcase}#{s[1..-1]}" }.join("")
+  def camelcase
+    split("_").map { |s| "#{s[0].to_s.upcase}#{s[1..-1]}" }.join("")
   end
 
+  alias camelize camelcase
+
+  def snakecase
+    gsub(/[A-Z\s-]/) { |s, t| "_#{s}" }[1..-1].to_s.downcase
+  end
+  
+  alias snakefy snakecase
+
   def rjust_blanks length
     rjust length, " "
   end

data/lib/lizarb/version.rb

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

data/lib/lizarb.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
 require "colorize"
+require "json"
 require "pathname"
 require "zeitwerk"
+require "lerb"
 
 require_relative "lizarb/version"
 
@@ -11,7 +13,8 @@ module Lizarb
 
   #
 
-  GEM_DIR = Gem::Specification.find_by_name("lizarb").gem_dir
+  SPEC    = Gem::Specification.find_by_name("lizarb")
+  GEM_DIR = SPEC.gem_dir
   CUR_DIR = Dir.pwd
 
   IS_APP_DIR = File.file? "#{CUR_DIR}/app.rb"
@@ -36,7 +39,10 @@ module Lizarb
 
     require "#{APP_DIR}/app"
 
-    VERSION
+    versions = {ruby: RUBY_VERSION, bundler: Bundler::VERSION, zeitwerk: Zeitwerk::VERSION, lizarb: VERSION}
+    bugs = SPEC.metadata["bug_tracker_uri"]
+    puts versions.to_s.green
+    puts "Report bugs at #{bugs}"
   end
 
   # called from "#{APP_DIR}/app"
@@ -65,4 +71,20 @@ module Lizarb
                   : "#{GEM_DIR}/exe/Gemfile"
   end
 
+  # threads
+
+  def thread_object_id
+    Thread.current.object_id
+  end
+
+  @thread_ids = {thread_object_id => 0}
+  @thread_ids_mutex = Mutex.new
+
+  def thread_id
+    @thread_ids[thread_object_id] ||=
+      @thread_ids_mutex.synchronize do
+        @thread_ids.count
+      end
+  end
+
 end

data/lib/net_system/dev/net_command.rb

@@ -1,14 +1,13 @@
-class NetSystem
-  class NetCommand < Liza::Command
+class NetSystem::NetCommand < Liza::Command
 
-    def self.call args
-      log :higher, "Called #{self} with args #{args}"
+  def self.call args
+    log :higher, "Called #{self} with args #{args}"
 
-      ruby_time   = Time.now
-      redis_time  = ::NetBox.databases.redis.now
-      sqlite_time = ::NetBox.databases.sqlite.now
-      # redis_time  = ::RedisDb.current.now
-      # sqlite_time = ::SqliteDb.current.now
+    ruby_time   = Time.now
+    redis_time  = ::NetBox.databases.redis.now
+    sqlite_time = ::NetBox.databases.sqlite.now
+    # redis_time  = ::RedisDb.current.now
+    # sqlite_time = ::SqliteDb.current.now
 
       puts <<-OUTPUT.bold
 
@@ -17,8 +16,7 @@ class NetSystem
           Time for Sqlite:  #{sqlite_time.to_s.light_red}
 
       OUTPUT
-      Liza::DevCommand.call []
-    end
-
+    Liza::DevCommand.call []
   end
+
 end