kuby-core 0.11.1 → 0.11.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8664691d15dc7ba054a6986e9b62ef0ad3fc1ff7aa9e80a12595bee3029b7814
-  data.tar.gz: 1a29a74242aa420dbf1c8c50804f85b24716d479f226bd8b411fdb5794031d41
+  metadata.gz: a3a59a9d3e923807647da18d834d994cc7b2d149f4c82d6d9966d72748d7bcd5
+  data.tar.gz: 2bbd8e7d1c92ed3d0eb7d6d05420d7119d6f20a249f4401e52191868baeb0996
 SHA512:
-  metadata.gz: 3fd0f6fc04d728e7122287889c6013a3578b4eb4a7bc0ae8903232bbd42b99265567271a6e171ec26838259e193f042558df583c2f66ac7d90454aa2f53943ef
-  data.tar.gz: e3480ec344cd46ca020cc7f4615028490f721ed21887b1c45efcb0d17f4d2e1739741946768ed52bab8a1fa75f417ff061a5c970a331fa003520044e0cfca508
+  metadata.gz: d8bf5fce8051029c8231e915035ec6c704ab361a6008b5335bf8a6747fb106ed55869164bb15eb704ecd72e6366ee320664d23d128a74726b6ca320edcb5c442
+  data.tar.gz: 679ad59207c201fb710e47e69c4682676a6fb12c826b59350a74d98c48f212d358c50fde0f8da0a5804391738d442a839cb4560d2cebd61ec7e7955677bd8e53

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.11.2
+* Attempt to auto-require the requested provider if it isn't registered.
+* Adjust error message when provider can't be found to include reminder to add a require statement.
+
 ## 0.11.1
 * Use integers for ports instead of strings to appease Kubernetes.
 

data/lib/kuby/basic_logger.rb

@@ -1,10 +1,30 @@
-# typed: false
+# typed: strict
+
 require 'logger'
 require 'colorized_string'
 
 module Kuby
   class BasicLogger < Logger
-    def initialize(*args)
+    extend T::Sig
+
+    sig {
+      override.params(
+        logdev: T.any(String, IO, StringIO, NilClass),
+        shift_age: Integer,
+        shift_size: Integer,
+        level: Integer,
+        progname: T.nilable(String),
+        formatter: T.nilable(FormatterProcType),
+        datetime_format: T.nilable(String),
+        shift_period_suffix: T.nilable(String)
+      ).void
+    }
+    def initialize(
+        logdev, shift_age = 0, shift_size = 1048576, level: DEBUG,
+        progname: nil, formatter: nil, datetime_format: nil,
+        shift_period_suffix: '%Y%m%d')
+      @logdev = T.let(@logdev, T.nilable(Logger::LogDevice))
+
       super
 
       self.formatter = proc do |_severity, _datetime, _progname, msg|
@@ -12,23 +32,51 @@ module Kuby
       end
     end
 
-    def info(msg, *args)
-      super(ColorizedString[msg].yellow, *args)
+    sig {
+      override.params(
+        progname_or_msg: T.untyped,
+        block: T.nilable(T.proc.returns(T.untyped))
+      ).void
+    }
+    def info(progname_or_msg = nil, &block)
+      if block
+        super(progname_or_msg) { ColorizedString[block.call].yellow }
+      else
+        super(ColorizedString[progname_or_msg].yellow)
+      end
     end
 
-    def fatal(msg, *args)
-      super(ColorizedString[msg].red, *args)
+    sig {
+      override.params(
+        progname_or_msg: T.untyped,
+        block: T.nilable(T.proc.returns(T.untyped))
+      ).void
+    }
+    def fatal(progname_or_msg, &block)
+      if block
+        super(progname_or_msg) { ColorizedString[block.call].red }
+      else
+        super(ColorizedString[progname_or_msg].red)
+      end
     end
 
     # adhere to the "CLI" interface
-    def with_pipes(out = STDOUT, err = STDERR)
-      previous_logdev = @logdev || STDERR
+    sig {
+      params(
+        out: T.any(IO, StringIO),
+        err: T.any(IO, StringIO),
+        block: T.proc.void
+      ).void
+    }
+    def with_pipes(out = STDOUT, err = STDERR, &block)
+      previous_logdev = @logdev&.dev || STDERR
       reopen(err)
       yield
     ensure
       reopen(previous_logdev)
     end
 
+    sig { returns(T.nilable(Process::Status)) }
     def last_status
       nil
     end

data/lib/kuby/cli_base.rb

@@ -1,24 +1,39 @@
-# typed: true
+# typed: strict
+
 require 'open3'
 require 'thread'
 
 module Kuby
   class CLIBase
