simple_model 1.2.22 → 1.2.23

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    YjQyN2Y0MzE5YjZkODA2MGIwOGYyNzRiNzk5NmUyMjYzYmEwNTExZg==
+    MTk1Y2IxMGU5Y2YxYzNhM2ZiZmIzNjVlN2E5MWUxMmQ1ZDkxNWNjYw==
   data.tar.gz: !binary |-
-    YzVjNGU4MGI2ZDFlYmE5M2ExODYyZWZkODUwYTZlMzhhMGU4YWE5NQ==
+    ZGU2ZjIxNGFkYzVlZTM3YjZjZDI2ODYyZmQzYTYwNzg0NmE0Mzk5MQ==
 SHA512:
   metadata.gz: !binary |-
-    MjAyM2JkMDRhMjdkMjc4NzRiMjE1OTI5MDlmNTJjMGMyNDQwM2E3ZjdhYTcz
-    YWQwY2RhMmVmNDliYzY0ZmQ5NjhlM2Y1MWVlMzljODQ4MWU5ZTc0OWRiZTgw
-    MTcwNmNmYjA5NWYyNzhmMjMwZDU0YTkzNGIzMmNlZGRkODU3ZTE=
+    Mjg4NzY3ZTViMjcwNjJjNWJhZDkxZmQ4YzViODdiNjVkMTYzZTQxZTU5YmRm
+    NDI1MGM2NGRiYTk4ZGQzMDRkYmI3MTg5YmYxMTlhMGI0ZjlkMjMzMzRkZTc1
+    YjU0ODM4OWQzN2U1OGI1ODBjYzQ3NGNiMTk3YzQ3NDlhNDVmNTk=
   data.tar.gz: !binary |-
-    YWQ2M2MzYTRmNjI5NmQwZWFmNTQ0ODAzZjM1NDdkNGEwNThhMWFjMjRiMzBk
-    ZTA5ZDhlZjVjNDExYWY0ZTIwMDdmNTVjZDdjOTIzZTZkMmJmMjVkNGRkMjYz
-    ZjYzY2QyYTI1NDg2OWEyODIzMDY3MGI4OTQzOTYwNzEyZWFiZWY=
+    MzE0YzVkOTZkMmFhNTM1OTUyMGFiM2UyOTU5OWIxYWRkZDVjYzgwY2Y2ZWQ3
+    YjA3YmY0NWQ0MDA4MTJkZDI4MmVjZTBhODE1OWJlYTk4MjFmOWRjNzQzMzJm
+    YWNlZjE4MDJhYmViOTNjN2VjOTNmZDM5ZDMzZmQ3MTFjNTQwZmU=

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2010-2013 Joshua T. McKinney
+Copyright (c) 2010-2014 Joshua T. McKinney
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/benchmarks/simple_model.rb

@@ -13,12 +13,13 @@ Benchmark.bm do |b|
       BenchClass.new()
     end
   end
-  BenchClass.new()
+
   b.report("initialize with attrs") do
     30000.times.each  do
       BenchClass.new(:num => 1, :dec => "12.4")
     end
   end
+  
   b.report("get") do
     30000.times.each  do
       klass = BenchClass.new

data/lib/simple_model.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2010-2012 Joshua Thomas Mckinney
+# Copyright (c) 2010-2014 Joshua Thomas Mckinney
 #
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the

data/lib/simple_model/attributes.rb

@@ -7,7 +7,7 @@ module SimpleModel
     
     def initialize(*attrs)
       attrs = attrs.extract_options!
-      attrs = attributes_with_for_init(attrs)
+      attrs = attributes_for_init(attrs)
       attrs = self.class.before_initialize.call(self,attrs) if self.class.before_initialize
       set(attrs)
       self.class.after_initialize.call(self) if self.class.after_initialize
@@ -19,11 +19,11 @@ module SimpleModel
 
     # Returns true if attribute has been initialized
     def initialized?(attr)
-      self.attributes.key?(attr.to_sym)
+      attributes.key?(attr)
     end
 
     def get(attr)
-      self.send(attr)
+      send(attr)
     end
     alias :read :get
 
@@ -31,7 +31,7 @@ module SimpleModel
     # set(:foo => "bar", :dime => 0.1)
     def set(*attrs)
       attrs.extract_options!.each do |attr,val|
-        self.send("#{attr.to_s}=",val)
+        send("#{attr}=",val)
       end
     end
     alias :set_attributes :set
