kuby-core 0.11.1 → 0.11.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8664691d15dc7ba054a6986e9b62ef0ad3fc1ff7aa9e80a12595bee3029b7814
-  data.tar.gz: 1a29a74242aa420dbf1c8c50804f85b24716d479f226bd8b411fdb5794031d41
+  metadata.gz: f148347cc0c776aabc5062f1e051c96d94277fe91831100befabc6976bbd6cd8
+  data.tar.gz: 2dba80a00dd2f460ad80fc97ecbb333fa5cc4f6bbbe21f1ddc798c3383da0015
 SHA512:
-  metadata.gz: 3fd0f6fc04d728e7122287889c6013a3578b4eb4a7bc0ae8903232bbd42b99265567271a6e171ec26838259e193f042558df583c2f66ac7d90454aa2f53943ef
-  data.tar.gz: e3480ec344cd46ca020cc7f4615028490f721ed21887b1c45efcb0d17f4d2e1739741946768ed52bab8a1fa75f417ff061a5c970a331fa003520044e0cfca508
+  metadata.gz: ca4e9a7342bde7b8c12623374648c9c4ca61d0dd78f36eaf729dcad17f6a8f23bd1b6ccbd51190c8499f459cdfce98fa7774ada82b314cf516236958d7c93d4f
+  data.tar.gz: 4d9f1dc0e672431c2828e9e2c96fe6c56bb410794dd32089e9443a65f4a0e51259e0c3f089477ab18b6760149586edddc17e6187e3dd76aa61215ec4dd8b5eed

data/CHANGELOG.md

@@ -1,3 +1,26 @@
+## 0.11.7
+* Properly namespace constant lookup for `Kubernetes::MissingPluginError`.
+* Add missing `#storage` method for Postgres plugin.
+
+## 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.
 

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

@@ -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/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/plugin_registry.rb

@@ -12,7 +12,7 @@ module Kuby
       plugins_by_env = plugins[plugin_name]
 
       unless plugins_by_env
-        raise MissingPluginError, "no plugin registered with name #{plugin_name}, "\
+        raise Kubernetes::MissingPluginError, "no plugin registered with name #{plugin_name}, "\
           'do you need to add a gem to your Gemfile?'
       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/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
@@ -58,6 +63,20 @@ module Kuby
             end
           end
         end
+        
+        def storage(amount)
+          database do
+            spec do
+              storage do
+                resources do
+                  requests do
+                    set :storage, amount
+                  end
+                end
+              end
+            end
+          end
+        end        
 
         def secret(&block)
           context = self

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.1'
+  VERSION = '0.11.7'.freeze
 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.7
 platform: ruby
 authors:
 - Cameron Dutro
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-10-05 00:00:00.000000000 Z
+date: 2020-10-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: colorize