modelish 0.3.0 → 1.0.0.pre.1

data/lib/modelish/validations.rb

@@ -1,6 +1,9 @@
+# frozen_string_literal: true
+
 require 'date'
 
 module Modelish
+  # Mixin for validated properties
   module Validations
     def self.included(base)
       base.extend(ClassMethods)
@@ -13,8 +16,8 @@ module Modelish
     # @see ClassMethods#add_validator
     def validate
       errors = {}
- 
-      call_validators do |name,message|
+
+      call_validators do |name, message|
         errors[name] ||= []
         errors[name] << to_error(message)
       end
@@ -27,7 +30,7 @@ module Modelish
     # @raise ArgumentError when any property fails validation
     def validate!
       errors = validate
-      raise validate.first[1].first unless validate.empty?
+      raise errors.first[1].first unless errors.empty?
     end
 
     def valid?
@@ -35,12 +38,12 @@ module Modelish
     end
 
     private
-    def call_validators(&error_handler)
-      self.class.validators.each_pair do |k,v|
-        v.each do |prop_validator|
-          if msg = prop_validator.call(self.send(k))
-            error_handler.call(k, msg)
-          end
+
+    def call_validators
+      self.class.validators.each_pair do |property_name, validators|
+        validators.each do |validator|
+          message = validator.call(send(property_name))
+          yield property_name, message if message
         end
       end
     end
@@ -49,27 +52,31 @@ module Modelish
       msg.is_a?(StandardError) ? msg : ArgumentError.new(msg.to_s)
     end
 
+    # Class methods for managing validated properties
     module ClassMethods
       # Sets up a block containing validation logic for a given property.
       # Each property may have 0 or more validators.
       #
-      # @param [String,Symbol] property_name the name of the property to validate
-      # @param [#call] validator the block containing the validation logic; must return
-      #                          either an error object or a string containing the error
-      #                          message if validation fails.
-      # 
+      # @param [String,Symbol] property_name the name of the property to
+      #                                      validate
+      # @param [#call] validator the block containing the validation logic; must
+      #                          return either an error object or a string
+      #                          containing the error message if validation
+      #                          fails.
+      #
       # @example adding a validator that only allows non-nil values
       #     class MyModel
       #       include Modelish::Validations
       #       attr_accessor :foo
-      #       add_validator(:foo) { |val| val.nil? ? 'foo must not be nil': nil }
+      #       add_validator(:foo) { |val| val.nil? ? 'foo must exist': nil }
       #     end
       def add_validator(property_name, &validator)
-        validators[property_name.to_sym] ||= [] 
-        validators[property_name.to_sym] << validator
+        property = property_name.to_sym
+        validators[property] ||= []
+        validators[property] << validator
 
         class_eval do
-          attr_accessor property_name.to_sym unless method_defined?(property_name.to_sym)
+          attr_accessor property unless method_defined?(property_name)
         end
       end
 
@@ -78,38 +85,41 @@ module Modelish
         @validators ||= {}
       end
 
-      # Validates the required values, returning a list of errors when validation
-      # fails.
+      # Validates the required values, returning a list of errors when
+      # validation fails.
       #
       # @param [Hash] args the map of name => value pairs to validate
-      # @return [Array<ArgumentError>] a list of ArgumentErrors for validation failures.
+      # @return [Array<ArgumentError>] a list of validation failures
       def validate_required(args)
-        errors = []
-        args.each do |name, value|
-          errors << ArgumentError.new("#{name} must not be nil or blank") if value.nil? || value.to_s.strip.empty?
+        blanks = args.select { |_k, v| v.nil? || v.to_s.strip.empty? }
+        blanks.keys.map do |name|
+          ArgumentError.new("#{name} must not be nil or blank")
         end
-        errors
       end
 
       # Validates the required values, raising an error when validation fails.
       #
       # @param [Hash] args the map of name => value pairs to validate
-      # @raise [ArgumentError] when any value in args hash is nil or empty. The name
-      #                        key will be used to construct an informative error message.
+      # @raise [ArgumentError] when any value in args hash is nil or empty.
+      #                        The name key will be used to construct an
+      #                        informative error message.
       def validate_required!(args)
         errors = validate_required(args)
         raise errors.first unless errors.empty?
       end
 
-      # Validates the required values, returning a boolean indicating validation success.
+      # Validates the required values, returning a boolean indicating validation
+      # success.
       #
       # @param [Hash] args the map of name => value pairs to validate
-      # @return [true,false] true when validation passes; false when validation fails
+      # @return [true,false] true when validation passes; false when validation
+      #                      fails
       def validate_required?(args)
         validate_required(args).empty?
       end
 
-      # Validates the length of a value, raising an error to indicate validation failure.
+      # Validates the length of a value, raising an error to indicate validation
+      # failure.
       #
       # @param (see .validate_length)
       # @raise [ArgumentError] when the value is longer than max_length
@@ -118,33 +128,37 @@ module Modelish
         raise error if error
       end
 
-      # Validates the length of a value, returning a boolean to indicate validation
-      # success.
+      # Validates the length of a value, returning a boolean to indicate
+      # validation success.
       #
       # @param (see .validate_length)
-      # @return [true,false] true if value does not exceed max_length; false otherwise
+      # @return [true,false] true if value does not exceed max_length; false
+      #                      otherwise
       def validate_length?(name, value, max_length)
         validate_length(name, value, max_length).nil?
       end
 
-      # Validates the length of a value, returning an error when validation fails.
+      # Validates the length of a value, returning an error when validation
+      # fails.
       #
-      # @param [Symbol,String] name the name of the property/argument to be validated
+      # @param [Symbol,String] name the property/argument to validate
       # @param [#length] value the value to be validated
       # @param [#to_i] max_length the maximum allowable length
       # @raise [ArgumentError] when the value is longer than max_length
       def validate_length(name, value, max_length)
         if max_length.to_i > 0 && value.to_s.length > max_length.to_i
-          ArgumentError.new("#{name} must be less than #{max_length} characters")
+          message = "#{name} must be less than #{max_length} characters"
+          ArgumentError.new(message)
         end
       end
 
-      # Validates the type of the value, returning a boolean indicating validation
-      # outcome.
+      # Validates the type of the value, returning a boolean indicating
+      # validation outcome.
       #
       # @see #validate_type
       # @param {see #validate_type}
-      # @return [true,false] true when the value is the correct type; false otherwise
+      # @return [true,false] true when the value is the correct type; false
+      #                      otherwise
       def validate_type?(name, value, type)
         validate_type(name, value, type).nil?
       end
@@ -160,18 +174,19 @@ module Modelish
         raise error if error
       end
 
-      # Validates the type of the value, returning an error when the value cannot
-      # be converted to the appropriate type.
+      # Validates the type of the value, returning an error when the value
+      # cannot be converted to the appropriate type.
       #
-      # @param [Symbol,String] name the name of the property/argument to be validated
+      # @param [Symbol,String] name the property/argument to validate
       # @param [Object] value the value to be validated
-      # @param [Class,Proc] type the type of the class to be validated. Supported types include:
-      #   * +Integer+
-      #   * +Float+
-      #   * +Date+
-      #   * +DateTime+
-      #   * +Symbol+ 
-      #   * any arbitrary +Class+ -- validates based on the results of is_a?
+      # @param [Class,Proc] type the type of the class to validate.
+      #   Supported types include:
+      #     * +Integer+
+      #     * +Float+
+      #     * +Date+
+      #     * +DateTime+
+      #     * +Symbol+
+      #     * any arbitrary +Class+ -- validates based on the results of is_a?
       # @return [ArgumentError] when validation fails
       def validate_type(name, value, type)
         error = nil
@@ -192,11 +207,15 @@ module Modelish
             end
 
             unless is_valid
-              error = ArgumentError.new("#{name} must be of type #{type}, but got #{value.inspect}")
+              message = "#{name} must be of type #{type}, " \
+                        "but got #{value.inspect}"
+              error = ArgumentError.new(message)
             end
           end
         rescue StandardError => e
-          error = ArgumentError.new("An error occurred validating #{name} with value #{value.inspect}: #{e.message}")
+          message = "An error occurred validating #{name} with " \
+                    "value #{value.inspect}: #{e.message}"
+          error = ArgumentError.new(message)
         end
 
         error

data/lib/modelish/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Modelish
-  VERSION = "0.3.0"
+  VERSION = '1.0.0-1'
 end

data/lib/modelish.rb

@@ -1,4 +1,6 @@
-$:.unshift(File.expand_path('modelish',File.dirname(__FILE__)))
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path('modelish', File.dirname(__FILE__)))
 
 require 'modelish/version'
 require 'modelish/base'

data/modelish.gemspec

@@ -1,29 +1,34 @@
 # -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
-require "modelish/version"
+# frozen_string_literal: true
+
+$LOAD_PATH.push File.expand_path('../lib', __FILE__)
+require 'modelish/version'
 
 Gem::Specification.new do |s|
-  s.name        = "modelish"
+  s.name        = 'modelish'
   s.version     = Modelish::VERSION
   s.platform    = Gem::Platform::RUBY
-  s.authors     = ["Maeve Revels"]
-  s.email       = ["maeve.revels@g5platform.com"]
-  s.homepage    = "http://github.com/maeve/#{s.name}"
-  s.summary     = %q{A lightweight pseudo-modeling not-quite-framework}
-  s.description = %q{Sometimes you need something just a little modelish.}
-
-  s.rubyforge_project = s.name
+  s.authors     = ['Maeve Revels']
+  s.email       = ['maeve.revels@g5platform.com']
+  s.homepage    = 'http://github.com/G5/modelish'
+  s.summary     = 'A lightweight pseudo-modeling not-quite-framework'
+  s.description = 'Sometimes you need something just a little modelish.'
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = ["lib"]
+  s.executables   = `git ls-files -- bin/*`.split("\n")
+                                           .map { |f| File.basename(f) }
+  s.require_paths = ['lib']
 
-  s.add_dependency('hashie','~> 2.0.5')
+  s.add_dependency('hashie', '>= 1.0.0')
 
-  s.add_development_dependency('rspec','~> 2.5')
+  s.add_development_dependency('appraisal')
+  s.add_development_dependency('fuubar')
+  s.add_development_dependency('rspec', '~> 3.6')
+  s.add_development_dependency('rspec-its')
+  s.add_development_dependency('simplecov')
   s.add_development_dependency('yard', '~> 0.6')
-  s.add_development_dependency('bluecloth','~> 2.0.11')
+  s.add_development_dependency('bluecloth', '~> 2.0')
 
   s.has_rdoc = true
 end