kuby-core 0.11.2 → 0.11.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a3a59a9d3e923807647da18d834d994cc7b2d149f4c82d6d9966d72748d7bcd5
-  data.tar.gz: 2bbd8e7d1c92ed3d0eb7d6d05420d7119d6f20a249f4401e52191868baeb0996
+  metadata.gz: 3e4b89049516b86853e5b3b4d41b4484cafae1244468d6721d5410af0ca071d1
+  data.tar.gz: 2b1d09c7e479cefd8b085dd4313d4f1ae4294b1b9fc4c6c22d713036b07178bf
 SHA512:
-  metadata.gz: d8bf5fce8051029c8231e915035ec6c704ab361a6008b5335bf8a6747fb106ed55869164bb15eb704ecd72e6366ee320664d23d128a74726b6ca320edcb5c442
-  data.tar.gz: 679ad59207c201fb710e47e69c4682676a6fb12c826b59350a74d98c48f212d358c50fde0f8da0a5804391738d442a839cb4560d2cebd61ec7e7955677bd8e53
+  metadata.gz: 3ae4889774de571b2198fde29edf5b9f58386c3f97f75d44d9e17a31c88b954f83dca6046ac41b2d5b18615d99b6a00b87e0d33136bc3515c46be6e46316eeb5
+  data.tar.gz: c43d154adad210913a7c181c41ff8cdabde9f60e6dff6719666c7b1ca6c4077686e8cadf8ac6cbf534c74e3de9f627f8ef6079d92958969b07d48b58acd585d9

data/CHANGELOG.md

@@ -1,3 +1,25 @@
+## 0.11.8
+* Alias Rails `config_map` to `env`.
+
+## 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.

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

@@ -202,6 +202,8 @@ module Kuby
           @config_map
         end
 
+        alias_method :env, :config_map
+
         def app_secrets(&block)
           spec = self
 

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.2'
+  VERSION = '0.11.8'.freeze
 end

metadata

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