4

How can I define custom getter functions for ActiveRecord objects in Ruby that will perform operations on an array of the ActiveRecord objects?

For example, I would like to return weighted averages on an array of objects. So if I have Loan objects (1,2,3) with fields amount (100, 200, 300) and default_rate (.1, .2, .3), then with the normal ActiveRecord functions Loan.find(1).amount should return 100, Loan.find(2).default_rate should return .2.

But if I had Loan.find(2,3).default_rate, I would like it to return the weighted average of the default rates, which is .26. I know I can do this using SQL select statements but how can I "overload" the ActiveRecord getter to allow be to define a function when I call the getter on an array of Loan objects rather than a single Loan object?

The loan table has fields amount id, amount, and default_rate

class Loan < ActiveRecord::Base
  module Collection
    def default_rate
      sum(:default_rate * :amount) / sum(:amount)
    end
  end
end

class LoanGroup
  has_many :loans, :extend => Loan::Collection
end

#Then I try
obj = LoanGroup.where('id < 10')

This gives me the error that has_many is undefined in LoanGroup

Improve this question
1
  • here LoanGroup would be an extension of ActiveRecord::Base and be persisted by the database. If you just want to call methods on Loan, you should do this via a class method on Loan instead. Commented Nov 9, 2012 at 20:24

4 Answers 4

Reset to default
2

To avoid polluting Array's namespace with methods specific to collections of Loan records, you might make a wrapper for such a collection and call your methods on that.

Something like:

class LoanArray < Array
  def initialize(*args)
    find(*args)
  end

  def find(*args)
    replace Array.wrap(Loan.find(*args))
    self
  end

  def default_rate
    if length == 1
      self[0].default_rate 
    else
      inject(0) {|mem,loan| mem + loan.defualt_rate } / count
    end
  end
end

# then
arr = LoanArray.new(2,3).default_rate #=> 0.26
arr.find(1,2,3).default_rate          #=> 0.2
arr.length                            #=> 3
arr.find(1)                           #=> [<Loan id=1>]
arr.default_rate                      #=> 0.1
arr.length                            #=> 1

Original answer below: using an association extension

Use an association extension. This way the method will be the same whether on a loan, or a collection of loans.

class MyClass
  has_many :loans do
    def default_rate
      sum(:default_rate) / count
    end
  end
end

obj = MyClass.find(1)
obj.loans.first.default_rate               #=> 0.1
obj.loans.default_rate                     #=> 0.2
obj.loans.where(:id => [2,3]).default_rate #=> 0.26

If you wanted to keep the logic for loans in the Loan class, you could also write the extension there, e.g.:

class Loan
  module Collection
    def default_rate
      sum(:default_rate) / count
    end

    # plus other methods, as needed, e.g.
    def average_amount
      sum(:amount) / count
    end
  end
end

class MyClass
  has_many :loans, :extend => Loan::Collection
end

Edit: as @Santosh points out association.find does not return a relation, so it will not work here. You'd have to use where or some other method which returns a relation.

Improve this answer
Sign up to request clarification or add additional context in comments.

7 Comments

Will this "MyClass.find(1).loans.find(2,3).default_rate" work? Because MyClass.find(1).loans.find(2,3) this will return an array not ActiveRecord::Relation object.
Yes, you're correct. You'd have to use where in this case to keep it a relation. Sorry, my rails is rusty ;-). Editing to fix.
I think this is what I am looking for but I'm having trouble making it work. Does MyClass need to inherit from ActiveRecord::Base?
Yep. That would be whatever class you're using that has a loans association. If there is no such class though, and you're just doing queries on Loan, then you probably want one of the other answers.
I should probably note that this answer is for the current version of rails 3. I think that the syntax for calling methods inside of associations has changed somewhat over Rails' lifetime.
|
1

If I understood your question correctly, you can write class method for this.

class Loan
  def self.default_rate
    sum = 0
    all.each do |loan|
      sum += loan.default_rate
    end
    sum / all.count
  end
end

Then

Loan.where(:id => [2, 3]).default_rate

Other solution if you want to use Loan.find(2,3) then you need to override the Array class.

class Array   
  def default_rate
    sum = 0     
    self.each do |loan|
      sum += loan.default_rate
    end
    sum / self.count
  end
end

Loan.find(2, 3).default_rate
Improve this answer

6 Comments

The problem with #2 is that you really shouldn't extend Array in this way. It would be perfectly fine though to implement something like Array#average(property) which tries to sum and average a property of an Array. In which case you could call something like Loan.find(2,3).average(:default_rate), and it wouldn't pollute Array with inappropriate methods.
@numbers1311407 I agree with you. But he wants custom method on array objects so I wrote this #2 solution for him.
Of course, and in a small-scoped application you can probably get away with it. But as even some popular and pervasive libraries pollute Array in inexcusable ways, I tend to try not to encourage the habit.
It would seem to me that this is creating an awful lot of queries to the database. I am essentially trying to do: SELECT sum(amount*default_rate)/sum(amount) FROM Loans
ActiveRecord has database summing built in, you could write the class method Loan.default_rate() sum(:default_rate) / count; end and it would just perform an SQL sum and count query. Note that works with @Santosh's first example, not the 2nd.
|
0

You might have a bit more freedom by not doing this as a class method; you could have a method header of default_rate (*args) to allow multiple arguments to be passed in using the splat operator, then check the args length. It can be done quite nicely recursively:

def default_rate(*args)
  sum = 0
  if args.length == 1
    return array_name[arg-1] # guessing that's how you store the actual var
  else
    args.each do |arg|
      sum += default_rate arg
    end
  end
  return sum/args.length
end
Improve this answer

Comments

0

If you accept introducing a named scope, than you can exploit the fact scopes have the methods of the classes they are defined on. This way, having

class Shirt < ActiveRecord::Base
  scope :red, where(:color => 'red')

  def self.sum
    # consider #all as the records you are processing - the scope will
    # make it return neccessary ones only
    all.map(&:id).sum
  end
end

Shirt.red.sum

will yield you a sum id red shirts' ids (as opposed to Shirt.sum will yield a sum of all ids).

Having your BL layed out this way not only makes it cleaner, but also enables it to be re-used (you can invoke the #sum method on any scope, no matter how complex it is and you will still get valid results). In addition to that, it appears to be easily readable and doesn't involve any magic (well, almost :)

Hope this would clean you code up a bit :)

Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.