aws-sdk-euca 1.8.5

data/lib/aws/record/validator.rb

@@ -0,0 +1,246 @@
+# Copyright 2011-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+module AWS
+  module Record
+
+    # Base class for all validators
+    # @private
+    class Validator
+
+      # these should be defined in subclasses
+      ACCEPTED_OPTIONS = []
+
+      def initialize record_class, *attribute_names, &block
+
+        @options = attribute_names.last.is_a?(Hash) ? attribute_names.pop : {}
+
+        @attribute_names = attribute_names
+
+        reject_unknown_options
+
+        ensure_type([Symbol, Proc], :if, :unless)
+        ensure_is([:save, :create, :update], :on) 
+
+        setup(record_class)
+
+      end
+
+      # @return [String] Returns the name of the attribute this validator
+      #   will check on the record during validation.
+      attr_reader :attribute_names
+
+      # @return [Hash] Returns the hash of options for this validator.
+      attr_reader :options
+
+      def validate record
+        if 
+          passes_on_condition?(record) and
+          passes_if_condition?(record) and
+          passes_unless_condition?(record)
+        then
+          validate_attributes(record)
+        end
+      end
+
+      # @private
+      protected
+      def setup klass
+      end
+
+      # @private
+      protected
+      def each_value value, &block
+        case value
+        when Array, Set then value.each{|v| yield(v) }
+        else yield(value)
+        end
+      end
+
+      # @private
+      protected
+      def add_accessors klass, *accessors
+
+        methods = klass.instance_methods.collect{|m| m.to_s }
+
+        accessors.each do |attr|
+
+          setter = "#{attr}="
+          getter = attr.to_s
+
+          unless methods.include?(getter)
+            klass.send(:attr_reader, attr)
+            klass.send(:public, getter)
+          end
+
+          unless methods.include?(setter)
+            klass.send(:attr_writer, attr) 
+            klass.send(:public, setter)
+          end
+
+        end
+
+      end
+
+      # @private
+      protected
+      def validate_attributes record
+        attribute_names.each do |attribute_name|
+          value = read_attribute_for_validation(record, attribute_name)
+          next if (value.nil? && options[:allow_nil]) || (blank?(value) && options[:allow_blank])
+          validate_attribute(record, attribute_name, value)
+        end
+      end
+
+      def blank? value
+        case value
+        when nil        then true
+        when String     then value !~ /\S/
+        else
+          !value
+        end
+      end
+
+      # @private
+      protected
+      def read_attribute_for_validation(record, attribute_name)
+        record.send(attribute_name)
+      end
+
+      # @private
+      def reject_unknown_options
+        invalid_keys = options.keys - self.class::ACCEPTED_OPTIONS
+        if invalid_keys.length == 1
+          raise ArgumentError, "unknown option :#{invalid_keys.first}"
+        elsif invalid_keys.length > 1
+          bad = invalid_keys.collect{|k| ":#{k}" }.join(', ')
+          raise ArgumentError, "unknown options #{bad}"
+        end
+      end
+
+      # @private
+      private
+      def passes_if_condition? record
+        case options[:if]
+        when nil            then true
+        when Proc           then options[:if].call(record)
+        when String, Symbol then record.send(options[:if])
+        else
+          raise 'invalid :if option, must be nil, a method name or a Proc'
+        end
+      end
+
+      # @private
+      private
+      def passes_unless_condition? record
+        case options[:unless]
+        when nil            then true
+        when Proc           then !options[:unless].call(record)
+        when String, Symbol then !record.send(options[:unless])
+        else
+          raise 'invalid :unless option, must be nil, a method name or a Proc'
+        end
+      end
+
+      # @private
+      private
+      def passes_on_condition? record
+        case options[:on]
+        when nil     then true
+        when :save   then true
+        when :create then record.new_record?
+        when :update then record.persisted?
+        else
+          raise 'invalid :on option, must be nil, :save, :create or :update'
+        end
+      end
+
+      # @private
+      protected
+      def ensure_type type_or_types, *keys
+
+        types = Array(type_or_types)
+
+        keys.each do |key|
+
+          next unless options.has_key?(key)
+          next unless types.none?{|type| options[key].is_a?(type) }
+
+          expected = types.map{|type| type.to_s }
+          if expected.count == 1
+            raise ArgumentError, "expected option :#{key} to be a #{expected}"
+          else
+            msg = "expected :#{key} to be one of #{expected.join(', ')}"
+            raise ArgumentError, msg
+          end
+
+        end
+      end
+
+      def ensure_is value_or_values, *keys
+        values = Array(value_or_values)
+        keys.each do |key|
+          next unless options.has_key?(key)
+          unless values.include?(options[key])
+            valid = values.map{|v| v.is_a?(Symbol) ? ":#{v}" : v.to_s }.join(', ')
+            raise ArgumentError, "expected :#{key} to be one of #{valid}"
+          end
+        end
+      end
+
+      # @private
+      protected
+      def ensure_exclusive *key_groups
+        key_groups.each do |key_group|
+          others = key_groups - [key_group]
+          Array(key_group).each do |key|
+            next unless options.has_key?(key)
+            conflicts = others.flatten.select{|other| options.has_key?(other) }
+            unless conflicts.empty?
+              msg = ":#{key} may not be used with :#{conflicts.first}"
+              raise ArgumentError, msg
+            end
+          end
+        end
+      end
+
+      # @private
+      protected
+      def ensure_present *keys
+        keys.each do |k|
+          unless options.has_key?(k)
+            raise ArgumentError, "missing required option :#{k}"
+          end
+        end
+      end
+
+      # @private
+      protected
+      def ensure_at_least_one *keys
+        found = keys.select{|k| options.has_key?(k) }
+        unless found.count >= 1
+          opts = keys.collect{|k| ":#{k}" }.join(', ')
+          msg = "must provide at least one of the following options: #{opts}"
+          raise ArgumentError, msg
+        end
+      end
+
+      protected
+      def set_default key, value
+        options[key] = value unless options.has_key?(key)
+      end
+
+    end
+
+  end
+end

