kuby-core 0.16.0 → 0.18.0

data/lib/kuby/docker/image.rb

@@ -3,137 +3,149 @@
 module Kuby
   module Docker
     class Image
-      extend T::Sig
+      # extend T::Sig
 
-      sig { returns(T.nilable(String)) }
+      # T::Sig::WithoutRuntime.sig { returns(T.nilable(String)) }
       attr_reader :identifier
 
-      sig { returns(String) }
+      # T::Sig::WithoutRuntime.sig { returns(String) }
       attr_reader :image_url
 
-      sig { returns(T.nilable(String)) }
+      # T::Sig::WithoutRuntime.sig { returns(T.nilable(String)) }
       attr_reader :registry_index_url
 
-      sig { returns(Credentials) }
+      # T::Sig::WithoutRuntime.sig { returns(Kuby::Docker::Credentials) }
       attr_reader :credentials
 
-      sig { returns(T.nilable(String)) }
+      # T::Sig::WithoutRuntime.sig { returns(T.nilable(String)) }
       attr_reader :main_tag
 
-      sig { returns T::Array[String] }
+      # T::Sig::WithoutRuntime.sig { returns T::Array[String] }
       attr_reader :alias_tags
 
-      sig {
-        params(
-          dockerfile: T.any(Dockerfile, T.proc.returns(Dockerfile)),
-          image_url: String,
-          credentials: Credentials,
-          registry_index_url: T.nilable(String),
-          main_tag: T.nilable(String),
-          alias_tags: T::Array[String]
-        ).void
-      }
+      # T::Sig::WithoutRuntime.sig {
+      #   params(
+      #     dockerfile: T.any(Dockerfile, T.proc.returns(Kuby::Docker::Dockerfile)),
+      #     image_url: String,
+      #     credentials: Kuby::Docker::Credentials,
+      #     registry_index_url: T.nilable(String),
+      #     main_tag: T.nilable(String),
+      #     alias_tags: T::Array[String]
+      #   ).void
+      # }
       def initialize(dockerfile, image_url, credentials, registry_index_url = nil, main_tag = nil, alias_tags = [])
-        @dockerfile = T.let(dockerfile, T.any(Dockerfile, T.proc.returns(Dockerfile)))
-        @image_url = T.let(image_url, String)
-        @registry_index_url = T.let(registry_index_url, T.nilable(String))
-        @credentials = T.let(credentials, Credentials)
-        @main_tag = T.let(main_tag, T.nilable(String))
-        @alias_tags = T.let(alias_tags, T::Array[String])
-        @identifier = T.let(@identifier, T.nilable(String))
-
-        @image_host = T.let(@image_host, T.nilable(String))
-        @image_hostname = T.let(@image_hostname, T.nilable(String))
-        @registry_index_host = T.let(@registry_index_host, T.nilable(String))
-        @registry_index_hostname = T.let(@registry_index_hostname, T.nilable(String))
-        @registry_index_uri = T.let(@registry_index_uri, T.nilable(DockerURI))
-        @image_repo = T.let(@image_repo, T.nilable(String))
-        @full_image_uri = T.let(@full_image_uri, T.nilable(DockerURI))
-        @docker_cli = T.let(@docker_cli, T.nilable(Docker::CLI))
-      end
-
-      sig { returns(Image) }
+        @dockerfile = dockerfile
+        @image_url = image_url
+        @registry_index_url = registry_index_url
+        @credentials = credentials
+        @main_tag = main_tag
+        @alias_tags = alias_tags
+        # @identifier = T.let(@identifier, T.nilable(String))
+
+        # @image_host = T.let(@image_host, T.nilable(String))
+        # @image_hostname = T.let(@image_hostname, T.nilable(String))
+        # @registry_index_host = T.let(@registry_index_host, T.nilable(String))
+        # @registry_index_hostname = T.let(@registry_index_hostname, T.nilable(String))
+        # @registry_index_uri = T.let(@registry_index_uri, T.nilable(DockerURI))
+        # @image_repo = T.let(@image_repo, T.nilable(String))
+        # @full_image_uri = T.let(@full_image_uri, T.nilable(DockerURI))
+        # @docker_cli = T.let(@docker_cli, T.nilable(Docker::CLI))
+      end
+
+      # T::Sig::WithoutRuntime.sig { returns(Kuby::Docker::Image) }
       def new_version
         raise NotImplementedError, 'please use a Docker::Image subclass'
       end
 
