kuby-core 0.10.1 → 0.11.0

data/lib/kuby/docker/inline_layer.rb

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

data/lib/kuby/docker/layer.rb

@@ -1,12 +1,22 @@
+# typed: strict
+
 module Kuby
   module Docker
     class Layer
+      extend T::Sig
+      extend T::Helpers
+
+      abstract!
+
+      sig { returns(Environment) }
       attr_reader :environment
 
+      sig { params(environment: Environment).void }
       def initialize(environment)
         @environment = environment
       end
 
+      sig { params(dockerfile: Dockerfile).void }
       def apply_to(dockerfile)
         raise NotImplementedError,
           "#{__method__} must be defined in derived classes"
@@ -14,6 +24,7 @@ module Kuby
 
       private
 
+      sig { returns(Metadata) }
       def metadata
         environment.docker.metadata
       end

data/lib/kuby/docker/layer_stack.rb

@@ -1,20 +1,46 @@
+# typed: strict
+
 module Kuby
   module Docker
     class LayerStack
+      extend T::Sig
+      extend T::Generic
+
+      Elem = type_member(fixed: Layer)
+
       include Enumerable
 
-      attr_reader :stack, :layers
+      sig { returns(T::Array[Symbol]) }
+      attr_reader :stack
+
+      sig { returns(T::Hash[Symbol, Layer]) }
+      attr_reader :layers
 
+      sig { void }
       def initialize
-        @stack = []
-        @layers = {}
+        @stack = T.let([], T::Array[Symbol])
+        @layers = T.let({}, T::Hash[Symbol, Layer])
       end
 
-      def each
-        return to_enum(__method__) unless block_given?
-        @stack.each { |name| yield layers[name] }
+      sig {
+        override.params(
+          block: T.nilable(T.proc.params(layer: Layer).void)
+        )
+        .void
+      }
+      def each(&block)
+        return to_enum(T.must(__method__)) unless block_given?
+        @stack.each { |name| yield T.must(layers[name]) }
       end
 
+      sig {
+        params(
+          name: Symbol,
+          layer: T.nilable(Layer),
+          block: T.nilable(T.proc.params(df: Dockerfile).void)
+        )
+        .void
+      }
       def use(name, layer = nil, &block)
         stack << name
 
@@ -27,6 +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
+      }
       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:
@@ -59,11 +94,13 @@ module Kuby
         end
       end
 
+      sig { params(name: Symbol).void }
       def delete(name)
         stack.delete(name)
         layers.delete(name)
       end
 
+      sig { params(name: Symbol).returns(T::Boolean) }
       def includes?(name)
         layers.include?(name)
       end

data/lib/kuby/docker/local_tags.rb

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

data/lib/kuby/docker/metadata.rb

@@ -1,51 +1,76 @@
+# typed: strict
+
 require 'uri'
 
 module Kuby
   module Docker
     class Metadata
+      extend T::Sig
+
       DEFAULT_DISTRO = :debian
-      DEFAULT_REGISTRY_HOST = 'https://www.docker.com'.freeze
-      DEFAULT_REGISTRY_SCHEME = 'https'
-      LATEST_TAG = 'latest'
+      DEFAULT_REGISTRY_HOST = T.let('https://www.docker.com'.freeze, String)
+      DEFAULT_REGISTRY_SCHEME = T.let('https', String)
+      LATEST_TAG = T.let('latest'.freeze, String)
+
+      sig { params(image_url: String).void }
+      attr_writer :image_url
 
-      attr_accessor :image_url
+      sig { returns(Environment) }
       attr_reader :environment
 
+      sig { params(environment: Environment).void }
       def initialize(environment)
         @environment = environment
-        @tags = []
+        @tags = T.let([], T::Array[String])
+
+        @image_url = T.let(@image_url, T.nilable(String))
+        @image_host = T.let(@image_host, T.nilable(String))
+        @image_hostname = T.let(@image_hostname, T.nilable(String))
+        @image_repo = T.let(@image_repo, T.nilable(String))
+        @distro = T.let(@distro, T.nilable(Symbol))
+        @full_image_uri = T.let(@full_image_uri, T.nilable(URI::Generic))
+        @default_image_url = T.let(@default_image_url, T.nilable(String))
+        @default_tags = T.let(@default_tags, T.nilable(T::Array[String]))
       end
 
+      sig { returns(String) }
       def image_url
         @image_url || default_image_url
       end
 
+      sig { returns(String) }
       def image_host
         @image_host ||= "#{full_image_uri.scheme}://#{full_image_uri.host}"
       end
 
+      sig { returns(String) }
       def image_hostname
-        @image_hostname ||= URI(image_host).host
+        @image_hostname ||= T.must(URI(image_host).host)
       end
 
+      sig { returns(String) }
       def image_repo
-        @image_repo ||= full_image_uri.path.sub(/\A[\/]+/, '')
+        @image_repo ||= T.must(full_image_uri.path).sub(/\A[\/]+/, '')
       end
 
