kuby-core 0.11.0 → 0.11.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 63e975e73abc299262e996d4bc336f951633d993c8fe56ce997543fb442abe57
-  data.tar.gz: 1a662d6ff200ecf2b9b8fdd7446d0936329599d940afd06800166537bf82005e
+  metadata.gz: 231bc8c37af35418336ba5bb5853049e0d9192932a65eeb3e81a0471b5761953
+  data.tar.gz: 9a4e4426e1d183505f09fac2761601c101c92423761647484c1dae3c3a75e235
 SHA512:
-  metadata.gz: 30d01ba9e76b0bc79c0d22c63ab65a4edbec0f35add876935233402ae6c96077adeb1b91cef3003858f0534441b1939beae31872860ba453ef3b9ef13aa84d76
-  data.tar.gz: bb75588789e02dc6bf4135ab59fb401d1ce8e07d8169460ff86282128d1ea610e01de01c44e564c4a9196959a9f6975640f0c14407bd3d02e8257499b0723099
+  metadata.gz: 64bd169c3454d196efcf0a21f400107ca8b8c584a20793a8ccf232767aba7ae52fab27307f01e104186b73f537d12907afc86c901538f86266773dacb740cbaa
+  data.tar.gz: a54f9fa2eb0cdbfe52a0d4799c1f4fa9bd4677bef8ef4ed4f11caa4690d28f077918a0feb76926b94923ee6ba00e5065d8edabb1997d829d4f7ff5f9b9832708

data/CHANGELOG.md

@@ -1,3 +1,25 @@
+## 0.11.6
+* Fix Rails generator.
+  - Causing `undefined method 'module_parent_name'`. Apparently `module_parent_name` wasn't introduced until Rails 6.
+
+## 0.11.5
+* Raise friendlier error when attempting to add Docker credentials in the development environment.
+* Raise friendlier error when attempting to set a username and password for SQLite databases.
+
+## 0.11.4
+* Fix bug causing crash when running CLI commands.
+  - Turns out was caused by adding a Sorbet type annotation inside an anonymous singleton class and forgetting to extend `T::Sig`. Thanks @lazyatom!
+
+## 0.11.3
+* I've gone back and forth a few times on this, but I decided to put the initializer code back into the Rails generator.
+
+## 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.
+
 ## 0.11.0
 * Defer evaluation of database config until after Kuby has been configured.
   - The issue that prompted this was that the `database` block was being evaluated before the Rails root had been set via `root`. Kuby couldn't find database.yml in a non-standard location and blew up with an error.

data/lib/kuby.rb

@@ -59,8 +59,10 @@ module Kuby
             tls_enabled false
 
             database do
-              user(DEFAULT_DB_USER) if respond_to?(:user)
-              password(DEFAULT_DB_PASSWORD) if respond_to?(:password)
+              if requires_credentials?
+                user(DEFAULT_DB_USER)
+                password(DEFAULT_DB_PASSWORD)
+              end
             end
           end
 

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/commands.rb

@@ -1,9 +1,11 @@
-# typed: true
+# typed: strict
+
 require 'kuby/version'
 require 'gli'
 
 module Kuby
   class Commands
+    extend T::Sig
     extend GLI::App
 
     # GLI doesn't have a wildcard option, so it's impossible to tell it to
@@ -17,8 +19,12 @@ module Kuby
     # avoid the usual series of cryptic alias_method calls (note that there
     # is no singleton class version of #prepend in the Ruby language).
     singleton_class.send(:prepend, Module.new do
+      extend T::Sig
+
+      sig { params(args: T::Array[String]).void }
       def run(args)
         if idx = args.index('rails') || idx = args.index('rake')
+          @rails_options = T.let(@rails_options, T.nilable(T::Array[String]))
           @rails_options = args[idx..-1]
           super(args[0..idx])
         else
@@ -27,10 +33,12 @@ module Kuby
       end
     end)
 
+    sig { returns(Kuby::Tasks) }
     def self.tasks
       Kuby::Tasks.new(Kuby.environment)
     end
 
