bmaland-has_many_polymorphs 2.5.0

data/lib/has_many_polymorphs/debugging_tools.rb

@@ -0,0 +1,103 @@
+
+=begin rdoc
+
+Debugging tools for Has_many_polymorphs. 
+
+Enable the different tools by setting the environment variable HMP_DEBUG. Settings with special meaning are <tt>"ruby-debug"</tt>, <tt>"trace"</tt>, and <tt>"dependencies"</tt>.
+
+== Code generation
+
+Enabled by default when HMP_DEBUG is set.
+
+Ouputs a folder <tt>generated_models/</tt> in RAILS_ROOT containing valid Ruby files explaining all the ActiveRecord relationships set up by the plugin, as well as listing the line in the plugin that called each particular association method.
+
+== Ruby-debug
+
+Enable by setting HMP_DEBUG to <tt>"ruby-debug"</tt>.
+
+Starts <tt>ruby-debug</tt> for the life of the process.
+
+== Trace
+
+Enable by setting HMP_DEBUG to <tt>"ruby-debug"</tt>.
+
+Outputs an indented trace of relevant method calls as they occur.
+
+== Dependencies
+
+Enable by setting HMP_DEBUG to <tt>"dependencies"</tt>.
+
+Turns on Rails' default dependency logging.
+
+=end
+
+_logger_warn "debug mode enabled"
+
+class << ActiveRecord::Base
+  COLLECTION_METHODS = [:belongs_to, :has_many, :has_and_belongs_to_many, :has_one, 
+      :has_many_polymorphs, :acts_as_double_polymorphic_join].each do |method_name|
+    alias_method "original_#{method_name}".to_sym, method_name
+    undef_method method_name
+  end      
+
+  unless defined? GENERATED_CODE_DIR
+    GENERATED_CODE_DIR = "#{RAILS_ROOT}/generated_models"
+  
+    begin
+      system "rm -rf #{GENERATED_CODE_DIR}" 
+      Dir.mkdir GENERATED_CODE_DIR
+    rescue Errno::EACCES
+      _logger_warn "no permissions for generated code dir: #{GENERATED_CODE_DIR}"
+    end
+
+    if File.exist? GENERATED_CODE_DIR
+      alias :original_method_missing :method_missing
+      def method_missing(method_name, *args, &block)
+        if COLLECTION_METHODS.include? method_name.to_sym
+          Dir.chdir GENERATED_CODE_DIR do
+            filename = "#{demodulate(self.name.underscore)}.rb"
+            contents = File.open(filename).read rescue "\nclass #{self.name}\n\nend\n"
+            line = caller[1][/\:(\d+)\:/, 1]
+            contents[-5..-5] = "\n  #{method_name} #{args[0..-2].inspect[1..-2]},\n     #{args[-1].inspect[1..-2].gsub(" :", "\n     :").gsub("=>", " => ")}\n#{ block ? "     #{block.inspect.sub(/\@.*\//, '@')}\n" : ""}     # called from line #{line}\n\n"
+            File.open(filename, "w") do |file| 
+              file.puts contents             
+            end
+          end
+          # doesn't actually display block contents
+          self.send("original_#{method_name}", *args, &block)
+        else
+          self.send(:original_method_missing, method_name, *args, &block)
+        end
+      end
+    end      
+    
+  end
+end
+
+case ENV['HMP_DEBUG']
+
+  when "ruby-debug"
+    require 'rubygems'
+    require 'ruby-debug'
+    Debugger.start
+    _logger_warn "ruby-debug enabled."
+
+  when "trace"
+    _logger_warn "method tracing enabled"  
+    $debug_trace_indent = 0
+    set_trace_func (proc do |event, file, line, id, binding, classname|
+      if id.to_s =~ /instantiate/ #/IRB|Wirble|RubyLex|RubyToken|Logger|ConnectionAdapters|SQLite3|MonitorMixin|Benchmark|Inflector|Inflections/ 
+        if event == 'call'
+          puts (" " * $debug_trace_indent) + "#{event}ed #{classname}\##{id} from #{file.split('/').last}::#{line}"
+          $debug_trace_indent += 1
+        elsif event == 'return'
+          $debug_trace_indent -= 1 unless $debug_trace_indent == 0
+          puts (" " * $debug_trace_indent) + "#{event}ed #{classname}\##{id}"
+        end
+      end
+    end)
+    
+  when "dependencies"
+    _logger_warn "dependency activity being logged"
+    (::Dependencies.log_activity = true) rescue nil
+end

data/lib/has_many_polymorphs/rake_task_redefine_task.rb

@@ -0,0 +1,35 @@
+
+# Redefine instead of chain a Rake task
+# http://www.bigbold.com/snippets/posts/show/2032
+
+module Rake
+  module TaskManager
+    def redefine_task(task_class, args, &block)
+      task_name, deps = resolve_args(args)
+      task_name = task_class.scope_name(@scope, task_name)
+      deps = [deps] unless deps.respond_to?(:to_ary)
+      deps = deps.collect {|d| d.to_s }
+      task = @tasks[task_name.to_s] = task_class.new(task_name, self)
+      task.application = self
+      task.add_comment(@last_comment)
+      @last_comment = nil
+      task.enhance(deps, &block)
+      task
+    end
+  end
+  class Task
+    class << self
+      def redefine_task(args, &block)
+        Rake.application.redefine_task(self, args, &block)
+      end
+    end
+  end
+end
+
+class Object
+  def silently
+    stderr, stdout, $stderr, $stdout = $stderr, $stdout, StringIO.new, StringIO.new
+    yield
+    $stderr, $stdout = stderr, stdout
+  end
+end

data/lib/has_many_polymorphs/reflection.rb

@@ -0,0 +1,58 @@
+module ActiveRecord #:nodoc:
+  module Reflection #:nodoc:
+    
+    module ClassMethods #:nodoc:
+      
+      # Update the default reflection switch so that <tt>:has_many_polymorphs</tt> types get instantiated. 
+      # It's not a composed method so we have to override the whole thing.
+      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)
+          # added by has_many_polymorphs #
+          when :has_many_polymorphs
+            reflection = PolymorphicReflection.new(macro, name, options, active_record)
+        end
+        write_inheritable_hash :reflections, name => reflection
+        reflection
+      end
+      
+    end
+
+    class PolymorphicError < ActiveRecordError #:nodoc:
+    end
+    
+=begin rdoc
+
+The reflection built by the <tt>has_many_polymorphs</tt> method. 
+
+Inherits from ActiveRecord::Reflection::AssociationReflection.
+
+=end
+
+    class PolymorphicReflection < ThroughReflection
+      # Stub out the validity check. Has_many_polymorphs checks validity on macro creation, not on reflection.
+      def check_validity! 
+        # nothing
+      end                 
+
+      # Return the source reflection.
+      def source_reflection
+        # normally is the has_many to the through model, but we return ourselves, 
+        # since there isn't a real source class for a polymorphic target
+        self
+      end      
+      
+      # Set the classname of the target. Uses the join class name.
+      def class_name
+        # normally is the classname of the association target
+        @class_name ||= options[:join_class_name]
+      end
+                     
+    end
+ 
+  end
+end

data/lib/has_many_polymorphs/support_methods.rb

@@ -0,0 +1,88 @@
+
+class String
+
+  # Changes an underscored string into a class reference.
+  def _as_class
+    # classify expects self to be plural
+    self.classify.constantize
+  end
+
+  # For compatibility with the Symbol extensions.
+  alias :_singularize :singularize
+  alias :_pluralize :pluralize
+  alias :_classify :classify
+end
+
+class Symbol
+  
+  # Changes an underscored symbol into a class reference.
+  def _as_class; self.to_s._as_class; end
+  
+  # Changes a plural symbol into a singular symbol.
+  def _singularize; self.to_s.singularize.to_sym; end
+
+  # Changes a singular symbol into a plural symbol.
+  def _pluralize; self.to_s.pluralize.to_sym; end
+
+  # Changes a symbol into a class name string.
+  def _classify; self.to_s.classify; end
+end
+
+class Array
+
+  # Flattens the first level of self.
+  def _flatten_once
+    self.inject([]){|r, el| r + Array(el)}
+  end
+
+  # Rails 1.2.3 compatibility method. Copied from http://dev.rubyonrails.org/browser/trunk/activesupport/lib/active_support/core_ext/array/extract_options.rb?rev=7217 
+  def _extract_options!
+    last.is_a?(::Hash) ? pop : {}
+  end
+end
+
+class Hash
+
+  # An implementation of select that returns a Hash.
+  def _select
+    if RUBY_VERSION >= "1.9"
+      Hash[*self.select {|k, v| yield k, v }.flatten]
+    else
+      Hash[*self.select do |key, value|
+        yield key, value
+      end._flatten_once]
+    end
+  end
+end
+
+class Object
+
+  # Returns the metaclass of self.
+  def _metaclass; (class << self; self; end); end
+
+  # Logger shortcut.
+  def _logger_debug s
+    s = "** has_many_polymorphs: #{s}"
+    Rails.logger.debug(s) if Rails and Rails.logger
+  end  
+
+  # Logger shortcut.  
+  def _logger_warn s
+    s = "** has_many_polymorphs: #{s}"
+    if Rails and Rails.logger
+      Rails.logger.warn(s) 
+    else
+      $stderr.puts(s)
+    end    
+  end
+  
+end
+
+class ActiveRecord::Base
+
+  # Return the base class name as a string.
+  def _base_class_name
+    self.class.base_class.name.to_s
+  end
+  
+end

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification 
+name: bmaland-has_many_polymorphs
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 2
+  - 5
+  - 0
+  version: 2.5.0
+platform: ruby
+authors: 
+- Evan Weaver
+- James Stewart
+- Matthias Viehweger
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-12-11 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+description: 
+email: 
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/has_many_polymorphs.rb
+- lib/has_many_polymorphs/base.rb
+- lib/has_many_polymorphs/association.rb
+- lib/has_many_polymorphs/debugging_tools.rb
+- lib/has_many_polymorphs/reflection.rb
+- lib/has_many_polymorphs/support_methods.rb
+- lib/has_many_polymorphs/autoload.rb
+- lib/has_many_polymorphs/rake_task_redefine_task.rb
+- lib/has_many_polymorphs/class_methods.rb
+- LICENSE
+- README
+- CHANGELOG
+has_rdoc: true
+homepage: http://blog.evanweaver.com/files/doc/fauna/has_many_polymorphs/
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 23
+      segments: 
+      - 1
+      - 3
+      - 6
+      version: 1.3.6
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: An ActiveRecord plugin for self-referential and double-sided polymorphic associations.
+test_files: []
+