ooor 2.0.3 → 2.0.4

data/lib/ooor/helpers/core_helpers.rb

@@ -19,9 +19,9 @@ Ooor.xtend('ir.module.module') do
     dependency_modules = []
     modules.select { |m| m.dependencies_id }.each do |mod|
       mod.dependencies_id.each do |dep|
-        dep_module = IrModuleModule.find(:first,
-                                         :domain => [['name', '=', dep.name]],
-                                         :fields => ['id', 'state', 'dependencies_id'])
+        dep_module = self.find(:first,
+                               :domain => [['name', '=', dep.name]],
+                               :fields => ['id', 'state', 'dependencies_id'])
         if dep_module.nil?
           raise RuntimeError, "#{dep.name} not found"
         end
@@ -32,66 +32,13 @@ Ooor.xtend('ir.module.module') do
     dependency_modules.uniq { |m| m.id }
   end
   
-  ##########################################################################
-  # Run the upgrade wizard in order to install the required
-  # modules. Upgrade installed modules as well.
-  # Input :
-  #  - modules : A [] of valid IrModuleModule instance
-  # Return
-  #  - True
-  # Usage Example:
-  # res = IrModuleModule.install_modules(@openerp, modules)
-  def self.install_modules(modules, dependencies=false)
-    res = true
-    if dependencies
-      dependency_modules = get_dependencies(modules)
-      modules.concat(dependency_modules) if dependency_modules
-    end
-    modules_toinstall_ids = []
-    modules_toupgrade_ids = []
-    # If not installed, do it. Otherwise update it
-    modules.each do |m|
-      if m.state == 'uninstalled'
-        m.state = 'to install'
-        m.save
-        modules_toinstall_ids << m.id
-      elsif m.state == 'installed'
-        m.state = 'to upgrade'
-        m.save
-        modules_toupgrade_ids << m.id
-      elsif m.state == 'to install'
-        modules_toinstall_ids << m.id
-      elsif m.state == 'to upgrade'
-        modules_toupgrade_ids << m.id
-      end
-    end
-    #First installed required modules, then upgrade the others
-    upgrade = BaseModuleUpgrade.create()
-    upgrade.upgrade_module()
-    # IrModuleModule.button_install(modules_toinstall_ids)
-    # IrModuleModule.button_upgrade(modules_toupgrade_ids)
-
-    if res
-      return true
-    else
-      raise "!!! --- HELPER ERROR : install_modules was unable to install needed modules.."
-    end
-    openerp.load_models() # reload in order to have model Classes for modules installed
-  end
-  
-  def print_uml
-    l = IrModelData.find(:all, :domain => {:model=>"ir.model", :module=>name})
-    model_names = []
-    l.each {|i| model_names << i.name.gsub('_', '.').gsub(/^model.report/, '').gsub(/^model./, '')}
-    classes = []
-    model_names.each {|i| begin classes << Object.const_get(IrModel.class_name_from_model_key i); rescue; end}
-    classes.reject! {|m| m.openerp_model.index("report")} #NOTE we would need a more robust test
-    begin
-      classes.reject! {|m| IrModel.read(m.openerp_id, ['osv_memory'])['osv_memory']}
-    rescue
+  def self.install_modules(modules)
+    modules = modules.map { |name| self.find(:first, domain: {name: name})}
+    modules.each do |mod|
+      mod.button_install unless mod.state == "installed"
     end
-    classes.reject! {|m| m.openerp_model == "res.company"} if classes.size > 10
-    OoorDoc::UML.print_uml(classes, {:file_name => "#{name}_uml"})
+    wizard = BaseModuleUpgrade.create
+    wizard.upgrade_module
   end
 
   def print_dependency_graph
@@ -122,7 +69,6 @@ Ooor.xtend('ir.module.module') do
     system("tred < #{self.name}-pre.dot > #{self.name}.dot")
     cmd_line2 = "dot -Tcmapx -o#{self.name}.map -Tpng -o#{self.name}.png #{self.name}.dot"
     system(cmd_line2)
