culturecode-acts_as_taggable 0.2.3 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 805daa96b56881db74f2db609fbdbe17c8b398b0
-  data.tar.gz: 97f49a0d3a0e429ad1f28c774eb71a379d49fb44
+SHA256:
+  metadata.gz: 192c7c327986f8aeb8d2bdeb9a735b72c4cd833e11450b75eb7126d88d2e55e6
+  data.tar.gz: 8532639665cbef5350856e35878983f6058a16fabf4e0eff0c01192d49251b64
 SHA512:
-  metadata.gz: f4bb21307f9e5e2981b02f98296a8a451f0cbb93619f48f646adc0b09905b19bc9784da654ecbda7450ee494a3c7a4838690e33e8922815199207183d681519b
-  data.tar.gz: 2723ee05f50b1a646b7b4ae0a4b505dee171ca0637cea8d3230d01e4b3ebe539705dfee0091e4c59527be01b1a7fa08c910e98062ab3858ef8c96db002de8c2d
+  metadata.gz: 19d1205d39b3ab97f410eea7ba0a15e03563c921b6ca7533633812b658bc5f3e9c4ddcae0e4ffc6b459c3482d5d2bd4a1362c94dd40c503f71c6989af262855d
+  data.tar.gz: '09782afefb72be61de7138490d3cb2f804c3969d3a3dedf2139a393a6c8649bf11a71488eba4e00ae34bb173bb585c297f45ed905ff58e097eb39382029ceef6'

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2015 Nicholas Jakobsen
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,34 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'ActsAsTaggable'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task default: :test

data/lib/acts_as_taggable.rb

@@ -2,4 +2,7 @@ require 'acts_as_taggable/acts_as_taggable'
 require 'acts_as_taggable/tag'
 require 'acts_as_taggable/tagging'
 
-ActiveRecord::Base.extend ActsAsTaggable::ActMethod
+module ActsAsTaggable
+end
+
+ActiveRecord::Base.extend ActsAsTaggable::ActMethod

data/lib/acts_as_taggable/acts_as_taggable.rb

@@ -1,47 +1,190 @@
 module ActsAsTaggable
   module ActMethod #:nodoc:
     def acts_as_taggable(options = {})
-      has_many :taggings, :as => :taggable
-      has_many :tags, :through => :taggings
+      class_attribute :acts_as_taggable_options
+      self.acts_as_taggable_options = options
+      self.acts_as_taggable_options.reverse_merge! :delimiter => ',', :downcase => true, :remove_tag_if_empty => true
+      self.acts_as_taggable_options.reverse_merge! :output_delimiter => acts_as_taggable_options[:delimiter]
+      self.acts_as_taggable_options[:types] = Array(self.acts_as_taggable_options[:types])
 
-      extend ActsAsTaggable::ClassMethods
-      include ActsAsTaggable::InstanceMethods
-    end    
+      has_many :taggings, -> { order("#{Tagging.table_name}.id") }, :as => :taggable, :after_remove => :delete_tag_if_necessary, :dependent => :destroy, :class_name => 'ActsAsTaggable::Tagging'
+      has_many :tags, :through => :taggings, :class_name => 'ActsAsTaggable::Tag', :after_add => :reset_scoped_associations
+
+      extend ClassMethods
+      include InstanceMethods
+
+      self.acts_as_taggable_options[:types].each do |tag_type|
+        has_many :"#{tag_type}_taggings", -> { joins(:tag).order("#{Tagging.table_name}.id").where(Tag.table_name => {:tag_type => tag_type}) }, :as => :taggable, :after_remove => :delete_tag_if_necessary, :class_name => 'ActsAsTaggable::Tagging'
+        has_many :"#{tag_type}_tags", -> { where(:tag_type => tag_type) }, :through => :taggings, :source => :tag, :class_name => 'ActsAsTaggable::Tag', :after_add => :reset_associations
+
+        metaclass = class << self; self; end
+        HelperMethods.scope_class_methods(metaclass, tag_type)
+        HelperMethods.scope_instance_methods(self, tag_type)
+      end
+    end
   end
 
   module ClassMethods
-    # TODO: tagged_with_all
-    
-    def tagged_with_any(*args)
-      args.flatten! # Allow an array of tags to be passed in
 