-      sig { returns(Image) }
+      # T::Sig::WithoutRuntime.sig { returns(Kuby::Docker::Image) }
       def current_version
         raise NotImplementedError, 'please use a Docker::Image subclass'
       end
 
-      sig { params(current_tag: T.nilable(String)).returns(Image) }
+      # T::Sig::WithoutRuntime.sig { params(current_tag: T.nilable(String)).returns(Image) }
       def previous_version(current_tag = nil)
         raise NotImplementedError, 'please use a Docker::Image subclass'
       end
 
-      sig { returns(Dockerfile) }
+      # T::Sig::WithoutRuntime.sig { returns(Kuby::Docker::Dockerfile) }
       def dockerfile
         if @dockerfile.respond_to?(:call)
-          T.cast(@dockerfile, T.proc.returns(Dockerfile)).call
+          @dockerfile.call
         else
-          T.cast(@dockerfile, Dockerfile)
+          @dockerfile
         end
       end
 
-      sig { returns(String) }
+      # T::Sig::WithoutRuntime.sig { returns(String) }
       def image_host
         @image_host ||= "#{image_uri.host}:#{image_uri.port}"
       end
 
-      sig { returns(String) }
+      # T::Sig::WithoutRuntime.sig { returns(String) }
       def registry_index_host
         @registry_index_host ||= "#{registry_index_uri.host}:#{registry_index_uri.port}"
       end
 
-      sig { returns(String) }
+      # T::Sig::WithoutRuntime.sig { returns(String) }
       def registry_index_hostname
         @registry_index_hostname ||= registry_index_uri.host
       end
 
-      sig { returns(String) }
+      # T::Sig::WithoutRuntime.sig { returns(String) }
       def image_hostname
         @image_hostname ||= image_uri.host
       end
 
-      sig { returns(String) }
+      # T::Sig::WithoutRuntime.sig { returns(String) }
       def image_repo
         @image_repo ||= image_uri.path
       end
 
-      sig { returns(DockerURI) }
+      # T::Sig::WithoutRuntime.sig { returns(Kuby::Docker::DockerURI) }
       def image_uri
         @full_image_uri ||= DockerURI.parse_uri(image_url)
       end
 
-      sig { returns(DockerURI) }
+      # T::Sig::WithoutRuntime.sig { returns(Kuby::Docker::DockerURI) }
       def registry_index_uri
         @registry_index_uri ||= DockerURI.parse_index_uri(registry_index_url || image_url)
       end
 
-      sig { returns(T::Array[String]) }
+      # T::Sig::WithoutRuntime.sig { returns(T::Array[String]) }
       def tags
         [main_tag, *alias_tags].compact
       end
 
-      sig { params(build_args: T::Hash[String, String], docker_args: T::Array[String]).void }
-      def build(build_args = {}, docker_args = [])
+      # T::Sig::WithoutRuntime.sig {
+      #   params(
+      #     build_args: T::Hash[String, String],
+      #     docker_args: T::Array[String],
+      #     context: T.nilable(String),
+      #     cache_from: T.nilable(String)
+      #   ).void
+      # }
+      def build(build_args = {}, docker_args = [], context: nil, cache_from: nil)
         raise NotImplementedError, 'please use a Docker::Image subclass'
       end
 
-      sig { params(tag: String).void }
+      # T::Sig::WithoutRuntime.sig { params(tag: String).void }
       def push(tag)
         raise NotImplementedError, 'please use a Docker::Image subclass'
       end
 
