invoicing 0.2.1 → 1.0.0

data/lib/invoicing/currency_value.rb

@@ -1,3 +1,5 @@
+require "active_support/concern"
+
 module Invoicing
   # = Input and output of monetary values
   #
@@ -56,9 +58,10 @@ module Invoicing
   # The string returned by a +_formatted+ method is UTF-8 encoded -- remember most currency symbols (except $)
   # are outside basic 7-bit ASCII.
   module CurrencyValue
-    
+    extend ActiveSupport::Concern
+
     # Data about currencies, indexed by ISO 4217 code. (Currently a very short list, in need of extending.)
-    # The values are hashes, in which the following keys are recognised: 
+    # The values are hashes, in which the following keys are recognised:
     # <tt>:round</tt>::  Smallest unit of the currency in normal use, to which values are rounded. Default is 0.01.
     # <tt>:symbol</tt>:: Symbol or string usually used to denote the currency. Encoded as UTF-8. Default is ISO 4217 code.
     # <tt>:suffix</tt>:: +true+ if the currency symbol appears after the number, +false+ if it appears before. Default +false+.
@@ -72,7 +75,7 @@ module Invoicing
       'INR' => {:symbol => "\xE2\x82\xA8"},                   # Indian Rupee
       'JPY' => {:symbol => "\xC2\xA5",     :round  => 1}      # Japanese Yen
     }
-    
+
     module ActMethods
       # Declares that the current model object has columns storing monetary amounts. Pass those attribute
       # names to +acts_as_currency_value+. By default, we try to find an attribute or method called +currency+,
@@ -111,26 +114,30 @@ module Invoicing
       # (The example above is actually a real part of +LedgerItem+.)
       def acts_as_currency_value(*args)
         Invoicing::ClassInfo.acts_as(Invoicing::CurrencyValue, self, args)
-
-        # Register callback if this is the first time acts_as_currency_value has been called
-        before_save :write_back_currency_values if currency_value_class_info.previous_info.nil?
       end
     end
 
+    included do
+      # Register callback if this is the first time acts_as_currency_value has been called
+      before_save :write_back_currency_values, :if => "currency_value_class_info.previous_info.nil?"
+    end
+
     # Format a numeric monetary value into a human-readable string, in the currency of the
     # current model object.
     def format_currency_value(value, options={})
       currency_value_class_info.format_value(self, value, options)
     end
-    
-    
+
+
     # Called automatically via +before_save+. Writes the result of converting +CurrencyValue+ attributes
     # back to the actual attributes, so that they are saved in the database. (This doesn't happen in
     # +convert_currency_values+ to avoid losing the +_before_type_cast+ attribute values.)
     def write_back_currency_values
-      currency_value_class_info.all_args.each {|attr| write_attribute(attr, send(attr)) }
+      currency_value_class_info.all_args.each do |attr|
+        write_attribute(attr, send(attr))
+      end
     end
-    
+
     protected :write_back_currency_values
 
 
@@ -138,7 +145,7 @@ module Invoicing
     # These methods do not depend on ActiveRecord and can thus also be called externally.
     module Formatter
       class << self
-        
+
         # Given the three-letter ISO 4217 code of a currency, returns a hash with useful bits of information:
         # <tt>:code</tt>::   The ISO 4217 code of the currency.
         # <tt>:round</tt>::  Smallest unit of the currency in normal use, to which values are rounded. Default is 0.01.
@@ -154,15 +161,15 @@ module Invoicing
             info.update(::Invoicing::CurrencyValue::CURRENCIES[code])
           end
           options.each_pair {|key, value| info[key] = value if valid_options.include? key }
-        
+
           info[:suffix] ||= (info[:code] == info[:symbol]) && !info[:code].nil?
           info[:space]  ||= info[:suffix]
           info[:digits] = -Math.log10(info[:round]).floor if info[:digits].nil?
           info[:digits] = 0 if info[:digits] < 0
-        
+
           info
         end
-      
+
         # Given the three-letter ISO 4217 code of a currency and a BigDecimal value, returns the
         # value formatted as an UTF-8 string, ready for human consumption.
         #
@@ -170,17 +177,17 @@ module Invoicing
         # as decimal separator and the comma as thousands separator.
         def format_value(currency_code, value, options={})
           info = currency_info(currency_code, options)
-          
+
           negative = false
           if value < 0
             negative = true
             value = -value
           end
-        
+
           value = "%.#{info[:digits]}f" % value
           while value.sub!(/(\d+)(\d\d\d)/, '\1,\2'); end
           value.sub!(/^\-/, '') # avoid displaying minus zero
