kube-dsl 0.4.0 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4c028c471596448f6e06ff1aa0bf50bc3ccdd93e22559a9805d4078921571f8a
-  data.tar.gz: b6e10a2a2f59d21af138e18db5a46b015a331e762642f7d2292daa69e9f4365f
+  metadata.gz: ee0373d4a49b731e08d691b25c84ba5c71f8e9a4018f411ba5bb8da87448096a
+  data.tar.gz: 7ffcad491b24630b21ae7a8799f75089816b066f4a9671db5774999d0fbac434
 SHA512:
-  metadata.gz: 7bda26da0d442fbe59af67f1a8c60aad632bb91f789332aa951032d6f25be6dd72461b20c0e24e0ed995f15f7a925ead791feca3b9e99a0d226cc6cf4c3dc423
-  data.tar.gz: 8102bb8df5fdc935f3df34c9ff9a2ae2e3d0f1c6eb3222441d4b082c9cc932a7d5d9856028435726b0d4821e94413e4af377d1869fcfba1e08153052d25f9af0
+  metadata.gz: 3d584e068dffddfea89b6aaca1baa27633fe8681d161a53cc274daa20426496a1358c71223866dfde883ba80d2119a021110196fac087d20fd5d1d82380e57fd
+  data.tar.gz: ef1c9a440f42c5d8777ff0dc08377e264456344754f09f146e848ae2964811d67c23ddb6cbbf4fa18fc1755161bddb6fc73d7646e1041a30c1bf178534076d75

data/CHANGELOG.md

@@ -1,3 +1,18 @@
+## 0.6.1
+* Fix additional naming discrepancy in autoload manifests causing "API" to become "Api."
+
+## 0.6.0
+* Improve path and namespace handling in generator.
+
+## 0.5.1
+* Support Ruby 2.7
+  - Stop using the `RubyToken` class from irb, which doesn't exist anymore.
+* Fix bug causing `NoMethodError`s if the type field contains a single string and not an array.
+
+## 0.5.0
+* Recursively validate.
+* Add README.
+
 ## 0.4.0
 * Add validations.
   - You can now call `#valid?` and `#validate` methods on DSL objects.

data/README.md