+      sig { returns(T::Array[String]) }
       def tags
         @tags.empty? ? default_tags : @tags
       end
 
+      sig { returns(Symbol) }
       def distro
         @distro || DEFAULT_DISTRO
       end
 
+      sig { params(distro_name: Symbol).void }
       def distro=(distro_name)
         @distro = distro_name
       end
 
       private
 
+      sig { returns(URI::Generic) }
       def full_image_uri
         @full_image_uri ||= if image_url.include?('://')
           URI.parse(image_url)
@@ -56,17 +81,20 @@ module Kuby
         end
       end
 
+      sig { returns(String) }
       def default_image_url
         # assuming dockerhub by not specifying full url
         @default_image_url ||= environment.app_name.downcase
       end
 
+      sig { returns(T::Array[String]) }
       def default_tags
         @default_tags ||= [
           TimestampTag.new(Time.now).to_s, LATEST_TAG
         ]
       end
 
+      sig { params(url: String).returns(URI::Generic) }
       def parse_url(url)
         uri = URI.parse(url)
         return uri if uri.scheme

data/lib/kuby/docker/package_list.rb

@@ -1,31 +1,50 @@
+# typed: strict
+
 module Kuby
   module Docker
     class PackageList
+      extend T::Sig
+      extend T::Generic
+
+      Elem = type_member(fixed: Distro::PackageImpl)
+
       include Enumerable
 
+      sig { returns(T::Array[Distro::PackageImpl]) }
       attr_reader :packages
 
+      sig { params(package_tuples: T::Array[[Symbol, T.nilable(String)]]).void }
       def initialize(package_tuples)
-        @packages = []
-        package_tuples.each { |pt| add(*pt) }
+        @packages = T.let([], T::Array[Distro::PackageImpl])
+        package_tuples.each { |name, version| add(name, version) }
       end
 
+      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 }
       def add(name, version = nil)
-        packages << Package.new(name, version)
+        packages << Packages::Package.new(name, version)
       end
 
+      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
+      }
       def each(&block)
         packages.each(&block)
       end
 
+      sig { returns(T::Boolean) }
       def empty?
         packages.empty?
       end

data/lib/kuby/docker/package_phase.rb

@@ -1,22 +1,33 @@
+# typed: strict
+
 module Kuby
   module Docker
     class PackagePhase < Layer
+      extend T::Sig
+
+      Operation = T.type_alias { [Symbol, Symbol, T.nilable(String)] }
+
+      sig { returns(T::Array[Operation]) }
       attr_reader :operations
 
-      def initialize(*args)
+      sig { params(environment: Environment).void }
+      def initialize(environment)
         super
 
-        @operations = []
+        @operations = T.let([], T::Array[Operation])
       end
 
+      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 }
       def remove(package_name)
-        operations << [:remove, package_name]
+        operations << [:remove, package_name, nil]
       end
 
+      sig { override.params(dockerfile: Dockerfile).void }
       def apply_to(dockerfile)
         packages = distro_spec.default_packages.dup
 
@@ -30,19 +41,27 @@ module Kuby
           end
         end
 
-        packages.map! do |package_name, version|
+        package_impls = packages.map do |package_name, version|
           get_package(package_name, version)
         end
 
-        distro_spec.install(packages, into: dockerfile)
+        distro_spec.install(package_impls, into: dockerfile)
       end
 
       private
 
+      sig { returns(Distro) }
       def distro_spec
         environment.docker.distro_spec
       end
 
+      sig {
+        params(
+          package_name: Symbol,
+          version: T.nilable(String)
+        )
+        .returns(Distro::PackageImpl)
+      }
       def get_package(package_name, version)
         if package = Kuby.packages[package_name]
           package.with_version(version)
@@ -51,6 +70,7 @@ module Kuby
         end
       end
 
+      sig { returns(Metadata) }
       def metadata
         environment.docker.metadata
       end

data/lib/kuby/docker/packages.rb

@@ -1,3 +1,4 @@
+# typed: strict
 module Kuby
   module Docker
     module Packages

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

@@ -1,14 +1,30 @@
+# typed: strict
+
 module Kuby
   module Docker
     module Packages
       class ManagedPackage
-        attr_reader :name, :names_per_distro
+        extend T::Sig
+
+        sig { returns(Symbol) }
+        attr_reader :name
+
+        sig { returns(T::Hash[Symbol, String]) }
+        attr_reader :names_per_distro
 
+        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) }
         def package_name_for(distro)
           names_per_distro.fetch(distro) do
             raise UnsupportedDistroError, "Couldn't install #{name} "\
@@ -16,10 +32,12 @@ module Kuby
           end
         end
 
-        def with_version(*)
+        sig { params(ver: String).returns(T.self_type) }
+        def with_version(ver)
           self
         end
 
+        sig { returns(T::Boolean) }
         def managed?
           true
         end