-          
+
           formatted = if ['', nil].include? info[:symbol]
             value
           elsif info[:space]
@@ -188,26 +195,26 @@ module Invoicing
           else
             info[:suffix] ? "#{value}#{info[:symbol]}" : "#{info[:symbol]}#{value}"
           end
-          
+
           if negative
             # default is to use proper unicode minus sign
             formatted = (options[:negative] == :brackets) ? "(#{formatted})" : (
               (options[:negative] == :hyphen) ? "-#{formatted}" : "\xE2\x88\x92#{formatted}"
             )
           end
-          formatted
+          formatted.force_encoding("utf-8")
         end
       end
     end
 
 
     class ClassInfo < Invoicing::ClassInfo::Base #:nodoc:
-      
+
       def initialize(model_class, previous_info, args)
         super
         new_args.each{|attr| generate_attrs(attr)}
       end
-      
+
       # Generates the getter and setter method for attribute +attr+.
       def generate_attrs(attr)
         model_class.class_eval do
@@ -215,23 +222,23 @@ module Invoicing
             currency_info = currency_value_class_info.currency_info_for(self)
             return read_attribute(attr) if currency_info.nil?
             round_factor = BigDecimal(currency_info[:round].to_s)
-            
+
             value = currency_value_class_info.attr_conversion_input(self, attr)
             value.nil? ? nil : (value / round_factor).round * round_factor
           end
-          
+
           define_method("#{attr}=") do |new_value|
             write_attribute(attr, new_value)
           end
-          
+
           define_method("#{attr}_formatted") do |*args|
             options = args.first || {}
             value_as_float = begin
-              Kernel.Float(send("#{attr}_before_type_cast")) 
+              Kernel.Float(send("#{attr}_before_type_cast"))
             rescue ArgumentError, TypeError
               nil
             end
-            
+
             if value_as_float.nil?
               ''
             else
@@ -240,7 +247,7 @@ module Invoicing
           end
         end
       end
-      
+
       # Returns the value of the currency code column of +object+, if available; otherwise the
       # default currency code (set by the <tt>:currency_code</tt> option), if available; +nil+ if all
       # else fails.
@@ -251,12 +258,12 @@ module Invoicing
           all_options[:currency_code]
         end
       end
-      
+
       # Returns a hash of information about the currency used by model +object+.
       def currency_info_for(object)
         ::Invoicing::CurrencyValue::Formatter.currency_info(currency_of(object), all_options)
       end
-      
+
       # Formats a numeric value as a nice currency string in UTF-8 encoding.
       # +object+ is the model object carrying the value (used to determine the currency).
       def format_value(object, value, options={})
@@ -267,16 +274,16 @@ module Invoicing
         end
         ::Invoicing::CurrencyValue::Formatter.format_value(currency_of(object), value, options)
       end
-      
+
       # If other modules have registered callbacks for the event of reading a rounded attribute,
       # they are executed here. +attr+ is the name of the attribute being read.
       def attr_conversion_input(object, attr)
         value = nil
-          
+
         if callback = all_options[:conversion_input]
           value = object.send(callback, attr)
         end
-          
+
         unless value
           raw_value = object.read_attribute(attr)
           value = BigDecimal.new(raw_value.to_s) unless raw_value.nil?

data/lib/invoicing/find_subclasses.rb

@@ -12,14 +12,14 @@ module Invoicing
   #     extend Invoicing::FindSubclasses
   #     def self.needs_refrigeration; false; end
   #   end
-  #   
+  #
   #   class Food < Product; end
   #   class Bread < Food; end
   #   class Yoghurt < Food
   #     def self.needs_refrigeration; true; end
   #   end
   #   class GreekYoghurt < Yoghurt; end
-  #   
+  #
   #   class Drink < Product; end
   #   class SoftDrink < Drink; end
   #   class Smoothie < Drink
@@ -72,11 +72,11 @@ module Invoicing
   # <tt>Class#inherited</tt> method; we use this to gather together a list of subclasses. Of course,
   # we won't necessarily know about every class in the world which may subclass our class; in
   # particular, <tt>Class#inherited</tt> won't be called until that subclass is loaded.
-  # 
+  #
   # If you're including the Ruby files with the subclass definitions using +require+, we will learn
-  # about subclasses as soon as they are defined. However, if class loading is delayed until a 
+  # about subclasses as soon as they are defined. However, if class loading is delayed until a
   # class is first used (for example, <tt>ActiveSupport::Dependencies</tt> does this with model
-  # objects in Rails projects), we could run into a situation where we don't yet know about all 
+  # objects in Rails projects), we could run into a situation where we don't yet know about all
   # subclasses used in a project at the point where we need to process a class method condition.
   # This would cause us to omit some objects we should have found.
   #