-      sig { returns(Docker::CLI) }
+      # T::Sig::WithoutRuntime.sig { params(tag: String).void }
+      def pull(tag)
+        raise NotImplementedError, 'please use a Docker::Image subclass'
+      end
+
+      # T::Sig::WithoutRuntime.sig { returns(Kuby::Docker::CLI) }
       def docker_cli
         @docker_cli ||= Docker::CLI.new
       end
 
       private
 
-      sig { params(main_tag: String, alias_tags: T::Array[String]).returns(Image) }
+      # T::Sig::WithoutRuntime.sig { params(main_tag: String, alias_tags: T::Array[String]).returns(Image) }
       def duplicate_with_tags(main_tag, alias_tags)
         self.class.new(dockerfile, image_url, credentials, registry_index_url, main_tag, alias_tags)
       end

data/lib/kuby/docker/inline_layer.rb

@@ -3,17 +3,17 @@
 module Kuby
   module Docker
     class InlineLayer < Layer
-      extend T::Sig
+      # extend T::Sig
 
-      sig { returns(T.proc.params(df: Dockerfile).void) }
+      # T::Sig::WithoutRuntime.sig { returns(T.proc.params(df: Dockerfile).void) }
       attr_reader :block
 
-      sig { params(block: T.proc.params(df: Dockerfile).void).void }
+      # T::Sig::WithoutRuntime.sig { params(block: T.proc.params(df: Dockerfile).void).void }
       def initialize(block)
         @block = block
       end
 
-      sig { override.params(dockerfile: Dockerfile).void }
+      # T::Sig::WithoutRuntime.sig { override.params(dockerfile: Dockerfile).void }
       def apply_to(dockerfile)
         block.call(dockerfile)
       end

data/lib/kuby/docker/layer.rb

@@ -3,20 +3,20 @@
 module Kuby
   module Docker
     class Layer
-      extend T::Sig
-      extend T::Helpers
+      # extend T::Sig
+      # extend T::Helpers
 
-      abstract!
+      # abstract!
 
-      sig { returns(Environment) }
+      # T::Sig::WithoutRuntime.sig { returns(Environment) }
       attr_reader :environment
 
-      sig { params(environment: Environment).void }
+      # T::Sig::WithoutRuntime.sig { params(environment: Environment).void }
       def initialize(environment)
         @environment = environment
       end
 
-      sig { params(dockerfile: Dockerfile).void }
+      # T::Sig::WithoutRuntime.sig { params(dockerfile: Dockerfile).void }
       def apply_to(dockerfile)
         raise NotImplementedError,
           "#{__method__} must be defined in derived classes"

data/lib/kuby/docker/layer_stack.rb

@@ -3,44 +3,44 @@
 module Kuby
   module Docker
     class LayerStack
-      extend T::Sig
-      extend T::Generic
+      # extend T::Sig
+      # extend T::Generic
 
-      Elem = type_member(fixed: Layer)
+      # Elem = type_member { { fixed: Kuby::Docker::Layer } }
 
       include Enumerable
 
-      sig { returns(T::Array[Symbol]) }
+      # T::Sig::WithoutRuntime.sig { returns(T::Array[Symbol]) }
       attr_reader :stack
 
-      sig { returns(T::Hash[Symbol, Layer]) }
+      # T::Sig::WithoutRuntime.sig { returns(T::Hash[Symbol, Kuby::Docker::Layer]) }
       attr_reader :layers
 
-      sig { void }
+      # T::Sig::WithoutRuntime.sig { void }
       def initialize
-        @stack = T.let([], T::Array[Symbol])
-        @layers = T.let({}, T::Hash[Symbol, Layer])
+        @stack = []
+        @layers = {}
       end
 
-      sig {
-        override.params(
-          block: T.nilable(T.proc.params(layer: Layer).void)
-        )
-        .void
-      }
+      # T::Sig::WithoutRuntime.sig {
+      #   override.params(
+      #     block: T.nilable(T.proc.params(layer: Kuby::Docker::Layer).void)
+      #   )
+      #   .void
+      # }
       def each(&block)
