kube-dsl 0.1.0 → 0.5.1

data/lib/kube-dsl/key_value_fields.rb

@@ -2,7 +2,7 @@ require 'base64'
 
 module KubeDSL
   class KeyValueFields
-    attr_reader :format
+    attr_reader :format, :kv_pairs
 
     def initialize(format: :string)
       @format = format
@@ -31,6 +31,10 @@ module KubeDSL
       end
     end
 
+    def merge!(other)
+      @kv_pairs.merge!(other.instance_variable_get(:@kv_pairs))
+    end
+
     private
 
     def serialize_value(data)

data/lib/kube-dsl/object_field_res.rb

@@ -0,0 +1,35 @@
+module KubeDSL
+  class ObjectFieldRes
+    include StringHelpers
+
+    attr_reader :name, :res
+
+    def initialize(name, res)
+      @name = name
+      @res = res
+    end
+
+    def fields_to_ruby(_inflector)
+      [
+        "object_field(:#{ruby_safe_name}) { #{res.ref.ruby_namespace.join('::')}::#{res.ref.kind}.new }"
+      ]
+    end
+
+    def validations(_inflector)
+      [].tap do |result|
+        ruby_type = [*res.ref.ruby_namespace, res.ref.kind].join('::')
+        result << "validates :#{ruby_safe_name}, object: { kind_of: #{ruby_type} }"
+      end
+    end
+
+    def serialize_call(_inflector)
+      "#{ruby_safe_name}.serialize"
+    end
+
+    private
+
+    def ruby_safe_name
+      @ruby_safe_name ||= unkeywordify(underscore(name))
+    end
+  end
+end

data/lib/kube-dsl/resource_meta.rb

@@ -2,19 +2,12 @@ module KubeDSL
   class ResourceMeta
     include StringHelpers
 
-    attr_reader :ref ,:inflector
-    attr_reader :fields, :key_value_fields, :array_fields, :object_fields
-    attr_reader :default_fields
+    attr_reader :ref ,:inflector, :fields
 
     def initialize(ref, inflector)
       @ref = ref
       @inflector = inflector
-
-      @fields = []
-      @key_value_fields = {}
-      @array_fields = {}
-      @object_fields = {}
-      @default_fields = {}
+      @fields = {}
     end
 
     def external?
@@ -22,13 +15,7 @@ module KubeDSL
     end
 
     def empty?
-      field_count = fields.size +
-        key_value_fields.size +
-        array_fields.size +
-        object_fields.size +
-        default_fields.size
-
-      field_count.zero?
+      fields.size.zero?
     end
 
     def to_ruby
@@ -37,6 +24,8 @@ module KubeDSL
         str << "  class #{ref.kind} < ::KubeDSL::DSLObject\n"
         str << fields_to_ruby
         str << "\n"
+        str << validations
+        str << "\n"
         str << serialize_method
         str << "\n"
         str << "    def kind_sym\n"
@@ -49,32 +38,30 @@ module KubeDSL
 
     private
 
-    def fields_to_ruby
-      ''.tap do |str|
-        unless fields.empty?
-          str << '    value_fields '
-          str << fields.map { |f| ":#{underscore(f)}" }.join(', ')
-          str << "\n"
-        end
+    def indent(lines, level)
+      lines.map do |line|
+        "#{'  ' * level}#{line}"
+      end
+    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
+    def fields_to_ruby
+      lines = fields.flat_map do |name, field|
+        indent(field.fields_to_ruby(inflector), 2)
+      end
 
-        object_fields.each do |name, field|
-          str << "    object_field(:#{underscore(name)}) { #{field.ref.ruby_namespace.join('::')}::#{field.ref.kind}.new }\n"
-        end
+      result = lines.join("\n")
+      result << "\n" unless result.empty?
+      result
+    end
 
-        key_value_fields.each do |name, fmt|
-          str << "    object_field(:#{underscore(name)}) { ::KubeDSL::KeyValueFields.new(format: :#{fmt}) }\n"
-        end
+    def validations
+      lines = fields.flat_map do |name, field|
+        indent(field.validations(inflector), 2)
       end
+
+      result = lines.join("\n")
+      result << "\n" unless result.empty?
+      result
     end
 
     def serialize_method
@@ -82,32 +69,8 @@ module KubeDSL
         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"
+        fields.each do |name, field|
+          str << "        result[:#{quote_sym(name)}] = #{field.serialize_call(inflector)}\n"
         end
 
         str << "      end\n"

data/lib/kube-dsl/string_helpers.rb

@@ -1,5 +1,11 @@
 module KubeDSL
   module StringHelpers
+    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 }
     end
@@ -11,6 +17,14 @@ module KubeDSL
         .gsub('-', '_')
         .downcase
     end
