bodhi-slam 0.0.5 → 0.1.0

data/lib/bodhi-slam/types.rb

@@ -0,0 +1,191 @@
+module Bodhi
+  class Type
+    include Bodhi::Validations
+    
+    BODHI_SYSTEM_ATTRIBUTES = [:sys_created_at, :sys_version, :sys_modified_at, :sys_modified_by,
+      :sys_namespace, :sys_created_by, :sys_type_version, :sys_id]
+    BODHI_TYPE_ATTRIBUTES = [:name, :namespace, :package, :embedded, :properties]
+    
+    attr_accessor *BODHI_TYPE_ATTRIBUTES
+    attr_reader *BODHI_SYSTEM_ATTRIBUTES
+    attr_reader :validations
+    
+    validates :name, required: true, is_not_blank: true
+    validates :namespace, required: true
+    validates :properties, required: true
+    
+    def initialize(params={})
+      params.symbolize_keys!
+      
+      BODHI_TYPE_ATTRIBUTES.each do |attribute|
+        send("#{attribute}=", params[attribute])
+      end
+      
+      @validations = {}
+      if properties
+        properties.symbolize_keys!
+        properties.each_pair do |attr_name, attr_properties|
+          attr_properties.symbolize_keys!
+          @validations[attr_name] = []
+          attr_properties.each_pair do |option, value|
+            underscored_name = option.to_s.gsub(/::/, '/').gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').gsub(/([a-z\d])([A-Z])/,'\1_\2').tr("-", "_").downcase.to_sym
+            unless [:system, :trim, :ref, :unique, :default, :is_current_user].include? underscored_name
+              klass = Bodhi::Validator.constantize(underscored_name)
+              if option == :type && value == "Enumerated"
+                if attr_properties[:ref].nil?
+                  raise RuntimeError.new("No reference property found!  Cannot build enumeration validator for #{name}.#{attr_name}")
+                end
+
+                @validations[attr_name] << klass.new(value, attr_properties[:ref])
+              else
+                @validations[attr_name] << klass.new(value)
+              end
+            end
+          end
+        end
+      end
+    end
+    
+    def self.find_all(context)
+      raise context.errors unless context.valid?
+      
+      result = context.connection.get do |request|
+        request.url "/#{context.namespace}/types"
+        request.headers[context.credentials_header] = context.credentials
+      end
+    
+      if result.status != 200
+        errors = JSON.parse result.body
+        errors.each{|error| error['status'] = result.status } if errors.is_a? Array
+        errors["status"] = result.status if errors.is_a? Hash
+        raise errors.to_s
+      end
+    
+      JSON.parse(result.body).collect{ |type| Bodhi::Type.new(type) }
+    end
+    
+    def self.create_class_with(type)
+      unless type.is_a? Bodhi::Type
+        raise ArgumentError.new("Expected #{type.class} to be a Bodhi::Type")
+      end
+      
+      klass = Object.const_set(type.name, Class.new {
+        include Bodhi::Resource
+        attr_accessor *type.properties.keys
+      })
+      
+      type.validations.each_pair do |attribute, validations|
+        attr_options = Hash.new
+        validations.each{ |validation| attr_options.merge!(validation.to_options) }
+        klass.validates(attribute, attr_options)
+      end
+      
+      klass
+    end
+    
+    def self.create_factory_with(type)
+      unless type.is_a? Bodhi::Type
+        raise ArgumentError.new("Expected #{type.class} to be a Bodhi::Type")
+      end
+
+      FactoryGirl.define do
+        factory type.name.to_sym do
+          type.properties.each_pair do |attribute, options|
+            unless options[:system]
+
+              case options[:type]
+              when "GeoJSON"
+                if options[:multi].nil?
+                  send(attribute) { {type: "Point", coordinates: [10,20]} }
+                else
+                  send(attribute) { [*0..5].sample.times.collect{ {type: "Point", coordinates: [10,20]} } }
+                end
+
+              when "Boolean"
+                if options[:multi].nil?
+                  send(attribute) { [true, false].sample }
+                else
+                  send(attribute) { [*0..5].sample.times.collect{ [true, false].sample } }
+                end
+
+              when "Enumerated"
+                reference = options[:ref].split('.')
+                name = reference[0]
+                field = reference[1]
+
+                if options[:multi].nil?
+                  if field.nil?
+                    send(attribute) { Bodhi::Enumeration.cache[name.to_sym].values.sample }
+                  else
+                    Bodhi::Enumeration.cache[name.to_sym].values.map!{ |value| value.symbolize_keys! }
+                    send(attribute) { Bodhi::Enumeration.cache[name.to_sym].values.sample[field.to_sym] }
+                  end
+                else
+                  if field.nil?
+                    send(attribute) { [*0..5].sample.times.collect{ Bodhi::Enumeration.cache[name.to_sym].values.sample } }
+                  else
+                    send(attribute) { [*0..5].sample.times.collect{ Bodhi::Enumeration.cache[name.to_sym].values.sample[field.to_sym] } }
+                  end
+                end
+
+              when "Object"
+                if options[:multi].nil?
+                  send(attribute) { {SecureRandom.hex => SecureRandom.hex} }
+                else
+                  send(attribute) { [*0..5].sample.times.collect{ {SecureRandom.hex => SecureRandom.hex} } }
+                end
+
+              when "String"
+                if options[:multi].nil?
+                  send(attribute) { SecureRandom.hex }
+                else
+                  send(attribute) { [*0..5].sample.times.collect{ SecureRandom.hex } }
+                end
+
+              when "DateTime"
+                if options[:multi].nil?
+                  send(attribute) { Time.at(rand * Time.now.to_i).iso8601 }
+                else
+                  send(attribute) { [*0..5].sample.times.collect{ Time.at(rand * Time.now.to_i).iso8601 } }
+                end
+
+              when "Integer"
+                min = -10000
+                max = 10000
+                if options[:min]
+                  min = options[:min]
+                end
+
+                if options[:max]
+                  max = options[:max]
+                end
+
+                if options[:multi].nil?
+                  send(attribute) { rand(min..max) }
+                else
+                  send(attribute) { [*0..5].sample.times.collect{ rand(min..max) } }
+                end
+
+              when "Real"
+                if options[:multi].nil?
+                  send(attribute) { SecureRandom.random_number*[-1,1,1,1].sample*[10,100,1000,10000].sample }
+                else
+                  send(attribute) { [*0..5].sample.times.collect{ SecureRandom.random_number*[-1,1,1,1].sample*[10,100,1000,10000].sample } }
+                end
+
+              else # Its an embedded type
+                if options[:multi].nil?
+                  send(attribute) { FactoryGirl.build(options[:type]) }
+                else
+                  send(attribute) { [*0..5].sample.times.collect{ FactoryGirl.build(options[:type]) } }
+                end
+              end
+            
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/bodhi-slam/validations.rb

@@ -0,0 +1,141 @@
+module Bodhi
+  module Validations
+    
+    module ClassMethods
+      
+      # Returns a Hash of all validations present for the class
+      #
+      #   class User
+      #     include Bodhi::Validations
+      #     attr_accessor :name, :tags
+      #
+      #     validates :tags, requried: true, multi: true
+      #     validates :name, required: true
+      #
+      #   User.validations
+      #   # => {
+      #   #      tags: [
+      #   #        #<RequiredValidator:0x007fbff403e808 @options={}>,
+      #   #        #<MultiValidator:0x007fbff403e808 @options={}>
+      #   #      ],
+      #   #      name: [
+      #   #        #<RequiredValidator:0x007fbff403e808 @options={}>
+      #   #      ]
+      #   #    }
+      def validators; @validators; end
+      
+      # Creates a new validation on the given +attribute+ using the supplied +options+
+      #
+      #   class User
+      #     include Bodhi::Validations
+      #     attr_accessor :name, :address, :tags
+      #
+      #     validates :name, type: "String", required: true
+      #     validates :address, type: "PostalAddress", required: true
+      #     validates :tags, type: "String", multi: true
+      def validates(attribute, options)
+        unless attribute.is_a? Symbol
+          raise ArgumentError.new("Invalid :attribute argument. Expected #{attribute.class} to be a Symbol")
+        end
+        
+        unless options.is_a? Hash
+          raise ArgumentError.new("Invalid :options argument. Expected #{options.class} to be a Hash")
+        end
+        
+        if options.keys.empty?
+          raise ArgumentError.new("Invalid :options argument. Options can not be empty")
+        end
+
+        @validators[attribute] = []
+        options.each_pair do |key, value|
+          unless [:ref].include?(key)
+            if key == :type && value == "Enumerated"
+              @validators[attribute] << Bodhi::Validator.constantize(key).new(value, options[:ref])
+            else
+              @validators[attribute] << Bodhi::Validator.constantize(key).new(value)
+            end
+          end
+        end
+      end
+    end
+    
+    module InstanceMethods
+      
+      # Returns a +Bodhi::Errors+ object that holds all information about attribute error messages.
+      #
+      #   class User
+      #     include Bodhi::Validations
+      #
+      #     attr_accessor :name
+      #     validates :name, required: true
+      #   end
+      #
+      #   user = User.new
+      #   user.valid? # => false
+      #   user.errors # => #<Bodhi::Errors:0x007fbff403e808 @messages={name:["is required"]}>
+      def errors
+        @errors ||= Bodhi::Errors.new
+      end
+      
+      # Runs all class validations on object and adds any errors to the +Bodhi::Errors+ object
+      #
+      #   class User
+      #     include Bodhi::Validations
+      #
+      #     attr_accessor :name
+      #     validates :name, required: true
+      #   end
+      #
+      #   user = User.new
+      #   user.validate! # => nil
+      #   user.errors.full_messages # => ["name is required"]
+      #
+      #   user.name = "Bob"
+      #   user.validate! # => nil
+      #   user.errors.full_messages # => []
+      def validate!
+        errors.clear
+        self.class.validators.each_pair do |attribute, array|
+          value = self.send(attribute)
+          array.each do |validator|
+            validator.validate(self, attribute, value)
+          end
+        end
+      end
+      
+      # Runs all validations and returns +true+ if no errors are present otherwise +false+.
+      #
+      #   class User
+      #     include Bodhi::Validations
+      #
+      #     attr_accessor :name
+      #     validates :name, required: true
+      #   end
+      #
+      #   user = User.new
+      #   user.valid? # => false
+      #   user.errors.full_messages # => ["name is required"]
+      #
+      #   user.name = "Bob"
+      #   user.valid? # => true
+      #   user.errors.full_messages # => []
+      def valid?
+        validate!
+        !errors.messages.any?
+      end
+      
+      # Runs all validations and returns +false+ if no errors are present otherwise +true+.
+      def invalid?
+        !valid?
+      end
+    end
+    
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.include(InstanceMethods)
+      base.instance_variable_set(:@validators, Hash.new)
+    end
+  end
+end
+
+require File.dirname(__FILE__) + "/validators.rb"

data/lib/bodhi-slam/validators.rb

@@ -0,0 +1,60 @@
+module Bodhi
+  class Validator
+    
+    # Override this method in subclasses with validation logic, adding errors
+    # to the records +errors+ array where necessary.
+    def validate(record, attribute, value)
+      raise NotImplementedError, "Subclasses must implement a validate(record, attribute, value) method."
+    end
+    
+    # Calls +underscore+ on the validation and returns it's class name as a symbol.
+    # Namespaces and the trailing "_validation" text will be trimmed
+    # 
+    # BaseValidation.to_sym # => :base
+    # StringValidation.to_sym # => :string
+    # NotBlankValidation.to_sym # => :not_blank
+    def to_sym
+      underscore.
+      gsub("bodhi/", "").
+      gsub("_validator", "").
+      to_sym
+    end
+    
+    # Returns the validation's class name in snake_case.
+    #
+    # BaseValidation.underscore # => "bodhi/base_validation"
+    # StringValidation.underscore # => "bodhi/string_validation"
+    # NotBlankValidation.underscore # => "bodhi/not_blank_validation"
+    def underscore
+      self.class.name.gsub(/::/, '/').
+      gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+      gsub(/([a-z\d])([A-Z])/,'\1_\2').
+      tr("-", "_").
+      downcase
+    end
+    
+    # Returns the validation as an options Hash.
+    # The options hash is suitable to be used in the Bodhi::Validations.valdiates method
+    #
+    # StringValidation.to_options # => { string: true }
+    # EmbeddedValidation.to_options # => { embedded: "ClassName" }
+    # EnumeratedValidation.to_options # => { enumerated: "Country.name" }
+    def to_options
+      raise NotImplementedError, "Subclasses must implement a to_options method."
+    end
+
+    # Returns the validator class with the given +name+
+    # Raises NameError if no validator class is found
+    # 
+    # Bodhi::Validator.constantize("type") # => Bodhi::TypeValidator
+    # Bodhi::Validator.constantize("multi") # => Bodhi::MutliValidator
+    # Bodhi::Validator.constantize("required") # => Bodhi::RequriedValidator
+    def self.constantize(name)
+      camelized_name = name.to_s.split('_').collect(&:capitalize).join
+      full_name = "Bodhi::#{camelized_name}Validator"      
+      Object.const_get(full_name)
+    end
+  end
+end
+
+Dir[File.dirname(__FILE__) + "/validators/*.rb"].each { |file| require file }