+    extend T::Sig
+
+    sig { returns(T.nilable(Process::Status)) }
     def last_status
       Thread.current[status_key]
     end
 
+    sig { params(block: T.proc.params(cmd: String).void).void }
     def before_execute(&block)
+      @before_execute = T.let(@before_execute, T.nilable(T::Array[T.proc.params(cmd: String).void]))
       @before_execute ||= []
       @before_execute << block
     end
 
+    sig { params(block: T.proc.params(cmd: String).void).void }
     def after_execute(&block)
+      @after_execute = T.let(@after_execute, T.nilable(T::Array[T.proc.params(cmd: String).void]))
       @after_execute ||= []
       @after_execute << block
     end
 
-    def with_pipes(out = STDOUT, err = STDERR)
+    sig {
+      params(
+        out: T.any(IO, StringIO),
+        err: T.any(IO, StringIO),
+        block: T.proc.void
+      ).void
+    }
+    def with_pipes(out = STDOUT, err = STDERR, &block)
       previous_stdout = self.stdout
       previous_stderr = self.stderr
       self.stdout = out
@@ -29,29 +44,39 @@ module Kuby
       self.stderr = previous_stderr
     end
 
+    sig { returns(T.nilable(T.any(IO, StringIO))) }
     def stdout
       Thread.current[stdout_key] || STDOUT
     end
 
+    sig { params(new_stdout: T.nilable(T.any(IO, StringIO))).void }
     def stdout=(new_stdout)
       Thread.current[stdout_key] = new_stdout
     end
 
+    sig { returns(T.nilable(T.any(IO, StringIO))) }
     def stderr
       Thread.current[stderr_key] || STDERR
     end
 
+    sig { params(new_stderr: T.nilable(T.any(IO, StringIO))).void }
     def stderr=(new_stderr)
       Thread.current[stderr_key] = new_stderr
     end
 
     private
 
-    def open3_w(env, cmd, opts = {}, &block)
+    sig {
+      params(
+        cmd: T::Array[String],
+        block: T.proc.params(stdin: IO).void
+      ).void
+    }
+    def open3_w(cmd, &block)
       run_before_callbacks(cmd)
       cmd_s = cmd.join(' ')
 
-      Open3.popen3(env, cmd_s, opts) do |p_stdin, p_stdout, p_stderr, wait_thread|
+      Open3.popen3(cmd_s) do |p_stdin, p_stdout, p_stderr, wait_thread|
         Thread.new(stdout) do |t_stdout|
           begin
             p_stdout.each { |line| t_stdout.puts(line) }
@@ -66,21 +91,23 @@ module Kuby
           end
         end
 
-        yield(p_stdin).tap do
-          p_stdin.close
-          self.last_status = wait_thread.value
-          run_after_callbacks(cmd)
-          wait_thread.join
-        end
+        yield(p_stdin)
+
+        p_stdin.close
+        self.last_status = T.cast(wait_thread.value, Process::Status)
+        run_after_callbacks(cmd)
+        wait_thread.join
       end
     end
 
+    sig { params(cmd: T::Array[String]).void }
     def execc(cmd)
       run_before_callbacks(cmd)
       cmd_s = cmd.join(' ')
       exec(cmd_s)
     end
 
+    sig { params(cmd: T::Array[String]).void }
     def systemm(cmd)
       if stdout == STDOUT && stderr == STDERR
         systemm_default(cmd)
@@ -89,6 +116,7 @@ module Kuby
       end
     end
 
+    sig { params(cmd: T::Array[String]).void }
     def systemm_default(cmd)
       run_before_callbacks(cmd)
       cmd_s = cmd.join(' ')
@@ -98,6 +126,7 @@ module Kuby
       end
     end
 
+    sig { params(cmd: T::Array[String]).void }
     def systemm_open3(cmd)
       run_before_callbacks(cmd)
       cmd_s = cmd.join(' ')
@@ -118,12 +147,14 @@ module Kuby
         end
 
         p_stdin.close
-        self.last_status = wait_thread.value
+        self.last_status = T.cast(wait_thread.value, Process::Status)
         run_after_callbacks(cmd)
         wait_thread.join
       end
     end
 
+
+    sig { params(cmd: T::Array[String]).returns(String) }
     def backticks(cmd)
       if stdout == STDOUT && stderr == STDERR
         backticks_default(cmd)
@@ -132,6 +163,7 @@ module Kuby
       end
     end
 
+    sig { params(cmd: T::Array[String]).returns(String) }
     def backticks_default(cmd)
       run_before_callbacks(cmd)
       cmd_s = cmd.join(' ')
@@ -141,6 +173,7 @@ module Kuby
       end
     end
 
