kuby-core 0.8.1 → 0.11.0

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,26 +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
@@ -29,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
@@ -58,59 +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
 
-      attr_reader :commands, :cursor
+      class Arg < Command
+        sig { returns(String) }
+        def to_s; "ARG #{super}"; end
+      end
+
+      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)
+      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
-        commands.map(&:to_s).join("\n")
+        # 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
@@ -119,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,16 +1,25 @@
+# typed: strict
+
 module Kuby
   module Docker
     class BuildError < StandardError; end
     class PushError < StandardError; end
+    class PullError < StandardError; end
     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

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,10 +94,16 @@ 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
     end
   end
 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,9 +49,15 @@ 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
     end
   end
 end