kuby-core 0.10.0 → 0.11.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f61bf7246e7fed1b51421252d1fee25da0bf1ad35da792e9f705d306ad5aeeba
-  data.tar.gz: fcaed876fd5da816cd1458c41c19fc735a7d3e5de2d23879427c526f2f0f94ea
+  metadata.gz: ed18879c6aaea9b7fa96be67e6fd3f4b9b59cfc7b79a1d0eef33017e8bf509aa
+  data.tar.gz: 1b36fab3efe73e5df8510ef4896fbb991d8d2b478c86af3a3b76fd7b185a92b9
 SHA512:
-  metadata.gz: 78f6cad56fd00b1265a43ac36169da5d46b15c50ceb5afce6f519ef175ff3949f84204ccf40ad9531b9dbb6b357d38ac0396e6969d848bfb17b42ba1c273ba6d
-  data.tar.gz: 056b9a151fd6f11079eb87fd5c0b7c4f92087cd8455a361ac7e668e9b94e4fc99a866b91c4f30d0a3eda582b0c2cafaac2e3ee882daebec0a52f1fd748786871
+  metadata.gz: bbc63d361f6ee464b88cdfca30be2974a99faf63824427d8f483aa136d55e3315242d02d0d8be1aebebddb0d954c863dfa5bff31af178d2f4e922870f8d206e5
+  data.tar.gz: d93d06d263c9c7fef24fcb15417f58c64033dbd9da492bd72728e5ac05d4ff0cf73ccf360d5cb7e03f363f9e22c99d003694a0ca30b81c30a7b6676307abcfa4

data/CHANGELOG.md

@@ -1,3 +1,28 @@
+## 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.
+* Fix tests broken in 0.10.1.
+* Set up Travis CI builds.
+* Add a few tests for custom build phases.
+* Add the `Environment#configured?` method that will return `true` if Kuby has been configured and `false` if configuration hasn't happened or is in progress.
+* Add sorbet typedefs for some classes.
+* Fix issue in Rails generator (hadn't been updated with new `environment` block).
+* Add kuby-core.rb so Bundler setup works for Kuby without having to add a Rails initializer.
+
+## 0.10.1
+* Fix bug causing some `rails` and `rake` commands to not be executed.
+* Fix issue restricting Docker CLI output.
+
 ## 0.10.0
 * Set default database user and password in dev environment.
 * Add ability to run rake tasks in dev environment.

data/Gemfile

@@ -5,6 +5,7 @@ gemspec
 group :development, :test do
   gem 'pry-byebug'
   gem 'rake'
+  gem 'sorbet', '~> 0.5'
 end
 
 group :test do

data/README.md

@@ -1,5 +1,7 @@
 ## Kuby
 
+[![Build Status](https://travis-ci.com/getkuby/kuby-core.svg?branch=master)](https://travis-ci.com/getkuby/kuby-core)
+
 Deploy your Rails app the easy way.
 
 ## What is Kuby?
@@ -20,11 +22,11 @@ Kuby embraces the same convention-over-configuration approach that Rails does. I
 
 ## Getting Started
 
-See the [Quick Start Guide](https://github.com/getkuby/kuby-core/wiki/Quick-Start-Guide)
+See the [Quick Start Guide](https://getkuby.io/docs)
 
 ## More Info
 
-See the [wiki](https://github.com/getkuby/kuby-core/wiki).
+Check out [getkuby.io](https://getkuby.io).
 
 ## Running Tests
 

data/kuby-core.gemspec

@@ -20,11 +20,12 @@ Gem::Specification.new do |s|
   # See: https://github.com/Shopify/krane/blob/master/CHANGELOG.md#114
   s.add_dependency 'krane', '>= 1.1.4', '< 2.0'
   s.add_dependency 'kuby-cert-manager', '>= 0.3'
-  s.add_dependency 'kube-dsl', '~> 0.3'
+  s.add_dependency 'kube-dsl', '~> 0.4'
   s.add_dependency 'kuby-kube-db', '>= 0.6'
   s.add_dependency 'kubernetes-cli', '~> 0.3'
   s.add_dependency 'railties', '>= 5.1'
   s.add_dependency 'rouge', '~> 3.0'
+  s.add_dependency 'sorbet-runtime-stub', '~> 0.2'
 
   s.add_development_dependency 'rspec'
 

data/lib/kuby-core.rb

@@ -0,0 +1 @@
+require 'kuby'

data/lib/kuby.rb

@@ -1,3 +1,6 @@
+# typed: false
+
+require 'sorbet-runtime-stub'
 require 'kuby/railtie'
 
 begin
@@ -69,6 +72,10 @@ module Kuby
         env.kubernetes.after_configuration
       end
 
+      @definition.environments.each do |_, env|
+        env.configured = true
+      end
+
       @definition
     end
 

data/lib/kuby/basic_logger.rb

@@ -1,9 +1,30 @@
+# 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|
@@ -11,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,23 +1,39 @@
+# 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
@@ -28,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) }
@@ -65,55 +91,111 @@ 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)
+      else
+        systemm_open3(cmd)
+      end
+    end
+
+    sig { params(cmd: T::Array[String]).void }
+    def systemm_default(cmd)
+      run_before_callbacks(cmd)
+      cmd_s = cmd.join(' ')
+      system(cmd_s).tap do
+        self.last_status = $?
+        run_after_callbacks(cmd)
+      end
+    end
+
+    sig { params(cmd: T::Array[String]).void }
+    def systemm_open3(cmd)
       run_before_callbacks(cmd)
       cmd_s = cmd.join(' ')
 
       Open3.popen3(cmd_s) do |p_stdin, p_stdout, p_stderr, wait_thread|
         Thread.new(stdout) do |t_stdout|
-          p_stdout.each { |line| t_stdout.puts(line) }
+          begin
+            p_stdout.each { |line| t_stdout.puts(line) }
+          rescue IOError
+          end
         end
 
         Thread.new(stderr) do |t_stderr|
-          p_stderr.each { |line| t_stderr.puts(line) }
+          begin
+            p_stderr.each { |line| t_stderr.puts(line) }
+          rescue IOError
+          end
         end
 
-        self.last_status = wait_thread.value
+        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]).returns(String) }
     def backticks(cmd)
+      if stdout == STDOUT && stderr == STDERR
+        backticks_default(cmd)
+      else
+        backticks_open3(cmd)
+      end
+    end
+
+    sig { params(cmd: T::Array[String]).returns(String) }
+    def backticks_default(cmd)
+      run_before_callbacks(cmd)
+      cmd_s = cmd.join(' ')
+      `#{cmd_s}`.tap do
+        self.last_status = $?
+        run_after_callbacks(cmd)
+      end
+    end
+
+    sig { params(cmd: T::Array[String]).returns(String) }
+    def backticks_open3(cmd)
       run_before_callbacks(cmd)
       cmd_s = cmd.join(' ')
       result = StringIO.new
 
       Open3.popen3(cmd_s) do |p_stdin, p_stdout, p_stderr, wait_thread|
         Thread.new do
-          p_stdout.each { |line| result.puts(line) }
+          begin
+            p_stdout.each { |line| result.puts(line) }
+          rescue IOError
+          end
         end
 
         Thread.new(stderr) do |t_stderr|
-          p_stderr.each { |line| t_stderr.puts(line) }
+          begin
+            p_stderr.each { |line| t_stderr.puts(line) }
+          rescue IOError
+          end
         end
 
-        self.last_status = wait_thread.value
+        p_stdin.close
+        self.last_status = T.cast(wait_thread.value, Process::Status)
         run_after_callbacks(cmd)
         wait_thread.join
       end
@@ -121,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,8 +1,11 @@
+# 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
@@ -16,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
@@ -26,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"
@@ -66,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