ooor 1.9.2 → 2.0.0

data/lib/{app → ooor}/helpers/core_helpers.rb

@@ -91,7 +91,7 @@ Ooor.xtend('ir.module.module') do
     rescue
     end
     classes.reject! {|m| m.openerp_model == "res.company"} if classes.size > 10
-    Ooor::UML.print_uml(classes, {:file_name => "#{name}_uml"})
+    OoorDoc::UML.print_uml(classes, {:file_name => "#{name}_uml"})
   end
 
   def print_dependency_graph
@@ -131,7 +131,7 @@ end
 Ooor.xtend('ir.ui.menu') do
   def menu_action
     #TODO put in cache eventually:
-    action_values = self.class.ooor.const_get('ir.values').rpc_execute('get', 'action', 'tree_but_open', [['ir.ui.menu', id]], false, self.class.ooor.global_context)[0][2]#get already exists
+    action_values = self.class.ooor.const_get('ir.values').rpc_execute('get', 'action', 'tree_but_open', [['ir.ui.menu', id]], false, self.class.ooor.web_session)[0][2]#get already exists
     @menu_action = self.class.ooor.const_get('ir.actions.act_window').new(action_values, []) #TODO deal with action reference instead
   end
 end

data/lib/ooor/locale.rb

@@ -0,0 +1,13 @@
+module Ooor
+  module Locale
+    # OpenERP requirs a locale+zone mapping while Rails uses locale only, so mapping is likely to be required
+    def self.to_erp_locale(locale)
+      if Ooor.default_config[:locale_mapping]
+        mapping = Ooor.default_config[:locale_mapping]
+      else
+        mapping = {'fr' => 'fr_FR', 'en' => 'en_US'}
+      end
+      (mapping[locale.to_s] || locale.to_s).gsub('-', '_')
+    end
+  end
+end

data/lib/ooor/mini_active_resource.rb

@@ -0,0 +1,94 @@
+require 'active_support'
+require 'active_support/core_ext/class/attribute_accessors'
+require 'active_model'
+
+module Ooor
+  class MiniActiveResource
+
+    class << self
+      def element_name
+        @element_name ||= model_name.element
+      end
+
+      private
+        # split an option hash into two hashes, one containing the prefix options,
+        # and the other containing the leftovers.
+        def split_options(options = {})
+          prefix_options, query_options = {}, {}
+
+          (options || {}).each do |key, value|
+            next if key.blank? || !key.respond_to?(:to_sym)
+            query_options[key.to_sym] = value
+          end
+
+          [ prefix_options, query_options ]
+        end
+    end
+
+    attr_accessor :attributes, :id
+
+    def to_json(options={})
+      super(include_root_in_json ? { :root => self.class.element_name }.merge(options) : options)
+    end
+
+    def to_xml(options={})
+      super({ :root => self.class.element_name }.merge(options))
+    end
+
+    def new?
+      !@persisted
+    end
+    alias :new_record? :new?
+
+    def persisted?
+      @persisted
+    end
+
+    def id
+      attributes["id"]
+    end
+
+    # Sets the <tt>\id</tt> attribute of the resource.
+    def id=(id)
+      attributes["id"] = id
+    end
+
+    def reload
+      self.class.find(id)
+    end
+
+    # Returns the Errors object that holds all information about attribute error messages.
+    def errors
+      @errors ||= ActiveModel::Errors.new(self)
+    end
+
+    private
+
+      def split_options(options = {})
+        self.class.__send__(:split_options, options)
+      end
+
+      def method_missing(method_symbol, *arguments) #:nodoc:
+        method_name = method_symbol.to_s
+
+        if method_name =~ /(=|\?)$/
+          case $1
+          when "="
+            attributes[$`] = arguments.first
+          when "?"
+            attributes[$`]
+          end
+        else
+          return attributes[method_name] if attributes.include?(method_name)
+          # not set right now but we know about it
+          return nil if known_attributes.include?(method_name)
+          super
+        end
+      end
+
+    include ActiveModel::Conversion
+    include ActiveModel::Serializers::JSON
+    include ActiveModel::Serializers::Xml
+
+  end
+end

data/lib/ooor/model_registry.rb

@@ -0,0 +1,19 @@
+module Ooor
+  class ModelRegistry
+    
+    def cache_key(config, model_name)
+      h = config.slice(:url, :database, :username, :scope_prefix) #sure we want username?
+      (h.map{|k, v| v} + [model_name]).join('-')
+    end
+
+    def get_template(config, model_name)
+      Ooor.cache.read(cache_key(config, model_name))
+    end
+    
+    def set_template(config, model)
+      key = cache_key(config, model.openerp_model)
+      Ooor.cache.write(key, model)
+    end
+
+  end
+end

data/lib/ooor/naming.rb

@@ -0,0 +1,73 @@
+require 'active_support/concern'
+
+module Ooor
+  module Naming
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def model_name
+        @_model_name ||= begin
+          namespace = self.parents.detect do |n|
+            n.respond_to?(:use_relative_model_naming?) && n.use_relative_model_naming?
+          end
+          ActiveModel::Name.new(self, namespace, self.description).tap do |r|
+            def r.param_key
+              @klass.openerp_model.gsub('.', '_')
+            end
+          end
+        end
+      end
+
+      def param_key(context={})
+        self.alias(context).gsub('.', '-') # we don't use model_name because model_name isn't bijective
+      end
+
+      #similar to Object#const_get but for OpenERP model key
+      def const_get(model_key)
+        scope = self.scope_prefix ? Object.const_get(self.scope_prefix) : Object
+        klass_name = connection.class_name_from_model_key(model_key)
+        if scope.const_defined?(klass_name) && Ooor.session_handler.connection_spec(scope.const_get(klass_name).connection.config) == Ooor.session_handler.connection_spec(connection.config)
+          scope.const_get(klass_name)
+        else
+          connection.define_openerp_model(model: model_key, scope_prefix: self.scope_prefix)
+        end
+      end
+
+      #required by form validators; TODO implement better?
+      def human_attribute_name(field_name, options={})
+        ""
+      end
+
+      def param_field
+        connection.config[:param_keys] && connection.config[:param_keys][openerp_model] || :id
+      end
+
+      def find_by_permalink(param, options={})
+        # NOTE in v8, see if we can use PageConverter here https://github.com/akretion/openerp-addons/blob/trunk-website-al/website/models/ir_http.py#L138
+        param = param.to_i unless param.to_i == 0
+        options.merge!(domain: {param_field => param})
+        find(:first, options)
+      end
+
+      def alias(context={})
+        # NOTE in v8, see if we can use ModelConvert here https://github.com/akretion/openerp-addons/blob/trunk-website-al/website/models/ir_http.py#L126
+        if connection.config[:aliases]
+          lang = context['lang'] || connection.config[:aliases][connection.config['lang'] || 'en_US']
+          if alias_data = connection.config[:aliases][lang]
+            alias_data.select{|key, value| value == openerp_model }.keys[0] || openerp_model
+          else
+            openerp_model
+          end
+        else
+          openerp_model
+        end
+      end
+    end
+
+    def to_param
+      field = self.class.param_field
+      send(field) && send(field).to_s
+    end
+
+  end
+end

data/lib/ooor/rack.rb

@@ -0,0 +1,114 @@
+require 'active_support/concern'
+
+module Ooor
+  class Rack
+
+    DEFAULT_OOOR_SESSION_CONFIG_MAPPER = Proc.new do |env|
+      Ooor.logger.debug "\n\nWARNING: using DEFAULT_OOOR_SESSION_CONFIG_MAPPER, you should probably define your own instead!
+      You can define an Ooor::Rack.ooor_session_config_mapper block that will be evaled
+      in the context of the rack middleware call after user is authenticated using Warden.
+      Use it to map a Warden authentication to the OpenERP authentication you want.\n"""
+      Ooor.default_config
+    end
+
+    module RackBehaviour
+      extend ActiveSupport::Concern
+      module ClassMethods
+        def ooor_session_config_mapper(&block)
+          @ooor_session_config_mapper = block if block
+          @ooor_session_config_mapper || DEFAULT_OOOR_SESSION_CONFIG_MAPPER
+        end
+      end
+
+      def set_ooor!(env)
+        ooor_session = self.get_ooor_session(env)
+        if defined?(I18n) && I18n.locale
+          lang = Ooor::Locale.to_erp_locale(I18n.locale)
+        elsif http_lang = env["HTTP_ACCEPT_LANGUAGE"]
+          lang = http_lang.split(',')[0].gsub('-', '_')
+        else
+          lang = ooor_session.config['lang'] || 'en_US'
+        end
+        context = {'lang' => lang} #TODO also deal with timezone
+        env['ooor'] = {'context' => context, 'ooor_session'=> ooor_session}
+      end
+
+      def get_ooor_session(env)
+        cookies_hash = env['rack.request.cookie_hash'] || ::Rack::Request.new(env).cookies
+        session = Ooor.session_handler.sessions[cookies_hash['ooor_session_id']]
+        session ||= Ooor.session_handler.sessions[cookies_hash['session_id']]
+        unless session # session could have been used by an other worker, try getting it
+          config = Ooor::Rack.ooor_session_config_mapper.call(env)
+          spec = config[:session_sharing] ? cookies_hash['session_id'] : cookies_hash['ooor_session_id']
+          web_session = Ooor.session_handler.get_web_session(spec) if spec # created by some other worker?
+          unless web_session
+            if config[:session_sharing]
+              web_session = {session_id: cookies_hash['session_id']}
+              spec = cookies_hash['session_id']
+            else
+              web_session = {}
+              spec = nil
+            end
+          end
+          session = Ooor.session_handler.retrieve_session(config, spec, web_session)
+        end       
+        session
+      end
+        
+      def set_ooor_session!(env, status, headers, body)
+        case headers["Set-Cookie"]
+        when nil, ''
+          headers["Set-Cookie"] = ""
+        when Array
+          headers["Set-Cookie"] = headers["Set-Cookie"].join("\n")
+        end
+        
+        ooor_session = env['ooor']['ooor_session']
+        if ooor_session.config[:session_sharing]
+          share_openerp_session!(headers, ooor_session)
+        else # NOTE: we don't put that in a Rails session because we want to remain server agnostic
+          headers["Set-Cookie"] = [headers["Set-Cookie"],
+            "ooor_session_id=#{ooor_session.id}; Path=/",
+          ].join("\n")
+        end
+        response = ::Rack::Response.new body, status, headers
+        response.finish
+      end
+        
+      def share_openerp_session!(headers, ooor_session)
+        if ooor_session.config[:username] == 'admin'
+          if ooor_session.config[:force_session_sharing]
+            Ooor.logger.debug "Warning! force_session_sharing mode with admin user, this may be a serious security breach! Are you really in development mode?"
+          else
+            raise "Sharing OpenERP session for admin user is suicidal (use force_session_sharing in dev mode and be paranoiac about it)"
+          end
+        end
+        cookie = ooor_session.web_session[:cookie]
+        headers["Set-Cookie"] = [headers["Set-Cookie"], cookie].join("\n")
+
+        if ooor_session.web_session[:sid] #v7
+          session_id = ooor_session.web_session[:session_id]
+          headers["Set-Cookie"] = [headers["Set-Cookie"],
+            "instance0|session_id=%22#{session_id}%22; Path=/",
+            "last_used_database=#{ooor_session.config[:database]}; Path=/",
+            "session_id=#{session_id}; Path=/",
+          ].join("\n")
+        end
+      end
+
+    end
+
+    include RackBehaviour
+
+    def initialize(app=nil)
+      @app=app
+    end
+
+    def call(env)
+      set_ooor!(env)
+      status, headers, body = @app.call(env)
+      set_ooor_session!(env, status, headers, body)
+    end
+
+  end
+end

data/lib/ooor/railtie.rb

@@ -0,0 +1,41 @@
+require "rails/railtie"
+require "ooor/rack"
+
+module Ooor
+  class Railtie < Rails::Railtie
+    initializer "ooor.middleware" do |app|
+      Ooor.logger = Rails.logger unless $0 != 'irb'
+      Ooor.default_config = load_config(false, Rails.env)
+      Ooor.logger.level = @config[:log_level] if @config[:log_level]
+      Ooor.cache_store = Rails.cache
+      Ooor.default_session = Ooor.session_handler.retrieve_session(Ooor.default_config)
+
+      if Ooor.default_config[:bootstrap]
+        Ooor.default_session.global_login(config.merge(generate_constants: true))
+      end
+      unless Ooor.default_config[:disable_locale_switcher]
+        if defined?(Rack::I18nLocaleSwitcher)
+          app.middleware.use '::Rack::I18nLocaleSwitcher'
+        else
+          puts "Could not load Rack::I18nLocaleSwitcher, if your application is internationalized, make sure to include rack-i18n_locale_switcher in your Gemfile"
+        end
+      end
+      if defined?(Warden::Manager)
+        app.middleware.insert_after Warden::Manager, '::Ooor::Rack'
+      else
+        app.middleware.insert_after ActionDispatch::ParamsParser, '::Ooor::Rack'
+      end
+    end
+
+    def load_config(config_file=nil, env=nil)
+      config_file ||= defined?(Rails.root) && "#{Rails.root}/config/ooor.yml" || 'ooor.yml'
+      @config = HashWithIndifferentAccess.new(YAML.load_file(config_file)[env || 'development'])
+    rescue SystemCallError
+      Ooor.logger.error """failed to load OOOR yaml configuration file.
+         make sure your app has a #{config_file} file correctly set up
+         if not, just copy/paste the default ooor.yml file from the OOOR Gem
+         to #{Rails.root}/config/ooor.yml and customize it properly\n\n"""
+      {}
+    end
+  end
+end

data/lib/ooor/reflection.rb

@@ -0,0 +1,537 @@
+require 'active_support/core_ext/class/attribute'
+require 'active_support/core_ext/object/inclusion'
+
+# NOTE this is a scoped copy of ActiveRecord reflection.rb
+# the few necessary hacks are explicited with a FIXME
+# an addition Ooor specific reflection module completes this one explicitely
+module Ooor
+  # = Active Record Reflection
+  module Reflection # :nodoc:
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :reflections
+      self.reflections = {}
+    end
+
+    # Reflection enables to interrogate Active Record classes and objects
+    # about their associations and aggregations. This information can,
+    # for example, be used in a form builder that takes an Active Record object
+    # and creates input fields for all of the attributes depending on their type
+    # and displays the associations to other objects.
+    #
+    # MacroReflection class has info for AggregateReflection and AssociationReflection
+    # classes.
+    module ClassMethods
+      def create_reflection(macro, name, options, active_record)
+        case macro
+          when :has_many, :belongs_to, :has_one, :has_and_belongs_to_many
+            klass = options[:through] ? ThroughReflection : AssociationReflection
+            reflection = klass.new(macro, name, options, active_record)
+          when :composed_of
+            reflection = AggregateReflection.new(macro, name, options, active_record)
+        end
+
+        self.reflections = self.reflections.merge(name => reflection)
+        reflection
+      end
+
+      # Returns an array of AggregateReflection objects for all the aggregations in the class.
+      def reflect_on_all_aggregations
+        reflections.values.grep(AggregateReflection)
+      end
+
+      # Returns the AggregateReflection object for the named +aggregation+ (use the symbol).
+      #
+      #   Account.reflect_on_aggregation(:balance) # => the balance AggregateReflection
+      #
+      def reflect_on_aggregation(aggregation)
+        reflections[aggregation].is_a?(AggregateReflection) ? reflections[aggregation] : nil
+      end
+
+      # Returns an array of AssociationReflection objects for all the
+      # associations in the class. If you only want to reflect on a certain
+      # association type, pass in the symbol (<tt>:has_many</tt>, <tt>:has_one</tt>,
+      # <tt>:belongs_to</tt>) as the first parameter.
+      #
+      # Example:
+      #
+      #   Account.reflect_on_all_associations             # returns an array of all associations
+      #   Account.reflect_on_all_associations(:has_many)  # returns an array of all has_many associations
+      #
+      def reflect_on_all_associations(macro = nil)
+        association_reflections = reflections.values.grep(AssociationReflection)
+        macro ? association_reflections.select { |reflection| reflection.macro == macro } : association_reflections
+      end
+
+      # Returns the AssociationReflection object for the +association+ (use the symbol).
+      #
+      #   Account.reflect_on_association(:owner)             # returns the owner AssociationReflection
+      #   Invoice.reflect_on_association(:line_items).macro  # returns :has_many
+      #
+      def reflect_on_association(association)
+        reflections[association].is_a?(AssociationReflection) ? reflections[association] : nil
+      end
+
+      # Returns an array of AssociationReflection objects for all associations which have <tt>:autosave</tt> enabled.
+      def reflect_on_all_autosave_associations
+        reflections.values.select { |reflection| reflection.options[:autosave] }
+      end
+    end
+
+
+    # Abstract base class for AggregateReflection and AssociationReflection. Objects of
+    # AggregateReflection and AssociationReflection are returned by the Reflection::ClassMethods.
+    class MacroReflection
+      # Returns the name of the macro.
+      #
+      # <tt>composed_of :balance, :class_name => 'Money'</tt> returns <tt>:balance</tt>
+      # <tt>has_many :clients</tt> returns <tt>:clients</tt>
+      attr_reader :name
+
+      # Returns the macro type.
+      #
+      # <tt>composed_of :balance, :class_name => 'Money'</tt> returns <tt>:composed_of</tt>
+      # <tt>has_many :clients</tt> returns <tt>:has_many</tt>
+      attr_reader :macro
+
+      # Returns the hash of options used for the macro.
+      #
+      # <tt>composed_of :balance, :class_name => 'Money'</tt> returns <tt>{ :class_name => "Money" }</tt>
+      # <tt>has_many :clients</tt> returns +{}+
+      attr_reader :options
+
+      attr_reader :active_record
+
+      attr_reader :plural_name # :nodoc:
+
+      def initialize(macro, name, options, active_record)
+        @macro         = macro
+        @name          = name
+        @options       = options
+        @active_record = active_record
+#        @plural_name   = active_record.pluralize_table_names ? #FIXME hacked for OOOR
+#                            name.to_s.pluralize : name.to_s
+      end
+
+      # Returns the class for the macro.
+      #
+      # <tt>composed_of :balance, :class_name => 'Money'</tt> returns the Money class
+      # <tt>has_many :clients</tt> returns the Client class
+      def klass
+        @klass ||= class_name.constantize
+      end
+
+      # Returns the class name for the macro.
+      #
+      # <tt>composed_of :balance, :class_name => 'Money'</tt> returns <tt>'Money'</tt>
+      # <tt>has_many :clients</tt> returns <tt>'Client'</tt>
+      def class_name
+        @class_name ||= (options[:class_name] || derive_class_name).to_s
+      end
+
+      # Returns +true+ if +self+ and +other_aggregation+ have the same +name+ attribute, +active_record+ attribute,
+      # and +other_aggregation+ has an options hash assigned to it.
+      def ==(other_aggregation)
+        super ||
+          other_aggregation.kind_of?(self.class) &&
+          name == other_aggregation.name &&
+          other_aggregation.options &&
+          active_record == other_aggregation.active_record
+      end
+
+      def sanitized_conditions #:nodoc:
+        @sanitized_conditions ||= klass.send(:sanitize_sql, options[:conditions]) if options[:conditions]
+      end
+
+      private
+        def derive_class_name
+          name.to_s.camelize
+        end
+    end
+
+
+    # Holds all the meta-data about an aggregation as it was specified in the
+    # Active Record class.
+    class AggregateReflection < MacroReflection #:nodoc:
+    end
+
+    # Holds all the meta-data about an association as it was specified in the
+    # Active Record class.
+    class AssociationReflection < MacroReflection #:nodoc:
+      # Returns the target association's class.
+      #
+      #   class Author < ActiveRecord::Base
+      #     has_many :books
+      #   end
+      #
+      #   Author.reflect_on_association(:books).klass
+      #   # => Book
+      #
+      # <b>Note:</b> Do not call +klass.new+ or +klass.create+ to instantiate
+      # a new association object. Use +build_association+ or +create_association+
+      # instead. This allows plugins to hook into association object creation.
+      def klass
+        @klass ||= active_record.send(:compute_type, class_name)
+      end
+
+      def initialize(macro, name, options, active_record)
+        super
+        @collection = macro.in?([:has_many, :has_and_belongs_to_many])
+      end
+
+      # Returns a new, unsaved instance of the associated class. +options+ will
+      # be passed to the class's constructor.
+      def build_association(*options, &block)
+        klass.new(*options, &block)
+      end
+
+      def table_name
+        @table_name ||= klass.table_name
+      end
+
+      def quoted_table_name
+        @quoted_table_name ||= klass.quoted_table_name
+      end
+
+      def foreign_key
+        @foreign_key ||= options[:foreign_key] || derive_foreign_key
+      end
+
+      def foreign_type
+        @foreign_type ||= options[:foreign_type] || "#{name}_type"
+      end
+
+      def type
+        @type ||= options[:as] && "#{options[:as]}_type"
+      end
+
+      def primary_key_column
+        @primary_key_column ||= klass.columns.find { |c| c.name == klass.primary_key }
+      end
+
+      def association_foreign_key
+        @association_foreign_key ||= options[:association_foreign_key] || class_name.foreign_key
+      end
+
+      # klass option is necessary to support loading polymorphic associations
+      def association_primary_key(klass = nil)
+        options[:primary_key] || primary_key(klass || self.klass)
+      end
+
+      def active_record_primary_key
+        @active_record_primary_key ||= options[:primary_key] || primary_key(active_record)
+      end
+
+      def counter_cache_column
+        if options[:counter_cache] == true
+          "#{active_record.name.demodulize.underscore.pluralize}_count"
+        elsif options[:counter_cache]
+          options[:counter_cache].to_s
+        end
+      end
+
+      def columns(tbl_name, log_msg)
+        @columns ||= klass.connection.columns(tbl_name, log_msg)
+      end
+
+      def reset_column_information
+        @columns = nil
+      end
+
+      def check_validity!
+        check_validity_of_inverse!
+      end
+
+      def check_validity_of_inverse!
+        unless options[:polymorphic]
+          if has_inverse? && inverse_of.nil?
+            raise InverseOfAssociationNotFoundError.new(self)
+          end
+        end
+      end
+
+      def through_reflection
+        nil
+      end
+
+      def source_reflection
+        nil
+      end
+
+      # A chain of reflections from this one back to the owner. For more see the explanation in
+      # ThroughReflection.
+      def chain
+        [self]
+      end
+
+      def nested?
+        false
+      end
+
+      # An array of arrays of conditions. Each item in the outside array corresponds to a reflection
+      # in the #chain. The inside arrays are simply conditions (and each condition may itself be
+      # a hash, array, arel predicate, etc...)
+      def conditions
+        [[options[:conditions]].compact]
+      end
+
+      alias :source_macro :macro
+
+      def has_inverse?
+        @options[:inverse_of]
+      end
+
+      def inverse_of
+        if has_inverse?
+          @inverse_of ||= klass.reflect_on_association(options[:inverse_of])
+        end
+      end
+
+      def polymorphic_inverse_of(associated_class)
+        if has_inverse?
+          if inverse_relationship = associated_class.reflect_on_association(options[:inverse_of])
+            inverse_relationship
+          else
+            raise InverseOfAssociationNotFoundError.new(self, associated_class)
+          end
+        end
+      end
+
+      # Returns whether or not this association reflection is for a collection
+      # association. Returns +true+ if the +macro+ is either +has_many+ or
+      # +has_and_belongs_to_many+, +false+ otherwise.
+      def collection?
+        @collection
+      end
+
+      # Returns whether or not the association should be validated as part of
+      # the parent's validation.
+      #
+      # Unless you explicitly disable validation with
+      # <tt>:validate => false</tt>, validation will take place when:
+      #
+      # * you explicitly enable validation; <tt>:validate => true</tt>
+      # * you use autosave; <tt>:autosave => true</tt>
+      # * the association is a +has_many+ association
+      def validate?
+        !options[:validate].nil? ? options[:validate] : (options[:autosave] == true || macro == :has_many)
+      end
+
+      # Returns +true+ if +self+ is a +belongs_to+ reflection.
+      def belongs_to?
+        macro == :belongs_to
+      end
+
+      def association_class
+        case macro
+        when :belongs_to
+          if options[:polymorphic]
+            Associations::BelongsToPolymorphicAssociation
+          else
+            Associations::BelongsToAssociation
+          end
+        when :has_and_belongs_to_many
+          Associations::HasAndBelongsToManyAssociation
+        when :has_many
+          if options[:through]
+            Associations::HasManyThroughAssociation
+          else
+            Associations::HasManyAssociation
+          end
+        when :has_one
+          if options[:through]
+            Associations::HasOneThroughAssociation
+          else
+            Associations::HasOneAssociation
+          end
+        end
+      end
+
+      private
+        def derive_class_name
+          class_name = name.to_s.camelize
+          class_name = class_name.singularize if collection?
+          class_name
+        end
+
+        def derive_foreign_key
+          if belongs_to?
+            "#{name}_id"
+          elsif options[:as]
+            "#{options[:as]}_id"
+          else
+            active_record.name.foreign_key
+          end
+        end
+
+        def primary_key(klass)
+          klass.primary_key || raise(UnknownPrimaryKey.new(klass))
+        end
+    end
+
+    # Holds all the meta-data about a :through association as it was specified
+    # in the Active Record class.
+    class ThroughReflection < AssociationReflection #:nodoc:
+#      delegate :foreign_key, :foreign_type, :association_foreign_key,       #FIXME hacked for OOOR
+#               :active_record_primary_key, :type, :to => :source_reflection
+
+      # Gets the source of the through reflection. It checks both a singularized
+      # and pluralized form for <tt>:belongs_to</tt> or <tt>:has_many</tt>.
+      #
+      #   class Post < ActiveRecord::Base
+      #     has_many :taggings
+      #     has_many :tags, :through => :taggings
+      #   end
+      #
+      def source_reflection
+        @source_reflection ||= source_reflection_names.collect { |name| through_reflection.klass.reflect_on_association(name) }.compact.first
+      end
+
+      # Returns the AssociationReflection object specified in the <tt>:through</tt> option
+      # of a HasManyThrough or HasOneThrough association.
+      #
+      #   class Post < ActiveRecord::Base
+      #     has_many :taggings
+      #     has_many :tags, :through => :taggings
+      #   end
+      #
+      #   tags_reflection = Post.reflect_on_association(:tags)
+      #   taggings_reflection = tags_reflection.through_reflection
+      #
+      def through_reflection
+        @through_reflection ||= active_record.reflect_on_association(options[:through])
+      end
+
+      # Returns an array of reflections which are involved in this association. Each item in the
+      # array corresponds to a table which will be part of the query for this association.
+      #
+      # The chain is built by recursively calling #chain on the source reflection and the through
+      # reflection. The base case for the recursion is a normal association, which just returns
+      # [self] as its #chain.
+      def chain
+        @chain ||= begin
+          chain = source_reflection.chain + through_reflection.chain
+          chain[0] = self # Use self so we don't lose the information from :source_type
+          chain
+        end
+      end
+
+      # Consider the following example:
+      #
+      #   class Person
+      #     has_many :articles
+      #     has_many :comment_tags, :through => :articles
+      #   end
+      #
+      #   class Article
+      #     has_many :comments
+      #     has_many :comment_tags, :through => :comments, :source => :tags
+      #   end
+      #
+      #   class Comment
+      #     has_many :tags
+      #   end
+      #
+      # There may be conditions on Person.comment_tags, Article.comment_tags and/or Comment.tags,
+      # but only Comment.tags will be represented in the #chain. So this method creates an array
+      # of conditions corresponding to the chain. Each item in the #conditions array corresponds
+      # to an item in the #chain, and is itself an array of conditions from an arbitrary number
+      # of relevant reflections, plus any :source_type or polymorphic :as constraints.
+      def conditions
+        @conditions ||= begin
+          conditions = source_reflection.conditions.map { |c| c.dup }
+
+          # Add to it the conditions from this reflection if necessary.
+          conditions.first << options[:conditions] if options[:conditions]
+
+          through_conditions = through_reflection.conditions
+
+          if options[:source_type]
+            through_conditions.first << { foreign_type => options[:source_type] }
+          end
+
+          # Recursively fill out the rest of the array from the through reflection
+          conditions += through_conditions
+
+          # And return
+          conditions
+        end
+      end
+
+      # The macro used by the source association
+      def source_macro
+        source_reflection.source_macro
+      end
+
+      # A through association is nested if there would be more than one join table
+      def nested?
+        chain.length > 2 || through_reflection.macro == :has_and_belongs_to_many
+      end
+
+      # We want to use the klass from this reflection, rather than just delegate straight to
+      # the source_reflection, because the source_reflection may be polymorphic. We still
+      # need to respect the source_reflection's :primary_key option, though.
+      def association_primary_key(klass = nil)
+        # Get the "actual" source reflection if the immediate source reflection has a
+        # source reflection itself
+        source_reflection = self.source_reflection
+        while source_reflection.source_reflection
+          source_reflection = source_reflection.source_reflection
+        end
+
+        source_reflection.options[:primary_key] || primary_key(klass || self.klass)
+      end
+
+      # Gets an array of possible <tt>:through</tt> source reflection names:
+      #
+      #   [:singularized, :pluralized]
+      #
+      def source_reflection_names
+        @source_reflection_names ||= (options[:source] ? [options[:source]] : [name.to_s.singularize, name]).collect { |n| n.to_sym }
+      end
+
+      def source_options
+        source_reflection.options
+      end
+
+      def through_options
+        through_reflection.options
+      end
+
+      def check_validity!
+        if through_reflection.nil?
+          raise HasManyThroughAssociationNotFoundError.new(active_record.name, self)
+        end
+
+        if through_reflection.options[:polymorphic]
+          raise HasManyThroughAssociationPolymorphicThroughError.new(active_record.name, self)
+        end
+
+        if source_reflection.nil?
+          raise HasManyThroughSourceAssociationNotFoundError.new(self)
+        end
+
+        if options[:source_type] && source_reflection.options[:polymorphic].nil?
+          raise HasManyThroughAssociationPointlessSourceTypeError.new(active_record.name, self, source_reflection)
+        end
+
+        if source_reflection.options[:polymorphic] && options[:source_type].nil?
+          raise HasManyThroughAssociationPolymorphicSourceError.new(active_record.name, self, source_reflection)
+        end
+
+        if macro == :has_one && through_reflection.collection?
+          raise HasOneThroughCantAssociateThroughCollection.new(active_record.name, self, through_reflection)
+        end
+
+        check_validity_of_inverse!
+      end
+
+      private
+        def derive_class_name
+          # get the class_name of the belongs_to association of the through reflection
+          options[:source_type] || source_reflection.class_name
+        end
+    end
+  end
+end