@@ -41,17 +41,17 @@ module SimpleModel
       if allow_attribute_action?(val,options)
         val = fetch_default_value(options[:default]) if (!options[:allow_blank] && options.key?(:default) && val.blank?)
         val = options[:on_set].call(self,val) if options[:on_set] #(!options.key?(:on_set) || (val.blank? && !options[:allow_blank]) )
-        self.send("#{attr}_will_change!") if (initialized?(attr) && val != self.attributes[attr])
-        self.attributes[attr] = val
+        send("#{attr}_will_change!") if (initialized?(attr) && val != attributes[attr])
+        attributes[attr] = val
         options[:after_set].call(self,val) if options[:after_set]
       end
     end
 
     def get_attribute(attr)
-      val = self.attributes[attr]
+      val = attributes[attr]
       options = self.class.defined_attributes[attr] || {}
-      if (options.key?(:default) && (!self.initialized?(attr) || (!options[:allow_blank] && val.blank?)))
-        val = self.attributes[attr] = fetch_default_value(options[:default])
+      if (options.key?(:default) && (!initialized?(attr) || (!options[:allow_blank] && val.blank?)))
+        val = attributes[attr] = fetch_default_value(options[:default])
       end
       if options[:on_get]
         options[:on_get].call(self,val)
@@ -77,18 +77,17 @@ module SimpleModel
     end
 
     def fetch_default_value(arg)
-      return self.send(arg) if (arg.is_a?(Symbol) && self.respond_to?(arg))
+      return send(arg) if (arg.is_a?(Symbol) && self.respond_to?(arg))
       arg
     end
 
     # Returns attribute that have defaults in a hash: {:attribute => "default value"}
     # Checks for alias attributes to ensure they are not overwritten
-    def attributes_with_for_init(attrs)
-      d = attrs.with_indifferent_access
+    def attributes_for_init(attrs)
+      d = (attrs.is_a?(HashWithIndifferentAccess) ? attrs : attrs.with_indifferent_access )
       self.class.defined_attributes.each do |k,v|
-        key = k.to_sym
-        if allow_init_default?(d,key,v)
-          d[key] = fetch_default_value(v[:default])
+        if allow_init_default?(d,k,v)
+          d[k] = fetch_default_value(v[:default])
         end
       end
       d
@@ -101,7 +100,7 @@ module SimpleModel
     end
 
     def attributes_have_alias?(attrs,attr)
-      !(self.class.alias_attributes.select{ |a, m| (m == attr && attrs.key?(a.to_sym)) }).empty?
+      !(self.class.alias_attributes.select{ |a, m| (m == attr.to_sym && attrs.key?(a)) }).empty?
     end
 
     def allow_attribute_action?(val,options)
@@ -131,8 +130,8 @@ module SimpleModel
     end
 
     # Rails 3.2 + required when searching for attributes in from inherited classes/models
-    def attribute(name)
-      attributes[name.to_sym]
+    def attribute(attr)
+       get_attribute(attr)
     end
 
     module ClassMethods
@@ -177,7 +176,7 @@ module SimpleModel
       def new_with_store(session_hash)
         nw = self.new()
         nw.attributes = session_hash
-        nw.set(nw.send(:attributes_with_for_init,session_hash))
+        nw.set(nw.send(:attributes_for_init,session_hash))
         nw
       end
 
@@ -198,7 +197,7 @@ module SimpleModel
       end
 
       def attribute_defined?(attr)
-        (self.defined_attributes.member?(attr) || self.superclass.respond_to?(:attribute_defined?) && self.superclass.attribute_defined?(attr))
+        defined_attributes.key?(attr)
       end
 
       # The default settings for a SimpeModel class
@@ -221,15 +220,15 @@ module SimpleModel
       # at once, so we must set @attribute_methods_generated to nil to allow the
       # re-run to occur ONLY IN RAILS 3.0.
       def add_defined_attribute(attr,options)
-        self.defined_attributes[attr] = options
+        defined_attributes[attr] = options
         @attribute_methods_generated = nil #if (ActiveModel::VERSION::MAJOR == 3 && ActiveModel::VERSION::MINOR == 0)
         define_attribute_methods(defined_attributes_keys)
       end
 
       # We don't want to call define_attribute_methods on methods defined in the parent class
       def defined_attributes_keys