+
+    def unkeywordify(str)
+      if RUBY_KEYWORDS.include?(str)
+        "#{str}_field"
+      else
+        str
+      end
+    end
   end
 
   StringHelpers.extend(StringHelpers)

data/lib/kube-dsl/validations.rb

@@ -0,0 +1,228 @@
+module KubeDSL
+  class ValidationError < StandardError; end
+
+  module Validations
+    class ValidationErrors
+      attr_reader :messages
+
+      def initialize
+        @messages = {}
+      end
+
+      def add(field_name, msg)
+        messages[field_name] ||= []
+        messages[field_name] << msg
+      end
+
+      def empty?
+        messages.empty?
+      end
+    end
+
+    class PresenceValidator
+      attr_reader :field_name, :presence
+
+      def initialize(field_name, presence)
+        @field_name = field_name
+        @presence = presence
+      end
+
+      def validate(obj, errors, nesting)
+        if presence && obj_empty?(obj)
+          errors.add([*nesting, field_name].join('.'), 'is required')
+        end
+      end
+
+      private
+
+      def obj_empty?(obj)
+        if obj.respond_to?(:empty)
+          obj.empty?
+        else
+          !!obj
+        end
+      end
+    end
+
+    class ArrayValidator
+      attr_reader :field_name, :kind_of
+
+      def initialize(field_name, opts)
+        @field_name = field_name
+        @kind_of = opts.fetch(:kind_of)
+      end
+
+      def validate(obj, errors, nesting)
+        unless obj.is_a?(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(
+              [*nesting, field_name].join('.'), "contains an object at index #{idx} "\
+                "of type '#{elem.class.name}', expected '#{kind_of.name}'"
+            )
+          end
+        end
+      end
+    end
+
+    class FormatValidator
+      attr_reader :format
+
+      def initialize(format)
+        @format = format
+      end
+
+      def valid?(obj)
+        klasses.any? { |k| obj.nil? || obj.is_a?(k) }
+      end
+
+      def klasses
+        @klasses ||= case format
+          when :string, :byte
+            [String]
+          when :integer
+            [Integer]
+          when :boolean
+            [TrueClass, FalseClass]
+          else
+            raise "format '#{format}' not recognized"
+        end
+      end
+    end
+
+    class FieldValidator
+      attr_reader :field_name, :format_validator
+
+      def initialize(field_name, options = {})
+        @field_name = field_name
+        @format_validator ||= FormatValidator.new(options[:format])
+      end
+
+      def validate(obj, errors, nesting)
+        unless format_validator.valid?(obj)
+          errors.add([*nesting, field_name].join('.'), "is not a #{format_validator.klasses.map(&:to_s).join(', ')}")
+        end
+      end
+    end
+
+    class ObjectValidator
+      attr_reader :field_name, :kind_of
+
+      def initialize(field_name, opts)
+        @field_name = field_name
+        @kind_of = opts.fetch(:kind_of)
+      end
+
+      def validate(obj, errors, nesting)
+        unless obj.nil? || obj.is_a?(kind_of)
+          errors.add([*nesting, field_name].join('.'), "'#{obj.class.name}', expected '#{kind_of.name}'")
+        end
+      end
+    end
+
+    class KeyValueValidator
+      attr_reader :field_name, :format_validator
+
+      def initialize(field_name, options = {})
+        @field_name = field_name
+        @format_validator ||= FormatValidator.new(options[:value_format])
+      end
+
+      def validate(obj, errors, nesting)
+        obj.kv_pairs.each_pair do |k, v|
+          unless format_validator.valid?(v)
+            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
+    end
+
+    class InclusionValidator
+      attr_reader :field_name, :list
+
+      def initialize(field_name, opts)
+        @field_name = field_name
+        @list = opts[:in]
+      end
+
+      def validate(obj, errors, nesting)
+        unless list.include?(obj)
+          errors.add([*nesting, field_name].join('.'), "is not in #{list.join(', ')}")
+        end
+      end
+    end
+
+    module ClassMethods
+      def validates(field_name, options)
+        validators[field_name] = options.map do |val, *val_args|
+          validator_class = case val
+            when :array
+              ArrayValidator
+            when :presence
+              PresenceValidator
+            when :field
+              FieldValidator
+            when :object
+              ObjectValidator
+            when :kv
+              KeyValueValidator
+            when :inclusion
+              InclusionValidator
+            else
+              raise "couldn't find a(n) #{val} validator"
+          end
+
+          validator_class.new(field_name, *val_args)
+        end
+      end
+
+      def validators
+        @validators ||= {}
+      end
+    end
+
+    module InstanceMethods
+      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, nesting) }
+
+          if field.respond_to?(:validate)
+            field.validate(errors, nesting + [field_name.to_s])
+          end
+        end
+
+        errors
+      end
+
+      def validate!
+        errors = validate
+
+        unless errors.empty?
+          field = errors.messages.keys.first
+          message = errors.messages[field].first
+          raise ValidationError, "#{field} #{message}"
+        end
+      end
+
+      def valid?
+        errors = validate
+        errors.empty?
+      end
+    end
+
+
+    def self.extended(base)
+      base.include(InstanceMethods)
+      base.extend(ClassMethods)
+    end
+  end
+end