@@ -89,7 +89,7 @@ module Invoicing
   # to be on the safe side you can ensure all subclasses are loaded when your application
   # initialises -- but that's not completely DRY ;-)
   module FindSubclasses
-    
+
     # Overrides <tt>ActiveRecord::Base.sanitize_sql_hash_for_conditions</tt> since this is the method
     # used to transform a hash of conditions into an SQL query fragment. This overriding method
     # searches for class method conditions in the hash and transforms them into a condition on the
@@ -103,14 +103,14 @@ module Invoicing
     #   {:my_class_method => false}       # known_subclasses.reject{|cls| cls.my_class_method }
     def sanitize_sql_hash_for_conditions(attrs, table_name = quoted_table_name)
       new_attrs = {}
-      
+
       attrs.each_pair do |attr, value|
         attr = attr_base = attr.to_s
         attr_table_name = table_name
 
         # Extract table name from qualified attribute names
         attr_table_name, attr_base = attr.split('.', 2) if attr.include?('.')
-        
+
         if columns_hash.include?(attr_base) || ![self.table_name, quoted_table_name].include?(attr_table_name)
           new_attrs[attr] = value   # Condition on a table column, or another table -- pass through unmodified
         else
@@ -125,10 +125,35 @@ module Invoicing
 
       super(new_attrs, table_name)
     end
-    
+
+    def expand_hash_conditions_for_aggregates(attrs)
+      new_attrs = {}
+
+      attrs.each_pair do |attr, value|
+        attr = attr_base = attr.to_s
+        attr_table_name = table_name
+
+        # Extract table name from qualified attribute names
+        attr_table_name, attr_base = attr.split('.', 2) if attr.include?('.')
+
+        if columns_hash.include?(attr_base) || ![self.table_name, quoted_table_name].include?(attr_table_name)
+          new_attrs[attr] = value   # Condition on a table column, or another table -- pass through unmodified
+        else
+          begin
+            matching_classes = select_matching_subclasses(attr_base, value)
+            new_attrs["#{self.table_name}.#{inheritance_column}"] = matching_classes.map{|cls| cls.name.to_s}
+          rescue NoMethodError
+            new_attrs[attr] = value # If the class method doesn't exist, fall back to passing condition through unmodified
+          end
+        end
+      end
+
+      super(new_attrs)
+    end
+
     # Returns a list of those classes within +known_subclasses+ which match a condition
     # <tt>method_name => value</tt>. May raise +NoMethodError+ if a class object does not
-    # respond to +method_name+. 
+    # respond to +method_name+.
     def select_matching_subclasses(method_name, value, table = table_name, type_column = inheritance_column)
       known_subclasses(table, type_column).select do |cls|
         returned = cls.send(method_name)
@@ -139,28 +164,28 @@ module Invoicing
         end
       end
     end
-    
+
     # Ruby callback which is invoked when a subclass is created. We use this to build a list of known
     # subclasses.
     def inherited(subclass)
       remember_subclass subclass
       super
     end
-    
+
     # Add +subclass+ to the list of know subclasses of this class.
     def remember_subclass(subclass)
       @known_subclasses ||= [self]
       @known_subclasses << subclass unless @known_subclasses.include? subclass
       self.superclass.remember_subclass(subclass) if self.superclass.respond_to? :remember_subclass
     end
-    
+
     # Return the list of all known subclasses of this class, if necessary checking the database for
     # classes which have not yet been loaded.
     def known_subclasses(table = table_name, type_column = inheritance_column)
       load_all_subclasses_found_in_database(table, type_column)
       @known_subclasses ||= [self]
     end
-    
+
   private
     # Query the database for all qualified class names found in the +type_column+ column
     # (called +type+ by default), and check that classes of that name have been loaded by the Ruby
@@ -190,4 +215,4 @@ module Invoicing
       end
     end
   end
-end
+end

data/lib/invoicing/ledger_item.rb

@@ -1,3 +1,7 @@
+require "active_support/concern"
+require "invoicing/ledger_item/render_html"
+require "invoicing/ledger_item/render_ubl"
+
 module Invoicing
   # = Ledger item objects
   #
@@ -285,7 +289,8 @@ module Invoicing
   #                            included though). If you're chaining scopes it would be advantageous
   #                            to put this one close to the beginning of your scope chain.
   module LedgerItem
-    
+    extend ActiveSupport::Concern
+
     module ActMethods
       # Declares that the current class is a model for ledger items (i.e. invoices, credit notes and
       # payment notes).