-        return to_enum(T.must(__method__)) unless block_given?
-        @stack.each { |name| yield T.must(layers[name]) }
+        return to_enum(__method__) unless block_given?
+        @stack.each { |name| yield layers[name] }
       end
 
-      sig {
-        params(
-          name: Symbol,
-          layer: T.nilable(Layer),
-          block: T.nilable(T.proc.params(df: Dockerfile).void)
-        )
-        .void
-      }
+      # T::Sig::WithoutRuntime.sig {
+      #   params(
+      #     name: Symbol,
+      #     layer: T.nilable(Layer),
+      #     block: T.nilable(T.proc.params(df: Kuby::Docker::Dockerfile).void)
+      #   )
+      #   .void
+      # }
       def use(name, layer = nil, &block)
         stack << name
 
@@ -53,15 +53,15 @@ module Kuby
         end
       end
 
-      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
-      }
+      # T::Sig::WithoutRuntime.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: Kuby::Docker::Dockerfile).void)
+      #   )
+      #   .void
+      # }
       def insert(name, layer = nil, options = {}, &block)
         # this is truly gross but it's the only way I can think of to be able
         # to call insert these two ways:
@@ -94,13 +94,13 @@ module Kuby
         end
       end
 
-      sig { params(name: Symbol).void }
+      # T::Sig::WithoutRuntime.sig { params(name: Symbol).void }
       def delete(name)
         stack.delete(name)
         layers.delete(name)
       end
 
-      sig { params(name: Symbol).returns(T::Boolean) }
+      # T::Sig::WithoutRuntime.sig { params(name: Symbol).returns(T::Boolean) }
       def includes?(name)
         layers.include?(name)
       end

data/lib/kuby/docker/local_tags.rb

@@ -3,34 +3,34 @@
 module Kuby
   module Docker
     class LocalTags
-      extend T::Sig
+      # extend T::Sig
 
-      sig { returns CLI }
+      # T::Sig::WithoutRuntime.sig { returns Kuby::Docker::CLI }
       attr_reader :cli
 
-      sig { returns(String) }
+      # T::Sig::WithoutRuntime.sig { returns(String) }
       attr_reader :image_url
 
-      sig {
-        params(
-          cli: CLI,
-          image_url: String
-        )
-        .void
-      }
+      # T::Sig::WithoutRuntime.sig {
+      #   params(
+      #     cli: Kuby::Docker::CLI,
+      #     image_url: String
+      #   )
+      #   .void
+      # }
       def initialize(cli, image_url)
         @cli = cli
         @image_url = image_url
-        @latest_timestamp_tag = T.let(@latest_timestamp_tag, T.nilable(TimestampTag))
+        # @latest_timestamp_tag = T.let(@latest_timestamp_tag, T.nilable(TimestampTag))
       end
 
-      sig { returns(T::Array[String]) }
+      # T::Sig::WithoutRuntime.sig { returns(T::Array[String]) }
       def tags
         images = cli.images(image_url)
-        images.map { |image| T.must(image[:tag]) }
+        images.map { |image| image[:tag] }
       end
 
-      sig { returns(T::Array[String]) }
+      # T::Sig::WithoutRuntime.sig { returns(T::Array[String]) }
       def latest_tags
         # find "latest" tag
         images = cli.images(image_url)
@@ -48,12 +48,12 @@ module Kuby
         end
       end
 
-      sig { returns(T::Array[TimestampTag]) }
+      # T::Sig::WithoutRuntime.sig { returns(T::Array[Kuby::Docker::TimestampTag]) }
       def timestamp_tags
         tags.map { |t| TimestampTag.try_parse(t) }.compact
       end
 
-      sig { returns(T.nilable(TimestampTag)) }
+      # T::Sig::WithoutRuntime.sig { returns(T.nilable(Kuby::Docker::TimestampTag)) }
       def latest_timestamp_tag
         @latest_timestamp_tag ||= timestamp_tags.sort.last
       end

