lean_tag 0.1.14 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5a7287a6748e83e628a9252001ede19ecf54367d
-  data.tar.gz: 71387636c3f542a78d1b0954e6798e7f1df97fa0
+  metadata.gz: 7952206ef32a8fed9dd302b89f3a3aff2dd4ec53
+  data.tar.gz: 2a46bed46e47c6857016bf32e36ea6dd598d9b53
 SHA512:
-  metadata.gz: 837aa758f9a4f40b9047835a2c7ab61fb6e89a1f27208324cd75aeb806435358d9e6b7e51f05c9a90b827ebae8bbebbfa328c53f6a0203abebdebb53c24f3766
-  data.tar.gz: 477411f18fefc4779620c7ace59128eed2a1ffb648861d0ba0714fc9205d7024d23e8ee7d879dc19795b6ba0d8d9034268f2fd6e7f5c0c4ea52d43968209180d
+  metadata.gz: c385cf6fddf49d527b297fcefab95fde367b203ae8f7508893e584649bff04a7b7047bc43e4e779ebc81a7291ed2d5171c5047bf0e63249ef1ee2b27d2376cb1
+  data.tar.gz: 332a667a76d6146068c23c18161bbb59f2ee7ae89054b50497e216c3a57110dfea4699a0af05622f757587b94d0e0a2e313b7a295f0d11ce240a284a4631ad16

data/db/migrate/2_create_taggings.rb

@@ -3,10 +3,10 @@ class CreateTaggings < ActiveRecord::Migration
     create_table :taggings do |t|
       t.references :tag, index: true
       t.references :record, polymorphic: true, index: true
-
+      t.string :filter, null: false, default: "tags"
       t.timestamps null: false
     end
 
-    add_index [:record_type, :record_id, :filter]
+    add_index :taggings, [:record_type, :record_id, :filter]
   end
 end

data/lib/lean_tag/tag.rb

@@ -4,7 +4,7 @@ module LeanTag
     self.table_name = :tags
 
     has_many :records, through: :taggings
-    has_many :taggings, class_name: "LeanTag::Tagging", inverse_of: :tag
+    has_many :taggings, class_name: "LeanTag::Tagging", inverse_of: :tag, dependent: :destroy
 
     scope :matches, -> (list) { where("tags.name IN (?)", list) }
     scope :ranked, -> { order("taggings_count DESC") }

data/lib/lean_tag/taggable.rb

@@ -1,33 +1,50 @@
 module LeanTag
   module Taggable
 
-    def self.included(base)
-      base.extend ClassMethods
-      base.send :include, InstanceMethods
+    def self.extended(base)
 
-      base.class_eval do
-        has_many :taggings, class_name: "LeanTag::Tagging", as: :record, inverse_of: :record, dependent: :destroy
-        has_many :tags, through: :taggings
+      def taggable_on(relation="tags")
+        extend ClassMethods
 
-        accepts_nested_attributes_for :taggings, allow_destroy: true
+        self.class_exec(relation) do |tag_relation|
+          include InstanceMethods
 
-        scope :with_tags, -> { includes(:tags) }
+          has_many "#{tag_relation}_taggings".to_sym, -> { where(filter: tag_relation) }, class_name: "LeanTag::Tagging", as: :record, inverse_of: :record, dependent: :destroy
+          has_many tag_relation.to_sym, through: "#{tag_relation}_taggings".to_sym, source: :tag
+
+          accepts_nested_attributes_for "#{tag_relation}_taggings", allow_destroy: true
+
+          scope "with_#{tag_relation}", -> { includes(tag_relation) }
+
+          define_method "add_#{tag_relation.to_s.singularize}", ->(tag) { _add_tag(tag, tag_relation) }
+          define_method "add_#{tag_relation.to_s.singularize}!", ->(tag) { _add_tag!(tag, tag_relation) }
+          define_method "#{tag_relation.to_s.singularize}_list", ->() { _get_tag_list(tag_relation) }
+          define_method "remove_#{tag_relation.to_s.singularize}", ->(tag) { _remove_tag(tag, tag_relation) }
+          define_method "remove_#{tag_relation.to_s.singularize}!", ->(tag) { _remove_tag(tag, tag_relation) }
+          define_method "#{tag_relation.to_s.singularize}_list=", ->(list) { _set_tag_list(list, tag_relation) }
+        end
       end
+
     end
 
 
     module ClassMethods
 
-      def tagged_in(list)
+      ##
+      # Returns all records which include at least one of the passed tags
+      def tagged_with(list, filter="tags")
         list = list.split(LeanTag.config.delimiter) if list.is_a?(String)
         tag_ids = Tag.matches(list).pluck(:id)
-        record_ids = Tagging.where(record_type: self.name, tag_id: tag_ids).pluck(:record_id).uniq
-        return self.where(id: record_ids)
+        taggings = Tagging.where(record_type: self.name, tag_id: tag_ids).where(filter: filter)
+        return self.where(id: taggings.select(:record_id).distinct)
       end
 
