kuby-core 0.11.2 → 0.11.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a3a59a9d3e923807647da18d834d994cc7b2d149f4c82d6d9966d72748d7bcd5
-  data.tar.gz: 2bbd8e7d1c92ed3d0eb7d6d05420d7119d6f20a249f4401e52191868baeb0996
+  metadata.gz: ed18879c6aaea9b7fa96be67e6fd3f4b9b59cfc7b79a1d0eef33017e8bf509aa
+  data.tar.gz: 1b36fab3efe73e5df8510ef4896fbb991d8d2b478c86af3a3b76fd7b185a92b9
 SHA512:
-  metadata.gz: d8bf5fce8051029c8231e915035ec6c704ab361a6008b5335bf8a6747fb106ed55869164bb15eb704ecd72e6366ee320664d23d128a74726b6ca320edcb5c442
-  data.tar.gz: 679ad59207c201fb710e47e69c4682676a6fb12c826b59350a74d98c48f212d358c50fde0f8da0a5804391738d442a839cb4560d2cebd61ec7e7955677bd8e53
+  metadata.gz: bbc63d361f6ee464b88cdfca30be2974a99faf63824427d8f483aa136d55e3315242d02d0d8be1aebebddb0d954c863dfa5bff31af178d2f4e922870f8d206e5
+  data.tar.gz: d93d06d263c9c7fef24fcb15417f58c64033dbd9da492bd72728e5ac05d4ff0cf73ccf360d5cb7e03f363f9e22c99d003694a0ca30b81c30a7b6676307abcfa4

data/CHANGELOG.md

@@ -1,3 +1,6 @@
+## 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/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,10 @@ 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
+      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 +31,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 +73,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/plugins/rails_app/generators/kuby.rb

@@ -3,6 +3,16 @@ 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
     create_file(
       'kuby.rb',

data/lib/kuby/version.rb

@@ -1,5 +1,5 @@
 # typed: strict
 
 module Kuby
-  VERSION = '0.11.2'
+  VERSION = '0.11.3'
 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.3
 platform: ruby
 authors:
 - Cameron Dutro
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-10-10 00:00:00.000000000 Z
+date: 2020-10-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: colorize