data/lib/kuby/docker/package_list.rb

@@ -3,48 +3,48 @@
 module Kuby
   module Docker
     class PackageList
-      extend T::Sig
-      extend T::Generic
+      # extend T::Sig
+      # extend T::Generic
 
-      Elem = type_member(fixed: Distro::PackageImpl)
+      # Elem = type_member { { fixed: Distro::PackageImpl } }
 
       include Enumerable
 
-      sig { returns(T::Array[Distro::PackageImpl]) }
+      # T::Sig::WithoutRuntime.sig { returns(T::Array[Distro::PackageImpl]) }
       attr_reader :packages
 
-      sig { params(package_tuples: T::Array[[Symbol, T.nilable(String)]]).void }
+      # T::Sig::WithoutRuntime.sig { params(package_tuples: T::Array[[Symbol, T.nilable(String)]]).void }
       def initialize(package_tuples)
-        @packages = T.let([], T::Array[Distro::PackageImpl])
+        @packages = []
         package_tuples.each { |name, version| add(name, version) }
       end
 
-      sig { params(name: Symbol).returns(T.nilable(Distro::PackageImpl)) }
+      # T::Sig::WithoutRuntime.sig { params(name: Symbol).returns(T.nilable(Distro::PackageImpl)) }
       def [](name)
         packages.find { |pkg| pkg.name == name }
       end
 
-      sig { params(name: Symbol, version: T.nilable(String)).void }
+      # T::Sig::WithoutRuntime.sig { params(name: Symbol, version: T.nilable(String)).void }
       def add(name, version = nil)
         packages << Packages::Package.new(name, version)
       end
 
-      sig { params(name: String).void }
+      # T::Sig::WithoutRuntime.sig { params(name: String).void }
       def delete(name)
         packages.delete_if { |pkg| pkg.name == name }
       end
 
-      sig {
-        override.params(
-          block: T.proc.params(package: Distro::PackageImpl).void
-        )
-        .void
-      }
+      # T::Sig::WithoutRuntime.sig {
+      #   override.params(
+      #     block: T.proc.params(package: Distro::PackageImpl).void
+      #   )
+      #   .void
+      # }
       def each(&block)
         packages.each(&block)
       end
 
-      sig { returns(T::Boolean) }
+      # T::Sig::WithoutRuntime.sig { returns(T::Boolean) }
       def empty?
         packages.empty?
       end

data/lib/kuby/docker/package_phase.rb

@@ -3,31 +3,31 @@
 module Kuby
   module Docker
     class PackagePhase < Layer
-      extend T::Sig
+      # extend T::Sig
 
-      Operation = T.type_alias { [Symbol, Symbol, T.nilable(String)] }
+      # Operation = T.type_alias { [Symbol, Symbol, T.nilable(String)] }
 
-      sig { returns(T::Array[Operation]) }
+      # T::Sig::WithoutRuntime.sig { returns(T::Array[Operation]) }
       attr_reader :operations
 
-      sig { params(environment: Environment).void }
+      # T::Sig::WithoutRuntime.sig { params(environment: Kuby::Environment).void }
       def initialize(environment)
         super
 
-        @operations = T.let([], T::Array[Operation])
+        @operations = []
       end
 
-      sig { params(package_name: Symbol, version: T.nilable(String)).void }
+      # T::Sig::WithoutRuntime.sig { params(package_name: Symbol, version: T.nilable(String)).void }
       def add(package_name, version = nil)
         operations << [:add, package_name, version]
       end
 
-      sig { params(package_name: Symbol).void }
+      # T::Sig::WithoutRuntime.sig { params(package_name: Symbol).void }
       def remove(package_name)
         operations << [:remove, package_name, nil]
       end
 