+    sig { void }
     def self.must_be_dev_env!
       unless Kuby.environment.development?
         fail "Command not supported in the '#{Kuby.environment.name}' environment"
@@ -67,6 +75,7 @@ module Kuby
       rc.action do |global_options, options, args|
         must_be_dev_env!
         exit 1 unless tasks.dev_deployment_ok
+        @rails_options = T.let(@rails_options, T.nilable(T::Array[String]))
         Kuby::RailsCommands.run(@rails_options)
       end
 

data/lib/kuby/definition.rb

@@ -1,12 +1,24 @@
-# typed: true
+# typed: strict
+
 module Kuby
   class Definition
+    extend T::Sig
+
+    sig { returns(String) }
     attr_reader :app_name
 
+    sig { params(app_name: String, block: T.nilable(T.proc.void)).void }
     def initialize(app_name, &block)
       @app_name = app_name
+      @environments = T.let(@environments, T.nilable(T::Hash[Symbol, Environment]))
     end
 
+    sig {
+      params(
+        name: Symbol,
+        block: T.nilable(T.proc.void)
+      ).returns(Environment)
+    }
     def environment(name = Kuby.env, &block)
       name = name.to_s
 
@@ -16,9 +28,10 @@ module Kuby
         environments[name].instance_eval(&block)
       end
 
-      environments[name]
+      T.must(environments[name])
     end
 
+    sig { returns(T::Hash[Symbol, Environment]) }
     def environments
       @environments ||= {}
     end

data/lib/kuby/dev_setup.rb

@@ -1,19 +1,34 @@
-# typed: true
+# typed: strict
+
 module Kuby
   class Spinner
-    PIECES = %w(- \\ | /).freeze
-    INTERVAL = 0.2  # seconds
-
-    def self.spin(message)
+    extend T::Sig
+
+    PIECES = T.let(%w(- \\ | /).freeze, T::Array[String])
+    INTERVAL = T.let(0.2, Float)  # seconds
+
+    sig {
+      params(
+        message: String,
+        block: T.proc.params(spinner: Spinner).void
+      )
+      .void
+    }
+    def self.spin(message, &block)
       yield new(message)
     end
 
-    attr_reader :message, :status
+    sig { returns(String) }
+    attr_reader :message
+
+    sig { returns(Symbol) }
+    attr_reader :status
 
+    sig { params(message: String).void }
     def initialize(message)
-      @message = message
-      @status = :running
-      @thread = Thread.new do
+      @message = T.let(message, String)
+      @status = T.let(:running, Symbol)
+      @thread = T.let(Thread.new do
         counter = 0
 
         while true
@@ -33,14 +48,16 @@ module Kuby
         end
 
         puts
-      end
+      end, Thread)
     end
 
+    sig { void }
     def success
       @status = :success
       @thread.join
     end
 
+    sig { void }
     def failure
       @status = :failure
       @thread.join
@@ -48,66 +65,116 @@ module Kuby
   end
 
   class SetupTask
-    attr_reader :message, :callable
+    extend T::Sig
 
+    sig { returns(String) }
+    attr_reader :message
+
+    sig { returns(T.proc.void) }
+    attr_reader :callable
+
+    sig { params(message: String, callable: T.proc.void).void }
     def initialize(message, callable)
       @message = message
       @callable = callable
     end
 
+    sig { void }
     def run
       callable.call
     end
   end
 
   class Pipe
-    attr_reader :name, :cli, :out, :err
+    extend T::Sig
+
+    sig { returns(Symbol) }
+    attr_reader :name
+
+    sig { returns(T.untyped) }
+    attr_reader :cli
 
+    sig { returns(StringIO) }
+    attr_reader :out
+
+    sig { returns(StringIO) }
+    attr_reader :err
+
+    sig { params(name: Symbol, cli: T.untyped).void }
     def initialize(name, cli)
-      @name = name
-      @cli = cli
-      @out = StringIO.new
-      @err = StringIO.new
+      @name = T.let(name, Symbol)
+      @cli = T.let(cli, T.untyped)
+      @out = T.let(StringIO.new, StringIO)
+      @err = T.let(StringIO.new, StringIO)
     end
 