@@ -0,0 +1,293 @@
+## kube-dsl
+A Ruby DSL for defining Kubernetes resources.
+
+## What is this thing?
+
+KubeDSL provides a [domain-specific language](https://en.wikipedia.org/wiki/Domain-specific_language) for defining Kubernetes resource objects in Ruby. Why would you want to do this? Well,
+
+1. I think Ruby code is easier to read than YAML.
+1. every property is a Ruby method, meaning Ruby will blow up if you try to configure the object the wrong way.
+1. doing so follows the principle of [infrastructure as code](https://en.wikipedia.org/wiki/Infrastructure_as_code).
+1. validations are built-in.
+
+## Installation
+
+Either run `gem install kube-dsl` or add it to your Gemfile:
+
+```ruby
+gem 'kube-dsl', '< 1'
+```
+
+## Usage
+
+KubeDSL directly mirrors the fields and nesting structure of each Kubernetes YAML (or JSON) object. Ruby fields are snake_cased while Kubernetes fields are camelCased. Let's take a look at a short example where we define a Namespace:
+
+```ruby
+ns = KubeDSL.namespace do
+  metadata do
+    name 'my-namespace'
+  end
+end
+```
+
+In the example above, we've defined a `KubeDSL::DSL::V1::Namespace` object and assigned it to a local variable called `ns`. Now let's convert it into a YAML string and print it out:
+
+```ruby
+# ---
+# apiVersion: v1
+# kind: Namespace
+# metadata:
+#   name: foo
+puts ns.to_resource.to_yaml
+```
+
+The `#to_resource` method returns an instance of the `KubeDSL::Resource` class while `#to_yaml` converts the resource into a YAML string. Pretty cool, eh? See the next few sections for examples creating other types of common Kubernetes objects.
+
+### ServiceAccount Example
+
+Note how key/value pairs are added to the `labels` field.
+
+```ruby
+KubeDSL.service_account do
+  metadata do
+    name 'my-service-account'
+    namespace 'my-namespace'
+
+    labels do
+      add :app, 'my-app'
+      add :role, 'web'
+    end
+  end
+end
+```
+
+### Service Example
+
+```ruby
+KubeDSL.service do
+  metadata do
+    name 'my-service'
+    namespace 'my-namespace'
+
+    labels do
+      add :app, 'my-app'
+      add :role, 'web'
+    end
+  end
+
+  spec do
+    type 'NodePort'
+
+    selector do
+      add :app, 'my-app'
+      add :role, 'web'
+    end
+
+    port do
+      name 'http'
+      port 3000
+      protocol 'TCP'
+      target_port 'http'
+    end
+  end
+end
+```
+
+### Deployment Example
+
+Note:
+
+1. Elements of arrays can be given names (see the use of the `#container` method below) so they can be easily retrieved and/or modified later.
+1. The example below shows how to add config maps and secrets to a deployment via references.
+
+```ruby
+KubeDSL.deployment do
+  metadata do
+    name 'my-deployment'
+    namespace 'my-namespace'
+
+    labels do
+      add :app, 'my-app'
+      add :role, 'web'
+    end
+  end
+
+  spec do
+    replicas 2
+
+    selector do
+      match_labels do
+        add :app, 'my-app'
+        add :role, 'web'
+      end
+    end
+
+    strategy do
+      type 'RollingUpdate'
+
+      rolling_update do
+        max_surge '25%'
+        max_unavailable 1
+      end
+    end
+
+    template do
+      metadata do
+        labels do
+          add :app, 'my-app'
+          add :role, 'web'
+        end
+      end
+
+      spec do
+        # elements of arrays can be given names (:web in this case) so they can be
+        # easily retrieved and/or modified later
+        container(:web) do
+          name 'my-web-container'
+          image_pull_policy 'IfNotPresent'
+
+          port do
+            container_port 3000
+            name 'http'
+            protocol 'TCP'
+          end
+
+          env_from do
+            config_map_ref do
+              name 'my-config-map'
+            end
+          end
+
+          env_from do
+            secret_ref do
+              name 'my-secrets'
+            end
+          end
+
+          readiness_probe do
+            success_threshold 1
+            failure_threshold 2
+            initial_delay_seconds 15
+            period_seconds 3
+            timeout_seconds 1
+
+            http_get do
+              path '/healthz'
+              port 3000
+              scheme 'HTTP'
+            end
+          end
+        end
+
+        image_pull_secret do
+          name 'my-registry-secret'
+        end
+      end
+
+      restart_policy 'Always'
+      service_account_name 'my-service-account'
+    end
+  end
+end
+```
+
+### Ingress Example
+
+NOTE: the example below includes an annotation that is specific to the Nginx ingress controller.
+
+```ruby
+KubeDSL::DSL::Extensions::V1beta1::Ingress.new do
+  metadata do
+    name 'my-ingress'
+    namespace 'my-namespace'
+
+    annotations do
+      add :'kubernetes.io/ingress.class', 'nginx'
+    end
+  end
+
+  spec do
+    rule do
+      host 'my-website.com'
+
+      http do
+        path do
+          path '/'
+
+          backend do
+            service_name 'my-service'
+            service_port 80
+          end
+        end
+      end
+    end
+  end
+end
+```
+
+### ConfigMap Example
+
+```ruby
+KubeDSL.config_map do
+  metadata do
+    name 'my-config-map'
+    namespace 'my-namespace'
+  end
+
+  data do
+    add :MY_VAR, 'value'
+    add :MY_OTHER_VAR, 'value'
+  end
+end
+```
+
+### Secret Example
+
+```ruby
+KubeDSL.secret do
+  metadata do
+    name 'my-secrets'
+    namespace 'my-namespace'
+  end
+
+  type 'Opaque'
+
+  data do
+    add :MY_SECRET, 'value'
+  end
+end
+```
+
+## Validations
+
+All `KubeDSL::DSLObject`s respond to `#valid?` and `#validate` methods. Use `#valid?` to determine whether or not an object is valid. Use `#validate` to retrieve a list of validation errors:
+
+```ruby
+ns = KubeDSL.namespace do
+  metadata do
+    name 123
+  end
+end
+
+ns.valid?  # => false
+ns.validate  # => #<KubeDSL::Validations::ValidationErrors:0x00007fc8ce276e80 ... >
+ns.validate.messages  # => {"metadata.name"=>["is not a String"]}
+```
+
+The handy `#validate!` method will raise a `KubeDSL::ValidationError` if the object is invalid.
+
+## Code Generation
+
+All the Ruby code present in KubeDSL is generated from the Kubernetes JSON schema available [here](https://github.com/instrumenta/kubernetes-json-schema). Run the following rake task to regenerate:
+
+```bash
+bundle exec rake generate
+```
+
+## Authors
+
+* Cameron C. Dutro: http://github.com/camertron
+
+## License
+
+Licensed under the MIT license.

data/Rakefile

@@ -16,6 +16,7 @@ end
 
 task :generate do
   require 'dry/inflector'
+  require 'fileutils'
 
   FileUtils.rm_rf('./lib/kube-dsl/entrypoint.rb')
   FileUtils.rm_rf('./lib/kube-dsl/dsl.rb')
@@ -24,33 +25,36 @@ task :generate do
   FileUtils.mkdir_p('./vendor')
 
   export_url = "https://github.com/instrumenta/kubernetes-json-schema/trunk/v#{KubeDSL::KUBERNETES_VERSION}-local"
-  local_path = "vendor/kubernetes-json-schema/v#{KubeDSL::KUBERNETES_VERSION}-local"
+  local_schema_path = "vendor/kubernetes-json-schema/v#{KubeDSL::KUBERNETES_VERSION}-local"
 
-  unless File.exist?(local_path)
-    system("svn export #{export_url} #{local_path}")
+  unless File.exist?(local_schema_path)
+    system("svn export #{export_url} #{local_schema_path}")
   end
 
-  Dir.chdir('lib') do
-    generator = KubeDSL::Generator.new(
-      schema_dir: File.join('..', local_path),
-      output_dir: File.join('kube-dsl', 'dsl'),
-      inflector: Dry::Inflector.new do |inflections|
-        inflections.acronym('DSL')
-
-        inflections.plural('tls', 'tlses')
-        inflections.singular('tls', 'tls')
-        inflections.plural('enum', 'enums')
-        inflections.plural('one_of', 'one_ofs')
-        inflections.plural('any_of', 'any_ofs')
-        inflections.plural('all_of', 'all_ofs')
-      end
-    )
-
-    generator.generate_resource_files
-    generator.generate_autoload_files
-    generator.generate_entrypoint_file do |resource, ns|
-      version = resource.ref.version || ''
-      !version.include?('beta') && !version.include?('alpha')
+  generator = KubeDSL::Generator.new(
+    schema_dir: local_schema_path,
+    output_dir: File.join('lib'),
+    autoload_prefix: File.join('kube-dsl', 'dsl'),
+    dsl_namespace: ['KubeDSL', 'DSL'],
+    entrypoint_namespace: ['KubeDSL'],
+    inflector: Dry::Inflector.new do |inflections|
+      inflections.acronym('DSL')
+
+      inflections.singular('tls', 'tls')
+      inflections.singular('causes', 'cause')
+
+      inflections.plural('tls', 'tlses')
+      inflections.plural('enum', 'enums')
+      inflections.plural('one_of', 'one_ofs')
+      inflections.plural('any_of', 'any_ofs')
+      inflections.plural('all_of', 'all_ofs')
     end
+  )
+
+  generator.generate_resource_files
+  generator.generate_autoload_files
+  generator.generate_entrypoint_file do |resource, ns|
+    version = resource.ref.version || ''
+    !version.include?('beta') && !version.include?('alpha')
   end
 end

data/lib/kube-dsl/builder.rb

@@ -4,12 +4,17 @@ module KubeDSL
   class Builder
     include StringHelpers
 
-    attr_reader :schema_dir, :output_dir, :namespace, :inflector, :resolvers
+    attr_reader :schema_dir, :output_dir, :autoload_prefix
+    attr_reader :dsl_namespace, :entrypoint_namespace
+    attr_reader :inflector, :resolvers
 
-    def initialize(schema_dir:, output_dir:, inflector:)
+    def initialize(schema_dir:, output_dir:, autoload_prefix:, inflector:, dsl_namespace:, entrypoint_namespace:)
       @schema_dir = schema_dir
       @output_dir = output_dir
+      @autoload_prefix = autoload_prefix
       @inflector = inflector
+      @dsl_namespace = dsl_namespace
+      @entrypoint_namespace = entrypoint_namespace
       @resolvers ||= {}
     end
 
@@ -19,25 +24,17 @@ module KubeDSL
       end
     end
 
-    def each_resource
+    def each_resource_file
       return to_enum(__method__) unless block_given?
 
-      resources.each do |res|
-        # "External" resources are ones that live outside the current
-        # schema, i.e. k8s resources like ObjectMeta that other
-        # k8s-compatible schemas depend on.
-        #
-        # Resources can be "empty" if they contain no properties. This
-        # usually happens for resources that are really just aliases
-        # for basic types like integer and string. The k8s' Duration
-        # object is a good example. It's just an alias for string.
-        yield res if !res.external? && !res.empty?
+      each_resource do |res|
+        yield File.join(output_dir, res.ref.ruby_autoload_path), res
       end
     end
 
     def entrypoint(&block)
       ''.tap do |ruby_code|
-        ruby_code << "module #{namespace[0..-2].join('::')}::Entrypoint\n"
+        ruby_code << "module #{entrypoint_namespace.join('::')}::Entrypoint\n"
 
         each_resource do |resource|
           ns = resource.ref.ruby_namespace.join('::')
@@ -53,26 +50,15 @@ module KubeDSL
       end
     end
 
-    def namespace
-      @namespace ||= inflector.classify(
-        File
-          .split(output_dir)
-          .map { |seg| inflector.camelize(underscore(seg)) }
-          .join('/')
-      ).split('::')
-    end
-
     def entrypoint_path
-      File.join(File.dirname(output_dir), 'entrypoint.rb')
+      File.join(output_dir, File.dirname(autoload_prefix), 'entrypoint.rb')
     end
 
     def each_autoload_file(&block)
       return to_enum(__method__) unless block
 
-      start = output_dir.split(File::SEPARATOR).first
-
       each_autoload_file_helper(
-        autoload_map[start], [start], &block
+        autoload_map[:root], [], &block
       )
     end
 
@@ -88,11 +74,27 @@ module KubeDSL
     end
 
     def parse_ref(ref_str)
-      Ref.new(ref_str, namespace, output_dir, inflector, schema_dir)
+      Ref.new(ref_str, dsl_namespace, inflector, schema_dir, autoload_prefix)
     end
 
     private
 
+    def each_resource
+      return to_enum(__method__) unless block_given?
+
+      resources.each do |res|
+        # "External" resources are ones that live outside the current
+        # schema, i.e. k8s resources like ObjectMeta that other
+        # k8s-compatible schemas depend on.
+        #
+        # Resources can be "empty" if they contain no properties. This
+        # usually happens for resources that are really just aliases
+        # for basic types like integer and string. The k8s' Duration
+        # object is a good example. It's just an alias for string.
+        yield res if !res.external? && !res.empty?
+      end
+    end
+
     def resources
       JSON.parse(File.read(start_path))['oneOf'].map do |entry|
         resource_from_ref(resolve_ref(entry['$ref']))
@@ -105,7 +107,7 @@ module KubeDSL
           parts = res.ref.ruby_autoload_path.split(File::SEPARATOR)
           parts.reject!(&:empty?)
 
-          parts.inject(amap) do |ret, seg|
+          [:root, *parts].inject(amap) do |ret, seg|
             if seg.end_with?('.rb')
               ret[seg] = res
             else
@@ -130,14 +132,14 @@ module KubeDSL
           autoload_path = File.join(*path, ns, child_ns).chomp('.rb')
 
           if res.is_a?(Hash)
-            ruby_code << "  autoload :#{capitalize(child_ns)}, '#{autoload_path}'\n"
+            ruby_code << "  autoload :#{inflector.camelize(child_ns)}, '#{autoload_path}'\n"
           else
             ruby_code << "  autoload :#{res.ref.kind}, '#{autoload_path}'\n"
           end
         end
 
         ruby_code << "end\n"
-        yield File.join(*path, "#{ns}.rb"), ruby_code
+        yield File.join(output_dir, *path, "#{ns}.rb"), ruby_code
         each_autoload_file_helper(children, path + [ns], &block)
       end
     end
@@ -194,7 +196,7 @@ module KubeDSL
             res.fields[name] = DefaultFieldRes.new(name, res, enum)
           else
             res.fields[name] = FieldRes.new(
-              name, prop['type'].first, required
+              name, Array(prop['type']).first, required
             )
           end
 
@@ -216,7 +218,7 @@ module KubeDSL
     end
 
     def start_path
-      @entrypoint_path ||= File.join(schema_dir, 'all.json')
+      @start_path ||= File.join(schema_dir, 'all.json')
     end
 
     def resource_cache

data/lib/kube-dsl/field_res.rb

@@ -1,5 +1,3 @@
-require 'irb/ruby-token'
-
 module KubeDSL
   class FieldRes
     include StringHelpers

data/lib/kube-dsl/generator.rb

@@ -13,14 +13,14 @@ module KubeDSL
     end
 
     def generate_resource_files
-      builder.each_resource do |res|
-        FileUtils.mkdir_p(File.dirname(res.ref.ruby_autoload_path))
+      builder.each_resource_file do |path, res|
+        FileUtils.mkdir_p(File.dirname(path))
 
-        if File.exist?(res.ref.ruby_autoload_path)
-          puts "Skipping #{res.ref.ruby_autoload_path} because it already exists"
+        if File.exist?(path)
+          puts "Skipping #{path} because it already exists"
         else
-          puts "Writing #{res.ref.ruby_autoload_path}"
-          File.write(res.ref.ruby_autoload_path, res.to_ruby)
+          puts "Writing #{path}"
+          File.write(path, res.to_ruby)
         end
       end
     end

data/lib/kube-dsl/ref.rb

@@ -5,12 +5,12 @@ module KubeDSL
     attr_reader :str, :kind, :namespace, :version, :inflector, :schema_dir
     attr_reader :ruby_namespace_prefix, :autoload_prefix
 
-    def initialize(str, ruby_namespace_prefix, autoload_prefix, inflector, schema_dir)
+    def initialize(str, ruby_namespace_prefix, inflector, schema_dir, autoload_prefix)
       @str = str
       @ruby_namespace_prefix = ruby_namespace_prefix
-      @autoload_prefix = autoload_prefix
       @inflector = inflector
       @schema_dir = schema_dir
+      @autoload_prefix = autoload_prefix
 
       ns, v, k = str.split('.').last(3)
 
@@ -41,15 +41,18 @@ module KubeDSL
     def ruby_namespace
       @ruby_namespace ||= begin
         [*ruby_namespace_prefix].tap do |mods|
-          mods << capitalize(namespace) if namespace
-          mods << capitalize(version) if version
+          mods << namespace if namespace
+          mods << version if version
+          mods.map! do |m|
+            inflector.camelize(underscore(m))
+          end
         end
       end
     end
 
     def ruby_autoload_path
       @ruby_autoload_path ||= File.join(
-        [*autoload_prefix.split(File::SEPARATOR)].tap do |path|
+        [autoload_prefix].tap do |path|
           path << underscore(namespace) if namespace
           path << underscore(version) if version
           path << "#{underscore(kind)}.rb"

data/lib/kube-dsl/string_helpers.rb

@@ -1,10 +1,10 @@
 module KubeDSL
   module StringHelpers
-    RUBY_KEYWORDS = RubyToken::TokenDefinitions
-      .select { |definition| definition[1] == RubyToken::TkId }
-      .map { |definition| definition[2] }
-      .compact
-      .freeze
+    RUBY_KEYWORDS = %w(
+      BEGIN END alias and begin break case class def defined? do else elsif
+      end ensure false for if in module next nil not or redo rescue retry
+      return self super then true undef unless until when while yield
+    )
 
     def capitalize(str)
       str.sub(/\A(.)/) { $1.upcase }

data/lib/kube-dsl/validations.rb

@@ -27,9 +27,9 @@ module KubeDSL
         @presence = presence
       end
 
-      def validate(obj, errors)
+      def validate(obj, errors, nesting)
         if presence && obj_empty?(obj)
-          errors.add(field_name, 'is required')
+          errors.add([*nesting, field_name].join('.'), 'is required')
         end
       end
 
@@ -52,17 +52,17 @@ module KubeDSL
         @kind_of = opts.fetch(:kind_of)
       end
 
-      def validate(obj, errors)
+      def validate(obj, errors, nesting)
         unless obj.is_a?(Array)
-          errors.add(field_name, 'is not an array')
+          errors.add([*nesting, field_name].join('.'), 'is not an array')
           return
         end
 
         obj.each_with_index do |elem, idx|
           unless elem.nil? || elem.is_a?(kind_of)
             errors.add(
-              field_name, "contains an object at index #{idx} of type '#{elem.class.name}', "\
-                "expected '#{kind_of.name}'"
+              [*nesting, field_name].join('.'), "contains an object at index #{idx} "\
+                "of type '#{elem.class.name}', expected '#{kind_of.name}'"
             )
           end
         end
@@ -102,9 +102,9 @@ module KubeDSL
         @format_validator ||= FormatValidator.new(options[:format])
       end
 
-      def validate(obj, errors)
+      def validate(obj, errors, nesting)
         unless format_validator.valid?(obj)
-          errors.add(field_name, "is not a #{format_validator.klasses.map(&:to_s).join(', ')}")
+          errors.add([*nesting, field_name].join('.'), "is not a #{format_validator.klasses.map(&:to_s).join(', ')}")
         end
       end
     end
@@ -117,9 +117,9 @@ module KubeDSL
         @kind_of = opts.fetch(:kind_of)
       end
 
-      def validate(obj, errors)
+      def validate(obj, errors, nesting)
         unless obj.nil? || obj.is_a?(kind_of)
-          errors.add(field_name, "'#{obj.class.name}', expected '#{kind_of.name}'")
+          errors.add([*nesting, field_name].join('.'), "'#{obj.class.name}', expected '#{kind_of.name}'")
         end
       end
     end
@@ -132,10 +132,12 @@ module KubeDSL
         @format_validator ||= FormatValidator.new(options[:value_format])
       end
 
-      def validate(obj, errors)
+      def validate(obj, errors, nesting)
         obj.kv_pairs.each_pair do |k, v|
           unless format_validator.valid?(v)
-            errors.add(field_name, "expected element '#{k}' to be a #{format_validator.klasses.map(&:to_s).join(', ')}, got #{v.class.name}")
+            errors.add(
+              [*nesting, field_name].join('.'),
+              "expected element '#{k}' to be a #{format_validator.klasses.map(&:to_s).join(', ')}, got #{v.class.name}")
           end
         end
       end
@@ -149,9 +151,9 @@ module KubeDSL
         @list = opts[:in]
       end
 
-      def validate(obj, errors)
+      def validate(obj, errors, nesting)
         unless list.include?(obj)
-          errors.add(field_name, "is not in #{list.join(', ')}")
+          errors.add([*nesting, field_name].join('.'), "is not in #{list.join(', ')}")
         end
       end
     end
@@ -186,12 +188,16 @@ module KubeDSL
     end
 
     module InstanceMethods
-      def validate
-        errors = ValidationErrors.new
+      def validate(errors = nil, nesting = [])
+        errors ||= ValidationErrors.new
 
         self.class.validators.each do |field_name, validators|
           field = send(field_name)
-          validators.each { |val| val.validate(field, errors) }
+          validators.each { |val| val.validate(field, errors, nesting) }
+
+          if field.respond_to?(:validate)
+            field.validate(errors, nesting + [field_name.to_s])
+          end
         end
 
         errors

data/lib/kube-dsl/value_fields.rb

@@ -15,7 +15,7 @@ module KubeDSL
         define_method(field) do |*args|
           if args.empty?
             instance_variable_get(:"@#{field}") || (
-              default.respond_to?(:call) ? default.call : default
+              default.respond_to?(:call) ? default.call(self) : default
             )
           else
             instance_variable_set(:"@#{field}", args.first)

data/lib/kube-dsl/version.rb

@@ -1,3 +1,3 @@
 module KubeDSL
-  VERSION = '0.4.0'
+  VERSION = '0.6.1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kube-dsl
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.6.1
 platform: ruby
 authors:
 - Cameron Dutro
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-09-30 00:00:00.000000000 Z
+date: 2021-08-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-inflector
@@ -34,6 +34,7 @@ files:
 - CHANGELOG.md
 - Gemfile
 - LICENSE
+- README.md
 - Rakefile
 - kube-dsl.gemspec
 - lib/kube-dsl.rb
@@ -802,7 +803,7 @@ files:
 homepage: http://github.com/getkuby/kube-dsl
 licenses: []
 metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -817,8 +818,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
-signing_key:
+rubygems_version: 3.1.6
+signing_key: 
 specification_version: 4
 summary: A Ruby DSL for defining Kubernetes resources.
 test_files: []