data/lib/bodhi-slam/validators/blank.rb

@@ -0,0 +1,24 @@
+module Bodhi
+  class IsNotBlankValidator < Validator
+
+    def initialize(value); end
+
+    def validate(record, attribute, value)
+      unless value.nil?
+        
+        if value.is_a?(Array)
+          unless value.empty?
+            record.errors.add(attribute, "must not contain blank Strings") unless value.delete_if{ |v| !v.empty? }.empty?
+          end
+        else
+          record.errors.add(attribute, "can not be blank") if value.empty?
+        end
+        
+      end
+    end
+    
+    def to_options
+      {self.to_sym => true}
+    end
+  end
+end

data/lib/bodhi-slam/validators/email.rb

@@ -0,0 +1,24 @@
+module Bodhi
+  class IsEmailValidator < Validator
+
+    def initialize(value); end
+
+    def validate(record, attribute, value)
+      unless value.nil?
+        
+        if value.is_a?(Array)
+          unless value.empty?
+            record.errors.add(attribute, "must only contain valid email addresses") unless value.delete_if{ |v| v =~ /.+@.+\..+/i }.empty?
+          end
+        else
+          record.errors.add(attribute, "must be a valid email address") unless value =~ /.+@.+\..+/i
+        end
+        
+      end
+    end
+    
+    def to_options
+      {self.to_sym => true}
+    end
+  end
+end

data/lib/bodhi-slam/validators/matches.rb

@@ -0,0 +1,27 @@
+module Bodhi
+  class MatchesValidator < Validator
+    attr_reader :value
+
+    def initialize(value)
+      @value = value
+    end
+
+    def validate(record, attribute, value)
+      unless value.nil?
+
+        if value.is_a?(Array)
+          unless value.empty?
+            record.errors.add(attribute, "must only contain values matching #{@value}") unless value.delete_if{ |v| v.match(@value) }.empty?
+          end
+        else
+          record.errors.add(attribute, "must match #{@value}") unless value.match(@value)
+        end
+
+      end
+    end
+    
+    def to_options
+      {self.to_sym => @value}
+    end
+  end
+end