How to create validations for initialized variables?

Question

I have a variable value that is initialized when I create a new object. However, this variable is not a column of my table. I just want to use it inside my model and have it available for some methods inside my class:

class MyClass < ActiveRecord::Base
  def initialize (value)
    @value = value
  end
end

So, when a create a new object @value will keep the some text temporarily, for example:

test = MyClass.new("some text")

There is a way to validates the variable value to accept only text?

class MyClass < ActiveRecord::Base
  validates_format_of :value => /^\w+$/ # it doesn't work

  def initialize (value)
    @value = value
  end
end

EDIT

I have tried all the answer, but my Rspec is still passing:

My new class:

class MyClass < ActiveRecord::Base
  validate :check_value

  def check_value
    errors.add(:base,"value is wrong") and return false if !@value || !@value.match(/^\w+$/)
  end  

  def initialize (value)
    @value = value
  end

  def mymethod
    @value
  end
end

My Rspec (I was expecting it to fail, but it is still passing):

describe MyClass do
  it 'checking the value' do
    @test = MyClass.new('1111').mymethod
    @test.should == '1111'
  end
end

I would like to raise an validation error before assigning 1111 to the @value.

Answer 1

It's because you're using the validates_format_of. It's a helper method that essentially calls validates_each. That method validates specific attribute. You can check its source here.

Since you're trying to validate on instance variable and not on an attribute, you have to write a custom validator.

Validate with this instead:

validate :check_value

def check_value
   unless @value && @value.match(/^\w+$/)
      errors.add(:base,"value is wrong") and return false
   end
end

I hope this is just a representative example of your code. Please tell me you don't use @value as variable name.

Answer 2

Rails does the validations only if you call valid? or save on the model. So if you want it to accept only values for your value when calling those methods, do a custom validation:

class MyClass < ActiveRecord::Base

  validate :value_string

  #further code

Setup your value validation like that under the protected scope

protected

  def value_string
    self.errors[:base] << 'Please assign a string to value' unless @value.match(/^\w+$/)
  end

These validations won't be called without calling valid?or save, like I said before. If you want value not to be assigned with another value than a word-like-value at any time, there's no other way than to prevent it on initialization:

def initialize(attributes = nil, options = {})
  attr_value = attributes.delete(:value) if attributes
  @value = attr_value if attr_value && attr_value.match(/^\w+$/)

  super
end

EDIT

I would not recommend raising an ActiveRecord validation error when assigning not accepted values on initialization. Try to raise your own custom error based on ArgumentError

Outside your class

YourError = Class.new(ArgumentError)

Inside your Class

def initialize(attributes = nil, options = {})
  attr_value = attributes.delete(:value) if attributes
  if attr_value && attr_value.match(/^\w+$/)
    @value = attr_value
  elsif attr_value
    raise YourError.new('Value only accepts words')
  end

  super
end

and then test it like this

describe Myclass do
  it 'should raise an error if value is assigned with something else than a word' do
    lambda{ MyClass.new(:value => 1111)}.should raise_error(YourError)
  end
  it 'should assign the value for words' do
    MyClass.new(:value => 'word').value.should == 'word'
  end
end

Answer 3

Watch out. the other methods will blow up when @value is nil.

validate :check_value

def check_value
  errors.add(:base,"value is wrong") and return false if !@value || !@value.match(/^\w+$/)
end

Answer 4

You should be able to do this by creating your own validator, like so:

class MyClass < ActiveRecord::Base

  validate :value_is_string

  protected

    def value_is_string
      unless @value.match(/^\w+$/)
        self.errors[:base] << 'Please put a string in value'
      end
    end
end

Answer 5

Validations run before save, so if you want to raise error on assigment you can do this

  def initialize (value)
    raise ActiveRecord::RecordInvalid if !@value || !@value.match(/^\w+$/)
    @value = value
  end

But i don't think that it is a good way to do that

Answer 6

You just need to call super when initializing. Try this:

    # Trigger validation on initialization.
    def initialize(attributes = {})
      super
      valid?
    end