kuby-core 0.10.1 → 0.11.0

data/lib/kuby/docker/dev_spec.rb

@@ -1,63 +1,121 @@
+# typed: strict
+
 module Kuby
   module Docker
     class WebserverDevPhase < Layer
-      DEFAULT_PORT = 3000
+      extend T::Sig
+
+      DEFAULT_PORT = T.let('3000'.freeze, String)
+
+      sig { params(port: String).void }
+      attr_writer :port
 
-      attr_accessor :port
+      sig { params(environment: Environment).void }
+      def initialize(environment)
+        super
+
+        @port = T.let(@port, T.nilable(String))
+      end
 
+      sig { override.params(dockerfile: Dockerfile).void }
       def apply_to(dockerfile)
         dockerfile.expose(port)
       end
 
+      sig { returns(String) }
       def port
         @port || DEFAULT_PORT
       end
     end
 
     class DevSpec
+      extend T::Sig
+
+      sig { returns(Environment) }
       attr_reader :environment
 
+      sig { params(environment: Environment).void }
       def initialize(environment)
         @environment = environment
+
+        @setup_phase = T.let(@setup_phase, T.nilable(SetupPhase))
+        @package_phase = T.let(@package_phase, T.nilable(PackagePhase))
+        @webserver_phase = T.let(@webserver_phase, T.nilable(WebserverDevPhase))
+        @metadata = T.let(@metadata, T.nilable(Metadata))
+        @distro_spec = T.let(@distro_spec, T.nilable(Distro))
+        @cli = T.let(@cli, T.nilable(CLI))
+        @tags = T.let(@tags, T.nilable(LocalTags))
+        @layer_stack = T.let(@layer_stack, T.nilable(Docker::LayerStack))
       end
 
+      sig { params(dir: String).void }
       def working_dir(dir)
         setup_phase.working_dir = dir
       end
 
+      sig { params(env: String).void }
       def rails_env(env)
         setup_phase.rails_env = env
       end
 
-      def package(*args)
-        package_phase.add(*args)
+      sig {
+        params(
+          package_name: Symbol,
+          version: T.nilable(String)
+        )
+        .void
+      }
+      def package(package_name, version = nil)
+        package_phase.add(package_name, version)
       end
 
+      sig { params(distro_name: Symbol).void }
       def distro(distro_name)
         metadata.distro = distro_name
         @distro_spec = nil
       end
 
+      sig { params(port: String).void }
       def port(port)
         webserver_phase.port = port
       end
 
-      def use(*args, &block)
-        layer_stack.use(*args, &block)
+      sig {
+        params(
+          name: Symbol,
+          layer: T.nilable(Layer),
+          block: T.nilable(T.proc.params(df: Dockerfile).void)
+        )
+        .void
+      }
+      def use(name, layer = nil, &block)
+        layer_stack.use(name, layer, &block)
       end
 
-      def insert(*args, &block)
-        layer_stack.insert(*args, &block)
+      sig {
+        params(
+          name: Symbol,
+          layer: T.nilable(T.any(Layer, T::Hash[Symbol, T.untyped])),
+          options: T::Hash[Symbol, T.untyped],
+          block: T.nilable(T.proc.params(df: Dockerfile).void)
+        )
+        .void
+      }
+      def insert(name, layer = nil, options = {}, &block)
+        layer_stack.insert(name, layer, options, &block)
       end
 
-      def delete(*args)
-        layer_stack.delete(*args)
+      sig { params(name: Symbol).void }
+      def delete(name)
+        layer_stack.delete(name)
       end
 
-      def exists?(*args)
-        layer_stack.includes?(*args)
+      sig { params(name: Symbol).returns(T::Boolean) }
+      def exists?(name)
+        layer_stack.includes?(name)
       end
 
+      sig { returns(Dockerfile) }
       def to_dockerfile
         Dockerfile.new.tap do |df|
           layer_stack.each { |layer| layer.apply_to(df) }
@@ -65,26 +123,27 @@ module Kuby
         end
       end
 
+      sig { returns(SetupPhase) }
       def setup_phase
         @setup_phase ||= SetupPhase.new(environment)
       end
 
+      sig { returns(PackagePhase) }
       def package_phase
         @package_phase ||= PackagePhase.new(environment)
       end
 