+    sig { params(block: T.proc.void).void }
     def wrap(&block)
       cli.with_pipes(out, err) do
         block.call
       end
     end
 
+    sig { returns(T::Boolean) }
     def success?
       cli.last_status.nil? || cli.last_status.success?
     end
   end
 
   class Pipes
+    extend T::Sig
+    extend T::Generic
+
     include Enumerable
 
-    attr_reader :pipes, :ex
+    Elem = type_member(fixed: Pipe)
+
+    sig { returns(T::Array[Pipe]) }
+    attr_reader :pipes
 
+    sig { returns(T.nilable(StandardError)) }
+    attr_reader :ex
+
+    sig { params(clis: T::Hash[Symbol, T.untyped]).returns(Pipes) }
     def self.build(clis)
       new(clis.map { |name, cli| Pipe.new(name, cli) })
     end
 
+    sig { params(pipes: T::Array[Pipe]).void }
     def initialize(pipes)
-      @pipes = pipes
+      @ex = T.let(@ex, T.nilable(StandardError))
+      @pipes = T.let(pipes, T::Array[Pipe])
     end
 
+    sig {
+      override.params(
+        block: T.proc.params(package: Pipe).void
+      )
+      .void
+    }
     def each(&block)
       pipes.each(&block)
     end
 
+    sig { params(block: T.proc.void).void }
     def wrap(&block)
       do_wrap(pipes, &block)
     end
 
+    sig { returns(T::Boolean) }
     def success?
       pipes.all?(&:success?) && !ex
     end
 
     private
 
+    sig {
+      params(
+        remaining_pipes: T::Array[Pipe],
+        block: T.proc.void
+      )
+      .void
+    }
     def do_wrap(remaining_pipes, &block)
       if remaining_pipes.empty?
         begin
@@ -119,20 +186,28 @@ module Kuby
         return
       end
 
-      remaining_pipes[0].wrap do
-        do_wrap(remaining_pipes[1..-1], &block)
+      T.must(remaining_pipes[0]).wrap do
+        do_wrap(T.must(remaining_pipes[1..-1]), &block)
       end
     end
   end
 
   class SetupTaskList
-    attr_reader :tasks, :clis
+    extend T::Sig
+
+    sig { returns(T::Array[SetupTask]) }
+    attr_reader :tasks
 
+    sig { returns T::Hash[Symbol, T.untyped] }
+    attr_reader :clis
+
+    sig { params(tasks: T::Array[SetupTask], clis: T::Hash[Symbol, T.untyped]).void }
     def initialize(tasks, clis)
       @tasks = tasks
       @clis = clis
     end
 
+    sig { void }
     def run
       tasks.each do |task|
         pipes = Pipes.build(clis)
@@ -160,6 +235,7 @@ module Kuby
 
     private
 
+    sig { params(pipe: Pipe).void }
     def print_streams(pipe)
       unless pipe.out.string.strip.empty?
         puts("========= #{pipe.name.upcase} STDOUT ========")
@@ -172,27 +248,37 @@ module Kuby
       end
     end
 
+    sig { params(ex: T.nilable(StandardError)).void }
     def print_error(ex)
       return unless ex
       puts("========= RUBY ERROR ========")
       puts(ex.message)
-      puts(ex.backtrace.join("\n"))
+      puts(T.must(ex.backtrace).join("\n"))
     end
   end
 
   class DevSetup
+    extend T::Sig
+
+    sig { returns(Environment) }
     attr_reader :environment
 
+    sig { params(environment: Environment).void }
     def initialize(environment)
-      @environment = environment
+      @environment = T.let(environment, Environment)
+      @setup_tasks = T.let(@setup_tasks, T.nilable(T::Array[SetupTask]))
+      @clis = T.let(@clis, T.nilable(T::Hash[Symbol, T.untyped]))
+      @tasks = T.let(@tasks, T.nilable(Tasks))
     end
 
+    sig { void }
     def run
       SetupTaskList.new(setup_tasks, clis).run
     end
 
     private
 