-        dak = self.defined_attributes.keys
-        dak = dak - self.superclass.defined_attributes.keys if self.superclass.respond_to?(:defined_attributes)
+        dak = defined_attributes.keys
+        dak = dak - superclass.defined_attributes.keys if superclass.respond_to?(:defined_attributes)
         dak
       end
 
@@ -276,13 +275,13 @@ module SimpleModel
         alias_attributes[new_alias] = attr
 
         define_method(new_alias) do
-          self.send(attr)
+          send(attr)
         end
         define_method("#{new_alias}?") do
-          self.send("#{attr}?")
+          send("#{attr}?")
         end
         define_method("#{new_alias.to_s}=") do |*args, &block|
-          self.send("#{attr.to_s}=",*args, &block)
+          send("#{attr}=",*args, &block)
         end
       end
 
@@ -299,7 +298,7 @@ module SimpleModel
       # should return a hash to be set
       # EX: lambda {|obj,attrs| attrs.select{|k,v| !v.blank?}}
       def before_initialize=before_initialize
-        raise TypeError "before_initialize must be a lambda that accepts the attirbutes to be initialize" unless before_initialize.is_a?(Proc)
+        raise TypeError "before_initialize must be a lambda that accepts the attributes to be initialize" unless before_initialize.is_a?(Proc)
         @before_initialize = before_initialize
       end
 
@@ -322,8 +321,8 @@ module SimpleModel
       # hack to keep things working when a class inherits from a super that
       # has ActiveModel::Dirty included
       def inherited(base)
-        base.defined_attributes = self.defined_attributes.merge(base.defined_attributes)
-        base.alias_attributes = self.alias_attributes.merge(base.alias_attributes)
+        base.defined_attributes = defined_attributes.merge(base.defined_attributes)
+        base.alias_attributes = alias_attributes.merge(base.alias_attributes)
         super
         # Rails 3.0 Hack
         if (ActiveModel::VERSION::MAJOR == 3 && ActiveModel::VERSION::MINOR == 0)

data/lib/simple_model/base.rb

@@ -1,167 +1,166 @@
 module SimpleModel
   # Require all that active support we know and love
-require 'active_support/time'
-require 'active_support/core_ext/class/attribute'
-require 'active_support/core_ext/class/attribute_accessors'
-require 'active_support/core_ext/class/delegating_attributes'
-require 'active_support/core_ext/class/attribute'
-require 'active_support/core_ext/array/extract_options'
-require 'active_support/core_ext/hash/deep_merge'
-require 'active_support/core_ext/hash/indifferent_access'
-require 'active_support/core_ext/hash/slice'
-require 'active_support/core_ext/string/behavior'
-require 'active_support/core_ext/kernel/singleton_class'
-require 'active_support/core_ext/module/delegation'
-require 'active_support/core_ext/module/introspection'
-require 'active_support/core_ext/object/duplicable'
-require 'active_support/core_ext/object/blank'
+  require 'active_support/time'
+  require 'active_support/core_ext/class/attribute'
+  require 'active_support/core_ext/class/attribute_accessors'
+  require 'active_support/core_ext/class/delegating_attributes'
+  require 'active_support/core_ext/class/attribute'
+  require 'active_support/core_ext/array/extract_options'
+  require 'active_support/core_ext/hash/deep_merge'
+  require 'active_support/core_ext/hash/indifferent_access'
+  require 'active_support/core_ext/hash/slice'
+  require 'active_support/core_ext/string/behavior'
+  require 'active_support/core_ext/kernel/singleton_class'
+  require 'active_support/core_ext/module/delegation'
+  require 'active_support/core_ext/module/introspection'
+  require 'active_support/core_ext/object/duplicable'
+  require 'active_support/core_ext/object/blank'
 
   # == SimpleModel::Base
   #
   # Provides an interface for any class to build table-less models.
-  # 
+  #
   # Implements Validations, Callbacks and Dirty from ActiveModel, and data-type specific
   # attribute definitions with default options. SimpleModel::Base is intended as
   # an example, while it may be used in production, which it is on many of my apps
   # today, it is recommend you use SimpleModel::Base as an example to implement your
   # own model actions.
-  # 
+  #
   # == SimpleModel Actions:
-  # 
+  #
   # Model actions provide a tool for making use of Active Model callbacks. Each
-  # action creates an instance method representing the action, which calls the 
-  # method(s) listed as symbols when defining the actions. Model actions also accept 
-  # a rollback option, which is called if the action fails. If you plan to 
+  # action creates an instance method representing the action, which calls the
+  # method(s) listed as symbols when defining the actions. Model actions also accept
+  # a rollback option, which is called if the action fails. If you plan to
   # implement SimpleModel's actions, avoid naming you own methods "save", "destroy",
   # "create", and "update", as these will override the methods defined by action.
-  # 
+  #
   # Available Actions:
   #   # save
   #   # update
   #   # create
   #   # destroy
-  # 
+  #
   # ==== Example
-  # 
+  #
   # class MyModel < SimpleModel::Base
   #   save :my_save, :rollback => :undo_save
   #   update :my_update, :rollback => :undo_update
   #   destroy :my_destory, :rollback => :undo_destory
   # end
-  # 
+  #
   # A basic SimpleModel implementation might resemble
-  # 
+  #
   # class MyModel < SimpleModel::Base
-  # 
+  #
   #   has_integers :first_int, :second_int, :default => 1
   #   has_times :now, :default => :get_now
-  #   
+  #
   #   save :save_record, :rollback => :rollback_save
-  # 
+  #
   #   def save_record
   #     puts "saved"
   #     true
   #   end
-  # 
+  #
   #   def get_today
   #     Time.now
   #   end
-  #   
+  #
   #   def rollback_save
   #     puts "rolled back"
   #   end
   # end
- 
+
   class Base
     include SimpleModel::Attributes
     include SimpleModel::ErrorHelpers
-    #Use ActiveModel Resources
-    
 
     define_model_callbacks :save, :update, :create, :destroy
-    
+
     class << self
-      
+
+      # Defines the model action's instance methods and applied defaults. For every
+      # action defined, we also define that actions ! method which raises exceptions
+      # when the action fails.
+      def define_model_action(methods,action,default_options={:validate => true})
+        default_options.merge!(methods.extract_options!)
+        actions = [action,"#{action}!".to_sym]
+        actions.each do |a|
+          define_method(a) do |opts = {}|
+            options = default_options.merge(opts)
+            options[:raise_exception] = a.to_s.match(/\!$/)
+            run_callbacks(action) do
+              run_model_action(methods,options)
+            end
+          end
+        end
+      end
+
       def save(*methods)
         define_model_action(methods,:save)
       end
-    
+
       def create(*methods)
         define_model_action(methods,:create)
       end
-    
+
       def update(*methods)
         define_model_action(methods,:update)
       end
-      
+
       # Destroy does not run normal validation in Rails, but with this we can if we choose to.
-      def destroy(*methods)   
+      def destroy(*methods)
         define_model_action(methods,:destroy, {:validate => false})
-      end     
+      end
+
     end
-    
+
     has_boolean :persisted
     has_boolean :new_record, :default => true
     has_attribute :id # may not be an integer
     alias :saved? :persisted?
 
     private
-      
+
     # Skeleton for action instance methods
     def run_model_action(methods,options)
       completed = true
-      if (!options[:validate] || (options[:validation_methods] && valid_using_other?(options[:validation_methods])) || self.valid?)     
+      if (!options[:validate] || (options[:validation_methods] && valid_using_other?(options[:validation_methods])) || self.valid?)
         methods.each do |method|
-          ran = self.send(method)
+          ran = send(method)
           completed = ran unless ran
         end
         if completed
           self.persisted = true
           @previously_changed = changes
-          @changed_attributes.clear   
+          @changed_attributes.clear
         else
-          self.send(options[:rollback]) unless options[:rollback].blank?
-        end    
+          send(options[:rollback]) unless options[:rollback].blank?
+        end
       else
         completed = false
       end
-      if !completed && options[:raise_exception]      
+      if !completed && options[:raise_exception]
         if !self.errors.blank?
           raise ValidationError, self.errors.full_messages.join(" ")
         else
           raise ActionError, "failed action: #{methods.join(', ')}"
         end
-      end 
+      end
       completed
-    end   
-    
+    end
+
     # Run supplied methods as validation. Each method should return a boolean
     # If using this option, to see if errors are present use object_name.errors.blank?,
-    # otherwise if you run object_name.valid? you will over write the errors 
+    # otherwise if you run object_name.valid? you will over write the errors
     # generated here.
     def valid_using_other?(methods)
       valid = true
       methods.each do |method|