+      sig { returns(WebserverDevPhase) }
       def webserver_phase
         @webserver_phase ||= WebserverDevPhase.new(environment)
       end
 
+      sig { returns(Metadata) }
       def metadata
         @metadata ||= Metadata.new(environment)
       end
 
-      def cli
-        @cli ||= Docker::CLI.new
-      end
-
+      sig { returns(Distro) }
       def distro_spec
         @distro_spec ||= if distro_klass = Kuby.distros[metadata.distro]
           distro_klass.new(self)
@@ -93,6 +152,7 @@ module Kuby
         end
       end
 
+      sig { returns(String) }
       def tag
         t = ENV.fetch('KUBY_DOCKER_TAG') do
           tags.latest_timestamp_tag
@@ -105,22 +165,26 @@ module Kuby
         t.to_s
       end
 
-      def previous_tag(*)
+      sig { params(current_tag: String).returns(String) }
+      def previous_tag(current_tag)
         raise MissingTagError, 'cannot roll back in the development environment'
       end
 
+      sig { returns(CLI) }
       def cli
         @cli ||= Docker::CLI.new
       end
 
       private
 
+      sig { returns(LocalTags) }
       def tags
         @tags ||= LocalTags.new(cli, metadata)
       end
 
+      sig { returns(Docker::LayerStack) }
       def layer_stack
-        @layer_stack ||= LayerStack.new.tap do |stack|
+        @layer_stack ||= Docker::LayerStack.new.tap do |stack|
           stack.use(:setup_phase, setup_phase)
           stack.use(:package_phase, package_phase)
           stack.use(:webserver_phase, webserver_phase)

data/lib/kuby/docker/distro.rb

@@ -0,0 +1,43 @@
+# typed: strict
+
+module Kuby
+  module Docker
+    class Distro
+      extend T::Sig
+      extend T::Helpers
+
+      abstract!
+
+      PackageImpl = T.type_alias {
+        T.any(Packages::Package, Packages::ManagedPackage, Packages::SimpleManagedPackage)
+      }
+
+      ManagedPackageImpl = T.type_alias {
+        T.any(Packages::ManagedPackage, Packages::SimpleManagedPackage)
+      }
+
+      sig { params(phase: Layer).void }
+      def initialize(phase)
+        @phase = phase
+      end
+
+      sig { params(packages: T::Array[PackageImpl], into: Dockerfile).void }
+      def install(packages, into:)
+        raise NotImplementedError,
+          "#{__method__} must be defined in derived classes"
+      end
+
+      sig { returns(T::Array[[Symbol, T.nilable(String)]]) }
+      def default_packages
+        raise NotImplementedError,
+          "#{__method__} must be defined in derived classes"
+      end
+
+      sig { returns(String) }
+      def shell_exe
+        raise NotImplementedError,
+          "#{__method__} must be defined in derived classes"
+      end
+    end
+  end
+end

data/lib/kuby/docker/dockerfile.rb

@@ -1,28 +1,43 @@
+# typed: strict
+
 require 'digest'
 
 module Kuby
   module Docker
     class Dockerfile
+      extend T::Sig
+
       class Command
+        extend T::Sig
+
+        sig { returns(T::Array[String]) }
         attr_reader :args
 
-        def initialize(*args)
+        sig { params(args: T::Array[String]).void }
+        def initialize(args)
           @args = args
         end
 
+        sig { returns(String) }
         def to_s
           args.join(' ')
         end
       end
 
       class From < Command
-        attr_reader :image_url, :as
+        sig { returns(String) }
+        attr_reader :image_url
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :as
 
+        sig { params(image_url: String, as: T.nilable(String)).void }
         def initialize(image_url, as: nil)
           @image_url = image_url
           @as = as
         end
 
+        sig { returns(String) }
         def to_s
           str = "FROM #{image_url}"
           str << " AS #{as}" if as
@@ -31,26 +46,38 @@ module Kuby
       end
 
       class Workdir < Command
+        sig { returns(String) }
         def to_s; "WORKDIR #{super}"; end
       end
 
       class Env < Command
+        sig { returns(String) }
         def to_s; "ENV #{super}"; end
       end
 
       class Run < Command