+    sig { returns(T::Array[SetupTask]) }
     def setup_tasks
       @setup_tasks ||= [
         SetupTask.new(
@@ -231,14 +317,17 @@ module Kuby
       ]
     end
 
+    sig { returns(Kubernetes::Spec) }
     def kubernetes
       environment.kubernetes
     end
 
+    sig { returns(Docker::Spec) }
     def docker
       environment.docker
     end
 
+    sig { returns T::Hash[Symbol, T.untyped] }
     def clis
       @clis ||= {
         kubectl: kubernetes.provider.kubernetes_cli,
@@ -249,6 +338,7 @@ module Kuby
       }
     end
 
+    sig { returns(Tasks) }
     def tasks
       @tasks ||= Kuby::Tasks.new(environment)
     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/docker/dev_spec.rb

@@ -5,16 +5,16 @@ module Kuby
     class WebserverDevPhase < Layer
       extend T::Sig
 
-      DEFAULT_PORT = T.let('3000'.freeze, String)
+      DEFAULT_PORT = T.let(3000, Integer)
 
-      sig { params(port: String).void }
+      sig { params(port: Integer).void }
       attr_writer :port
 
       sig { params(environment: Environment).void }
       def initialize(environment)
         super
 
-        @port = T.let(@port, T.nilable(String))
+        @port = T.let(@port, T.nilable(Integer))
       end
 
       sig { override.params(dockerfile: Dockerfile).void }
@@ -22,7 +22,7 @@ module Kuby
         dockerfile.expose(port)
       end
 
-      sig { returns(String) }
+      sig { returns(Integer) }
       def port
         @port || DEFAULT_PORT
       end
@@ -75,7 +75,7 @@ module Kuby
         @distro_spec = nil
       end
 
-      sig { params(port: String).void }
+      sig { params(port: Integer).void }
       def port(port)
         webserver_phase.port = port
       end
@@ -115,6 +115,13 @@ module Kuby
         layer_stack.includes?(name)
       end
 
+      sig {
+        params(block: T.nilable(T.proc.void)).returns(Credentials)
+      }
+      def credentials(&block)
+        raise 'Docker credentials are not supported in the development environment'
+      end
+
       sig { returns(Dockerfile) }
       def to_dockerfile
         Dockerfile.new.tap do |df|

data/lib/kuby/docker/dockerfile.rb

@@ -10,10 +10,10 @@ module Kuby
       class Command
         extend T::Sig
 
-        sig { returns(T::Array[String]) }
+        sig { returns(T::Array[T.any(String, Integer)]) }
         attr_reader :args
 
-        sig { params(args: T::Array[String]).void }
+        sig { params(args: T::Array[T.any(String, Integer)]).void }
         def initialize(args)
           @args = args
         end
@@ -143,9 +143,9 @@ module Kuby
         add Copy.new(source, dest, from: from)
       end
 
-      sig { params(args: String).void }
-      def expose(*args)
-        add Expose.new(args)
+      sig { params(port: Integer).void }
+      def expose(port)
+        add Expose.new([port])
       end
 
       sig { params(args: String).void }
@@ -164,11 +164,11 @@ module Kuby
         Digest::SHA256.hexdigest(to_s)
       end
 
-      sig { returns(T::Array[String]) }
+      sig { returns(T::Array[Integer]) }
       def exposed_ports
         commands
           .select { |c| c.is_a?(Expose) }
-          .map { |c| T.must(c.args.first) }
+          .map { |c| T.cast(c.args.first, Integer) }
       end
 
       sig { params(pos: Integer, block: T.proc.void).void }

data/lib/kuby/docker/spec.rb

@@ -78,7 +78,7 @@ module Kuby
         copy_phase << path
       end
 
-      sig { params(port: String).void }
+      sig { params(port: Integer).void }
       def port(port)
         webserver_phase.port = port
       end

data/lib/kuby/docker/webserver_phase.rb

@@ -30,7 +30,7 @@ module Kuby
             'puma',
             '--workers', '4',
             '--bind', 'tcp://0.0.0.0',
-            '--port', phase.port,
+            '--port', phase.port.to_s,
             '--pidfile', './server.pid',
             './config.ru'
           )
@@ -39,10 +39,10 @@ module Kuby
         end
       end
 
-      DEFAULT_PORT = T.let('8080', String)
+      DEFAULT_PORT = T.let(8080, Integer)
       WEBSERVER_MAP = T.let({ puma: Puma }.freeze, T::Hash[Symbol, T.class_of(Webserver)])
 
-      sig { params(port: String).void }
+      sig { params(port: Integer).void }
       attr_writer :port
 
       sig { returns(T.nilable(Symbol)) }
@@ -55,7 +55,7 @@ module Kuby
       def initialize(environment)
         super
 
-        @port = T.let(@port, T.nilable(String))
+        @port = T.let(@port, T.nilable(Integer))
         @webserver = T.let(@webserver, T.nilable(Symbol))
       end
 
@@ -68,7 +68,7 @@ module Kuby
         ws_class.new(self).apply_to(dockerfile)
       end
 
-      sig { returns(String) }
+      sig { returns(Integer) }
       def port
         @port || DEFAULT_PORT
       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/plugins/rails_app/generators/kuby.rb

@@ -3,7 +3,25 @@ require 'rails/generators'
 require 'rails/generators/base'
 
 class KubyGenerator < Rails::Generators::Base
+  def create_initializer_file
+    create_file(
+      File.join(*%w(config initializers kuby.rb)),
+      <<~END
+        require 'kuby'
+        Kuby.load!
+      END
+    )
+  end
+
   def create_config_file
+    app_class = Rails.application.class
+
+    app_name = if app_class.respond_to?(:module_parent_name)
+      app_class.module_parent_name
+    else
+      app_class.parent_name
+    end
+
     create_file(
       'kuby.rb',
       <<~END
@@ -11,7 +29,7 @@ class KubyGenerator < Rails::Generators::Base
         require 'active_support/encrypted_configuration'
 
         # Define a production Kuby deploy environment
-        Kuby.define('#{Rails.application.class.module_parent_name}') do
+        Kuby.define('#{app_name}') do
           environment(:production) do
             # Because the Rails environment isn't always loaded when
             # your Kuby config is loaded, provide access to Rails

data/lib/kuby/plugins/rails_app/mysql.rb

@@ -1,4 +1,5 @@
 # typed: false
+
 require 'kube-dsl'
 require 'kuby/kube-db'
 
@@ -15,6 +16,10 @@ module Kuby
           @configs = configs
         end
 
+        def requires_credentials?
+          true
+        end
+
         def name
           :mysql
         end

data/lib/kuby/plugins/rails_app/plugin.rb

@@ -33,7 +33,6 @@ module Kuby
           @asset_url = DEFAULT_ASSET_URL
           @packs_url = DEFAULT_PACKS_URL
           @asset_path = DEFAULT_ASSET_PATH
-          # @database = Database.get(self)
         end
 
         def configure(&block)

data/lib/kuby/plugins/rails_app/postgres.rb

@@ -1,4 +1,5 @@
 # typed: false
+
 require 'kube-dsl'
 require 'kuby/kube-db'
 
@@ -18,6 +19,10 @@ module Kuby
           password(config['password'])
         end
 
+        def requires_credentials?
+          true
+        end
+
         def name
           :postgres
         end

data/lib/kuby/plugins/rails_app/sqlite.rb

@@ -1,4 +1,5 @@
 # typed: true
+
 module Kuby
   module Plugins
     module RailsApp
@@ -14,6 +15,18 @@ module Kuby
           environment.docker.package_phase.add(:sqlite_client)
         end
 
+        def requires_credentials?
+          false
+        end
+
+        def user(_user)
+          raise 'SQLite databases do not require a username or password'
+        end
+
+        def password(_password)
+          raise 'SQLite databases do not require a username or password'
+        end
+
         def name
           :sqlite
         end

data/lib/kuby/version.rb

@@ -1,5 +1,5 @@
-# typed: strict
+# typed: true
 
 module Kuby
-  VERSION = '0.11.0'
+  VERSION = '0.11.6'.freeze
 end

metadata

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