@@ -302,98 +307,33 @@ module Invoicing
       #   acts_as_ledger_item :total_amount => :gross_amount
       def acts_as_ledger_item(*args)
         Invoicing::ClassInfo.acts_as(Invoicing::LedgerItem, self, args)
-        
+
         info = ledger_item_class_info
         return unless info.previous_info.nil? # Called for the first time?
-        
-        before_validation :calculate_total_amount
-        
+
         # Set the 'amount' columns to act as currency values
         acts_as_currency_value(info.method(:total_amount), info.method(:tax_amount),
           :currency => info.method(:currency), :value_for_formatting => :value_for_formatting)
-        
-        extend Invoicing::FindSubclasses
+
+        extend  Invoicing::FindSubclasses
         include Invoicing::LedgerItem::RenderHTML
         include Invoicing::LedgerItem::RenderUBL
-        
-        # Dynamically created named scopes
-        named_scope :sent_by, lambda{ |sender_id|
-          { :conditions => {info.method(:sender_id) => sender_id} }
-        }
-        
-        named_scope :received_by, lambda{ |recipient_id|
-          { :conditions => {info.method(:recipient_id) => recipient_id} }
-        }
-        
-        named_scope :sent_or_received_by, lambda{ |sender_or_recipient_id|
-          sender_col = connection.quote_column_name(info.method(:sender_id))
-          recipient_col = connection.quote_column_name(info.method(:recipient_id))
-          { :conditions => ["#{sender_col} = ? OR #{recipient_col} = ?",
-                            sender_or_recipient_id, sender_or_recipient_id] }
-        }
-        
-        named_scope :in_effect, :conditions => {info.method(:status) => ['closed', 'cleared']}
-        
-        named_scope :open_or_pending, :conditions => {info.method(:status) => ['open', 'pending']}
-        
-        named_scope :due_at, lambda{ |date|
-          due_date = connection.quote_column_name(info.method(:due_date))
-          {:conditions => ["#{due_date} <= ? OR #{due_date} IS NULL", date]}
-        }
-        
-        named_scope :sorted, lambda{|column|
-          column = ledger_item_class_info.method(column).to_s
-          if column_names.include?(column)
-            {:order => "#{connection.quote_column_name(column)}, #{connection.quote_column_name(primary_key)}"}
-          else
-            {:order => connection.quote_column_name(primary_key)}
-          end
-        }
-        
-        named_scope :exclude_empty_invoices, lambda{
-          line_items_assoc_id = info.method(:line_items).to_sym
-          line_items_refl = reflections[line_items_assoc_id]
-          line_items_table = line_items_refl.quoted_table_name
-          
-          # e.g. `ledger_items`.`id`
-          ledger_items_id = quoted_table_name + "." + connection.quote_column_name(primary_key)
-          
-          # e.g. `line_items`.`id`
-          line_items_id = line_items_table + "." +
-            connection.quote_column_name(line_items_refl.klass.primary_key)
-          
-          # e.g. `line_items`.`ledger_item_id`
-          ledger_item_foreign_key = line_items_table + "." + connection.quote_column_name(
-            line_items_refl.klass.send(:line_item_class_info).method(:ledger_item_id))
-          
-          payment_classes = select_matching_subclasses(:is_payment, true).map{|c| c.name}
-          is_payment_class = merge_conditions({info.method(:type) => payment_classes})
-          
-          subquery = construct_finder_sql(
-            :select => "#{quoted_table_name}.*, COUNT(#{line_items_id}) AS number_of_line_items",
-            :joins => "LEFT JOIN #{line_items_table} ON #{ledger_item_foreign_key} = #{ledger_items_id}",
-            :group => Invoicing::ConnectionAdapterExt.group_by_all_columns(self)
-          )
-            
-          {:from => "(#{subquery}) AS #{quoted_table_name}",
-           :conditions => "number_of_line_items > 0 OR #{is_payment_class}"}
-        }
       end # def acts_as_ledger_item
-      
+
       # Synonym for <tt>acts_as_ledger_item :subtype => :invoice</tt>. All options other than
       # <tt>:subtype</tt> are passed on to +acts_as_ledger_item+. You should apply
       # +acts_as_invoice+ only to a model which is a subclass of an +acts_as_ledger_item+ type.
       def acts_as_invoice(options={})
         acts_as_ledger_item(options.clone.update({:subtype => :invoice}))
       end
-      
+
       # Synonym for <tt>acts_as_ledger_item :subtype => :credit_note</tt>. All options other than
       # <tt>:subtype</tt> are passed on to +acts_as_ledger_item+. You should apply
       # +acts_as_credit_note+ only to a model which is a subclass of an +acts_as_ledger_item+ type.
       def acts_as_credit_note(options={})
         acts_as_ledger_item(options.clone.update({:subtype => :credit_note}))
       end
-      
+
       # Synonym for <tt>acts_as_ledger_item :subtype => :payment</tt>. All options other than
       # <tt>:subtype</tt> are passed on to +acts_as_ledger_item+. You should apply
       # +acts_as_payment+ only to a model which is a subclass of an +acts_as_ledger_item+ type.
@@ -401,7 +341,73 @@ module Invoicing
         acts_as_ledger_item(options.clone.update({:subtype => :payment}))
       end
     end # module ActMethods
-    
+
+    included do
+      before_validation :calculate_total_amount
+
+      # Dynamically created named scopes
+      scope :sent_by, lambda { |sender_id|
+        where(ledger_item_class_info.method(:sender_id) => sender_id)
+      }
+
+      scope :received_by, lambda {|recipient_id|
+        where(ledger_item_class_info.method(:recipient_id) => recipient_id)
+      }
+
+      scope :sent_or_received_by, lambda { |sender_or_recipient_id|
+        sender_col = connection.quote_column_name(ledger_item_class_info.method(:sender_id))
+        recipient_col = connection.quote_column_name(ledger_item_class_info.method(:recipient_id))
+
+        where(["#{sender_col} = ? OR #{recipient_col} = ?",
+                sender_or_recipient_id, sender_or_recipient_id])
+        }
+
+      scope :in_effect, lambda {
+        where(ledger_item_class_info.method(:status) => ['closed', 'cleared'])
+      }
+
+      scope :open_or_pending, lambda {
+        where(ledger_item_class_info.method(:status) => ['open', 'pending'])
+      }
+
+      scope :due_at, lambda { |date|
+        due_date = connection.quote_column_name(ledger_item_class_info.method(:due_date))
+        where(["#{due_date} <= ? OR #{due_date} IS NULL", date])
+      }
+
+      scope :sorted, lambda { |column|
+        column = ledger_item_class_info.method(column).to_s
+        if column_names.include?(column)
+          order("#{connection.quote_column_name(column)}, #{connection.quote_column_name(primary_key)}")
+        else
+          order(connection.quote_column_name(primary_key))
+        end
+      }
+
+      scope :exclude_empty_invoices, lambda {
+        line_items_assoc_id = ledger_item_class_info.method(:line_items).to_sym
+        line_items_refl = reflections[line_items_assoc_id]
+        line_items_table = line_items_refl.quoted_table_name
+
+        # e.g. `ledger_items`.`id`
+        ledger_items_id = quoted_table_name + "." + connection.quote_column_name(primary_key)
+
+        # e.g. `line_items`.`id`
+        line_items_id = line_items_table + "." +
+          connection.quote_column_name(line_items_refl.klass.primary_key)
+
+        # e.g. `line_items`.`ledger_item_id`
+        ledger_item_foreign_key = line_items_table + "." + connection.quote_column_name(
+                                                                                        line_items_refl.klass.send(:line_item_class_info).method(:ledger_item_id))
+
+        payment_classes = select_matching_subclasses(:is_payment, true).map{|c| c.name}
+        is_payment_class = merge_conditions({ledger_item_class_info.method(:type) => payment_classes})
+
+        joins("LEFT JOIN #{line_items_table} ON #{ledger_item_foreign_key} = #{ledger_items_id}").
+        where("(#{ledger_item_foreign_key} IS NULL) OR #{is_payment_class}")
+      }
+    end
+
     # Overrides the default constructor of <tt>ActiveRecord::Base</tt> when +acts_as_ledger_item+
     # is called. If the +uuid+ gem is installed, this constructor creates a new UUID and assigns
     # it to the +uuid+ property when a new ledger item model object is created.
@@ -413,7 +419,7 @@ module Invoicing
         write_attribute(info.method(:uuid), info.uuid_generator.generate)
       end
     end
-    
+
     # Calculate sum of net_amount and tax_amount across all line items, and assign it to total_amount;
     # calculate sum of tax_amount across all line items, and assign it to tax_amount.
     # Called automatically as a +before_validation+ callback. If the LedgerItem subtype is +payment+
@@ -423,25 +429,26 @@ module Invoicing
       return if self.class.is_payment && line_items.empty?
 
       net_total = tax_total = BigDecimal('0')
-      
+
       line_items.each do |line|
         info = line.send(:line_item_class_info)
-        
+
         # Make sure ledger_item association is assigned -- the CurrencyValue
         # getters depend on it to fetch the currency
         info.set(line, :ledger_item, self)
         line.valid? # Ensure any before_validation hooks are called
-        
+
         net_amount = info.get(line, :net_amount)
         tax_amount = info.get(line, :tax_amount)
         net_total += net_amount unless net_amount.nil?
         tax_total += tax_amount unless tax_amount.nil?
       end
-      
+
       ledger_item_class_info.set(self, :total_amount, net_total + tax_total)
       ledger_item_class_info.set(self, :tax_amount,   tax_total)
+      return net_total
     end
-    
+
     # We don't actually implement anything using +method_missing+ at the moment, but use it to
     # generate slightly more useful error messages in certain cases.
     def method_missing(method_id, *args)
@@ -461,13 +468,13 @@ module Invoicing
       tax_amount   = ledger_item_class_info.get(self, :tax_amount)
       (total_amount && tax_amount) ? (total_amount - tax_amount) : nil
     end
-    
+
     # +net_amount+ formatted in human-readable form using the ledger item's currency.
     def net_amount_formatted
       format_currency_value(net_amount)
     end
-    
-    
+
+
     # You must overwrite this method in subclasses of +Invoice+, +CreditNote+ and +Payment+ so that it returns
     # details of the party sending the document. See +sender_id+ above for a detailed interpretation of
     # sender and receiver.
@@ -501,28 +508,28 @@ module Invoicing
     def sender_details
       raise 'overwrite this method'
     end
-    
+
     # You must overwrite this method in subclasses of +Invoice+, +CreditNote+ and +Payment+ so that it returns
     # details of the party receiving the document. See +recipient_id+ above for a detailed interpretation of
     # sender and receiver. See +sender_details+ for a list of fields to return in the hash.
     def recipient_details
       raise 'overwrite this method'
     end
-    
+
     # Returns +true+ if this document was sent by the user with ID +user_id+. If the argument is +nil+
     # (indicating yourself), this also returns +true+ if <tt>sender_details[:is_self]</tt>.
     def sent_by?(user_id)
       (ledger_item_class_info.get(self, :sender_id) == user_id) ||
         !!(user_id.nil? && ledger_item_class_info.get(self, :sender_details)[:is_self])
     end
-    
+
     # Returns +true+ if this document was received by the user with ID +user_id+. If the argument is +nil+
     # (indicating yourself), this also returns +true+ if <tt>recipient_details[:is_self]</tt>.
     def received_by?(user_id)
       (ledger_item_class_info.get(self, :recipient_id) == user_id) ||
         !!(user_id.nil? && ledger_item_class_info.get(self, :recipient_details)[:is_self])
     end
-    
+
     # Returns a boolean which specifies whether this transaction should be recorded as a debit (+true+)
     # or a credit (+false+) on a particular ledger. Unless you know what you are doing, you probably
     # do not need to touch this method.
@@ -560,8 +567,8 @@ module Invoicing
       value = -value if (options[:credit] == :negative) && !debit?(options[:self_id])
       value
     end
-    
-    
+
+
     module ClassMethods
       # Returns +true+ if this type of ledger item should be recorded as a debit when the party
       # viewing the account is the sender of the document, and recorded as a credit when
@@ -578,22 +585,22 @@ module Invoicing
           else nil
         end
       end
-      
+
       # Returns +true+ if this type of ledger item is a +invoice+ subtype, and +false+ otherwise.
       def is_invoice
         ledger_item_class_info.subtype == :invoice
       end
-      
+
       # Returns +true+ if this type of ledger item is a +credit_note+ subtype, and +false+ otherwise.
       def is_credit_note
         ledger_item_class_info.subtype == :credit_note
       end
-      
+
       # Returns +true+ if this type of ledger item is a +payment+ subtype, and +false+ otherwise.
       def is_payment
         ledger_item_class_info.subtype == :payment
       end
-      
+
       # Returns a summary of the customer or supplier account between two parties identified
       # by +self_id+ (the party from whose perspective the account is seen, 'you') and +other_id+
       # ('them', your supplier/customer). The return value is a hash with ISO 4217 currency codes
@@ -627,7 +634,7 @@ module Invoicing
         info = ledger_item_class_info
         self_id = self_id.to_i
         other_id = [nil, ''].include?(other_id) ? nil : other_id.to_i
-        
+
         if other_id.nil?
           result = {}
           # Sum over all others, grouped by currency
@@ -641,16 +648,13 @@ module Invoicing
             end
           end
           result
-          
         else
           conditions = {info.method(:sender_id)    => [self_id, other_id],
                         info.method(:recipient_id) => [self_id, other_id]}
-          with_scope(:find => {:conditions => conditions}) do
-            account_summaries(self_id, options)[other_id] || {}
-          end
+          where(conditions).account_summaries(self_id, options)[other_id] || {}
         end
       end
-    
+
       # Returns a summary account status for all customers or suppliers with which a particular party
       # has dealings. Takes into account all +closed+ invoices/credit notes and all +cleared+ payments
       # which have +self_id+ as their +sender_id+ or +recipient_id+. Returns a hash whose keys are the
@@ -678,44 +682,38 @@ module Invoicing
       def account_summaries(self_id, options={})
         info = ledger_item_class_info
         ext = Invoicing::ConnectionAdapterExt
-        scope = scope(:find)
-        
+
         debit_classes  = select_matching_subclasses(:debit_when_sent_by_self, true,  self.table_name, self.inheritance_column).map{|c| c.name}
         credit_classes = select_matching_subclasses(:debit_when_sent_by_self, false, self.table_name, self.inheritance_column).map{|c| c.name}
-        debit_when_sent      = merge_conditions({info.method(:sender_id)    => self_id, info.method(:type) => debit_classes})
-        debit_when_received  = merge_conditions({info.method(:recipient_id) => self_id, info.method(:type) => credit_classes})
-        credit_when_sent     = merge_conditions({info.method(:sender_id)    => self_id, info.method(:type) => credit_classes})
-        credit_when_received = merge_conditions({info.method(:recipient_id) => self_id, info.method(:type) => debit_classes})
+
+        # rails 3 idiocricies. in case of STI, type of base class is nil. Need special handling
+        debit_when_sent      = merge_conditions(inheritance_condition(debit_classes),  info.method(:sender_id)    => self_id)
+        debit_when_received  = merge_conditions(inheritance_condition(credit_classes), info.method(:recipient_id) => self_id)
+        credit_when_sent     = merge_conditions(inheritance_condition(credit_classes), info.method(:sender_id)    => self_id)
+        credit_when_received = merge_conditions(inheritance_condition(debit_classes),  info.method(:recipient_id) => self_id)
 
         cols = {}
         [:total_amount, :sender_id, :recipient_id, :status, :currency].each do |col|
           cols[col] = connection.quote_column_name(info.method(col))
         end
-        
+
         sender_is_self    = merge_conditions({info.method(:sender_id)    => self_id})
         recipient_is_self = merge_conditions({info.method(:recipient_id) => self_id})
         other_id_column = ext.conditional_function(sender_is_self, cols[:recipient_id], cols[:sender_id])
-        accept_status = sanitize_sql_hash_for_conditions(info.method(:status) => (options[:with_status] || %w(closed cleared)))
+        accept_status = merge_conditions(info.method(:status) => (options[:with_status] || %w(closed cleared)))
         filter_conditions = "#{accept_status} AND (#{sender_is_self} OR #{recipient_is_self})"
 
-        sql = "SELECT #{other_id_column} AS other_id, #{cols[:currency]} AS currency, " + 
+        sql = select("#{other_id_column} AS other_id, #{cols[:currency]} AS currency, " +
           "SUM(#{ext.conditional_function(debit_when_sent,      cols[:total_amount], 0)}) AS sales, " +
           "SUM(#{ext.conditional_function(debit_when_received,  cols[:total_amount], 0)}) AS purchase_payments, " +
           "SUM(#{ext.conditional_function(credit_when_sent,     cols[:total_amount], 0)}) AS sale_receipts, " +
-          "SUM(#{ext.conditional_function(credit_when_received, cols[:total_amount], 0)}) AS purchases " +
-          "FROM #{(scope && scope[:from]) || quoted_table_name} "
-        
-        # Structure borrowed from ActiveRecord::Base.construct_finder_sql
-        add_joins!(sql, nil, scope)
-        add_conditions!(sql, filter_conditions, scope)
-        
-        sql << " GROUP BY other_id, currency"
-
-        add_order!(sql, nil, scope)
-        add_limit!(sql, {}, scope)
-        add_lock!(sql, {}, scope)
-        
-        rows = connection.select_all(sql)
+          "SUM(#{ext.conditional_function(credit_when_received, cols[:total_amount], 0)}) AS purchases ")
+
+        sql = sql.where(filter_conditions)
+        sql = sql.group("other_id, currency")
+
+        # add order, limit, and lock from outside
+        rows = connection.execute(sql.to_sql).to_a
 
         results = {}
         rows.each do |row|
@@ -723,16 +721,16 @@ module Invoicing
           other_id = row[:other_id].to_i
           currency = row[:currency].to_sym
           summary = {:balance => BigDecimal('0'), :currency => currency}
-          
+
           {:sales => 1, :purchases => -1, :sale_receipts => -1, :purchase_payments => 1}.each_pair do |field, factor|
-            summary[field] = BigDecimal(row[field])
+            summary[field] = BigDecimal(row[field].to_s)
             summary[:balance] += BigDecimal(factor.to_s) * summary[field]
           end
-          
+
           results[other_id] ||= {}
           results[other_id][currency] = AccountSummary.new summary
         end
-        
+
         results
       end
 
@@ -750,7 +748,7 @@ module Invoicing
         sender_recipient_to_ledger_item_ids = {}
         result_map = {}
         info = ledger_item_class_info
-        
+
         # Find the most recent occurrence of each ID, first in the sender_id column, then in recipient_id
         [:sender_id, :recipient_id].each do |column|
           column = info.method(column)
@@ -758,19 +756,19 @@ module Invoicing
           sql = "SELECT MAX(#{primary_key}) AS id, #{quoted_column} AS ref FROM #{quoted_table_name} WHERE "
           sql << merge_conditions({column => sender_recipient_ids})
           sql << " GROUP BY #{quoted_column}"
-          
+
           ActiveRecord::Base.connection.select_all(sql).each do |row|
             sender_recipient_to_ledger_item_ids[row['ref'].to_i] = row['id'].to_i
           end
-          
+
           sender_recipient_ids -= sender_recipient_to_ledger_item_ids.keys
         end
-        
+
         # Load all the ledger items needed to get one representative of each name
         find(sender_recipient_to_ledger_item_ids.values.uniq).each do |ledger_item|
           sender_id = info.get(ledger_item, :sender_id)
           recipient_id = info.get(ledger_item, :recipient_id)
-          
+
           if sender_recipient_to_ledger_item_ids.include? sender_id
             details = info.get(ledger_item, :sender_details)
             result_map[sender_id] = details[:name]
@@ -780,25 +778,48 @@ module Invoicing
             result_map[recipient_id] = details[:name]
           end
         end
-        
+
         result_map
       end
-      
+
+      def inheritance_condition(classes)
+        segments = []
+        segments << sanitize_sql(inheritance_column => classes)
+
+        if classes.include?(self.to_s) && self.new.send(inheritance_column).nil?
+          segments << sanitize_sql(type: nil)
+        end
+
+        "(#{segments.join(') OR (')})" unless segments.empty?
+      end
+
+      def merge_conditions(*conditions)
+        segments = []
+
+        conditions.each do |condition|
+          unless condition.blank?
+            sql = sanitize_sql(condition)
+            segments << sql unless sql.blank?
+          end
+        end
+
+        "(#{segments.join(') AND (')})" unless segments.empty?
+      end
     end # module ClassMethods
-    
-    
+
+
     # Very simple class for representing the sum of all sales, purchases and payments on
     # an account.
     class AccountSummary #:nodoc:
       NUM_FIELDS = [:sales, :purchases, :sale_receipts, :purchase_payments, :balance]
       attr_reader *([:currency] + NUM_FIELDS)
-            
+
       def initialize(hash)
         @currency = hash[:currency]; @sales = hash[:sales]; @purchases = hash[:purchases]
         @sale_receipts = hash[:sale_receipts]; @purchase_payments = hash[:purchase_payments]
         @balance = hash[:balance]
       end
-      
+
       def method_missing(name, *args)
         if name.to_s =~ /(.*)_formatted$/
           ::Invoicing::CurrencyValue::Formatter.format_value(currency, send($1))
@@ -806,13 +827,13 @@ module Invoicing
           super
         end
       end
-      
+
       def +(other)
         hash = {:currency => currency}
         NUM_FIELDS.each {|field| hash[field] = send(field) + other.send(field) }
         AccountSummary.new hash
       end
-      
+
       def to_s
         NUM_FIELDS.map do |field|
           val = send("#{field}_formatted")
@@ -820,24 +841,24 @@ module Invoicing
         end.join('; ')
       end
     end
-    
-    
+
+
     # Stores state in the ActiveRecord class object
     class ClassInfo < Invoicing::ClassInfo::Base #:nodoc:
       attr_reader :subtype, :uuid_generator
-      
+
       def initialize(model_class, previous_info, args)
         super
         @subtype = all_options[:subtype]
-        
+
         begin # try to load the UUID gem
           require 'uuid'
           @uuid_generator = UUID.new
-        rescue LoadError, NameError # silently ignore if gem not found          
+        rescue LoadError, NameError # silently ignore if gem not found
           @uuid_generator = nil
         end
       end
-      
+
       # Allow methods generated by +CurrencyValue+ to be renamed as well
       def method(name)
         if name.to_s =~ /^(.*)_formatted$/