dm-taggings 0.11.0 → 1.0.0

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--colour

data/Gemfile

@@ -1,106 +1,23 @@
-# If you're working on more than one datamapper gem at a time, then it's
-# recommended to create a local Gemfile and use this instead of the git
-# sources. This will make sure that you are  developing against your
-# other local datamapper sources that you currently work on. Gemfile.local
-# will behave identically to the standard Gemfile apart from the fact that
-# it fetches the datamapper gems from local paths. This means that you can use
-# the same environment variables, like ADAPTER(S) or PLUGIN(S) when running
-# bundle commands. Gemfile.local is added to .gitignore, so you don't need to
-# worry about accidentally checking local development paths into git.
-# In order to create a local Gemfile, all you need to do is run:
-#
-#   bundle exec rake local_gemfile
-#
-# This will give you a Gemfile.local file that points to your local clones of
-# the various datamapper gems. It's assumed that all datamapper repo clones
-# reside in the same directory. You can use the Gemfile.local like so for
-# running any bundle command:
-#
-#   BUNDLE_GEMFILE=Gemfile.local bundle foo
-#
-# You can also specify which adapter(s) should be part of the bundle by setting
-# an environment variable. This of course also works when using the Gemfile.local
-#
-#   bundle foo                        # dm-sqlite-adapter
-#   ADAPTER=mysql bundle foo          # dm-mysql-adapter
-#   ADAPTERS=sqlite,mysql bundle foo  # dm-sqlite-adapter and dm-mysql-adapter
-#
-# Of course you can also use the ADAPTER(S) variable when using the Gemfile.local
-# and running specs against selected adapters.
-#
-# For easily working with adapters supported on your machine, it's recommended
-# that you first install all adapters that you are planning to use or work on
-# by doing something like
-#
-#   ADAPTERS=sqlite,mysql,postgres bundle install
-#
-# This will clone the various repositories and make them available to bundler.
-# Once you have them installed you can easily switch between adapters for the
-# various development tasks. Running something like
-#
-#   ADAPTER=mysql bundle exec rake spec
-#
-# will make sure that the dm-mysql-adapter is part of the bundle, and will be used
-# when running the specs.
-#
-# You can also specify which plugin(s) should be part of the bundle by setting
-# an environment variable. This also works when using the Gemfile.local
-#
-#   bundle foo                                 # dm-migrations
-#   PLUGINS=dm-validations bundle foo          # dm-migrations and dm-validations
-#   PLUGINS=dm-validations,dm-types bundle foo # dm-migrations, dm-validations and dm-types
-#
-# Of course you can combine the PLUGIN(S) and ADAPTER(S) env vars to run specs
-# for certain adapter/plugin combinations.
-#
-# Finally, to speed up running specs and other tasks, it's recommended to run
-#
-#   bundle lock
-#
-# after running 'bundle install' for the first time. This will make 'bundle exec' run
-# a lot faster compared to the unlocked version. With an unlocked bundle you would
-# typically just run 'bundle install' from time to time to fetch the latest sources from
-# upstream. When you locked your bundle, you need to run
-#
-#   bundle install --relock
-#
-# to make sure to fetch the latest updates and then lock the bundle again. Gemfile.lock
-# is added to the .gitignore file, so you don't need to worry about accidentally checking
-# it into version control.
+require 'pathname'
 
 source 'http://rubygems.org'
 
-DATAMAPPER = 'git://github.com/datamapper'
-DM_VERSION = '~> 1.0.2'
-
-group :runtime do # Runtime dependencies (as in the gemspec)
-
-  if ENV['EXTLIB']
-    gem 'extlib',        '~> 0.9.15', :git => "#{DATAMAPPER}/extlib.git"
-  else
-    gem 'activesupport', '~> 3.0.0',  :git => 'git://github.com/rails/rails.git', :branch => '3-0-stable', :require => nil
-  end
-
-  gem 'dm-core',         DM_VERSION, :git => "#{DATAMAPPER}/dm-core.git"
-  gem 'dm-constraints',  DM_VERSION, :git => "#{DATAMAPPER}/dm-constraints.git"
-  gem 'dm-is-remixable', DM_VERSION, :git => "#{DATAMAPPER}/dm-is-remixable.git"
-
-end
+SOURCE       = ENV['SOURCE']   ? ENV['SOURCE'].to_sym              : :git
+REPO_POSTFIX = SOURCE == :path ? ''                                : '.git'
+DATAMAPPER   = SOURCE == :path ? Pathname(__FILE__).dirname.parent : 'http://github.com/datamapper'
+DM_VERSION   = '~> 1.1.0'
 
 group(:development) do # Development dependencies (as in the gemspec)
 
-  gem 'rake',           '~> 0.8.7'
-  gem 'rspec',          '~> 1.3', :git => 'git://github.com/snusnu/rspec', :branch => 'heckle_fix_plus_gemfile'
-  gem 'jeweler',        '~> 1.4'
+  gem 'rake',    '~> 0.8.7'
+  gem 'rspec',   '~> 2.4', :require => false
+  gem 'jeweler', '~> 1.5.2'
 
 end
 
 group :quality do # These gems contain rake tasks that check the quality of the source code
 
-  gem 'metric_fu',      '~> 1.3'
-  gem 'rcov',           '~> 0.9.8'
-  gem 'reek',           '~> 1.2.8'
-  gem 'roodi',          '~> 2.1'
+  gem 'rcov',           '~> 0.9.7', :platforms => :mri_18
   gem 'yard',           '~> 0.5'
   gem 'yardstick',      '~> 0.1'
 
@@ -108,15 +25,17 @@ end
 
 group :datamapper do # We need this because we want to pin these dependencies to their git master sources
 
-  adapters = ENV['ADAPTER'] || ENV['ADAPTERS']
-  adapters = adapters.to_s.tr(',', ' ').split.uniq - %w[ in_memory ]
+  gem 'dm-taggings', '~> 1.0.0', :path => File.dirname(__FILE__) # Make ourself available to the adapters
+
+  adapters = ENV['ADAPTERS'] || ENV['ADAPTER'] || 'in_memory'
+  adapters = adapters.to_s.tr(',', ' ').split.uniq
 
   DO_VERSION     = '~> 0.10.2'
   DM_DO_ADAPTERS = %w[ sqlite postgres mysql oracle sqlserver ]
 
   if (do_adapters = DM_DO_ADAPTERS & adapters).any?
     options = {}
-    options[:git] = "#{DATAMAPPER}/do.git" if ENV['DO_GIT'] == 'true'
+    options[:git] = "#{DATAMAPPER}/do#{REPO_POSTFIX}" if ENV['DO_GIT'] == 'true'
 
     gem 'data_objects',  DO_VERSION, options.dup
 
@@ -125,18 +44,24 @@ group :datamapper do # We need this because we want to pin these dependencies to
       gem "do_#{adapter}", DO_VERSION, options.dup
     end
 
-    gem 'dm-do-adapter', DM_VERSION, :git => "#{DATAMAPPER}/dm-do-adapter.git"
+    gem 'dm-do-adapter', DM_VERSION, SOURCE => "#{DATAMAPPER}/dm-do-adapter#{REPO_POSTFIX}"
   end
 
   adapters.each do |adapter|
-    gem "dm-#{adapter}-adapter", DM_VERSION, :git => "#{DATAMAPPER}/dm-#{adapter}-adapter.git"
+    unless adapter == 'in_memory'
+      gem "dm-#{adapter}-adapter", DM_VERSION, SOURCE => "#{DATAMAPPER}/dm-#{adapter}-adapter#{REPO_POSTFIX}"
+    end
   end
 
   plugins = ENV['PLUGINS'] || ENV['PLUGIN']
-  plugins = plugins.to_s.tr(',', ' ').split.push('dm-migrations').uniq
+  plugins = plugins.to_s.tr(',', ' ').split.push('dm-core').uniq
+
+  %w(dm-migrations dm-validations dm-constraints dm-is-remixable).each do |plugin|
+    plugins.push(plugin)
+  end
 
-  plugins.each do |plugin|
-    gem plugin, DM_VERSION, :git => "#{DATAMAPPER}/#{plugin}.git"
+  plugins.uniq.each do |plugin|
+    gem plugin, DM_VERSION, SOURCE => "#{DATAMAPPER}/#{plugin}#{REPO_POSTFIX}"
   end
 
 end

data/Rakefile

@@ -10,26 +10,25 @@ end
 
 Bundler.require(:default, :development)
 
-
 begin
-
   require 'rake'
+
+  gem 'jeweler', '~> 1.5.2'
   require 'jeweler'
 
   Jeweler::Tasks.new do |gem|
 
     gem.name        = 'dm-taggings'
     gem.summary     = 'Tagging plugin for DataMapper'
-    gem.description = 'DataMapper plugin that adds the possibility to tag models'
+    gem.description = 'DataMapper plugin providing taggable and tagger models'
     gem.email       = 'piotr.solnica@gmail.com'
     gem.homepage    = 'http://github.com/solnic/dm-taggings'
     gem.authors     = [ 'Piotr Solnica' ]
 