-      
   end
     
 end

data/lib/ooor/mini_active_resource.rb

@@ -68,24 +68,6 @@ module Ooor
         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

data/lib/ooor/naming.rb

@@ -10,7 +10,7 @@ module Ooor
           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|
+          ActiveModel::Name.new(self, namespace, self.description || self.openerp_model).tap do |r|
             def r.param_key
               @klass.openerp_model.gsub('.', '_')
             end
@@ -52,7 +52,7 @@ module Ooor
       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']
+          lang = context['lang'] || 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

data/lib/ooor/persistence.rb

@@ -0,0 +1,140 @@
+#    OOOR: OpenObject On Ruby
+#    Copyright (C) 2009-2014 Akretion LTDA (<http://www.akretion.com>).
+#    Author: Raphaël Valyi
+#    Licensed under the MIT license, see MIT-LICENSE file
+
+require 'active_support/core_ext/hash/indifferent_access'
+require 'active_model/attribute_methods'
+require 'active_model/dirty'
+require 'ooor/errors'
+
+module Ooor
+
+  # the base class for proxies to OpenERP objects
+  module Persistence
+
+    def load(attributes, remove_root=false, persisted=false)#an attribute might actually be a association too, will be determined here
+      self.class.reload_fields_definition(false, object_session)
+      raise ArgumentError, "expected an attributes Hash, got #{attributes.inspect}" unless attributes.is_a?(Hash)
+      @prefix_options, attributes = split_options(attributes)
+      @associations ||= {}
+      @attributes ||= {}
+      @loaded_associations = {}
+      attributes.each do |key, value|
+        self.send "#{key}=".to_sym, value if self.respond_to?("#{key}=".to_sym)
+      end
+      self
+    end
+
+    #takes care of reading OpenERP default field values.
+    def initialize(attributes = {}, default_get_list=false, context={}, persisted=false)
+      @attributes = {}
+      @prefix_options = {}
+      @ir_model_data_id = attributes.delete(:ir_model_data_id)
+      @object_session = {}
+      @object_session = HashWithIndifferentAccess.new(context)
+      @persisted = persisted
+      self.class.reload_fields_definition(false, @object_session)
+      if default_get_list == []
+        load(attributes)
+      else
+        load_with_defaults(attributes, default_get_list)
+      end.tap do
+        if id
+          @previously_changed = ActiveSupport::HashWithIndifferentAccess.new # see ActiveModel::Dirty reset_changes
+          @changed_attributes = ActiveSupport::HashWithIndifferentAccess.new
+        end
+      end
+    end
+
+    # Saves (+create+) or \updates (+write+) a resource. Delegates to +create+ if the object is \new,
+    # +update+ if it exists.
+    def save(context={}, reload=true)
+      create_or_update(context, reload)
+    end
+
+    def create_or_update(context={}, reload=true)
+      run_callbacks :save do
+        new? ? create_record(context, reload) : update_record(context, reload)
+      end
+    rescue ValidationError => e
+      e.extract_validation_error!(errors)
+      return false
+    end
+
+    # Create (i.e., \save to OpenERP service) the \new resource.
+    def create(context={}, reload=true)
+      create_or_update(context, reload)
+    end
+
+    def create_record(context={}, reload=true)
+      run_callbacks :create do
+        self.id = rpc_execute('create', to_openerp_hash, context)
+        if @ir_model_data_id
+          IrModelData.create(model: self.class.openerp_model,
+            'module' => @ir_model_data_id[0],
+            'name' => @ir_model_data_id[1],
+            'res_id' => self.id)
+        end
+        @persisted = true
+        reload_fields(context) if reload
+      end
+    end
+
+    def update_attributes(attributes, context={}, reload=true)
+      load(attributes, false) && save(context, reload)
+    end
+
+    # Update the resource on the remote service.
+    def update(context={}, reload=true, keys=nil)
+      create_or_update(context, reload, keys)
+    end
+
+    def update_record(context={}, reload=true)
+      run_callbacks :update do
+        rpc_execute('write', [self.id], to_openerp_hash, context)
+        reload_fields(context) if reload
+        @persisted = true
+      end
+    end
+
+    #Deletes the record in OpenERP and freezes this instance to reflect that no changes should be made (since they can’t be persisted).
+    def destroy(context={})
+      run_callbacks :destroy do
+        rpc_execute('unlink', [self.id], context)
+        @destroyed = true
+        freeze 
+      end
+    end
+
+    #OpenERP copy method, load persisted copied Object
+    def copy(defaults={}, context={})
+      self.class.find(rpc_execute('copy', self.id, defaults, context), context: context)
+    end
+
+    private
+
+    def load_with_defaults(attributes, default_get_list)
+      defaults = rpc_execute("default_get", default_get_list || self.class.fields.keys + self.class.associations_keys, object_session.dup)
+      attributes = HashWithIndifferentAccess.new(defaults.merge(attributes.reject {|k, v| v.blank? }))
+      load(attributes)
+    end
+      
+    def load_on_change_result(result, field_name, field_value)
+      if result["warning"]
+        self.class.logger.info result["warning"]["title"]
+        self.class.logger.info result["warning"]["message"]
+      end
+      attrs = @attributes.merge(field_name => field_value)
+      attrs.merge!(result["value"])
+      load(attrs)
+    end
+
+    def reload_fields(context)
+      record = self.class.find(self.id, context: context)
+      load(record.attributes.merge(record.associations))
+      @changed_attributes = ActiveSupport::HashWithIndifferentAccess.new # see ActiveModel::Dirty
+    end
+
+  end
+end

data/lib/ooor/railtie.rb

@@ -1,5 +1,6 @@
 require "rails/railtie"
 require "ooor/rack"
+require "yaml"
 
 module Ooor
   class Railtie < Rails::Railtie
@@ -29,7 +30,7 @@ module Ooor
 
     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'])
+      @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

data/lib/ooor/reflection.rb

@@ -2,7 +2,7 @@ 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
+# the few necessary hacks are explicited with a FIXME or a NOTE
 # an addition Ooor specific reflection module completes this one explicitely
 module Ooor
   # = Active Record Reflection
@@ -23,18 +23,7 @@ module Ooor
     # 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
+      #def create_reflection(macro, name, options, active_record) #NOTE overriden in Ooor
 
       # Returns an array of AggregateReflection objects for all the aggregations in the class.
       def reflect_on_all_aggregations
@@ -64,14 +53,7 @@ module Ooor
         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
+      # def reflect_on_association(association) # NOTE overriden in Ooor
 
       # Returns an array of AssociationReflection objects for all associations which have <tt>:autosave</tt> enabled.
       def reflect_on_all_autosave_associations
@@ -118,9 +100,9 @@ module Ooor
       #
       # <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
+#      def klass #NOTE overriden in Ooor
+#        @klass ||= class_name.constantize
+#      end
 
       # Returns the class name for the macro.
       #
@@ -140,9 +122,9 @@ module Ooor
           active_record == other_aggregation.active_record
       end
 
-      def sanitized_conditions #:nodoc:
-        @sanitized_conditions ||= klass.send(:sanitize_sql, options[:conditions]) if options[:conditions]
-      end
+#      def sanitized_conditions #:nodoc: #NOTE not applicable in Ooor
+#        @sanitized_conditions ||= klass.send(:sanitize_sql, options[:conditions]) if options[:conditions]
+#      end
 
       private
         def derive_class_name
@@ -158,380 +140,10 @@ module Ooor
 
     # 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
+    #class AssociationReflection < MacroReflection #:nodoc: #NOTE totally overriden in Ooor
 
     # 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
+    #class ThroughReflection < AssociationReflection #:nodoc: #NOTE commented out because not used in Ooor
   end
 end