kube-dsl 0.1.0

data/lib/kube-dsl/external_ref.rb

@@ -0,0 +1,16 @@
+module KubeDSL
+  class ExternalRef < Ref
+    def meta
+      @meta ||= ExternalResourceMeta.new(self)
+    end
+
+    def document
+      {}
+    end
+
+    # assume external refs are always object fields
+    def object?
+      true
+    end
+  end
+end

data/lib/kube-dsl/external_resource_meta.rb

@@ -0,0 +1,13 @@
+module KubeDSL
+  class ExternalResourceMeta
+    attr_reader :ref
+
+    def initialize(ref)
+      @ref = ref
+    end
+
+    def external?
+      true
+    end
+  end
+end

data/lib/kube-dsl/generator.rb

@@ -0,0 +1,48 @@
+module KubeDSL
+  class Generator
+    attr_reader :builder
+
+    def initialize(*args, **kwargs)
+      @builder = Builder.new(*args, **kwargs)
+    end
+
+    def generate
+      generate_resource_files
+      generate_autoload_files
+      generate_entrypoint_file
+    end
+
+    def generate_resource_files
+      builder.each_resource do |res|
+        FileUtils.mkdir_p(File.dirname(res.ref.ruby_autoload_path))
+
+        if File.exist?(res.ref.ruby_autoload_path)
+          puts "Skipping #{res.ref.ruby_autoload_path} because it already exists"
+        else
+          puts "Writing #{res.ref.ruby_autoload_path}"
+          File.write(res.ref.ruby_autoload_path, res.to_ruby)
+        end
+      end
+    end
+
+    def generate_autoload_files
+      builder.each_autoload_file do |path, ruby_code|
+        if File.exist?(path)
+          puts "Skipping #{path} because it already exists"
+        else
+          puts "Writing #{path}"
+          File.write(path, ruby_code)
+        end
+      end
+    end
+
+    def generate_entrypoint_file(&block)
+      if File.exist?(builder.entrypoint_path)
+        puts "Skipping #{builder.entrypoint_path} because it already exists"
+      else
+        puts "Writing #{builder.entrypoint_path}"
+        File.write(builder.entrypoint_path, builder.entrypoint(&block))
+      end
+    end
+  end
+end

data/lib/kube-dsl/inflector.rb

@@ -0,0 +1,25 @@
+require 'dry/inflector'
+require 'singleton'
+
+module KubeDSL
+  class Inflector
+    include Singleton
+
+    class << self
+      def pluralize(*args)
+        instance.inflector.pluralize(*args)
+      end
+
+      def singularize(*args)
+        instance.inflector.singularize(*args)
+      end
+    end
+
+    def inflector
+      @inflector ||= Dry::Inflector.new do |inflections|
+        inflections.plural('tls', 'tlses')
+        inflections.singular('tls', 'tls')
+      end
+    end
+  end
+end

data/lib/kube-dsl/key_value_fields.rb

@@ -0,0 +1,45 @@
+require 'base64'
+
+module KubeDSL
+  class KeyValueFields
+    attr_reader :format
+
+    def initialize(format: :string)
+      @format = format
+      @kv_pairs = {}
+    end
+
+    def add(key, value)
+      @kv_pairs[key] = value
+    end
+
+    def remove(key)
+      @kv_pairs.delete(key)
+    end
+
+    def get(key)
+      @kv_pairs[key]
+    end
+
+    def set(key, value)
+      @kv_pairs[key] = value
+    end
+
+    def serialize
+      @kv_pairs.each_with_object({}) do |(key, value), ret|
+        ret[key] = serialize_value(value)
+      end
+    end
+
+    private
+
+    def serialize_value(data)
+      case format
+        when :byte
+          Base64.strict_encode64(data.to_s)
+        else
+          data
+      end
+    end
+  end
+end

data/lib/kube-dsl/ref.rb

@@ -0,0 +1,84 @@
+module KubeDSL
+  class Ref
+    include StringHelpers
+
+    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)
+      @str = str
+      @ruby_namespace_prefix = ruby_namespace_prefix
+      @autoload_prefix = autoload_prefix
+      @inflector = inflector
+      @schema_dir = schema_dir
+
+      ns, v, k = str.split('.').last(3)
+
+      if ns == 'api' && v == 'resource'
+        @kind = k
+      elsif ns == 'core'
+        @kind = k
+        @version = v
+      else
+        @kind = k
+        @namespace = ns
+        @version = v
+      end
+    end
+
+    def meta
+      @meta ||= ResourceMeta.new(self, inflector)
+    end
+
+    def document
+      JSON.parse(File.read(filename))
+    end
+
+    def object?
+      document.include?('properties')
+    end
+
+    def ruby_namespace
+      @ruby_namespace ||= begin
+        [*ruby_namespace_prefix].tap do |mods|
+          mods << capitalize(namespace) if namespace
+          mods << capitalize(version) if version
+        end
+      end
+    end
+
+    def ruby_autoload_path
+      @ruby_autoload_path ||= File.join(
+        [*autoload_prefix.split(File::SEPARATOR)].tap do |path|
+          path << underscore(namespace) if namespace
+          path << underscore(version) if version
+          path << "#{underscore(kind)}.rb"
+        end
+      )
+    end
+
+    private
+
+    def filename
+      @filename ||= begin
+        parts = [kind, namespace, version]
+
+        filenames = (parts.size - 1).downto(0).map do |i|
+          File.join(
+            schema_dir,
+            "#{parts[i..-1].compact.map(&:downcase).join('-')}.json"
+          )
+        end
+
+        filenames += 0.upto(parts.size - 1).map do |i|
+          File.join(
+            schema_dir,
+            "#{parts[0..i].compact.map(&:downcase).join('-')}.json"
+          )
+        end
+
+        filenames.find { |f| File.exist?(f) }
+      end
+    end
+  end
+end

data/lib/kube-dsl/resource.rb

@@ -0,0 +1,41 @@
+module KubeDSL
+  class Resource
+    attr_reader :contents
+
+    def initialize(contents)
+      @contents = contents
+    end
+
+    def serialize
+      cleanup(contents)
+    end
+
+    def to_yaml
+      YAML.dump(serialize)
+    end
+
+    def to_resource
+      self
+    end
+
+    private
+
+    def cleanup(obj)
+      case obj
+        when Array
+          cleaned = obj.map { |child| cleanup(child) }.compact
+          cleaned.empty? ? nil : cleaned
+        when Hash
+          cleaned = obj.each_with_object({}) do |(key, val), ret|
+            if new_val = cleanup(val)
+              ret[key.to_s] = new_val
+            end
+          end
+
+          cleaned.empty? ? nil : cleaned
+        else
+          obj
+      end
+    end
+  end
+end

data/lib/kube-dsl/resource_meta.rb

@@ -0,0 +1,122 @@
+module KubeDSL
+  class ResourceMeta
+    include StringHelpers
+
+    attr_reader :ref ,:inflector
+    attr_reader :fields, :key_value_fields, :array_fields, :object_fields
+    attr_reader :default_fields
+
+    def initialize(ref, inflector)
+      @ref = ref
+      @inflector = inflector
+
+      @fields = []
+      @key_value_fields = {}
+      @array_fields = {}
+      @object_fields = {}
+      @default_fields = {}
+    end
+
+    def external?
+      false
+    end
+
+    def empty?
+      field_count = fields.size +
+        key_value_fields.size +
+        array_fields.size +
+        object_fields.size +
+        default_fields.size
+
+      field_count.zero?
+    end
+
+    def to_ruby
+      ''.tap do |str|
+        str << "module #{ref.ruby_namespace.join('::')}\n"
+        str << "  class #{ref.kind} < ::KubeDSL::DSLObject\n"
+        str << fields_to_ruby
+        str << "\n"
+        str << serialize_method
+        str << "\n"
+        str << "    def kind_sym\n"
+        str << "      :#{underscore(ref.kind)}\n"
+        str << "    end\n"
+        str << "  end\n"
+        str << "end\n"
+      end
+    end
+
+    private
+
+    def fields_to_ruby
+      ''.tap do |str|
+        unless fields.empty?
+          str << '    value_fields '
+          str << fields.map { |f| ":#{underscore(f)}" }.join(', ')
+          str << "\n"
+        end
+
+        array_fields.each do |name, field|
+          if field
+            str << "    array_field(:#{underscore(inflector.singularize(name))})"
+            str << " { #{field.ref.ruby_namespace.join('::')}::#{field.ref.kind}.new }"
+            str << "\n"
+          else
+            str << "    array_field :#{underscore(inflector.singularize(name))}\n"
+          end
+        end
+
+        object_fields.each do |name, field|
+          str << "    object_field(:#{underscore(name)}) { #{field.ref.ruby_namespace.join('::')}::#{field.ref.kind}.new }\n"
+        end
+
+        key_value_fields.each do |name, fmt|
+          str << "    object_field(:#{underscore(name)}) { ::KubeDSL::KeyValueFields.new(format: :#{fmt}) }\n"
+        end
+      end
+    end
+
+    def serialize_method
+      ''.tap do |str|
+        str << "    def serialize\n"
+        str << "      {}.tap do |result|\n"
+
+        default_fields.each do |name, value|
+          str << "        result[:#{quote_sym(name)}] = #{value}\n"
+        end
+
+        fields.each do |f|
+          str << "        result[:#{quote_sym(f)}] = #{underscore(f)}\n"
+        end
+
+        array_fields.each do |name, field|
+          plural_name = inflector.pluralize(
+            underscore(inflector.singularize(name))
+          )
+
+          if field
+            str << "        result[:#{quote_sym(name)}] = #{plural_name}.map(&:serialize)\n"
+          else
+            str << "        result[:#{quote_sym(name)}] = #{plural_name}\n"
+          end
+        end
+
+        object_fields.each do |name, field|
+          str << "        result[:#{quote_sym(name)}] = #{underscore(name)}.serialize\n"
+        end
+
+        key_value_fields.each do |name, _|
+          str << "        result[:#{quote_sym(name)}] = #{underscore(name)}.serialize\n"
+        end
+
+        str << "      end\n"
+        str << "    end\n"
+      end
+    end
+
+    def quote_sym(sym_str)
+      sym_str.include?('-') ? "'#{sym_str}'" : sym_str
+    end
+  end
+end

data/lib/kube-dsl/string_helpers.rb

@@ -0,0 +1,17 @@
+module KubeDSL
+  module StringHelpers
+    def capitalize(str)
+      str.sub(/\A(.)/) { $1.upcase }
+    end
+
+    def underscore(str)
+      str
+        .gsub(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2')
+        .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+        .gsub('-', '_')
+        .downcase
+    end
+  end
+
+  StringHelpers.extend(StringHelpers)
+end

data/lib/kube-dsl/value_fields.rb

@@ -0,0 +1,78 @@
+require 'securerandom'
+
+module KubeDSL
+  module ValueFields
+    def value_fields(*fields)
+      fields.each { |field| value_field(field) }
+    end
+
+    def value_field(field, default: nil)
+      define_method(field) do |*args|
+        if args.empty?
+          instance_variable_get(:"@#{field}") || (
+            default.respond_to?(:call) ? default.call : default
+          )
+        else
+          instance_variable_set(:"@#{field}", args.first)
+        end
+      end
+    end
+
+    def object_field(field, &field_block)
+      define_method(field) do |*args, &block|
+        ivar = :"@#{field}"
+        val = instance_variable_get(ivar)
+
+        unless val
+          val = field_block.call(*args)
+          instance_variable_set(ivar, val)
+        end
+
+        val.instance_exec(&block) if block
+        val
+      end
+    end
+
+    def array_field(field, accessor = nil, &field_block)
+      accessor ||= Inflector.pluralize(field.to_s).to_sym
+
+      define_method(field) do |elem_name = nil, &block|
+        ivar = :"@#{accessor}"
+        arr = instance_variable_get(ivar)
+
+        # use a hash so elements can be named and modified later
+        unless arr
+          arr = {}
+          instance_variable_set(ivar, arr)
+        end
+
+        if elem_name && elem = arr[elem_name]
+          elem.instance_eval(&block) if block
+        else
+          if field_block
+            new_val = field_block.call
+            new_val.instance_eval(&block) if block
+          else
+            new_val = block.call if block
+          end
+
+          arr[elem_name || SecureRandom.hex] = new_val
+        end
+
+        nil
+      end
+
+      define_method(accessor) do
+        ivar = :"@#{accessor}"
+        arr = instance_variable_get(ivar)
+
+        unless arr
+          arr = {}
+          instance_variable_set(ivar, arr)
+        end
+
+        arr.values
+      end
+    end
+  end
+end

data/lib/kube-dsl/version.rb

@@ -0,0 +1,3 @@
+module KubeDSL
+  VERSION = '0.1.0'
+end

data/lib/kube-dsl.rb

@@ -0,0 +1,20 @@
+module KubeDSL
+  KUBERNETES_VERSION = '1.17.4'.freeze
+
+  autoload :Builder,              'kube-dsl/builder'
+  autoload :DSL,                  'kube-dsl/dsl'
+  autoload :DSLObject,            'kube-dsl/dsl_object'
+  autoload :Entrypoint,           'kube-dsl/entrypoint'
+  autoload :ExternalRef,          'kube-dsl/external_ref'
+  autoload :ExternalResourceMeta, 'kube-dsl/external_resource_meta'
+  autoload :Generator,            'kube-dsl/generator'
+  autoload :Inflector,            'kube-dsl/inflector'
+  autoload :KeyValueFields,       'kube-dsl/key_value_fields'
+  autoload :Ref,                  'kube-dsl/ref'
+  autoload :Resource,             'kube-dsl/resource'
+  autoload :ResourceMeta,         'kube-dsl/resource_meta'
+  autoload :StringHelpers,        'kube-dsl/string_helpers'
+  autoload :ValueFields,          'kube-dsl/value_fields'
+
+  extend Entrypoint
+end