+    sig { params(cmd: T::Array[String]).returns(String) }
     def backticks_open3(cmd)
       run_before_callbacks(cmd)
       cmd_s = cmd.join(' ')
@@ -162,7 +195,7 @@ module Kuby
         end
 
         p_stdin.close
-        self.last_status = wait_thread.value
+        self.last_status = T.cast(wait_thread.value, Process::Status)
         run_after_callbacks(cmd)
         wait_thread.join
       end
@@ -170,26 +203,32 @@ module Kuby
       result.string
     end
 
+    sig { params(cmd: T::Array[String]).void }
     def run_before_callbacks(cmd)
       (@before_execute || []).each { |cb| cb.call(cmd) }
     end
 
+    sig { params(cmd: T::Array[String]).void }
     def run_after_callbacks(cmd)
       (@after_execute || []).each { |cb| cb.call(cmd, last_status) }
     end
 
+    sig { params(status: Process::Status).void }
     def last_status=(status)
       Thread.current[status_key] = status
     end
 
+    sig { returns(Symbol) }
     def status_key
       raise NotImplementedError, "#{__method__} must be defined in derived classes"
     end
 
+    sig { returns(Symbol) }
     def stdout_key
       raise NotImplementedError, "#{__method__} must be defined in derived classes"
     end
 
+    sig { returns(Symbol) }
     def stderr_key
       raise NotImplementedError, "#{__method__} must be defined in derived classes"
     end

data/lib/kuby/docker/cli.rb

@@ -35,13 +35,13 @@ module Kuby
           executable, 'login', url, '--username', username, '--password-stdin'
         ]
 
-        open3_w({}, cmd) do |stdin, _wait_threads|
+        open3_w(cmd) do |stdin, _wait_threads|
           stdin.puts(password)
         end
 
-        unless last_status.success?
+        unless T.must(last_status).success?
           raise LoginError, 'build failed: docker command exited with '\
-            "status code #{last_status.exitstatus}"
+            "status code #{T.must(last_status).exitstatus}"
         end
       end
 
@@ -72,13 +72,13 @@ module Kuby
           '-f-', '.'
         ]
 
-        open3_w({}, cmd) do |stdin, _wait_threads|
+        open3_w(cmd) do |stdin, _wait_threads|
           stdin.puts(dockerfile.to_s)
         end
 
-        unless last_status.success?
+        unless T.must(last_status).success?
           raise BuildError, 'build failed: docker command exited with '\
-            "status code #{last_status.exitstatus}"
+            "status code #{T.must(last_status).exitstatus}"
         end
       end
 
@@ -124,9 +124,9 @@ module Kuby
           executable, 'push', "#{image_url}:#{tag}"
         ])
 
-        unless last_status.success?
+        unless T.must(last_status).success?
           raise PushError, 'push failed: docker command exited with '\
-            "status code #{last_status.exitstatus}"
+            "status code #{T.must(last_status).exitstatus}"
         end
       end
 
@@ -136,9 +136,9 @@ module Kuby
           executable, 'pull', "#{image_url}:#{tag}"
         ])
 
-        unless last_status.success?
+        unless T.must(last_status).success?
           raise PullError, 'pull failed: docker command exited with '\
-            "status code #{last_status.exitstatus}"
+            "status code #{T.must(last_status).exitstatus}"
         end
       end
 

data/lib/kuby/kubernetes/spec.rb

@@ -18,13 +18,28 @@ module Kuby
 
       def provider(provider_name = nil, &block)
         if provider_name
-          if @provider || provider_klass = Kuby.providers[provider_name]
-            @provider ||= provider_klass.new(environment)
+          provider_klass = Kuby.providers[provider_name]
+
+          unless provider_klass
+            begin
+              # attempt to auto-require
+              require "kuby/#{provider_name}"
+              provider_klass = Kuby.providers[provider_name]
+            rescue LoadError
+            end
+          end
+
+          if provider_klass
+            if !@provider || !@provider.is_a?(provider_klass)
+              @provider = provider_klass.new(environment)
+            end
+
             @provider.configure(&block)
           else
             msg = if provider_name
               "no provider registered with name #{provider_name}, "\
-                'do you need to add a gem to your Gemfile?'
+                'do you need to add a gem to your Gemfile and/or a '\
+                'require statement to your Kuby config?'
             else
               'no provider configured'
             end

data/lib/kuby/version.rb

@@ -1,5 +1,5 @@
 # typed: strict
 
 module Kuby
-  VERSION = '0.11.1'
+  VERSION = '0.11.2'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kuby-core
 version: !ruby/object:Gem::Version
-  version: 0.11.1
+  version: 0.11.2
 platform: ruby
 authors:
 - Cameron Dutro
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-10-05 00:00:00.000000000 Z
+date: 2020-10-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: colorize