invoicing 0.1.0

data/CHANGELOG

@@ -0,0 +1,3 @@
+v0.1.0. Core API is now usable. RCov reports 100% test coverage.
+
+v0.0.1. Initial public release

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Martin Kleppmann
+Copyright (c) 2009 Ept Computing Limited
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/Manifest

@@ -0,0 +1,60 @@
+CHANGELOG
+lib/invoicing/cached_record.rb
+lib/invoicing/class_info.rb
+lib/invoicing/connection_adapter_ext.rb
+lib/invoicing/countries/uk.rb
+lib/invoicing/currency_value.rb
+lib/invoicing/find_subclasses.rb
+lib/invoicing/ledger_item/render_html.rb
+lib/invoicing/ledger_item/render_ubl.rb
+lib/invoicing/ledger_item.rb
+lib/invoicing/line_item.rb
+lib/invoicing/price.rb
+lib/invoicing/tax_rate.rb
+lib/invoicing/taxable.rb
+lib/invoicing/time_dependent.rb
+lib/invoicing/version.rb
+lib/invoicing.rb
+LICENSE
+Manifest
+Rakefile
+README
+test/cached_record_test.rb
+test/class_info_test.rb
+test/connection_adapter_ext_test.rb
+test/currency_value_test.rb
+test/find_subclasses_test.rb
+test/fixtures/cached_record.sql
+test/fixtures/class_info.sql
+test/fixtures/currency_value.sql
+test/fixtures/find_subclasses.sql
+test/fixtures/ledger_item.sql
+test/fixtures/line_item.sql
+test/fixtures/price.sql
+test/fixtures/README
+test/fixtures/tax_rate.sql
+test/fixtures/taxable.sql
+test/fixtures/time_dependent.sql
+test/ledger_item_test.rb
+test/line_item_test.rb
+test/models/README
+test/models/test_subclass_in_another_file.rb
+test/models/test_subclass_not_in_database.rb
+test/price_test.rb
+test/ref-output/creditnote3.html
+test/ref-output/creditnote3.xml
+test/ref-output/invoice1.html
+test/ref-output/invoice1.xml
+test/ref-output/invoice2.html
+test/ref-output/invoice2.xml
+test/ref-output/invoice_null.html
+test/render_html_test.rb
+test/render_ubl_test.rb
+test/setup.rb
+test/tax_rate_test.rb
+test/taxable_test.rb
+test/test_helper.rb
+test/time_dependent_test.rb
+website/curvycorners.js
+website/screen.css
+website/template.html.erb

data/README

@@ -0,0 +1,48 @@
+h1. Ruby invoicing framework
+
+* "Homepage":http://invoicing.rubyforge.org/
+* "API Reference Docs":http://invoicing.rubyforge.org/docs/invoicing/
+* "RubyForge project":http://rubyforge.org/projects/invoicing/
+* Email: Martin Kleppmann <ept@rubyforge.org>
+
+h2. DESCRIPTION
+
+Framework for generating and displaying invoices (ideal for commercial Rails
+apps). Allows for flexible business logic; provides tools for tax handling,
+commission calculation etc. Both developer-friendly and accountant-friendly.
+
+The Ruby invoicing framework provides tools, helpers and a structure for
+applications (particularly web apps) which need to generate invoices for
+customers. It builds on ActiveRecord and is particularly suited for Rails
+applications, but could be used with other frameworks too.
+
+h2. FEATURES
+
+* Dealing with tax rates changing over time
+* Calculating commissions (e.g. in a reseller setting)
+
+h2. SYNOPSIS
+
+<pre syntax="ruby">
+require 'invoicing'
+</pre>
+
+h2. STATUS
+
+So far, the Ruby Invoicing Framework has been tested with ActiveRecord 2.2.2,
+MySQL 5.0.67 and PostgreSQL 8.3.5. We will be testing it across a wider
+variety of versions soon.
+
+h2. CREDITS
+
+The Ruby invoicing framework originated as part of the website Bid for Wine
+(http://www.bidforwine.co.uk), developed by Patrick Dietrich, Conrad Irwin
+and Michael Arnold for Ept Computing Ltd. It was extracted from the Bid for
+Wine codebase and substantially extended by Martin Kleppmann.
+
+h2. LICENSE
+
+Copyright (c) 2009 Martin Kleppmann, Ept Computing Limited.
+
+This gem is made publicly available under the terms of the MIT license.
+See LICENSE and/or COPYING for details.

data/Rakefile

@@ -0,0 +1,75 @@
+require 'rubygems'
+require 'echoe'
+
+# Add the project's top level directory and the lib directory to the Ruby search path
+$: << File.expand_path(File.join(File.dirname(__FILE__), "lib"))
+$: << File.expand_path(File.dirname(__FILE__))
+
+require 'invoicing'
+
+Echoe.new('invoicing', Invoicing::VERSION) do |p|
+  p.summary = 'Ruby invoicing framework'
+  p.description = 'Provides tools for applications which need to generate invoices for customers.'
+  p.url = 'http://invoicing.rubyforge.org/'
+  p.author = 'Martin Kleppmann'
+  p.email = 'rubyforge@eptcomputing.com'
+  p.dependencies = ['activerecord >=2.1.0', 'builder >= 2.0']
+  p.docs_host = 'ept@rubyforge.org:/var/www/gforge-projects/'
+  p.test_pattern = 'test/*_test.rb' # do not include test/models/*.rb
+  p.rcov_options = "-x '/Library/'"
+end
+
+
+desc "Generate a new website from README file"
+task 'website' do
+  require 'rubygems'
+  require 'redcloth'
+  require 'syntax/convertors/html'
+  require 'erb'
+  
+  version  = Invoicing::VERSION
+  download = 'http://rubyforge.org/projects/invoicing'
+  
+  def convert_syntax(syntax, source)
+    return Syntax::Convertors::HTML.for_syntax(syntax).convert(source).gsub(%r!^<pre>|</pre>$!,'')
+  end
+  
+  template = ERB.new(File.open(File.join(File.dirname(__FILE__), '/website/template.html.erb')).read)
+  
+  title = nil
+  body = nil
+  File.open(File.join(File.dirname(__FILE__), '/README')) do |fsrc|
+    title = fsrc.readline.gsub(/^[^ ]* /, '')
+    body_text = fsrc.read
+    syntax_items = []
+    body_text.gsub!(%r!<(pre|code)[^>]*?syntax=['"]([^'"]+)[^>]*>(.*?)</\1>!m){
+      ident = syntax_items.length
+      element, syntax, source = $1, $2, $3
+      syntax_items << "<#{element} class='syntax'>#{convert_syntax(syntax, source)}</#{element}>"
+      "syntax-temp-#{ident}"
+    }
+    body = RedCloth.new(body_text).to_html
+    body.gsub!(%r!(?:<pre><code>)?syntax-temp-(\d+)(?:</code></pre>)?!){ syntax_items[$1.to_i] }
+  end
+  
+  File.open(File.join(File.dirname(__FILE__), '/website/index.html'), 'w') do |fout|
+    fout.write(template.result(binding))
+  end
+end
+
+
+desc "Generate and publish website"
+task :publish_website => :website do
+  require 'net/sftp'
+  upload_user = 'ept'
+  upload_host = 'rubyforge.org'
+  upload_dir = '/var/www/gforge-projects/invoicing'
+  local_dir = File.join(File.dirname(__FILE__), 'website')
+  Net::SFTP.start(upload_host, upload_user) do |sftp|
+    for f in Dir.entries(local_dir)
+      next if f =~ /^\./
+      puts "Uploading #{f} to #{upload_user}@#{upload_host}:#{upload_dir}/#{f}"
+      sftp.upload!(File.join(local_dir, f), "#{upload_dir}/#{f}")
+    end
+  end
+end

data/invoicing.gemspec

@@ -0,0 +1,41 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{invoicing}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Martin Kleppmann"]
+  s.date = %q{2009-02-10}
+  s.description = %q{Provides tools for applications which need to generate invoices for customers.}
+  s.email = %q{rubyforge@eptcomputing.com}
+  s.extra_rdoc_files = ["CHANGELOG", "lib/invoicing/cached_record.rb", "lib/invoicing/class_info.rb", "lib/invoicing/connection_adapter_ext.rb", "lib/invoicing/countries/uk.rb", "lib/invoicing/currency_value.rb", "lib/invoicing/find_subclasses.rb", "lib/invoicing/ledger_item/render_html.rb", "lib/invoicing/ledger_item/render_ubl.rb", "lib/invoicing/ledger_item.rb", "lib/invoicing/line_item.rb", "lib/invoicing/price.rb", "lib/invoicing/tax_rate.rb", "lib/invoicing/taxable.rb", "lib/invoicing/time_dependent.rb", "lib/invoicing/version.rb", "lib/invoicing.rb", "LICENSE", "README"]
+  s.files = ["CHANGELOG", "lib/invoicing/cached_record.rb", "lib/invoicing/class_info.rb", "lib/invoicing/connection_adapter_ext.rb", "lib/invoicing/countries/uk.rb", "lib/invoicing/currency_value.rb", "lib/invoicing/find_subclasses.rb", "lib/invoicing/ledger_item/render_html.rb", "lib/invoicing/ledger_item/render_ubl.rb", "lib/invoicing/ledger_item.rb", "lib/invoicing/line_item.rb", "lib/invoicing/price.rb", "lib/invoicing/tax_rate.rb", "lib/invoicing/taxable.rb", "lib/invoicing/time_dependent.rb", "lib/invoicing/version.rb", "lib/invoicing.rb", "LICENSE", "Manifest", "Rakefile", "README", "test/cached_record_test.rb", "test/class_info_test.rb", "test/connection_adapter_ext_test.rb", "test/currency_value_test.rb", "test/find_subclasses_test.rb", "test/fixtures/cached_record.sql", "test/fixtures/class_info.sql", "test/fixtures/currency_value.sql", "test/fixtures/find_subclasses.sql", "test/fixtures/ledger_item.sql", "test/fixtures/line_item.sql", "test/fixtures/price.sql", "test/fixtures/README", "test/fixtures/tax_rate.sql", "test/fixtures/taxable.sql", "test/fixtures/time_dependent.sql", "test/ledger_item_test.rb", "test/line_item_test.rb", "test/models/README", "test/models/test_subclass_in_another_file.rb", "test/models/test_subclass_not_in_database.rb", "test/price_test.rb", "test/ref-output/creditnote3.html", "test/ref-output/creditnote3.xml", "test/ref-output/invoice1.html", "test/ref-output/invoice1.xml", "test/ref-output/invoice2.html", "test/ref-output/invoice2.xml", "test/ref-output/invoice_null.html", "test/render_html_test.rb", "test/render_ubl_test.rb", "test/setup.rb", "test/tax_rate_test.rb", "test/taxable_test.rb", "test/test_helper.rb", "test/time_dependent_test.rb", "website/curvycorners.js", "website/screen.css", "website/template.html.erb", "invoicing.gemspec"]
+  s.has_rdoc = true
+  s.homepage = %q{http://invoicing.rubyforge.org/}
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Invoicing", "--main", "README"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{invoicing}
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %q{Ruby invoicing framework}
+  s.test_files = ["test/cached_record_test.rb", "test/class_info_test.rb", "test/connection_adapter_ext_test.rb", "test/currency_value_test.rb", "test/find_subclasses_test.rb", "test/ledger_item_test.rb", "test/line_item_test.rb", "test/price_test.rb", "test/render_html_test.rb", "test/render_ubl_test.rb", "test/tax_rate_test.rb", "test/taxable_test.rb", "test/time_dependent_test.rb"]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<activerecord>, [">= 2.1.0"])
+      s.add_runtime_dependency(%q<builder>, [">= 0", "= 2.0"])
+      s.add_development_dependency(%q<echoe>, [">= 0"])
+    else
+      s.add_dependency(%q<activerecord>, [">= 2.1.0"])
+      s.add_dependency(%q<builder>, [">= 0", "= 2.0"])
+      s.add_dependency(%q<echoe>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<activerecord>, [">= 2.1.0"])
+    s.add_dependency(%q<builder>, [">= 0", "= 2.0"])
+    s.add_dependency(%q<echoe>, [">= 0"])
+  end
+end

data/lib/invoicing.rb

@@ -0,0 +1,9 @@
+require 'activerecord'
+
+require 'invoicing/class_info'  # load first because other modules depend on this
+Dir.glob(File.join(File.dirname(__FILE__), 'invoicing/**/*.rb')).sort.each {|f| require f }
+
+# Mix all modules Invoicing::*::ActMethods into ActiveRecord::Base as class methods
+Invoicing.constants.map{|c| Invoicing.const_get(c) }.select{|m| m.is_a?(Module) && m.const_defined?('ActMethods') }.each{
+  |m| ActiveRecord::Base.send(:extend, m.const_get('ActMethods'))
+}

data/lib/invoicing/cached_record.rb

@@ -0,0 +1,107 @@
+module Invoicing
+  # == Aggressive ActiveRecord cache
+  #
+  # This module implements a cache of +ActiveRecord+ objects. It is suitable for database
+  # tables with a small number of rows (no more than a few dozen is recommended) which
+  # change very infrequently. The contents of the table is loaded into memory when the
+  # class is first created; <b>to clear the cache you must call +clear_cache+ or
+  # restart the Ruby interpreter</b>. It is recommended that if you need to change the
+  # data in this table, you do so in a database migration, and apply that migration as
+  # part of a release deployment.
+  #
+  # The cache works as a simple identity map: it has a hash where the key is the primary
+  # key of each model object and the value is the model object itself. +ActiveRecord+
+  # methods are overridden so that if +find+ is called with one or more IDs, the object(s)
+  # are returned from cache; if +find+ is called with more complex conditions, the usual
+  # database mechanisms are used and the cache is ignored. Note that this does not
+  # guarantee that the same ID value will always map to the same model object instance;
+  # it just reduces the number of database queries.
+  #
+  # To activate +CachedRecord+, call +acts_as_cached_record+ in the scope of an
+  # <tt>ActiveRecord::Base</tt> class.
+  module CachedRecord
+
+    module ActMethods
+      # Call +acts_as_cached_record+ on an <tt>ActiveRecord::Base</tt> class to declare
+      # that objects of this class should be cached using +CachedRecord+.
+      #
+      # Accepts options in a hash, all of which are optional:
+      # * +id+ -- If the primary key of this model is not +id+, declare the method name
+      #   of the primary key.
+      def acts_as_cached_record(*args)
+        Invoicing::ClassInfo.acts_as(Invoicing::CachedRecord, self, args)
+      end
+    end
+
+    module ClassMethods
+      # This method overrides the default <tt>ActiveRecord::Base.find_from_ids</tt> (which is called
+      # from <tt>ActiveRecord::Base.find</tt>) with caching behaviour. +find+ is also used by
+      # +ActiveRecord+ when evaluating associations; therefore if another model object refers to
+      # a cached record by its ID, calling the getter of that association should result in a cache hit.
+      #
+      # FIXME: Currently +options+ is ignored -- we should do something more useful with it
+      # to ensure CachedRecord behaviour is fully compatible with +ActiveRecord+.
+      def find_from_ids(ids, options)
+        expects_array = ids.first.kind_of?(Array)
+        return ids.first if expects_array && ids.first.empty?
+
+        ids = ids.flatten.compact.uniq
+
+        case ids.size
+          when 0
+            raise ::ActiveRecord::RecordNotFound, "Couldn't find #{name} without an ID"
+          when 1
+            result = cached_record_class_info.find_one(ids.first, options)
+            expects_array ? [ result ] : result
+          else
+            cached_record_class_info.find_some(ids, options)
+        end
+      end
+
+      # Returns a list of all objects of this class. Like <tt>ActiveRecord::Base.find(:all)</tt>
+      # but coming from the cache.
+      def cached_record_list
+        cached_record_class_info.list
+      end
+      
+      # Reloads the cached objects from the database.
+      def reload_cache
+        cached_record_class_info.reload_cache
+      end
+    end # module ClassMethods
+
+
+    # Stores state in the ActiveRecord class object, including the cache --
+    # a hash which maps ID to model object for all objects of this model object type
+    class ClassInfo < Invoicing::ClassInfo::Base #:nodoc:
+      def initialize(model_class, previous_info, args)
+        super
+        reload_cache
+      end
+      
+      def reload_cache
+        @cache = {}
+        model_class.find(:all).each {|obj| @cache[get(obj, :id)] = obj }
+      end
+  
+      # Returns one object from the cache, given its ID.
+      def find_one(id, options)
+        if result = @cache[id]
+          result
+        else
+          raise ::ActiveRecord::RecordNotFound, "Couldn't find #{model_class.name} with ID=#{id}"
+        end
+      end
+      
+      # Returns a list of objects from the cache, given a list of IDs.
+      def find_some(ids, options)
+        ids.map{|id| find_one(id, options) }
+      end
+      
+      # Returns a list of all objects in the cache.
+      def list
+        @cache.values
+      end
+    end # class ClassInfo
+  end # module CachedRecord
+end

data/lib/invoicing/class_info.rb

@@ -0,0 +1,187 @@
+module Invoicing
+  # This module is intended for use only internally within this framework. It implements
+  # a pattern needed in several other modules: an +acts_as_something_or_other+ method can
+  # be called within the scope of an +ActiveRecord+ class, given a number of arguments;
+  # including options which define how columns are renamed in a given model object.
+  # The information from these arguments needs to be stored in a class variable for later
+  # use in instances of that class. It must be possible to call the +acts_as_+ method
+  # multiple times, combining the arguments from the various calls, to make the whole thing
+  # look nicely declarative. Subclasses should inherit +acts_as_+ arguments from their
+  # superclass, but should be able to override them with their own values.
+  #
+  # This pattern assumes a particular module structure, like the following:
+  #
+  #   module MyNamespace                    # you may use arbitrarily nested modules for namespacing (optional)
+  #     module Teleporter                   # the name of this module defines auto-generated method names
+  #       module ActMethods
+  #         def acts_as_teleporter(*args)   # should be called "acts_as_#{module_name.underscore}"
+  #           Invoicing::ClassInfo.acts_as(MyNamespace::Teleporter, self, args)
+  #         end
+  #       end
+  #       
+  #       def transmogrify_the_instance     # will become an instance method of the class on which the
+  #         info = teleporter_class_info    # acts_as_ method is called.
+  #         info.do_transmogrify
+  #       end
+  #       
+  #       module ClassMethods
+  #         def transmogrify_the_class      # will become a class method of the class on which the
+  #           info = teleporter_class_info  # acts_as_ method is called.
+  #           info.do_transmogrify
+  #         end
+  #       end
+  #       
+  #       class ClassInfo < Invoicing::ClassInfo::Base
+  #         def do_transmogrify
+  #           case all_options[:transmogrification]
+  #             when :total then "Transmogrified by #{all_args.first}"
+  #           end
+  #         end
+  #       end
+  #     end
+  #   end
+  #   
+  #   ActiveRecord::Base.send(:extend, MyNamespace::Teleporter::ActMethods)
+  #
+  #
+  # +ClassInfo+ is used to store and process the arguments passed to the +acts_as_teleporter+ method
+  # when it is called in the scope of an +ActiveRecord+ model class. Finally, the feature defined by
+  # the +Teleporter+ module above can be used like this:
+  #
+  #   class Teleporter < ActiveRecord::Base
+  #     acts_as_teleporter 'Zoom2020', :transmogrification => :total
+  #   end
+  #   
+  #   Teleporter.transmogrify_the_class               # both return "Transmogrified by Zoom2020"
+  #   Teleporter.find(42).transmogrify_the_instance
+  module ClassInfo
+    
+    # Provides the main implementation pattern for an +acts_as_+ method. See the example above
+    # for usage.
+    # +source_module+:: The module object which is using the +ClassInfo+ pattern
+    # +calling_class+:: The class in whose scope the +acts_as_+ method was called
+    # +args+::          The array of arguments (including options hash) to the +acts_as_+ method
+    def self.acts_as(source_module, calling_class, args)
+      # The name by which the particular module using ClassInfo is known
+      module_name = source_module.name.split('::').last.underscore
+      class_info_method = "#{module_name}_class_info"
+      
+      previous_info = if calling_class.private_instance_methods(true).include?(class_info_method)
+        # acts_as has been called before on the same class, or a superclass
+        calling_class.send(class_info_method)
+      else
+        # acts_as is being called for the first time -- do the mixins!
+        calling_class.send(:include, source_module)
+        calling_class.send(:extend,  source_module.const_get('ClassMethods')) if source_module.constants.include? 'ClassMethods'
+        nil # no previous_info
+      end
+      
+      # Instantiate the ClassInfo::Base subclass and assign it to an instance variable in calling_class
+      class_info_class = source_module.const_get('ClassInfo')
+      class_info = class_info_class.new(calling_class, previous_info, args)
+      calling_class.instance_variable_set("@#{class_info_method}", class_info)
+      
+      # Define a getter class method on calling_class through which the ClassInfo::Base
+      # instance can be accessed.
+      calling_class.class_eval <<-CLASSEVAL
+        class << self
+          def #{class_info_method}
+            if superclass.private_instance_methods(true).include?("#{class_info_method}")
+              @#{class_info_method} ||= superclass.send("#{class_info_method}")
+            end
+            @#{class_info_method}
+          end
+          private "#{class_info_method}"
+        end
+      CLASSEVAL
+      
+      # For convenience, also define an instance method which does the same as the class method
+      calling_class.class_eval do
+        define_method class_info_method do
+          self.class.send(class_info_method)
+        end
+        private class_info_method
+      end
+    end
+    
+     
+    # Base class for +ClassInfo+ objects, from which you need to derive a subclass in each module where
+    # you want to use +ClassInfo+. An instance of a <tt>ClassInfo::Base</tt> subclass is created every
+    # time an +acts_as_+ method is called, and that instance can be accessed through the
+    # +my_module_name_class_info+ method on the class which called +acts_as_my_module_name+.
+    class Base
+      # The class on which the +acts_as_+ method was called
+      attr_reader :model_class
+      
+      # The <tt>ClassInfo::Base</tt> instance created by the last +acts_as_+ method
+      # call on the same class (or its superclass); +nil+ if this is the first call.
+      attr_reader :previous_info
+      
+      # The list of arguments passed to the current +acts_as_+ method call (excluding the final options hash)
+      attr_reader :current_args
+      
+      # Union of +current_args+ and <tt>previous_info.all_args</tt>
+      attr_reader :all_args
+      
+      # <tt>self.all_args - previous_info.all_args</tt>
+      attr_reader :new_args
+      
+      # The options hash passed to the current +acts_as_+ method call
+      attr_reader :current_options
+      
+      # Hash of options with symbolized keys, with +option_defaults+ overridden by +previous_info+ options,
+      # in turn overridden by +current_options+.
+      attr_reader :all_options
+      
+      # Initialises a <tt>ClassInfo::Base</tt> instance and parses arguments.
+      # If subclasses override +initialize+ they should call +super+.
+      # +model_class+::   The class on which the +acts_as+ method was called
+      # +previous_info+:: The <tt>ClassInfo::Base</tt> instance created by the last +acts_as_+ method
+      #                   call on the same class (or its superclass); +nil+ if this is the first call.
+      # +args+::          Array of arguments given to the +acts_as_+ method when it was invoked.
+      #
+      # If the last element of +args+ is a hash, it is used as an options array. All other elements
+      # of +args+ are concatenated into an array, +uniq+ed and flattened. (They could be a list of symbols
+      # representing method names, for example.)
+      def initialize(model_class, previous_info, args)
+        @model_class = model_class
+        @previous_info = previous_info
+
+        @current_options = args.extract_options!.symbolize_keys
+        @all_options = (@previous_info.nil? ? option_defaults : @previous_info.all_options).clone
+        @all_options.update(@current_options)
+        
+        @all_args = @new_args = @current_args = args.flatten.uniq
+        unless @previous_info.nil?
+          @all_args = (@previous_info.all_args + @all_args).uniq
+          @new_args = @all_args - previous_info.all_args
+        end
+      end
+      
+      # Override this method to return a hash of default option values.
+      def option_defaults
+        {}
+      end
+    
+      # If there is an option with the given key, returns the associated value; otherwise returns
+      # the key. This is useful for mapping method names to their renamed equivalents through options.
+      def method(name)
+        name = name.to_sym
+        (all_options[name] || name).to_s
+      end
+      
+      # Returns the value returned by calling +method_name+ (renamed through options using +method+)
+      # on +object+. Returns +nil+ if +object+ is +nil+ or +object+ does not respond to that method.
+      def get(object, method_name)
+        meth = method(method_name)
+        (object.nil? || !object.respond_to?(meth)) ? nil : object.send(meth)
+      end
+
+      # Assigns +new_value+ to <tt>method_name=</tt> (renamed through options using +method+)
+      # on +object+. +method_name+ should not include the equals sign.
+      def set(object, method_name, new_value)
+        object.send("#{method(method_name)}=", new_value) unless object.nil?
+      end
+    end
+  end
+end