-      joins(:tags).where(:tags => {:name => args.collect {|tag_name| Tag.sanitize_name(tag_name) } }).uniq
+    def tagged_with_any(*tags)
+      tags = find_tags(tags)
+      return none if tags.empty?
+
+      table_alias = "alias_#{tags.hash.abs}"
+      scope = all.uniq.select "#{table_name}.*"
+      scope = scope.joins "JOIN #{Tagging.table_name} AS #{table_alias} ON #{table_alias}.taggable_id = #{table_name}.id"
+      scope = scope.where "#{table_alias}.tag_id" => tags
+
+      return scope
+    end
+
+    def tagged_with_all(*tags)
+      tags = find_tags(tags)
+      return none if tags.empty?
+
+      tags.inject(all.uniq) do |scope, tag|
+        scope = scope.joins "LEFT OUTER JOIN #{Tagging.table_name} AS alias_#{tag.id} ON alias_#{tag.id}.taggable_id = #{table_name}.id"
+        scope = scope.where "alias_#{tag.id}.tag_id" => tag
+      end
+    end
+
+    # Make it possible to ask for tags on a scoped Taggable relation. e.g. Users.online.applied_tags
+    def applied_tags
+      Tag.select("#{Tag.table_name}.*, COUNT(*) AS count").joins(:taggings).where(:taggable_type => self.name, Tagging.table_name => {:taggable_id => all}).group("#{Tag.table_name}.id")
+    end
+
+    def applied_tag_names
+      applied_tags.pluck(:name)
     end
 
-    # Make it possible to ask for tags on a scoped Taggable relation. e.g. Users.online.tags
     def tags
-      Tag.joins(:taggings).where(:taggings => {:taggable_type => self, :taggable_id => all}).group('tags.id').select("tags.*, COUNT(*) AS count")
+      Tag.where(:taggable_type => name)
+    end
+
+    def tag_names
+      tags.pluck(:name)
+    end
+
+    def create_tag(tag_name)
+      find_tags(tag_name).first || tags.create!(:name => tag_name)
+    end
+
+    # Given an unsanitized string or list of tags, Returns a list of tags
+    def find_tags(*input)
+      input = input.flatten
+      input = input.first if input.one?
+      case input
+      when Tag
+        HelperMethods.filter_tags_by_current_tag_scope([input])
+      when String
+        tags.where(:name => input.split(acts_as_taggable_options[:delimiter]).collect {|tag_name| tag_name.strip}).to_a
+      when Array
+        input.flat_map {|tag| find_tags(tag)}.select(&:present?).uniq
+      when ActiveRecord::Relation
+        input.uniq.to_a
+      else
+        []
+      end
     end
   end
 
   module InstanceMethods
-    TAG_DELIMITER = ','
-    
     def acts_like_taggable?
       true
     end
 
-    def tags_list=(tag_string)
-      self.tags = tag_string.to_s.split(TAG_DELIMITER).collect{|tag_name| Tag.find_or_create_by!(:name => Tag.sanitize_name(tag_name)) }
+    def tag_with(*tag_names)
+      self.tag_names = tag_names.flatten
     end
-    
-    def tags_list
-      tag_names.join(TAG_DELIMITER + ' ')
+
+    def untag_with(*tag_names)
+      self.tag_names = self.tag_names - self.class.find_tags(tag_names).collect(&:name)
+    end
+
+    def tag_string
+      tag_names.join(acts_as_taggable_options[:output_delimiter] + ' ')
     end
-    
+
+    def tag_string=(tag_string)
+      self.tag_names = tag_string.to_s.split(acts_as_taggable_options[:delimiter])
+    end
+
     def tag_names
-      tags.collect(&:name) # don't use pluck since we want to use the cached association
+      send(HelperMethods.scoped_association_name).collect(&:name) # don't use pluck since we want to use the cached association
+    end
+
+    def tag_names=(names)
+      send HelperMethods.scoped_association_assignment_name, names.select(&:present?).collect {|tag_name| self.class.create_tag(tag_name) }
+    end
+
+    private
+
+    def delete_tag_if_necessary(tagging)
+      self.class.tags.where(:id => tagging.tag_id).destroy_all if acts_as_taggable_options[:remove_tag_if_empty] && tagging.tag.taggings.count == 0
+    end
+
+    def reset_scoped_associations(record)
+      return unless record.tag_type
+      send("#{record.tag_type}_taggings").reset
+      send("#{record.tag_type}_tags").reset
+    end
+
+    def reset_associations(record)
+      send(:taggings).reset
+      send(:tags).reset
     end
   end