-        valid = false unless self.send(method)
+        valid = false unless send(method)
       end
       valid
-    end   
-    
-    # Defines the model action's instance methods and applied defaults. For every
-    # action defined, we also define that actions ! method which raises exceptions
-    # when the action fails.
-    def self.define_model_action(methods,action,default_options={:validate => true})
-      default_options.merge!(methods.extract_options!)
-      actions = [action,"#{action}!".to_sym]
-      actions.each do |a|
-        define_method(a) do |opts = {}|
-          options = default_options.merge(opts)
-          options[:raise_exception] = a.to_s.match(/\!$/)
-          self.run_callbacks(action) do  
-            run_model_action(methods,options)
-          end
-        end
-      end
     end
   end
-end
+end

data/lib/simple_model/error_helpers.rb

@@ -1,6 +1,6 @@
 module SimpleModel
   module ErrorHelpers
- 
+
     attr_accessor :errors_count
 
     def errors?
@@ -10,13 +10,12 @@ module SimpleModel
 
     def errors_for_flash(options={})
       #set defaults and overwrite
-      options = {
-        :failed_action => "saving",
-        :id => 'errorExplanation',
-        :classes =>  ''}.merge!(options)
-    
+      options = {:failed_action => "saving",
+                 :id => 'errorExplanation',
+                 :classes =>  ''}.merge!(options)
+
       error_list  = ""
-      
+
       # The active_model errors object is not a normal hash and the each method
       # for the active_mode errors object does not perform as expected
       # so make it a plain hash
@@ -39,7 +38,7 @@ module SimpleModel
         value.uniq!
         if value.length == 1
           self.errors_count = (self.errors_count.to_i + 1)
-          error_items << "<li>#{key.to_s.titleize} #{value[0]}</li>" 
+          error_items << "<li>#{key.to_s.titleize} #{value[0]}</li>"
         else
           error_items << "<li><ul>#{key.to_s.titleize} errors:"
           value.each do |item|
@@ -78,6 +77,6 @@ module SimpleModel
       end
       error_string
     end
-   
+
   end
 end

data/lib/simple_model/extend_core.rb

@@ -1,16 +1,36 @@
 module SimpleModel
+  module ToCurrencyS
+    def to_currency_s(symbol='$',rnd=2)
+      cs = self.round(rnd).abs.to_s
+      while cs.index('.') != (cs.length-3)
+        cs << '0'
+      end
+      comma = 6
+      while cs.length > (comma)
+        cs.insert((cs.length - comma), ",")
+        comma += 4
+      end
+      cs.insert(0,symbol) if symbol
+      if self < 0
+        cs.insert(0, "-")
+      end
+      cs
+    end
+  end
+
   module ExtendCore
     require 'time'
     require 'date'
     require 'bigdecimal'
     require 'bigdecimal/util'
-    
-    Float.class_eval do   
+
+    Float.class_eval do
+      include ToCurrencyS
       # that does not equal 0.0 is true
       def to_b
-        self != 0.0
+        zero?
       end
-      
+
       # Rounds float to the precision specified
       # 100.5235.round_to #=> 101.0
       # 100.5235.round_to(1) #=> 101.5
@@ -25,26 +45,6 @@ module SimpleModel
       def to_currency
         self.to_d.round(2)
       end
-
-      # Returns a string with representation of currency, rounded to nearest hundredth
-      def to_currency_s(symbol="$")      
-        num = self.round_to(2).to_s
-        neg = num.include?("-")
-        while num.index('.') != (num.length-3)
-          num << '0'
-        end
-        comma = 6
-        while num.length > (comma)
-          num.insert((num.length - comma), ",")
-          comma += 4
-        end
-        num.insert(0,symbol)
-        if neg
-          num.delete!("-")
-          num.insert(0, "-")
-        end
-        num
-      end
       
       def to_time
         Time.at(self)
@@ -71,23 +71,19 @@ module SimpleModel
       # * safe_date_string("12/31/2010")              # => '2010-12-31'
       # * safe_date_string("12/31/2010T23:30:25")     # => '2010-12-31T23:30:25'
       # * safe_date_string("12/31/2010 23:30:25")     # => '2010-12-31 23:30:25'
-      # * safe_date_string("\/Date(1310669017000)\/") # => 
+      # * safe_date_string("\/Date(1310669017000)\/") # =>
       def safe_datetime_string
         safe_date = nil
         if self[0..9].match(/^(0[1-9]|[1-9]|1[012])[- \/.]([1-9]|0[1-9]|[12][0-9]|3[01])[- \/.][0-9][0-9][0-9][0-9]/)
           safe_date = ""