-      sig { override.params(dockerfile: Dockerfile).void }
+      # T::Sig::WithoutRuntime.sig { override.params(dockerfile: Kuby::Docker::Dockerfile).void }
       def apply_to(dockerfile)
         packages = distro_spec.default_packages.dup
 
@@ -50,18 +50,18 @@ module Kuby
 
       private
 
-      sig { returns(Distro) }
+      # T::Sig::WithoutRuntime.sig { returns(Kuby::Docker::Distro) }
       def distro_spec
         environment.docker.distro_spec
       end
 
-      sig {
-        params(
-          package_name: Symbol,
-          version: T.nilable(String)
-        )
-        .returns(Distro::PackageImpl)
-      }
+      # T::Sig::WithoutRuntime.sig {
+      #   params(
+      #     package_name: Symbol,
+      #     version: T.nilable(String)
+      #   )
+      #   .returns(Kuby::Docker::Distro::PackageImpl)
+      # }
       def get_package(package_name, version)
         if package = Kuby.packages[package_name]
           package.with_version(version)

data/lib/kuby/docker/packages/managed_package.rb

@@ -4,27 +4,27 @@ module Kuby
   module Docker
     module Packages
       class ManagedPackage
-        extend T::Sig
+        # extend T::Sig
 
-        sig { returns(Symbol) }
+        # T::Sig::WithoutRuntime.sig { returns(Symbol) }
         attr_reader :name
 
-        sig { returns(T::Hash[Symbol, String]) }
+        # T::Sig::WithoutRuntime.sig { returns(T::Hash[Symbol, String]) }
         attr_reader :names_per_distro
 
-        sig {
-          params(
-            name: Symbol,
-            names_per_distro: T::Hash[Symbol, String]
-          )
-          .void
-        }
+        # T::Sig::WithoutRuntime.sig {
+        #   params(
+        #     name: Symbol,
+        #     names_per_distro: T::Hash[Symbol, String]
+        #   )
+        #   .void
+        # }
         def initialize(name, names_per_distro)
           @name = name
           @names_per_distro = names_per_distro
         end
 
-        sig { params(distro: Symbol).returns(String) }
+        # T::Sig::WithoutRuntime.sig { params(distro: Symbol).returns(String) }
         def package_name_for(distro)
           names_per_distro.fetch(distro) do
             raise UnsupportedDistroError, "Couldn't install #{name} "\
@@ -32,12 +32,12 @@ module Kuby
           end
         end
 
-        sig { params(ver: String).returns(T.self_type) }
+        # T::Sig::WithoutRuntime.sig { params(ver: String).returns(T.self_type) }
         def with_version(ver)
           self
         end
 
-        sig { returns(T::Boolean) }
+        # T::Sig::WithoutRuntime.sig { returns(T::Boolean) }
         def managed?
           true
         end

data/lib/kuby/docker/packages/nodejs.rb

@@ -4,26 +4,26 @@ module Kuby
   module Docker
     module Packages
       class Nodejs < Package
-        extend T::Sig
+        # extend T::Sig
 
-        sig { params(dockerfile: Dockerfile).void }
+        # T::Sig::WithoutRuntime.sig { params(dockerfile: Dockerfile).void }
         def install_on_debian(dockerfile)
           install_from_image("node:#{version}", dockerfile)
         end
 
-        sig { params(dockerfile: Dockerfile).void }
+        # T::Sig::WithoutRuntime.sig { params(dockerfile: Dockerfile).void }
         def install_on_alpine(dockerfile)
           install_from_image("node:#{version}-alpine", dockerfile)
         end
 
-        sig { returns(String) }
+        # T::Sig::WithoutRuntime.sig { returns(String) }
         def version
           @version || 'current'
         end
 
         private
 
-        sig { params(image: String, dockerfile: Dockerfile).void }
+        # T::Sig::WithoutRuntime.sig { params(image: String, dockerfile: Dockerfile).void }
         def install_from_image(image, dockerfile)
           dockerfile.insert_at(0) do
             dockerfile.from(image, as: 'nodejs')