-end
 
+  module HelperMethods
+    def self.scope_class_methods(metaclass, tag_type)
+      scope_tag_method(metaclass, tag_type, :create_tag, "create_#{tag_type}_tag")
+      scope_tag_method(metaclass, tag_type, :find_tags, "find_#{tag_type}_tags")
+      scope_tag_method(metaclass, tag_type, :tagged_with_any, "tagged_with_any_#{tag_type}")
+      scope_tag_method(metaclass, tag_type, :tagged_with_all, "tagged_with_all_#{tag_type.to_s.pluralize}")
+      scope_tag_method(metaclass, tag_type, :tags, "#{tag_type}_tags")
+      scope_tag_method(metaclass, tag_type, :tag_names, "#{tag_type}_tag_names")
+      scope_tag_method(metaclass, tag_type, :applied_tags, "applied_#{tag_type}_tags")
+      scope_tag_method(metaclass, tag_type, :applied_tag_names, "applied_#{tag_type}_tag_names")
+    end
+
+    def self.scope_instance_methods(klass, tag_type)
+      scope_tag_method(klass, tag_type, :tag_names, "#{tag_type}_tag_names")
+      scope_tag_method(klass, tag_type, :tag_names=, "#{tag_type}_tag_names=")
+      scope_tag_method(klass, tag_type, :tag_string, "#{tag_type}_tag_string")
+      scope_tag_method(klass, tag_type, :tag_string=, "#{tag_type}_tag_string=")
+      scope_tag_method(klass, tag_type, :tag_with, "tag_with_#{tag_type}")
+      scope_tag_method(klass, tag_type, :untag_with, "untag_with_#{tag_type}")
+    end
+
+    def self.scope_tag_method(context, tag_type, method_name, scoped_method_name)
+      context.send :define_method, scoped_method_name do |*args|
+        Tag.where(:tag_type => tag_type).scoping do
+          send(method_name, *args)
+        end
+      end
+    end
+
+    # Filters an array of tags by the current tag scope
+    def self.filter_tags_by_current_tag_scope(tags)
+      return tags unless current_tag_scope
+      tags.select do |tag|
+        current_tag_scope.all? do |attribute, value|
+          tag[attribute].to_s == value.to_s
+        end
+      end
+    end
+
+    def self.scoped_association_name
+      current_tag_scope ? "#{current_tag_scope['tag_type']}_tags" : "tags"
+    end
+
+    def self.scoped_association_assignment_name
+      current_tag_scope ? "#{current_tag_scope['tag_type']}_tags=" : "tags="
+    end
+
+    # Returns the current tag scope, e.g. :tag_type => 'material'
+    def self.current_tag_scope
+      Tag.current_scope.where_values_hash if Tag.current_scope
+    end
+  end
+end

data/lib/acts_as_taggable/tag.rb

@@ -1,21 +1,32 @@
-class Tag < ActiveRecord::Base
-  has_many :taggings
-  default_scope lambda { order(:name) }
-  
-  validates_presence_of :name
-  before_save :sanitize_name
-  
-  def self.sanitize_name(name)
-    name.to_s.strip.squeeze(' ').downcase
-  end
-  
-  def to_s
-    self.name
-  end
+module ActsAsTaggable
+  class Tag < ActiveRecord::Base
+    self.table_name = "acts_as_taggable_tags"
+
+    has_many :taggings, :dependent => :destroy
+    default_scope lambda { order(:name) }
+
+    validates_presence_of :name, :taggable_type
+    before_save :sanitize_name
+
+    def to_s
+      self.name
+    end
+
+    def taggable_class
+      self.taggable_type.constantize
+    end
+
+    # Returns a cache key that is unique based on the last time the tags were updated or applied
+    def taggings_cache_key
+      [name, taggings.maximum(:id), taggings.count]
+    end
+
+    private
 
-  private
-  
-  def sanitize_name
-    self.name = self.class.sanitize_name(self.name)
+    def sanitize_name
+      name = self.name.to_s.squish
+      name.downcase! if taggable_class.acts_as_taggable_options[:downcase]
+      self.name = name
+    end
   end
-end
+end

data/lib/acts_as_taggable/tagging.rb

@@ -1,4 +1,17 @@
-class Tagging < ActiveRecord::Base
-  belongs_to :tag
-  belongs_to :taggable, :polymorphic => true  
-end
+module ActsAsTaggable
+  class Tagging < ActiveRecord::Base
+    self.table_name = "acts_as_taggable_taggings"
+
+    belongs_to :tag
+    belongs_to :taggable, :polymorphic => true
+
+    validate :taggable_type_matches
+
+
+    private
+
+    def taggable_type_matches
+      errors.add(:taggable_type, "can't be tagged with a tag from another class") if tag.taggable_type != taggable_type
+    end
+  end
+end

data/lib/acts_as_taggable/version.rb

@@ -0,0 +1,3 @@
+module ActsAsTaggable
+  VERSION = "1.0.0"
+end

data/lib/generators/migration_generator.rb

@@ -1,23 +1,5 @@
 class ActsAsTaggableMigrationGenerator < Rails::Generators::Base
   def create_migration_file
-    create_file "db/migrations/initializer.rb", <<-EOV
-      class ActsAsTaggableTable < ActiveRecord::Migration
-        def change
-          create_table :tags do |t|
-            t.string :name
-            t.string :tag_type
-          end
-
-          create_table :taggings do |t|
-            t.belongs_to :tag
-            t.belongs_to :taggable, :polymorphic => true
-          end
-
-          add_index :tags, [:name, :tag_type], :unique => true
-          add_index :taggings, [:taggable_type, :taggable_id]
-          add_index :taggings, :tag_id
-        end
-      end
-    EOV
+    create_file "db/migrations/initializer.rb", File.open('schema.rb').read
   end
-end
+end

data/lib/generators/schema.rb

@@ -0,0 +1,18 @@
+class ActsAsTaggableTable < ActiveRecord::Migration
+  def change
+    create_table :acts_as_taggable_tags do |t|
+      t.string :name
+      t.string :taggable_type
+      t.string :tag_type
+    end
+
+    create_table :acts_as_taggable_taggings do |t|
+      t.belongs_to :tag
+      t.belongs_to :taggable, :polymorphic => true
+    end
+
+    add_index :acts_as_taggable_tags, [:name, :taggable_type, :tag_type], :name => "ensure_uniqueness_of_acts_as_taggable_tags", :unique => true
+    add_index :acts_as_taggable_taggings, [:taggable_type, :taggable_id], :name => "index_acts_as_taggable_tagging_associations"
+    add_index :acts_as_taggable_taggings, :tag_id
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: culturecode-acts_as_taggable
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 1.0.0
 platform: ruby
 authors:
 - Nicholas Jakobsen
@@ -9,36 +9,68 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-23 00:00:00.000000000 Z
+date: 2020-05-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rails
+  name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: 4.2.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.0'
-description: 
+        version: 4.2.0
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Simple record tagging
 email: contact@culturecode.ca
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- MIT-LICENSE
+- Rakefile
+- lib/acts_as_taggable.rb
 - lib/acts_as_taggable/acts_as_taggable.rb
 - lib/acts_as_taggable/tag.rb
 - lib/acts_as_taggable/tagging.rb
-- lib/acts_as_taggable.rb
+- lib/acts_as_taggable/version.rb
 - lib/generators/migration_generator.rb
-- README.rdoc
+- lib/generators/schema.rb
 homepage: http://github.com/culturecode/acts_as_taggable
-licenses: []
+licenses:
+- MIT
 metadata: {}
 post_install_message: 
 rdoc_options: []
@@ -46,17 +78,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.5
+rubygems_version: 2.7.9
 signing_key: 
 specification_version: 4
 summary: Simple record tagging

data/README.rdoc

@@ -1,3 +0,0 @@
-== ActsAsTaggable
-
-Simple tagging.