data/lib/aws/record/validators/acceptance.rb

@@ -0,0 +1,51 @@
+# Copyright 2011-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+require 'aws/record/validator'
+
+module AWS
+  module Record
+
+    # @private
+    class AcceptanceValidator < Validator
+
+      ACCEPTED_OPTIONS = [:accept, :message, :allow_nil, :allow_blank, :on, :if, :unless]
+
+      def setup record_class
+        set_default(:allow_nil, true)
+        add_accessors(record_class, *attribute_names)
+      end
+
+      def validate_attribute record, attribute_name, value
+
+        accepted = case value
+        when '1'  then true
+        when true then true
+        else 
+          options.has_key?(:accept) ?
+            value == options[:accept] :
+            false
+        end
+
+        record.errors.add(attribute_name, message) unless accepted
+
+      end
+
+      def message
+        options[:message] || 'must be accepted'
+      end
+
+    end
+
+  end
+end

data/lib/aws/record/validators/block.rb

@@ -0,0 +1,38 @@
+# Copyright 2011-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+require 'aws/record/validator'
+
+module AWS
+  module Record
+    
+    # @private
+    class BlockValidator < Validator
+
+      ACCEPTED_OPTIONS = [:allow_nil, :allow_blank, :on, :if, :unless]
+
+      def initialize *args, &block
+        @block = block
+        super(*args)
+      end
+
+      attr_reader :block
+
+      def validate_attribute record, attribute_name, value
+        block.call(record, attribute_name, value)
+      end
+
+    end
+
+  end
+end

data/lib/aws/record/validators/confirmation.rb

@@ -0,0 +1,43 @@
+# Copyright 2011-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+require 'aws/record/validator'
+
+module AWS
+  module Record
+    
+    # @private
+    class ConfirmationValidator < Validator
+
+      ACCEPTED_OPTIONS = [:message, :on, :if, :unless]
+
+      def setup record_class
+        accessors = attribute_names.collect{|m| "#{m}_confirmation" }
+        add_accessors(record_class, *accessors)
+      end
+
+      def validate_attribute record, attribute_name, value
+        confirmation_value = record.send("#{attribute_name}_confirmation")
+        unless value == confirmation_value
+          record.errors.add(attribute_name, message)
+        end
+      end
+
+      def message
+        options[:message] || "doesn't match confirmation"
+      end
+
+    end
+
+  end
+end

data/lib/aws/record/validators/count.rb

@@ -0,0 +1,108 @@
+# Copyright 2011-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+require 'aws/record/validator'
+
+module AWS
+  module Record
+
+    # @private
+    class CountValidator < Validator
+
+      ACCEPTED_OPTIONS = [
+        :exactly, :within, :minimum, :maximum,
+        :too_many, :too_few, :wrong_number,
+        :on, :if, :unless,
+      ]
+
+      def setup record_class
+        ensure_at_least_one(:within, :exactly, :minimum, :maximum)
+        ensure_exclusive(:within, :exactly, [:minimum, :maximum])
+        ensure_type(Range, :within)
+        ensure_type(Integer, :exactly, :minimum, :maximum)
+        ensure_type(String, :too_many, :too_few, :wrong_number)
+      end
+
+      def validate_attribute record, attribute_name, value
+
+        count = case value
+        when nil then 0
+        when String then 1
+        when Enumerable then value.count
+        else 1
+        end
+
+        if exact = options[:exactly]
+          unless count == exact
+            record.errors.add(attribute_name, wrong_number(exact, count))
+          end
+        end
+
+        if within = options[:within]
+          if count < within.first
+            record.errors.add(attribute_name, too_few(within.first, count))
+          end
+          if count > within.last
+            record.errors.add(attribute_name, too_many(within.last, count))
+          end
+        end
+
+        if min = options[:minimum]
+          if count < min
+            record.errors.add(attribute_name, too_few(min, count))
+          end
+        end
+
+        if max = options[:maximum]
+          if count > max
+            record.errors.add(attribute_name, too_many(max, count))
+          end
+        end
+
+      end
+
+      # @private
+      protected
+      def wrong_number exactly, got
+        msg = options[:wrong_number] || 
+          "has the wrong number of values (should have %{exactly})"
+        interpolate(msg, :exactly => exactly, :count => got)
+      end
+
+      # @private
+      protected
+      def too_few min, got
+        msg = options[:too_few] || "has too few values (minimum is %{minimum})"
+        interpolate(msg, :minimum => min, :count => got)
+      end
+
+      # @private
+      protected
+      def too_many max, got
+        msg = options[:too_many] || "has too many values (maximum is %{maximum})"
+        interpolate(msg, :maximum => max, :count => got)
+      end
+
+      protected
+      def interpolate message_with_placeholders, values
+        msg = message_with_placeholders.dup 
+        values.each_pair do |key,value|
+          msg.gsub!(/%\{#{key}\}/, value.to_s)
+        end
+        msg
+      end
+
+    end
+
+  end
+end