data/lib/kube-dsl/value_fields.rb

@@ -2,77 +2,163 @@ require 'securerandom'
 
 module KubeDSL
   module ValueFields
-    def value_fields(*fields)
-      fields.each { |field| value_field(field) }
-    end
+    class ClassMismatchError < StandardError; 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
+    module ClassMethods
+      def value_fields(*fields)
+        fields.each { |field| value_field(field) }
       end
-    end
 
-    def object_field(field, &field_block)
-      define_method(field) do |*args, &block|
-        ivar = :"@#{field}"
-        val = instance_variable_get(ivar)
+      def value_field(field, default: nil)
+        __fields__[:value] << field
 
-        unless val
-          val = field_block.call(*args)
-          instance_variable_set(ivar, val)
+        define_method(field) do |*args|
+          if args.empty?
+            instance_variable_get(:"@#{field}") || (
+              default.respond_to?(:call) ? default.call(self) : default
+            )
+          else
+            instance_variable_set(:"@#{field}", args.first)
+          end
         end
+      end
+
+      def object_field(field, &field_block)
+        __fields__[:object] << field
+
+        define_method(field) do |*args, &block|
+          ivar = :"@#{field}"
+          val = instance_variable_get(ivar)
 
-        val.instance_exec(&block) if block
-        val
+          unless val
+            val = field_block.call(*args)
+            instance_variable_set(ivar, val)
+          end
+
+          val.instance_exec(&block) if block
+          val
+        end
       end
-    end
 
-    def array_field(field, accessor = nil, &field_block)
-      accessor ||= Inflector.pluralize(field.to_s).to_sym
+      def key_value_field(field, format:)
+        __fields__[:key_value] << field
+
+        define_method(field) do |*args, &block|
+          ivar = :"@#{field}"
+          val = instance_variable_get(ivar)
 
-      define_method(field) do |elem_name = nil, &block|
-        ivar = :"@#{accessor}"
-        arr = instance_variable_get(ivar)
+          unless val
+            val = ::KubeDSL::KeyValueFields.new(format: format)
+            instance_variable_set(ivar, val)
+          end
 
-        # use a hash so elements can be named and modified later
-        unless arr
-          arr = {}
-          instance_variable_set(ivar, arr)
+          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
+
+        __fields__[:array] << { field: field, accessor: accessor }
 
-        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
+        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
+            elem
           else
-            new_val = block.call if block
+            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
+            new_val
           end
+        end
 
-          arr[elem_name || SecureRandom.hex] = new_val
+        define_method(accessor) do
+          ivar = :"@#{accessor}"
+          arr = instance_variable_get(ivar)
+
+          unless arr
+            arr = {}
+            instance_variable_set(ivar, arr)
+          end
+
+          arr.values
         end
+      end
 
-        nil
+      def __fields__
+        @__fields__ ||= {
+          value: [],
+          object: [],
+          key_value: [],
+          array: []
+        }
       end
+    end
+
+
+    module InstanceMethods
+      def merge!(other, fields: nil)
+        unless other.is_a?(self.class)
+          raise ClassMismatchError, 'cannot merge two objects of '\
+            "different types, namely '#{self.class}' and '#{other.class}'"
+        end
+
+        (self.class.__fields__[:value] + self.class.__fields__[:object]).each do |field|
+          next if fields && !fields.include?(field)
+          ivar = :"@#{field}"
+
+          if other_val = other.instance_variable_get(ivar)
+            instance_variable_set(ivar, other_val)
+          end
+        end
+
+        self.class.__fields__[:key_value].each do |field|
+          next if fields && !fields.include?(field)
+          send(field).merge!(other.send(field))
+        end
 
-      define_method(accessor) do
-        ivar = :"@#{accessor}"
-        arr = instance_variable_get(ivar)
+        self.class.__fields__[:array].each do |af|
+          next if fields && !fields.include?(af[:field])
+          ivar = :"@#{af[:accessor]}"
+
+          arrs = instance_variable_get(ivar) || {}
+
+          arrs.merge!(
+            other.instance_variable_get(ivar) || {}
+          )
 
-        unless arr
-          arr = {}
-          instance_variable_set(ivar, arr)
+          instance_variable_set(ivar, arrs)
         end
+      end
 
-        arr.values
+      def merge(other, fields)
+        self.class.new.tap do |result|
+          result.merge!(self)
+          result.merge!(other, fields: fields)
+        end
       end
     end
+
+
+    def self.extended(base)
+      base.include(InstanceMethods)
+      base.extend(ClassMethods)
+    end
   end
 end