lizarb 0 → 1.0.1

data/lib/liza/unit.rb

@@ -0,0 +1,149 @@
+module Liza
+  class Unit
+
+    # PARTS
+
+    def self.part key, system: nil
+      App.connect_part self, key, system
+    end
+
+    # SETTINGS
+
+    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
+
+    # LOG
+
+    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
+
+      source = (self.is_a? Class) ? self : self.class
+      source = source.to_s.ljust(LOG_JUST).bold.colorize(source.log_color)
+
+      string = "#{source} #{string}"
+
+      DevBox.logs.call string
+    end
+
+    def self.log_level
+      get(:log_level) || :normal
+    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?(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(...)
+
+    # SYSTEM
+
+    def self.inherited_explicitly_sets_system
+
+      def self.inherited sub
+        super
+
+        return unless sub.name.to_s.include? "::"
+
+        system = Object.const_get sub.first_namespace
+
+        sub.set :system, system
+      end
+
+    end
+
+  end
+end

data/lib/liza/unit_test.rb

@@ -0,0 +1,79 @@
+module Liza
+  class UnitTest < 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
+
+        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}
+    end
+
+  end
+end

data/lib/liza.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Liza
+  class Error < StandardError; end
+
+  #
+
+  module_function
+
+  def log s
+    puts s.bold
+  end
+
+  #
+
+  # Checks Object, each system, then Liza for Liza::Unit classes
+  def const name
+    name = name.to_s.camelize.to_sym
+
+    k = const_check_object name
+    return k if k
+
+    k = const_check_systems name
+    return k if k
+
+    k = const_get name
+    return k if k
+
+    nil
+  end
+
+  # Checks each system, then Liza for Liza::Unit classes
+  def const_missing name
+    k = const_check_systems name
+    return k if k
+
+    super
+  end
+
+  def const_check_object name
+    return if not Object.const_defined? name
+    kk = Object.const_get name
+    return kk if is_unit? kk
+
+    nil
+  end
+
+  def const_check_systems name
+    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
+      return kk if is_unit? kk
+    end
+
+    nil
+  end
+
+  def is_unit? kk
+    kk && kk < Liza::Unit
+  end
+
+end

data/lib/lizarb/ruby/class.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class Class
+  public :eval
+
+  def descendants
+    ObjectSpace.each_object(Class).select { |klass| klass < self }
+  end
+
+  def first_namespace
+    name.rpartition('::')[0]
+  end
+
+  def last_namespace
+    name.rpartition('::')[-1]
+  end
+end

data/lib/lizarb/ruby/proc.rb

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+class String
+  alias lpartition partition
+
+  def camelize
+    split("_").map { |s| "#{s[0].upcase}#{s[1..-1]}" }.join("")
+  end
+
+  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

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

data/lib/{viral → lizarb}/version.rb

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

data/lib/lizarb.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "colorize"
+require "pathname"
+require "zeitwerk"
+
+require_relative "lizarb/version"
+
+module Lizarb
+  class Error < StandardError; end
+
+  #
+
+  GEM_DIR = Gem::Specification.find_by_name("lizarb").gem_dir
+  CUR_DIR = Dir.pwd
+
+  IS_APP_DIR = File.file? "#{CUR_DIR}/app.rb"
+  IS_LIZ_DIR = File.file? "#{CUR_DIR}/lib/lizarb.rb"
+
+  APP_DIR = IS_APP_DIR ? CUR_DIR : GEM_DIR
+
+  #
+
+  module_function
+
+  def log s
+    puts s.bold
+  end
+
+  # called from exe/lizarb
+  def call
+    require "app"
+
+    setup_core_ext
+    setup_gemfile
+
+    require "#{APP_DIR}/app"
+
+    VERSION
+  end
+
+  # called from "#{APP_DIR}/app"
+  def bundle
+    require "bundler/setup"
+    Bundler.require :default
+
+    bundle_liza
+
+    check_mode!
+  end
+
+  # setup
+
+  def setup_core_ext
+    pattern =
+      IS_LIZ_DIR  ? "lib/lizarb/ruby/*.rb"
+                  : "#{GEM_DIR}/lib/lizarb/ruby/*.rb"
+
+    Dir[pattern].each &method(:load)
+  end
+
+  def setup_gemfile
+    ENV["BUNDLE_GEMFILE"] =
+      IS_APP_DIR  ? "#{CUR_DIR}/Gemfile"
+                  : "#{GEM_DIR}/exe/Gemfile"
+  end
+
+end

data/lib/net_system/dev/net_command.rb

@@ -0,0 +1,24 @@
+class NetSystem
+  class NetCommand < Liza::Command
+
+    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
+
+      puts <<-OUTPUT.bold
+
+          Time for Ruby:    #{ruby_time.to_s.light_red}
+          Time for Redis:   #{redis_time.to_s.light_red}
+          Time for Sqlite:  #{sqlite_time.to_s.light_red}
+
+      OUTPUT
+      Liza::DevCommand.call []
+    end
+
+  end
+end

data/lib/net_system/net/controllers/client/redis_client.rb

@@ -0,0 +1,28 @@
+class NetSystem
+  class RedisClient < Client
+
+    # https://redis.io/
+    # https://github.com/redis/redis-rb
+    def initialize *args
+      args = [url: Liza.const(:net_box).clients.get(:redis_url)] if args.empty?
+      log "Connecting to #{args}"
+      @conn = Redis.new *args
+    end
+
+    attr_reader :conn
+
+    def call cmd_name, *args
+      t = Time.now
+      result = @conn.send cmd_name, *args
+
+      result
+    ensure
+      log "#{t.diff}s | #{cmd_name} | #{args}"
+    end
+
+    def now
+      call :time
+    end
+
+  end
+end

data/lib/net_system/net/controllers/client/redis_client_test.rb

@@ -0,0 +1,29 @@
+class NetSystem
+  class RedisClientTest < ClientTest
+
+    def subject
+      @subject ||= subject_class.new
+    end
+
+    test :subject_class do
+      assert subject_class == Liza::RedisClient
+    end
+
+    test :subject do
+      assert subject.conn.class == Redis
+    end
+
+    test :call do
+      result = subject.call :keys
+      assert result.class == Array
+      assert result.count == 0
+    end
+
+    test :now do
+      result = subject.now
+      assert result.class == Array
+      assert result.map(&:class) == [Integer, Integer]
+    end
+
+  end
+end

data/lib/net_system/net/controllers/client/sqlite_client.rb

@@ -0,0 +1,28 @@
+class NetSystem
+  class SqliteClient < Client
+
+    # https://www.sqlite.org/
+    # https://github.com/sparklemotion/sqlite3-ruby
+    def initialize *args
+      args = [Liza.const(:net_box).clients.get(:sqlite)] if args.empty?
+      log "Connecting to #{args}"
+      @conn = SQLite3::Database.new *args
+    end
+
+    attr_reader :conn
+
+    def call sql, *args
+      t = Time.now
+      result = @conn.execute2 sql, *args
+
+      result
+    ensure
+      log "#{t.diff}s | #{sql} | #{args}"
+    end
+
+    def now
+      call "SELECT strftime('%Y-%m-%dT%H:%M:%S.%f', 'now', 'localtime');"
+    end
+
+  end
+end

data/lib/net_system/net/controllers/client/sqlite_client_test.rb

@@ -0,0 +1,29 @@
+class NetSystem
+  class SqliteClientTest < ClientTest
+
+    def subject
+      @subject ||= subject_class.new ":memory:"
+    end
+
+    test :subject_class do
+      assert subject_class == Liza::SqliteClient
+    end
+
+    test :subject do
+      assert subject.conn.class == SQLite3::Database
+    end
+
+    test :call do
+      result = subject.call "SELECT name, sql FROM sqlite_master WHERE type = 'table';"
+      assert result == [["name", "sql"]]
+    end
+
+    test :now do
+      result = subject.now
+      assert result.class == Array
+      assert result[0] == ["strftime('%Y-%m-%dT%H:%M:%S.%f', 'now', 'localtime')"]
+      assert result[1][0].class == String
+    end
+
+  end
+end

data/lib/net_system/net/controllers/client.rb

@@ -0,0 +1,5 @@
+class NetSystem
+  class Client < Liza::Controller
+
+  end
+end

data/lib/net_system/net/controllers/client_test.rb

@@ -0,0 +1,14 @@
+class NetSystem
+  class ClientTest < Liza::ControllerTest
+
+    test :subject_class do
+      assert subject_class == NetSystem::Client
+    end
+
+    test :settings do
+      assert subject_class.log_level == :normal
+      assert subject_class.log_color == :red
+    end
+
+  end
+end

data/lib/net_system/net/controllers/database/redis_db.rb

@@ -0,0 +1,11 @@
+class NetSystem
+  class RedisDb < Database
+    set_client :redis
+
+    def now
+      array = client.now
+      Time.at array[0]
+    end
+
+  end
+end

data/lib/net_system/net/controllers/database/redis_db_test.rb

@@ -0,0 +1,23 @@
+class NetSystem
+  class RedisDbTest < DatabaseTest
+
+    test :subject_class do
+      assert subject_class == NetSystem::RedisDb
+    end
+
+    test :subject do
+      assert subject.client.class == NetSystem::RedisClient
+    end
+
+    test :now do
+      t = subject.now
+      assert! t.is_a? Time
+      assert t.yday == Time.now.yday
+    end
+
+    # test :call do
+    #   todo "write this"
+    # end
+
+  end
+end

data/lib/net_system/net/controllers/database/sqlite_db.rb

@@ -0,0 +1,11 @@
+class NetSystem
+  class SqliteDb < Database
+    set_client :sqlite
+
+    def now
+      array = client.now
+      Time.parse array[1][0]
+    end
+
+  end
+end

data/lib/net_system/net/controllers/database/sqlite_db_test.rb

@@ -0,0 +1,23 @@
+class NetSystem
+  class SqliteDbTest < DatabaseTest
+
+    test :subject_class do
+      assert subject_class == NetSystem::SqliteDb
+    end
+
+    test :subject do
+      assert subject.client.class == NetSystem::SqliteClient
+    end
+
+    test :now do
+      t = subject.now
+      assert! t.is_a? Time
+      assert t.yday == Time.now.yday
+    end
+
+    # test :call do
+    #   todo "write this"
+    # end
+
+  end
+end