-    gem.add_dependency 'dm-core',           '~> 1.0.2'
-    gem.add_dependency 'dm-constraints',    '~> 1.0.2'
-    gem.add_dependency 'dm-is-remixable',   '~> 1.0.2'
+    gem.add_dependency 'dm-constraints',    '~> 1.1.0'
+    gem.add_dependency 'dm-is-remixable',   '~> 1.1.0'
 
-    gem.add_development_dependency 'rspec', '~> 1.3'
+    gem.add_development_dependency 'rspec', '~> 2.4'
     gem.add_development_dependency 'yard',  '~> 0.5'
 
   end

data/VERSION

@@ -1 +1 @@
-0.11.0
+1.0.0

data/dm-taggings.gemspec

@@ -1,88 +1,91 @@
 # Generated by jeweler
 # DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
 
 Gem::Specification.new do |s|
   s.name = %q{dm-taggings}
-  s.version = "0.11.0"
+  s.version = "1.0.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Piotr Solnica"]
-  s.date = %q{2010-10-14}
-  s.description = %q{DataMapper plugin that adds the possibility to tag models}
+  s.date = %q{2011-03-17}
+  s.description = %q{DataMapper plugin providing taggable and tagger models}
   s.email = %q{piotr.solnica@gmail.com}
   s.extra_rdoc_files = [
     "LICENSE",
-     "README.rdoc",
-     "TODO"
+    "README.rdoc",
+    "TODO"
   ]
   s.files = [
-    ".gitignore",
-     "Gemfile",
-     "History.txt",
-     "LICENSE",
-     "Manifest.txt",
-     "README.rdoc",
-     "Rakefile",
-     "TODO",
-     "VERSION",
-     "dm-taggings.gemspec",
-     "lib/dm-taggings.rb",
-     "lib/dm-taggings/is/tag.rb",
-     "lib/dm-taggings/is/taggable.rb",
-     "lib/dm-taggings/is/tagger.rb",
-     "lib/dm-taggings/is/tagging.rb",
-     "lib/dm-taggings/is/version.rb",
-     "lib/dm-taggings/spec/taggable_shared_spec.rb",
-     "lib/dm-taggings/spec/tagger_shared_spec.rb",
-     "spec/fixtures/models.rb",
-     "spec/integration/post_spec.rb",
-     "spec/integration/tag_spec.rb",
-     "spec/integration/taggable_spec.rb",
-     "spec/integration/user_spec.rb",
-     "spec/spec.opts",
-     "spec/spec_helper.rb",
-     "tasks/hoe.rb",
-     "tasks/yard.rake",
-     "tasks/yardstick.rake"
+    ".rspec",
+    "Gemfile",
+    "History.txt",
+    "LICENSE",
+    "Manifest.txt",
+    "README.rdoc",
+    "Rakefile",
+    "TODO",
+    "VERSION",
+    "dm-taggings.gemspec",
+    "lib/dm-taggings.rb",
+    "lib/dm-taggings/is/tag.rb",
+    "lib/dm-taggings/is/taggable.rb",
+    "lib/dm-taggings/is/tagger.rb",
+    "lib/dm-taggings/is/tagging.rb",
+    "lib/dm-taggings/is/version.rb",
+    "lib/dm-taggings/spec/taggable_shared_spec.rb",
+    "lib/dm-taggings/spec/tagger_shared_spec.rb",
+    "spec/fixtures/models.rb",
+    "spec/integration/post_spec.rb",
+    "spec/integration/tag_spec.rb",
+    "spec/integration/taggable_spec.rb",
+    "spec/integration/user_spec.rb",
+    "spec/spec_helper.rb",
+    "tasks/hoe.rb",
+    "tasks/yard.rake",
+    "tasks/yardstick.rake"
   ]
   s.homepage = %q{http://github.com/solnic/dm-taggings}
-  s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.7}
+  s.rubygems_version = %q{1.6.2}
   s.summary = %q{Tagging plugin for DataMapper}
   s.test_files = [
+    "spec/fixtures/models.rb",
+    "spec/integration/post_spec.rb",
+    "spec/integration/tag_spec.rb",
     "spec/integration/taggable_spec.rb",
-     "spec/integration/post_spec.rb",
-     "spec/integration/tag_spec.rb",
-     "spec/integration/user_spec.rb",
-     "spec/fixtures/models.rb",
-     "spec/spec_helper.rb"
+    "spec/integration/user_spec.rb",
+    "spec/spec_helper.rb"
   ]
 
   if s.respond_to? :specification_version then
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
     s.specification_version = 3
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<dm-core>, ["~> 1.0.2"])
-      s.add_runtime_dependency(%q<dm-constraints>, ["~> 1.0.2"])
-      s.add_runtime_dependency(%q<dm-is-remixable>, ["~> 1.0.2"])
-      s.add_development_dependency(%q<rspec>, ["~> 1.3"])
+      s.add_development_dependency(%q<rake>, ["~> 0.8.7"])
+      s.add_development_dependency(%q<rspec>, ["~> 2.4"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.5.2"])
+      s.add_runtime_dependency(%q<dm-constraints>, ["~> 1.1.0"])
+      s.add_runtime_dependency(%q<dm-is-remixable>, ["~> 1.1.0"])
+      s.add_development_dependency(%q<rspec>, ["~> 2.4"])
       s.add_development_dependency(%q<yard>, ["~> 0.5"])
     else
-      s.add_dependency(%q<dm-core>, ["~> 1.0.2"])
-      s.add_dependency(%q<dm-constraints>, ["~> 1.0.2"])
-      s.add_dependency(%q<dm-is-remixable>, ["~> 1.0.2"])
-      s.add_dependency(%q<rspec>, ["~> 1.3"])
+      s.add_dependency(%q<rake>, ["~> 0.8.7"])
+      s.add_dependency(%q<rspec>, ["~> 2.4"])
+      s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+      s.add_dependency(%q<dm-constraints>, ["~> 1.1.0"])
+      s.add_dependency(%q<dm-is-remixable>, ["~> 1.1.0"])
+      s.add_dependency(%q<rspec>, ["~> 2.4"])
       s.add_dependency(%q<yard>, ["~> 0.5"])
     end
   else
-    s.add_dependency(%q<dm-core>, ["~> 1.0.2"])
-    s.add_dependency(%q<dm-constraints>, ["~> 1.0.2"])
-    s.add_dependency(%q<dm-is-remixable>, ["~> 1.0.2"])
-    s.add_dependency(%q<rspec>, ["~> 1.3"])
+    s.add_dependency(%q<rake>, ["~> 0.8.7"])
+    s.add_dependency(%q<rspec>, ["~> 2.4"])
+    s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+    s.add_dependency(%q<dm-constraints>, ["~> 1.1.0"])
+    s.add_dependency(%q<dm-is-remixable>, ["~> 1.1.0"])
+    s.add_dependency(%q<rspec>, ["~> 2.4"])
     s.add_dependency(%q<yard>, ["~> 0.5"])
   end
 end

data/lib/dm-taggings.rb

@@ -7,12 +7,12 @@ require 'dm-is-remixable'
 
 # Require plugin-files
 
-dir = Pathname(__FILE__).dirname.expand_path / 'dm-taggings' / 'is'
+dir = File.dirname(__FILE__) + '/dm-taggings/is/'
 
-require dir / 'taggable.rb'
-require dir / 'tag.rb'
-require dir / 'tagging.rb'
-require dir / 'tagger.rb'
+require dir + 'taggable.rb'
+require dir + 'tag.rb'
+require dir + 'tagging.rb'
+require dir + 'tagger.rb'
 
 # Include the plugin in Resource
 DataMapper::Model.append_extensions DataMapper::Is::Taggable

data/lib/dm-taggings/is/taggable.rb

@@ -31,39 +31,46 @@ module DataMapper
 
         class << self
           attr_reader :tagging_parent_name, :tagging_relationship_name, :tagging_relationship,
-            :tagging_class, :taggable_relationship_name
+            :tagging_class, :taggable_relationship_name, :taggable_options
         end
 
+        # set up options hash
+        @taggable_options = {}
+        @taggable_options[:tag_list_separator] = options.fetch(:tag_list_separator, ',')
+
         # Make the magic happen
         options[:by] ||= []
 
-        remix n, :taggings
+        remix n, :taggings, :constraint => :destroy!
+
+        inflector = DataMapper::Inflector
 
-        @tagging_parent_name       = DataMapper::Inflector.underscore(name).to_sym
+        @tagging_parent_name       = inflector.underscore(inflector.demodulize(name)).to_sym
         @tagging_relationship_name = "#{@tagging_parent_name}_tags".to_sym
         @tagging_relationship      = relationships[@tagging_relationship_name]
         @tagging_class             = @tagging_relationship.child_model
 
-        @taggable_relationship_name = DataMapper::Inflector.underscore(name).pluralize.to_sym
+        @taggable_relationship_name = inflector.pluralize(inflector.underscore(inflector.demodulize(name))).to_sym
 
         @tagging_relationship.add_constraint_option(
           @taggable_relationship_name, @tagging_class, self, :constraint => :destroy!)
 
         tagging_parent_name = @tagging_parent_name
+        model_name          = name
 
         enhance :taggings do
           belongs_to :tag
-          belongs_to tagging_parent_name
+          belongs_to tagging_parent_name, model_name
 
           options[:by].each do |tagger_class|
-            belongs_to DataMapper::Inflector.underscore(tagger_class.name), :required => false
+            belongs_to inflector.underscore(inflector.demodulize(tagger_class.name)), tagger_class.name, :required => false
           end
         end
 
-        has n, :tags, :through => @tagging_relationship_name, :constraint => :destroy!
+        has n, :tags, :through => @tagging_relationship_name
 
-        Tag.has n, @tagging_relationship_name,  :constraint => :destroy!
-        Tag.has n, @taggable_relationship_name, :through => @tagging_relationship_name
+        Tag.has n, @tagging_relationship_name,  :model => tagging_class, :constraint => :destroy!
+        Tag.has n, @taggable_relationship_name, :model => name, :through => @tagging_relationship_name
 
         options[:by].each do |tagger_class|
           tagger_class.is :tagger, :for => [self]
@@ -119,14 +126,8 @@ module DataMapper
         #
         # @api public
         def tag(tags_or_names)
-          tags = extract_tags_from_names(tags_or_names)
-
-          tags.each do |tag|
-            next if self.tags.include?(tag)
-            taggings.new(:tag => tag)
-          end
-
-          taggings
+          tags_to_add = extract_tags_from_names(tags_or_names) - tags
+          tags.push(*tags_to_add)
         end
 
         # Add tags to a resource and persists them.
@@ -139,9 +140,9 @@ module DataMapper
         #
         # @api public
         def tag!(tags_or_names)
-          taggings = tag(tags_or_names)
-          taggings.save! unless new?
-          taggings
+          added_tags = tag(tags_or_names)
+          save unless new?
+          added_tags
         end
 
         # Delete given tags from a resource collection without actually deleting
@@ -155,17 +156,13 @@ module DataMapper
         #
         # @api public
         def untag(tags_or_names=nil)
-          tags = extract_tags_from_names(tags_or_names) if tags_or_names
-
-          taggings_to_destroy = if tags.blank?
-                             taggings.all
+          tags_to_remove = if tags_or_names
+                             extract_tags_from_names(tags_or_names)
                            else
-                             taggings.all(:tag => tags)
+                             tags.dup
                            end
 
-          self.taggings = taggings - taggings_to_destroy
-
-          taggings_to_destroy
+          tags_to_remove.each { |tag| tags.delete(tag) }
         end
 
         # Same as untag but actually delete the tags from the datastore.
@@ -178,9 +175,9 @@ module DataMapper
         #
         # @api public
         def untag!(tags_or_names=nil)
-          taggings_to_destroy = untag(tags_or_names)
-          taggings_to_destroy.destroy! unless new?
-          taggings_to_destroy
+          removed_tags = untag(tags_or_names)
+          save unless new?
+          removed_tags
         end
 
         # Return a string representation of tags collection
@@ -190,7 +187,7 @@ module DataMapper
         #
         # @api public
         def tag_list
-          @tag_list ||= tags.collect { |tag| tag.name }.join(", ")
+          @tag_list ||= tags.collect { |tag| tag.name }.join("#{self.class.taggable_options[:tag_list_separator]} ")
         end
 
         # Tag a resource using tag names from the give list separated by commas.
@@ -200,14 +197,19 @@ module DataMapper
         #
         # @return [DataMapper::Associations::OneToMany::Collection]
         #   A DataMapper collection of resource's tags
+        #
+        # @api public
         def tag_list=(list)
           @tag_list = list
 
-          tag_names = list.split(",").map { |name| name.blank? ? nil : name.strip }.compact
+          tag_names = list.split(self.class.taggable_options[:tag_list_separator]).map do |name|
+            name.strip!
+            name.size == 0 ? nil : name
+          end.compact
 
-          old_tag_names = taggings.map { |tagging| tagging.tag.name } - tag_names
+          old_tag_names = tags.map { |tag| tag.name } - tag_names
 
-          untag!(old_tag_names)
+          untag(old_tag_names)
           tag(tag_names)
         end