+        sig { returns(String) }
         def to_s; "RUN #{super}"; end
       end
 
       class Copy < Command
-        attr_reader :source, :dest, :from
+        sig { returns(String) }
+        attr_reader :source
 
+        sig { returns(String) }
+        attr_reader :dest
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :from
+
+        sig { params(source: String, dest: String, from: T.nilable(String)).void }
         def initialize(source, dest, from: nil)
           @source = source
           @dest = dest
           @from = from
         end
 
+        sig { returns(String) }
         def to_s
           cmd = ['COPY']
           cmd << "--from=#{from}" if from
@@ -60,72 +87,92 @@ module Kuby
       end
 
       class Expose < Command
+        sig { returns(String) }
         def to_s; "EXPOSE #{super}"; end
       end
 
       class Cmd < Command
+        sig { returns(String) }
         def to_s; "CMD #{super}"; end
       end
 
       class Arg < Command
+        sig { returns(String) }
         def to_s; "ARG #{super}"; end
       end
 
-      attr_reader :commands, :cursor
+      sig { returns(T::Array[Command]) }
+      attr_reader :commands
+
+      sig { returns(Integer) }
+      attr_reader :cursor
 
+      sig { void }
       def initialize
-        @commands = []
-        @cursor = 0
+        @commands = T.let([], T::Array[Command])
+        @cursor = T.let(0, Integer)
       end
 
-      def from(*args, **kwargs)
-        add From.new(*args, **kwargs)
+      sig { params(image_url: String, as: T.nilable(String)).void }
+      def from(image_url, as: nil)
+        add From.new(image_url, as: as)
       end
 
+      sig { params(args: String).void }
       def workdir(*args)
-        add Workdir.new(*args)
+        add Workdir.new(args)
       end
 
+      sig { params(args: String).void }
       def env(*args)
-        add Env.new(*args)
+        add Env.new(args)
       end
 
+      sig { params(args: String).void }
       def arg(*args)
-        add Arg.new(*args)
+        add Arg.new(args)
       end
 
+      sig { params(args: String).void }
       def run(*args)
-        add Run.new(*args)
+        add Run.new(args)
       end
 
-      def copy(*args, **kwargs)
-        add Copy.new(*args, **kwargs)
+      sig { params(source: String, dest: String, from: T.nilable(String)).void }
+      def copy(source, dest, from: nil)
+        add Copy.new(source, dest, from: from)
       end
 
+      sig { params(args: String).void }
       def expose(*args)
-        add Expose.new(*args)
+        add Expose.new(args)
       end
 
+      sig { params(args: String).void }
       def cmd(*args)
-        add Cmd.new(*args)
+        add Cmd.new(args)
       end
 
+      sig { returns(String) }
       def to_s
         # ensure trailing newline
         "#{commands.map(&:to_s).join("\n")}\n"
       end
 
+      sig { returns(String) }
       def checksum
         Digest::SHA256.hexdigest(to_s)
       end
 
+      sig { returns(T::Array[String]) }
       def exposed_ports
         commands
           .select { |c| c.is_a?(Expose) }
-          .map { |c| c.args.first }
+          .map { |c| T.must(c.args.first) }
       end
 
-      def insert_at(pos)
+      sig { params(pos: Integer, block: T.proc.void).void }
+      def insert_at(pos, &block)
         @cursor = pos
         yield
       ensure
@@ -134,6 +181,7 @@ module Kuby
 
       private
 
+      sig { params(cmd: Command).void }
       def add(cmd)
         commands.insert(cursor, cmd)
         @cursor += 1

data/lib/kuby/docker/errors.rb

@@ -1,3 +1,5 @@
+# typed: strict
+
 module Kuby
   module Docker
     class BuildError < StandardError; end
@@ -6,12 +8,18 @@ module Kuby
     class LoginError < StandardError; end
 
     class MissingTagError < StandardError
+      extend T::Sig
+
+      sig { returns(String) }
       attr_reader :tag
 
+      sig { params(tag: String).void }
       def initialize(tag)
         @tag = tag
+        @message = T.let(@message, T.nilable(String))
       end
 
+      sig { returns(String) }
       def message
         @message ||= "Could not find tag '#{tag}'."
       end