-          if self.include?("/")
-            split = self.split("/")
-          else
-            split = self.split("-")
-          end
+          splt = split(/\-|\/|\./)
           time = ""
-          if split[2].length > 4
-            time = split[2][4..(split[2].length - 1)]
-            split[2] = split[2][0..3]
+          if splt[2].length > 4
+            time = splt[2][4..(splt[2].length - 1)]
+            splt[2] = splt[2][0..3]
           end
-          if split.length == 3 && split[2].length == 4
-            safe_date << "#{split[2]}-#{split[0]}-#{split[1]}"
+          if splt.length == 3 && splt[2].length == 4
+            safe_date << "#{splt[2]}-#{splt[0]}-#{splt[1]}"
             safe_date << "#{time}" unless time.nil? || time.to_s.length == 0
           end
         elsif self.match(/^\/Date\(/)
@@ -97,7 +93,7 @@ module SimpleModel
         end
         safe_date
       end
-      
+
       # Use safe_datetime_string help with those pesky US date formats in Ruby 1.9
       # or to change an integer string to date
       def to_date
@@ -118,44 +114,38 @@ module SimpleModel
       def to_f
         gsub(/[^0-9\.\+\-]/, '').core_to_f
       end
-      
+
       alias :core_to_d :to_d
-      
+
       def to_d
         gsub(/[^0-9\.\+\-]/, '').core_to_d
       end
       alias :to_currency :to_d
-      
+
     end
-    
+
     BigDecimal.class_eval do
-      def to_currency_s(symbol="$")
-        self.to_f.to_currency_s(symbol)
-      end 
-      
+      include ToCurrencyS
+
       def to_b
-        self != 0.0
+        zero?
       end
     end
-    
     Fixnum.class_eval do
-      def to_currency_s(symbol="$")
-        self.to_f.to_currency_s(symbol)
-      end
-      
+      include ToCurrencyS
+
       unless Fixnum.instance_methods.include?(:to_b)
-        #Any value greater than 0 is true
         def to_b
-          self > 0
+          zero?
         end
       end
-      
+
       unless Fixnum.instance_methods.include?(:to_d)
         def to_d
-          BigDecimal.new("#{self}.0")
+          BigDecimal.new(self)
         end
       end
-      
+
       unless Fixnum.instance_methods.include?(:to_date)
         def to_date
           Time.at(self).to_date
@@ -176,7 +166,7 @@ module SimpleModel
       end
       unless NilClass.instance_methods.include?(:to_d)
         def to_d
-          BigDecimal.new("0.0")
+          BigDecimal.new('')
         end
       end
     end
@@ -195,4 +185,4 @@ module SimpleModel
       end
     end
   end
-end
+end

data/lib/simple_model/simple_model_railtie.rb

@@ -11,4 +11,4 @@ module SimpleModel
       end
     end
   end
-end
+end

data/lib/simple_model/validation.rb

@@ -25,13 +25,13 @@ module SimpleModel
         end
       end
     end
-    
+
     def validates_length_of(*attr_names)
       options = attr_names.extract_options!
 
       attr_names.each do |attr|
         break if conditional?(options)
-    
+
         att_method = send(attr)
         unless att_method.blank?
           errors.add(attr,(options[:message].blank? ? "must equal #{options[:is]} characters in length." : options[:message]))  if options[:is] && att_method.to_s.length != options[:is]
@@ -59,8 +59,8 @@ module SimpleModel
     private
     def conditional?(options)
       return true unless ((options[:if].blank? && options[:unless].blank?) ||
-          !options[:if].blank? && send(options[:if])) ||
+      !options[:if].blank? && send(options[:if])) ||
         (!options[:unless].blank? && !send(options[:unless]))
-    end 
+    end
   end
 end

data/lib/simple_model/version.rb

@@ -1,3 +1,3 @@
 module SimpleModel
-  VERSION = "1.2.22"
+  VERSION = "1.2.23"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: simple_model
 version: !ruby/object:Gem::Version
-  version: 1.2.22
+  version: 1.2.23
 platform: ruby
 authors:
 - Joshua T Mckinney
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-10 00:00:00.000000000 Z
+date: 2014-12-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport