tagtical 1.0.6

data/lib/tagtical/taggable/core.rb

@@ -0,0 +1,317 @@
+module Tagtical::Taggable
+  module Core
+    def self.included(base)
+      base.class_eval do
+        include Tagtical::Taggable::Core::InstanceMethods
+        extend Tagtical::Taggable::Core::ClassMethods
+
+        after_save :save_tags
+
+        initialize_tagtical_core
+      end
+    end
+    
+    module ClassMethods
+      def initialize_tagtical_core
+        has_many :taggings, :as => :taggable, :dependent => :destroy, :include => :tag, :class_name => "Tagtical::Tagging"
+        has_many :tags, :through => :taggings, :source => :tag, :class_name => "Tagtical::Tag",
+                 :select => "#{Tagtical::Tag.table_name}.*, #{Tagtical::Tagging.table_name}.relevance" # include the relevance on the tags
+
+        tag_types.each do |tag_type| # has_many :tags gets created here
+
+          # Aryk: Instead of defined multiple associations for the different types of tags, I decided
+          # to define the main associations (tags and taggings) and use AR scope's to build off of them.
+          # This keeps your reflections cleaner.
+
+          # In the case of the base tag type, it will just use the :tags association defined above.
+          Tagtical::Tag.scope(tag_type.scope_name, Proc.new { |options| tag_type.scoping(options || {}) }) unless Tagtical::Tag.respond_to?(tag_type.scope_name)
+
+          # If the tag_type is base? (type=="tag"), then we add additional functionality to the AR
+          # has_many :tags.
+          #
+          #   taggable_model.tags(:only => :children)
+          #   taggable_model.tags <-- still works like normal has_many
+          #   taggable_model.tags(true, :only => :current) <-- reloads the tags association and appends scope for only current type.
+          if tag_type.has_many_name==:tags
+            define_method("tags_with_finder_type_options") do |*args|
+              options = args.pop if args.last.is_a?(Hash)
+              scope = tags_without_finder_type_options(*args)
+              options ? scope.tags(options) : scope
+            end
+            alias_method_chain :tags, :finder_type_options
+          else
+            delegate tag_type.has_many_name, :to => :tags
+          end
+
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def self.with_#{tag_type.pluralize}(*tags)
+              options = tags.extract_options!
+              tagged_with(tags.flatten, options.merge(:on => :#{tag_type}))
+            end
+
+            def #{tag_type}_list
+              tag_list_on('#{tag_type}')
+            end
+
+            def #{tag_type}_list=(new_tags)
+              set_tag_list_on('#{tag_type}', new_tags)
+            end
+
+            def all_#{tag_type.pluralize}_list
+              all_tags_list_on('#{tag_type}')
+            end
+          RUBY
+
+        end
+      end
+      
+      def acts_as_taggable(*args)
+        super(*args)
+        initialize_tagtical_core
+      end
+      
+      # all column names are necessary for PostgreSQL group clause
+      def grouped_column_names_for(object)
+        object.column_names.map { |column| "#{object.table_name}.#{column}" }.join(", ")
+      end
+
+      ##
+      # Return a scope of objects that are tagged with the specified tags.
+      #
+      # @param tags The tags that we want to query for
+      # @param [Hash] options A hash of options to alter you query:
+      #                       * <tt>:exclude</tt> - if set to true, return objects that are *NOT* tagged with the specified tags
+      #                       * <tt>:any</tt> - if set to true, return objects that are tagged with *ANY* of the specified tags
+      #                       * <tt>:match_all</tt> - if set to true, return objects that are *ONLY* tagged with the specified tags
+      #
+      # Example:
+      #   User.tagged_with("awesome", "cool")                     # Users that are tagged with awesome and cool
+      #   User.tagged_with("awesome", "cool", :exclude => true)   # Users that are not tagged with awesome or cool
+      #   User.tagged_with("awesome", "cool", :any => true)       # Users that are tagged with awesome or cool
+      #   User.tagged_with("awesome", "cool", :match_all => true) # Users that are tagged with just awesome and cool
+      #   User.tagged_with("awesome", "cool", :on => :skills)     # Users that are tagged with just awesome and cool on skills
+      def tagged_with(tags, options = {})
+        tag_list = Tagtical::TagList.from(tags)
+        return scoped(:conditions => "1 = 0") if tag_list.empty? && !options[:exclude]
+
+        joins = []
+        conditions = []
+
+        options[:on] ||= Tagtical::Tag::Type::BASE
+        tag_type = Tagtical::Tag::Type.find(options.delete(:on))
+        finder_type_condition_options = options.extract!(:only)
+
+        tag_table, tagging_table = Tagtical::Tag.table_name, Tagtical::Tagging.table_name
+
+        if options.delete(:exclude)
+          conditions << "#{table_name}.#{primary_key} NOT IN (" +
+            "SELECT #{tagging_table}.taggable_id " +
+            "FROM #{tagging_table} " +
+            "JOIN #{tag_table} ON #{tagging_table}.tag_id = #{tag_table}.id AND #{tag_list.to_sql_conditions(:operator => "LIKE")} " +
+            "WHERE #{tagging_table}.taggable_type = #{quote_value(base_class.name)})"
+
+        elsif options.delete(:any)
+          conditions << tag_list.to_sql_conditions(:operator => "LIKE")
+
+          tagging_join  = " JOIN #{tagging_table}" +
+            "   ON #{tagging_table}.taggable_id = #{table_name}.#{primary_key}" +
+            "  AND #{tagging_table}.taggable_type = #{quote_value(base_class.name)}" +
+            " JOIN #{tag_table}" +
+            "   ON #{tagging_table}.tag_id = #{tag_table}.id"
+
+
+          if (finder_condition = tag_type.finder_type_condition(finder_type_condition_options.merge(:sql => true))).present?
+            conditions << finder_condition
+          end
+
+          select_clause = "DISTINCT #{table_name}.*" unless !tag_type.base? and tag_types.one?
+
+          joins << tagging_join
+
+        else
+          tags_by_value = tag_type.scoping(finder_type_condition_options).where_any_like(tag_list).group_by(&:value)
+          return scoped(:conditions => "1 = 0") unless tags_by_value.length == tag_list.length # allow for chaining
+
+          # Create only one join per tag value.
+          tags_by_value.each do |value, tags|
+            tags.each do |tag|
+              safe_tag = value.gsub(/[^a-zA-Z0-9]/, '')
+              prefix   = "#{safe_tag}_#{rand(1024)}"
+
+              taggings_alias = "#{undecorated_table_name}_taggings_#{prefix}"
+
+              tagging_join  = "JOIN #{tagging_table} #{taggings_alias}" +
+                "  ON #{taggings_alias}.taggable_id = #{table_name}.#{primary_key}" +
+                " AND #{taggings_alias}.taggable_type = #{quote_value(base_class.name)}" +
+                " AND #{sanitize_sql("#{taggings_alias}.tag_id" => tags.map(&:id))}"
+
+              joins << tagging_join
+            end
+          end
+        end
+
+        taggings_alias, tags_alias = "#{undecorated_table_name}_taggings_group", "#{undecorated_table_name}_tags_group"
+
+        if options.delete(:match_all)
+          joins << "LEFT OUTER JOIN #{tagging_table} #{taggings_alias}" +
+            "  ON #{taggings_alias}.taggable_id = #{table_name}.#{primary_key}" +
+            " AND #{taggings_alias}.taggable_type = #{quote_value(base_class.name)}"
+
+
+          group_columns = Tagtical::Tag.using_postgresql? ? grouped_column_names_for(self) : "#{table_name}.#{primary_key}"
+          group = "#{group_columns} HAVING COUNT(#{taggings_alias}.taggable_id) = #{tag_list.size}"
+        end
+      
+        scoped(:select     => select_clause,
+               :joins      => joins.join(" "),
+               :group      => group,
+               :conditions => conditions.join(" AND "),
+               :order      => options[:order],
+               :readonly   => false)
+      end
+
+      def is_taggable?
+        true
+      end
+    end    
+    
+    module InstanceMethods
+      # all column names are necessary for PostgreSQL group clause
+      def grouped_column_names_for(object)
+        self.class.grouped_column_names_for(object)
+      end
+
+      def is_taggable?
+        self.class.is_taggable?
+      end
+
+      def cached_tag_list_on(context)
+        self[tag_type(context).tag_list_name(:cached)]
+      end
+
+      def tag_list_cache_set_on?(context)
+        variable_name = tag_type(context).tag_list_ivar
+        !instance_variable_get(variable_name).nil?
+      end
+
+      def tag_list_cache_on(context)
+        variable_name = tag_type(context).tag_list_ivar
+        instance_variable_get(variable_name) || instance_variable_set(variable_name, Tagtical::TagList.new(tags_on(context).map(&:value)))
+      end
+
+      def tag_list_on(context)
+        tag_list_cache_on(context)
+      end
+
+      def tag_types
+        @tag_types ||= self.class.tag_types.dup
+      end
+
+      def all_tags_list_on(context)
+        variable_name = tag_type(context).tag_list_ivar(:all)
+        return instance_variable_get(variable_name) if instance_variable_get(variable_name)
+
+        instance_variable_set(variable_name, Tagtical::TagList.new(all_tags_on(context).map(&:value)).freeze)
+      end
+
+      ##
+      # Returns all tags of a given context
+      def all_tags_on(context, options={})
+        scope = tag_scope(context, options)
+        if Tagtical::Tag.using_postgresql?
+          group_columns = grouped_column_names_for(Tagtical::Tag)
+          scope = scope.order("max(#{Tagtical::Tagging.table_name}.created_at)").group(group_columns)
+        else
+          scope = scope.group("#{Tagtical::Tag.table_name}.#{Tagtical::Tag.primary_key}")
+        end
+        scope.all
+      end
+
+      ##
+      # Returns all tags that aren't owned.
+      def tags_on(context, options={})
+        tag_scope(context, options).where("#{Tagtical::Tagging.table_name}.tagger_id IS NULL").all
+      end
+
+      def set_tag_list_on(context, new_list)
+        variable_name = tag_type(context).tag_list_ivar
+        instance_variable_set(variable_name, Tagtical::TagList.from(new_list))
+      end
+
+      def reload(*args)
+        tag_types.each do |tag_type|
+          instance_variable_set(tag_type.tag_list_ivar, nil)
+          instance_variable_set(tag_type.tag_list_ivar(:all), nil)
+        end
+      
+        super(*args)
+      end
+
+      def save_tags
+        # Do the classes from top to bottom. We want the list from "tag" to run before "sub_tag" runs.
+        # Otherwise, we will end up removing taggings from "sub_tag" since they aren't on "tag'.
+        tag_types.sort_by(&:active_record_sti_level).each do |tag_type|
+          next unless tag_list_cache_set_on?(tag_type)
+
+          tag_list = tag_list_cache_on(tag_type).uniq
+
+          # Find existing tags or create non-existing tags:
+          tag_value_lookup = tag_type.scoping { find_or_create_tags(tag_list) }
+          tags = tag_value_lookup.keys
+
+          current_tags = tags_on(tag_type, :only => [:current, :parents, :children])
+          old_tags     = current_tags - tags
+          new_tags     = tags         - current_tags
+
+          unowned_taggings = taggings.where(:tagger_id => nil)
+
+          # If relevances are specified on current tags, make sure to update those 
+          tags_requiring_relevance_update = tag_value_lookup.map { |tag, value| tag if !value.relevance.nil? }.compact & current_tags
+          if tags_requiring_relevance_update.present? && (update_taggings = unowned_taggings.find_all_by_tag_id(tags_requiring_relevance_update)).present?
+            update_taggings.each { |tagging| tagging.update_attribute(:relevance, tag_value_lookup[tagging.tag].relevance) }
+          end
+
+          # Find and remove old taggings:
+          if old_tags.present? && (old_taggings = unowned_taggings.find_all_by_tag_id(old_tags)).present?
+            old_taggings.reject! do |tagging|
+              if tagging.tag.class > tag_type.klass! # parent of current tag type/class, make sure not to remove these taggings.
+                update_tagging_with_inherited_tag!(tagging, new_tags, tag_value_lookup)
+                true
+              end
+            end
+            Tagtical::Tagging.destroy_all :id => old_taggings.map(&:id) # Destroy old taggings:
+          end
+
+          new_tags.each do |tag|
+            taggings.create!(:tag_id => tag.id, :taggable => self, :relevance => tag_value_lookup[tag].relevance) # Create new taggings:
+          end
+        end
+
+        true
+      end
+
+      private
+
+      def tag_scope(input, options={})
+        tags.where(tag_type(input).finder_type_condition(options))
+      end
+
+      # Returns the tag type for the given context and adds any new types tag_types array on this instance.
+      def tag_type(input)
+        (@tag_type ||= {})[input] ||= Tagtical::Tag::Type[input].tap do |tag_type|
+          tag_types << tag_type unless tag_types.include?(tag_type)
+        end
+      end
+
+      # Lets say tag class A inherits from B and B has a tag with value "foo". If we tag A with value "foo",
+      # we want B to have only one instance of "foo" and that tag should be an instance of A (a subclass of B).
+      def update_tagging_with_inherited_tag!(tagging, tags, tag_value_lookup)
+        if tags.present? && (tag = Tagtical::Tag.send(:detect_comparable, tags, tagging.tag.value))
+          tagging.update_attributes!(:tag => tag, :relevance => tag_value_lookup[tag].relevance)
+          tags.delete(tag)
+        end
+      end
+
+    end
+  end
+end

data/lib/tagtical/taggable/ownership.rb

@@ -0,0 +1,110 @@
+module Tagtical::Taggable
+  module Ownership
+    def self.included(base)
+      base.send :include, Tagtical::Taggable::Ownership::InstanceMethods
+      base.extend Tagtical::Taggable::Ownership::ClassMethods
+
+      base.after_save :save_owned_tags
+
+      base.initialize_acts_as_taggable_ownership
+    end
+
+    module ClassMethods
+      def acts_as_taggable(*args)
+        initialize_acts_as_taggable_ownership
+        super(*args)
+      end
+
+      def initialize_acts_as_taggable_ownership
+        tag_types.each do |tag_type|
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{tag_type.pluralize}_from(owner)
+              owner_tag_list_on(owner, '#{tag_type}')
+            end      
+          RUBY
+        end
+      end
+    end
+
+    module InstanceMethods
+      def owner_tags_on(owner, context, options={})
+        scope = tag_scope(context, options)
+        if owner
+          scope = scope.where([%{#{Tagtical::Tagging.table_name}.tagger_id = ?}, owner.id])
+          scope = scope.where([%{#{Tagtical::Tagging.table_name}.tagger_type = ?}, owner.class.to_s]) if Tagtical.config.polymorphic_tagger?
+        end
+        scope.all
+      end
+
+      def cached_owned_tag_list_on(context)
+        variable_name = tag_type(context).tag_list_ivar(:owned)
+        cache = instance_variable_get(variable_name) || instance_variable_set(variable_name, {})
+      end
+
+      def owner_tag_list_on(owner, context)
+        cache = cached_owned_tag_list_on(context)
+        cache.delete_if { |key, value| key.id == owner.id && key.class == owner.class }
+
+        cache[owner] ||= Tagtical::TagList.new(*owner_tags_on(owner, context).map(&:value))
+      end
+
+      def set_owner_tag_list_on(owner, context, new_list)
+        cache = cached_owned_tag_list_on(context)
+        cache.delete_if { |key, value| key.id == owner.id && key.class == owner.class }
+
+        cache[owner] = Tagtical::TagList.from(new_list)
+      end
+
+      def reload(*args)
+        tag_types.each do |tag_type|
+          instance_variable_set(tag_type.tag_list_ivar(:owned), nil)
+        end
+
+        super(*args)
+      end
+
+      def save_owned_tags
+        # Do the classes from top to bottom. We want the list from "tag" to run before "sub_tag" runs.
+        # Otherwise, we will end up removing taggings from "sub_tag" since they aren't on "tag'.
+        tag_types.sort_by(&:active_record_sti_level).each do |tag_type|
+          cached_owned_tag_list_on(tag_type).each do |owner, tag_list|
+            # Find existing tags or create non-existing tags:
+            tag_value_lookup = tag_type.scoping { find_or_create_tags(tag_list) }
+            tags = tag_value_lookup.keys
+
+            owned_tags = owner_tags_on(owner, tag_type, :only => [:current, :parents, :children])
+            old_tags   = owned_tags - tags
+            new_tags   = tags       - owned_tags
+
+            # Find and remove old taggings:
+            if old_tags.present? && (old_taggings = owner_taggings(owner).find_all_by_tag_id(old_tags)).present?
+              old_taggings.reject! do |tagging|
+                if tagging.tag.class > tag_type.klass! # parent of current tag type/class, make sure not to remove these taggings.
+                  update_tagging_with_inherited_tag!(tagging, new_tags, tag_value_lookup)
+                  true
+                end
+              end
+              Tagtical::Tagging.destroy_all :id => old_taggings.map(&:id) # Destroy old taggings:
+            end
+
+            # Create new taggings:
+            new_tags.each do |tag|
+              taggings.create!(:tagger => owner, :relevance => tag_value_lookup[tag].relevance, :tag_id => tag.id)
+            end
+          end
+        end
+
+        true
+      end
+
+      # Find all taggings that belong to the taggable (self), are owned by the owner,
+      # have the correct context, and are removed from the list.
+      def owner_taggings(owner)
+        relation = taggings.where(:tagger_id   => owner.id)
+        relation = relation.where(:tagger_type => owner.class.to_s) if Tagtical.config.polymorphic_tagger?
+        relation
+      end
+
+    end
+  end
+end

data/lib/tagtical/taggable/related.rb

@@ -0,0 +1,60 @@
+module Tagtical::Taggable
+  module Related
+    def self.included(base)
+      base.send :include, Tagtical::Taggable::Related::InstanceMethods
+      base.extend Tagtical::Taggable::Related::ClassMethods
+      base.initialize_tagtical_related
+    end
+    
+    module ClassMethods
+      def initialize_tagtical_related
+        tag_types.each do |tag_type|
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def find_related_#{tag_type.pluralize}(options = {})
+              related_tags_for('#{tag_type}', self.class, options)
+            end
+            alias_method :find_related_on_#{tag_type.pluralize}, :find_related_#{tag_type.pluralize}
+
+            def find_related_#{tag_type.pluralize}_for(klass, options = {})
+              related_tags_for('#{tag_type}', klass, options)
+            end
+
+            def find_matching_contexts(search_context, result_context, options = {})
+              matching_contexts_for(search_context.to_s, result_context.to_s, self.class, options)
+            end
+
+            def find_matching_contexts_for(klass, search_context, result_context, options = {})
+              matching_contexts_for(search_context.to_s, result_context.to_s, klass, options)
+            end
+          RUBY
+        end        
+      end
+      
+      def acts_as_taggable(*args)
+        super(*args)
+        initialize_tagtical_related
+      end
+    end
+    
+    module InstanceMethods
+      def matching_contexts_for(search_context, result_context, klass, options = {})
+        related_tags_for(search_context, klass, options.update(:result_context => result_context))
+      end
+      
+      def related_tags_for(context, klass, options = {})
+        tags_to_find = tags_on(context).collect { |t| t.value }
+        exclude_self = "#{klass.table_name}.id != #{id} AND" if self.class == klass
+        group_columns = Tagtical::Tag.using_postgresql? ? grouped_column_names_for(klass) : "#{klass.table_name}.#{klass.primary_key}"
+
+        conditions = ["#{exclude_self} #{klass.table_name}.id = #{Tagtical::Tagging.table_name}.taggable_id AND #{Tagtical::Tagging.table_name}.taggable_type = '#{klass.to_s}' AND #{Tagtical::Tagging.table_name}.tag_id = #{Tagtical::Tag.table_name}.id AND #{Tagtical::Tag.table_name}.value IN (?)", tags_to_find]
+        conditions[0] << tag_type(options.delete(:result_context)).finder_type_condition(:sql => :append).to_s if options[:result_context]
+                
+        klass.scoped({ :select     => "#{klass.table_name}.*, COUNT(#{Tagtical::Tag.table_name}.id) AS count",
+                       :from       => "#{klass.table_name}, #{Tagtical::Tag.table_name}, #{Tagtical::Tagging.table_name}",
+                       :conditions => conditions,
+                       :group      => group_columns,
+                       :order      => "count DESC" }.update(options))
+      end
+    end
+  end
+end

data/lib/tagtical/taggable.rb

@@ -0,0 +1,51 @@
+module Tagtical
+  module Taggable
+    def taggable?
+      false
+    end
+
+    ##
+    # Make a model taggable on specified contexts.
+    #
+    # @param [Array] tag_types An array of taggable contexts. These must have an associated subclass under Tag.
+    #
+    # Example:
+    #   module Tag
+    #     class Language < Tagtical::Tag
+    #     end
+    #     class Skill < Tagtical::Tag
+    #     end
+    #   end
+    #   class User < ActiveRecord::Base
+    #     acts_as_taggable :languages, :skills
+    #   end
+    def acts_as_taggable(*tag_types)
+      tag_types.flatten!
+      tag_types << Tagtical::Tag::Type::BASE # always include the base type.
+      tag_types = Tagtical::Tag::Type[tag_types.uniq.compact]
+
+      if taggable?
+        write_inheritable_attribute(:tag_types, (self.tag_types + tag_types).uniq)
+      else
+        write_inheritable_attribute(:tag_types, tag_types)
+        class_inheritable_reader(:tag_types)
+        
+        class_eval do
+          has_many :taggings, :as => :taggable, :dependent => :destroy, :include => :tag, :class_name => "Tagtical::Tagging"
+          has_many :tags, :through => :taggings, :class_name => "Tagtical::Tag"
+
+          def self.taggable?
+            true
+          end
+        
+          include Tagtical::Taggable::Core
+          include Tagtical::Taggable::Collection
+          include Tagtical::Taggable::Cache
+          include Tagtical::Taggable::Ownership
+          include Tagtical::Taggable::Related
+        end
+      end
+      
+    end
+  end
+end 

data/lib/tagtical/tagging.rb

@@ -0,0 +1,42 @@
+module Tagtical
+  class Tagging < ::ActiveRecord::Base #:nodoc:
+    include Tagtical::ActiveRecord::Backports if ::ActiveRecord::VERSION::MAJOR < 3
+
+    attr_accessible :tag,
+                    :tag_id,
+                    :taggable,
+                    :taggable_type,
+                    :taggable_id,
+                    :tagger,
+                    :tagger_id,
+                    :relevance
+
+    belongs_to :tag, :class_name => 'Tagtical::Tag'
+    belongs_to :taggable, :polymorphic => true
+
+    validates_presence_of :tag_id
+    validates_uniqueness_of :tag_id, :scope => [:taggable_type, :taggable_id, :tagger_id]
+
+    if Tagtical.config.polymorphic_tagger?
+      attr_accessible :tagger_type
+       belongs_to :tagger, :polymorphic => true
+    else
+      belongs_to :tagger, case Tagtical.config.tagger
+       when Hash then Tagtical.config.tagger
+       when true then {:class_name => "User"} # default to using User class.
+       when String then {:class_name => Tagtical.config.tagger}
+                           end
+    end
+
+
+    before_create { |record| record.relevance ||= default_relevance }
+
+    class_attribute :default_relevance, :instance_writer => false
+    self.default_relevance = 1
+
+    def <=>(tagging)
+      relevance <=> tagging.relevance
+    end
+
+  end
+end

data/lib/tagtical/tags_helper.rb

@@ -0,0 +1,17 @@
+module Tagtical
+  module TagsHelper
+    # See the README for an example using tag_cloud.
+    def tag_cloud(tags, classes)
+      tags = tags.all if tags.respond_to?(:all)
+
+      return [] if tags.empty?
+
+      max_count = tags.sort_by(&:count).last.count.to_f
+
+      tags.each do |tag|
+        index = ((tag.count / max_count) * (classes.size - 1)).round
+        yield tag, classes[index]
+      end
+    end
+  end
+end

data/lib/tagtical.rb

@@ -0,0 +1,47 @@
+require "active_record"
+require "action_view"
+require "active_support/hash_with_indifferent_access"
+
+module Tagtical
+
+  # Place a tagtical.yml file in the config directory to control settings
+  mattr_accessor :config
+  self.config = ActiveSupport::InheritableOptions.new(ActiveSupport::HashWithIndifferentAccess.new.tap do |hash|
+    require 'yaml'
+    path = Rails.root.join("config", "tagtical.yml") rescue ""
+    hash.update(YAML.load_file(path)) if File.exists?(path)
+    # If tagger association options were not provided, then use the polymorphic_tagger association.
+    hash.reverse_merge!(
+      :polymorphic_tagger? => !hash[:tagger]
+    )
+  end)
+
+end
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require "tagtical/compatibility/active_record_backports" if ActiveRecord::VERSION::MAJOR < 3
+
+require "tagtical/taggable"
+require "tagtical/taggable/core"
+require "tagtical/taggable/collection"
+require "tagtical/taggable/cache"
+require "tagtical/taggable/ownership"
+require "tagtical/taggable/related"
+
+require "tagtical/acts_as_tagger"
+require "tagtical/tag"
+require "tagtical/tag_list"
+require "tagtical/tags_helper"
+require "tagtical/tagging"
+
+$LOAD_PATH.shift
+
+if defined?(ActiveRecord::Base)
+  ActiveRecord::Base.extend Tagtical::Taggable
+  ActiveRecord::Base.send :include, Tagtical::Tagger
+end
+
+if defined?(ActionView::Base)
+  ActionView::Base.send :include, Tagtical::TagsHelper
+end

data/rails/init.rb

@@ -0,0 +1 @@
+require 'tagtical'