-      def tags
-        tag_ids = Tagging.where(record_type: self.name).pluck(:tag_id).uniq
-        return Tag.where(id: tag_ids)
+
+      ##
+      # Get all tags used by this class
+      def tags(filter="tags")
+        taggings = Tagging.where(record_type: self.name, filter: filter).where(filter: filter)
+        return Tag.where(id: taggings.select(:tag_id).distinct)
       end
 
     end
@@ -37,76 +54,75 @@ module LeanTag
 
       ##
       # Adds a single tag on parent save
-      def add_tag(tag)
+      def _add_tag(tag, filter="tags")
         if tag.is_a?(String)
           record = Tag.find_by_name(tag)
         end
 
         if record.nil?
-          self.tags.build(name: tag)
-        elsif !self.taggings.exists?(tag_id: record.id)
-          self.taggings.build(tag_id: record.id)
+          self._tags(filter).build(name: tag)
+        elsif !self._taggings(filter).exists?(tag_id: record.id)
+          self._taggings(filter).build(tag_id: record.id)
         end
       end
 
       ##
       # Adds a single tag immediately
-      def add_tag!(tag)
-        self.add_tag(tag)
+      def _add_tag!(tag, filter="tags")
+        self._add_tag(tag, filter)
         self.save!
       end
 
       ##
-      # Finds current tags on this record which aren't in the passed list
-      def excluded_tags(tag_names)
-        self.tags.reject { |t| t.name.in?(tag_names) }
-      end
-
-      ##
-      # Finds current tags on this record which are in the passed list
-      def included_tags(tag_names)
-        self.tags.select { |t| t.name.in?(tag_names) }
+      # Returns a delimited list of tag names
+      def _get_tag_list(filter="tags")
+        self._taggings(filter).map(&:tag).map(&:name).join(',')
       end
 
-      ##
       # Removes a single tag on parent save
-      def remove_tag(tag)
+      def _remove_tag(tag, filter="tags")
         if tag.is_a?(String)
-          tag = self.tags.where(name: tag).first
+          tag = Tag.find_by_name(tag)
         end
 
-        self.taggings.each { |t| t.mark_for_destruction if t.tag.eql?(tag) }
+        self._taggings(filter).each { |t| t.mark_for_destruction if t.tag.eql?(tag) }
       end
 
       ##
       # Removes a single tag immediately
-      def remove_tag!(tag)
-        self.remove_tag(tag)
+      def _remove_tag!(tag, filter="tags")
+        self._remove_tag(tag, filter)
         self.save!
       end
 
       ##
       # Set a list of tags
-      def tag_list=(value)
-        if value.is_a?(String)
-          tag_names = value.split(LeanTag.config.delimiter)
-        elsif value.is_a?(Array)
-          tag_names = value
+      def _set_tag_list(list, filter="tags")
+        if list.is_a?(String)
+          tag_names = list.split(LeanTag.config.delimiter)
+        elsif list.is_a?(Array)
+          tag_names = list
         else
           tag_names = []
         end
 
-        # Get rid of existing tags that aren't in the list
-        self.excluded_tags(tag_names).each { |t| self.remove_tag(t) }
+        tags = Tag.where(id: self._taggings(filter).select(:tag_id).distinct)
+        tags.reject { |t| t.name.in?(tag_names) }.each { |t| self._remove_tag(t, filter) }
 
         # Add any new tags
-        tag_names.each { |t| self.add_tag(t) }
+        tag_names.each { |t| self._add_tag(t, filter) }
       end
 
       ##
-      # Returns a delimited list of tag names
-      def tag_list
-        self.tags.map(&:name).join(',')
+      # Gets relevant tag association
+      def _tags(filter)
+        self.send(filter)
+      end
+
+      ##
+      # Gets relevant taggings association
+      def _taggings(filter)
+        self.send("#{filter}_taggings")
       end
 
     end

data/lib/lean_tag/tagging.rb

@@ -4,7 +4,9 @@ module LeanTag
     self.table_name = :taggings
 
     belongs_to :record, polymorphic: true, inverse_of: :taggings
-    belongs_to :tag, class_name: "LeanTag::Tag", inverse_of: :taggings, counter_cache: :taggings_count
+    belongs_to :tag, class_name: "LeanTag::Tag", inverse_of: :taggings, counter_cache: :taggings_count, autosave: true
+
+    scope :for, -> (filter) { where(filter: filter) }
 
     validates :record_id, presence: true
     validates :record_type, presence: true

data/lib/lean_tag/version.rb

@@ -1,5 +1,5 @@
 module LeanTag
 
-  VERSION = '0.1.14'
+  VERSION = '1.0.0'
 
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lean_tag
 version: !ruby/object:Gem::Version
-  version: 0.1.14
+  version: 1.0.0
 platform: ruby
 authors:
 - Matt Ellis
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-26 00:00:00.000000000 Z
+date: 2015-04-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec