gutentag 0.9.0 → 1.0.0

data/lib/gutentag/dirty.rb

@@ -1,10 +1,13 @@
+# frozen_string_literal: true
+
 class Gutentag::Dirty
   def self.call(instance, tag_names)
     new(instance, tag_names).call
   end
 
   def initialize(instance, tag_names)
-    @instance, @tag_names = instance, tag_names
+    @instance  = instance
+    @tag_names = tag_names
   end
 
   def call

data/lib/gutentag/engine.rb

@@ -1,7 +1,5 @@
+# frozen_string_literal: true
+
 class Gutentag::Engine < Rails::Engine
   engine_name :gutentag
-
-  ActiveSupport.on_load :active_record do
-    extend Gutentag::HasManyTags
-  end
 end

data/lib/gutentag/persistence.rb

@@ -1,11 +1,14 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
 class Gutentag::Persistence
+  extend Forwardable
 
-  attr_writer :tagger, :normaliser
+  attr_writer :tagger
 
-  def initialize(taggable)
-    @taggable = taggable
-    @existing = normalised taggable.tags.collect(&:name)
-    @changes  = normalised taggable.tag_names
+  def initialize(change_state)
+    @change_state = change_state
   end
 
   def persist
@@ -17,20 +20,18 @@ class Gutentag::Persistence
 
   private
 
-  attr_reader :taggable, :existing, :changes
+  attr_reader :change_state
+
+  def_delegators :change_state, :taggable, :added, :removed
 
   def add_new
-    (changes - existing).each do |name|
+    added.each do |name|
       taggable.tags << tagger.find_or_create(name)
     end
   end
 
-  def normalised(names)
-    names.collect { |name| normaliser.call(name) }.uniq
-  end
-
   def remove_old
-    (existing - changes).each do |name|
+    removed.each do |name|
       taggable.tags.delete tagger.find_by_name(name)
     end
   end
@@ -38,8 +39,4 @@ class Gutentag::Persistence
   def tagger
     @tagger ||= Gutentag::Tag
   end
-
-  def normaliser
-    @normaliser ||= Proc.new { |name| Gutentag.normaliser.call(name) }
-  end
 end

data/lib/gutentag/tag_validations.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Gutentag::TagValidations
   def self.call(klass)
     new(klass).call
@@ -8,7 +10,8 @@ class Gutentag::TagValidations
   end
 
   def call
-    klass.validates :name, :presence => true,
+    klass.validates :name,
+      :presence   => true,
       :uniqueness => {:case_sensitive => false}
   end
 

data/lib/gutentag/tagged_with.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Gutentag::TaggedWith
   def self.call(model, options)
     new(model, options).call
@@ -33,6 +35,6 @@ class Gutentag::TaggedWith
   end
 end
 
-require 'gutentag/tagged_with/query'
-require 'gutentag/tagged_with/id_query'
-require 'gutentag/tagged_with/name_query'
+require "gutentag/tagged_with/query"
+require "gutentag/tagged_with/id_query"
+require "gutentag/tagged_with/name_query"

data/lib/gutentag/tagged_with/id_query.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Gutentag::TaggedWith::IDQuery < Gutentag::TaggedWith::Query
   private
 

data/lib/gutentag/tagged_with/name_query.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Gutentag::TaggedWith::NameQuery < Gutentag::TaggedWith::Query
   def initialize(model, values, match)
     super

data/lib/gutentag/tagged_with/query.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Gutentag::TaggedWith::Query
   def initialize(model, values, match)
     @model  = model

data/spec/acceptance/tag_names_spec.rb

@@ -1,38 +1,40 @@
-require 'spec_helper'
+# frozen_string_literal: true
+
+require "spec_helper"
 
 describe "Managing tags via names" do
   let(:article)   { Article.create }
 
   it "returns tag names" do
-    melbourne = Gutentag::Tag.create :name => 'melbourne'
+    melbourne = Gutentag::Tag.create :name => "melbourne"
 
     article.tags << melbourne
 
-    expect(article.tag_names).to eq(['melbourne'])
+    expect(article.tag_names).to eq(["melbourne"])
   end
 
   it "adds tags via their names" do
-    article.tag_names << 'melbourne'
+    article.tag_names << "melbourne"
     article.save!
 
-    expect(article.tags.collect(&:name)).to eq(['melbourne'])
+    expect(article.tags.collect(&:name)).to eq(["melbourne"])
   end
 
   it "makes model dirty when changing through tag_names" do
-    article.tag_names << 'melbourne'
+    article.tag_names << "melbourne"
     article.save!
 
-    article.tag_names = ['sydney']
+    article.tag_names = ["sydney"]
 
     expect(article.changed_attributes.stringify_keys).
-      to eq('tag_names' => ['melbourne'])
+      to eq("tag_names" => ["melbourne"])
   end if Gutentag.dirtier
 
   it "does not make model dirty when changing through tag_names" do
-    article.tag_names << 'melbourne'
+    article.tag_names << "melbourne"
     article.save!
 
-    article.tag_names = ['melbourne']
+    article.tag_names = ["melbourne"]
 
     expect(article.changed_attributes).to eq({})
   end
@@ -40,87 +42,87 @@ describe "Managing tags via names" do
   it "allows for different tag normalisation" do
     Gutentag.normaliser = lambda { |name| name.upcase }
 
-    tag = Gutentag::Tag.create(:name => 'melbourne')
-    expect(tag.name).to eq('MELBOURNE')
+    tag = Gutentag::Tag.create(:name => "melbourne")
+    expect(tag.name).to eq("MELBOURNE")
 
     Gutentag.normaliser = nil
   end
 
   it "doesn't complain when adding an existing tag" do
-    article.tag_names << 'melbourne'
-    article.tag_names << 'melbourne'
+    article.tag_names << "melbourne"
+    article.tag_names << "melbourne"
     article.save!
 
-    expect(article.tags.collect(&:name)).to eq(['melbourne'])
+    expect(article.tags.collect(&:name)).to eq(["melbourne"])
   end
 
   it "accepts a completely new set of tags" do
-    article.tag_names = ['portland', 'oregon']
+    article.tag_names = %w[ portland oregon ]
     article.save!
 
-    expect(article.tags.collect(&:name)).to eq(['portland', 'oregon'])
+    expect(article.tags.collect(&:name)).to eq(%w[ portland oregon ])
   end
 
   it "does not allow duplication of tags" do
     existing = Article.create
-    existing.tags << Gutentag::Tag.create(:name => 'portland')
+    existing.tags << Gutentag::Tag.create(:name => "portland")
 
-    article.tag_names = ['portland']
+    article.tag_names = %w[ portland ]
     article.save!
 
     expect(existing.tag_ids).to eq(article.tag_ids)
   end
 
   it "appends tag names" do
-    article.tag_names  = ['portland']
-    article.tag_names += ['oregon', 'ruby']
+    article.tag_names  = %w[ portland ]
+    article.tag_names += %w[ oregon ruby ]
     article.save!
 
-    expect(article.tags.collect(&:name)).to eq(['portland', 'oregon', 'ruby'])
+    expect(article.tags.collect(&:name)).to eq(%w[ portland oregon ruby ])
   end
 
   it "does not repeat appended names that already exist" do
-    article.tag_names  = ['portland', 'oregon']
-    article.tag_names += ['oregon', 'ruby']
+    article.tag_names  = %w[ portland oregon ]
+    article.tag_names += %w[ oregon ruby ]
     article.save!
 
-    expect(article.tags.collect(&:name)).to eq(['portland', 'oregon', 'ruby'])
+    expect(article.tags.collect(&:name)).to eq(%w[ portland oregon ruby ])
   end
 
   it "removes a single tag name" do
-    article.tag_names = ['portland', 'oregon']
-    article.tag_names.delete 'oregon'
+    article.tag_names = %w[ portland oregon ]
+    article.tag_names.delete "oregon"
     article.save!
 
-    expect(article.tags.collect(&:name)).to eq(['portland'])
+    expect(article.tags.collect(&:name)).to eq(%w[ portland ])
   end
 
   it "removes tag names" do
-    article.tag_names  = ['portland', 'oregon', 'ruby']
-    article.tag_names -= ['oregon', 'ruby']
+    article.tag_names  = %w[ portland oregon ruby ]
+    article.tag_names -= %w[ oregon ruby ]
     article.save!
 
-    expect(article.tags.collect(&:name)).to eq(['portland'])
+    expect(article.tags.collect(&:name)).to eq(%w[ portland ])
   end
 
   it "matches tag names ignoring case" do
-    article.tag_names  = ['portland']
-    article.tag_names += ['Portland']
+    article.tag_names  = %w[ portland ]
+    article.tag_names += %w[ Portland ]
     article.save!
 
-    expect(article.tags.collect(&:name)).to eq(['portland'])
+    expect(article.tags.collect(&:name)).to eq(%w[ portland ])
 
-    article.tag_names << 'Portland'
+    article.tag_names << "Portland"
     article.save!
 
-    expect(article.tags.collect(&:name)).to eq(['portland'])
+    expect(article.tags.collect(&:name)).to eq(%w[ portland ])
   end
 
   it "allows setting of tag names on unpersisted objects" do
-    article = Article.new :tag_names => ['melbourne', 'pancakes']
+    article = Article.new :tag_names => %w[ melbourne pancakes ]
     article.save!
 
-    expect(article.tag_names).to eq(['melbourne', 'pancakes'])
+    expect(article.tag_names).to eq(%w[ melbourne pancakes ])
   end
 
   it "allows overriding of tag_names=" do

data/spec/acceptance/tags_spec.rb

@@ -1,8 +1,10 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
-describe 'Adding and removing tags' do
+require "spec_helper"
+
+describe "Adding and removing tags" do
   let(:article)  { Article.create }
-  let(:pancakes) { Gutentag::Tag.create :name => 'pancakes' }
+  let(:pancakes) { Gutentag::Tag.create :name => "pancakes" }
 
   it "stores new tags" do
     article.tags << pancakes
@@ -24,7 +26,7 @@ describe 'Adding and removing tags' do
     article.destroy
 
     expect(Gutentag::Tagging.where(
-      :taggable_type => 'Article', :taggable_id => article.id
+      :taggable_type => "Article", :taggable_id => article.id
     ).count).to be_zero
   end
 
@@ -36,8 +38,8 @@ describe 'Adding and removing tags' do
     expect(Gutentag::Tagging.where(:tag_id => pancakes.id).count).to be_zero
   end
 
-  it 'should have a mean tag cloud' do
-    gorillas = Gutentag::Tag.create(:name => 'gorillas')
+  it "should have a mean tag cloud" do
+    gorillas = Gutentag::Tag.create(:name => "gorillas")
     another_article = Article.create
 
     article.tags << pancakes

data/spec/gutentag/active_record_spec.rb

@@ -1,37 +1,39 @@
-require 'spec_helper'
+# frozen_string_literal: true
+
+require "spec_helper"
 
 describe Gutentag::ActiveRecord do
-  describe '.tagged_with' do
+  describe ".tagged_with" do
     let!(:melbourne_article) do
-      article = Article.create :title => 'Overview'
-      article.tag_names << 'melbourne'
+      article = Article.create :title => "Overview"
+      article.tag_names << "melbourne"
       article.save!
       article
     end
 
     let!(:oregon_article) do
       article = Article.create
-      article.tag_names << 'oregon'
+      article.tag_names << "oregon"
       article.save!
       article
     end
 
     let!(:melbourne_oregon_article) do
       article = Article.create
-      article.tag_names = %w(oregon melbourne)
+      article.tag_names = %w[ oregon melbourne ]
       article.save!
       article
     end
 
-    context 'given a single tag name' do
-      subject { Article.tagged_with(:names => 'melbourne') }
+    context "given a single tag name" do
+      subject { Article.tagged_with(:names => "melbourne") }
 
       it { expect(subject.count).to eq 2 }
       it { is_expected.to include melbourne_article, melbourne_oregon_article }
       it { is_expected.not_to include oregon_article }
     end
 
-    context 'given a single tag name[symbol]' do
+    context "given a single tag name[symbol]" do
       subject { Article.tagged_with(:names => :melbourne) }
 
       it { expect(subject.count).to eq 2 }
@@ -39,7 +41,7 @@ describe Gutentag::ActiveRecord do
       it { is_expected.not_to include oregon_article }
     end
 
-    context 'given a denormalized tag name' do
+    context "given a denormalized tag name" do
       subject { Article.tagged_with(:names => "MelbournE") }
 
       it { expect(subject.count).to eq 2 }
@@ -47,160 +49,115 @@ describe Gutentag::ActiveRecord do
       it { is_expected.not_to include oregon_article }
     end
 
-    context 'given multiple tag names' do
-      subject { Article.tagged_with(:names => ['melbourne', 'oregon']) }
+    context "given multiple tag names" do
+      subject { Article.tagged_with(:names => %w[ melbourne oregon ]) }
 
       it { expect(subject.count).to eq 3 }
-      it { is_expected.to include melbourne_article, oregon_article, melbourne_oregon_article }
+      it do
+        is_expected.to include(
+          melbourne_article, oregon_article, melbourne_oregon_article
+        )
+      end
     end
 
-    context 'given an array of tag names' do
-      subject { Article.tagged_with(:names => %w(melbourne oregon)) }
+    context "given an array of tag names" do
+      subject { Article.tagged_with(:names => %w[ melbourne oregon ]) }
 
       it { expect(subject.count).to eq 3 }
-      it { is_expected.to include melbourne_article, oregon_article, melbourne_oregon_article }
+      it do
+        is_expected.to include(
+          melbourne_article, oregon_article, melbourne_oregon_article
+        )
+      end
     end
 
-    context 'given a single tag instance' do
-      subject { Article.tagged_with(:tags => Gutentag::Tag.find_by_name!('melbourne')) }
+    context "given a single tag instance" do
+      subject do
+        Article.tagged_with(:tags => Gutentag::Tag.find_by_name!("melbourne"))
+      end
 
       it { expect(subject.count).to eq 2 }
       it { is_expected.to include melbourne_article, melbourne_oregon_article }
       it { is_expected.not_to include oregon_article }
-      it { expect(subject.to_sql).not_to include 'gutentag_tags' }
+      it { expect(subject.to_sql).not_to include "gutentag_tags" }
     end
 
-    context 'given a single tag id' do
-      subject { Article.tagged_with(:ids => Gutentag::Tag.find_by_name!('melbourne').id) }
+    context "given a single tag id" do
+      subject do
+        Article.tagged_with(:ids => Gutentag::Tag.find_by_name!("melbourne").id)
+      end
 
       it { expect(subject.count).to eq 2 }
       it { is_expected.to include melbourne_article, melbourne_oregon_article }
       it { is_expected.not_to include oregon_article }
-      it { expect(subject.to_sql).not_to include 'gutentag_tags' }
+      it { expect(subject.to_sql).not_to include "gutentag_tags" }
     end
 
-    context 'given multiple tag objects' do
-      subject { Article.tagged_with(:tags => Gutentag::Tag.where(name: %w(melbourne oregon))) }
+    context "given multiple tag objects" do
+      subject do
+        Article.tagged_with(
+          :tags => Gutentag::Tag.where(:name => %w[ melbourne oregon ])
+        )
+      end
 
       it { expect(subject.count).to eq 3 }
-      it { is_expected.to include melbourne_article, oregon_article, melbourne_oregon_article }
-      it { expect(subject.to_sql).not_to include 'gutentag_tags' }
+      it do
+        is_expected.to include(
+          melbourne_article, oregon_article, melbourne_oregon_article
+        )
+      end
+      it { expect(subject.to_sql).not_to include "gutentag_tags" }
     end
 
-    context 'chaining where clause' do
-      subject { Article.tagged_with(:names => %w(melbourne oregon)).where(title: 'Overview') }
+    context "chaining where clause" do
+      subject do
+        Article.tagged_with(:names => %w[ melbourne oregon ]).
+          where(:title => "Overview")
+      end
 
       it { expect(subject.count).to eq 1 }
       it { is_expected.to include melbourne_article }
       it { is_expected.not_to include oregon_article, melbourne_oregon_article }
     end
 
-    context 'appended onto a relation' do
-      subject { Article.where(title: 'Overview').tagged_with(:names => %w(melbourne oregon)) }
+    context "appended onto a relation" do
+      subject do
+        Article.where(:title => "Overview").
+          tagged_with(:names => %w[ melbourne oregon ])
+      end
 
       it { expect(subject.count).to eq 1 }
       it { is_expected.to include melbourne_article }
       it { is_expected.not_to include oregon_article, melbourne_oregon_article }
     end
 
-    context 'matching against all tags' do
-      subject { Article.tagged_with(:names => %w(melbourne oregon), :match => :all) }
+    context "matching against all tags" do
+      subject do
+        Article.tagged_with(:names => %w[ melbourne oregon ], :match => :all)
+      end
 
       it { expect(subject.count).to eq 1 }
       it { is_expected.to include melbourne_oregon_article }
       it { is_expected.not_to include oregon_article, melbourne_article }
     end
 
-    context 'matching against all tag ids' do
-      subject { Article.tagged_with(:ids => Gutentag::Tag.where(:name => %w(melbourne oregon)).pluck(:id), :match => :all) }
+    context "matching against all tag ids" do
+      let(:tag_ids) do
+        Gutentag::Tag.where(:name => %w[ melbourne oregon ]).pluck(:id)
+      end
+      subject { Article.tagged_with(:ids => tag_ids, :match => :all) }
 
       it { expect(subject.count).to eq 1 }
       it { is_expected.to include melbourne_oregon_article }
       it { is_expected.not_to include oregon_article, melbourne_article }
     end
 
-    context 'matching against all one tag is the same as any' do
-      subject { Article.tagged_with(:names => %w(melbourne), :match => :all) }
+    context "matching against all one tag is the same as any" do
+      subject { Article.tagged_with(:names => %w[ melbourne ], :match => :all) }
 
       it { expect(subject.count).to eq 2 }
       it { is_expected.to include melbourne_article, melbourne_oregon_article }
       it { is_expected.not_to include oregon_article }
     end
-
-    context "deprecated" do
-      before { expect(ActiveSupport::Deprecation).to receive(:warn) }
-
-      context 'given a single tag name' do
-        subject { Article.tagged_with('melbourne') }
-
-        it { expect(subject.count).to eq 2 }
-        it { is_expected.to include melbourne_article, melbourne_oregon_article }
-        it { is_expected.not_to include oregon_article }
-      end
-
-      context 'given a single tag name[symbol]' do
-        subject { Article.tagged_with(:melbourne) }
-
-        it { expect(subject.count).to eq 2 }
-        it { is_expected.to include melbourne_article, melbourne_oregon_article }
-        it { is_expected.not_to include oregon_article }
-      end
-
-      context 'given a denormalized tag name' do
-        subject { Article.tagged_with("MelbournE") }
-
-        it { expect(subject.count).to eq 2 }
-        it { is_expected.to include melbourne_article, melbourne_oregon_article }
-        it { is_expected.not_to include oregon_article }
-      end
-
-      context 'given multiple tag names' do
-        subject { Article.tagged_with('melbourne', 'oregon') }
-
-        it { expect(subject.count).to eq 3 }
-        it { is_expected.to include melbourne_article, oregon_article, melbourne_oregon_article }
-      end
-
-      context 'given an array of tag names' do
-        subject { Article.tagged_with(%w(melbourne oregon)) }
-
-        it { expect(subject.count).to eq 3 }
-        it { is_expected.to include melbourne_article, oregon_article, melbourne_oregon_article }
-      end
-
-      context 'given a single tag instance' do
-        subject { Article.tagged_with(Gutentag::Tag.find_by_name!('melbourne')) }
-
-        it { expect(subject.count).to eq 2 }
-        it { is_expected.to include melbourne_article, melbourne_oregon_article }
-        it { is_expected.not_to include oregon_article }
-        it { expect(subject.to_sql).not_to include 'gutentag_tags' }
-      end
-
-      context 'given a single tag id' do
-        subject { Article.tagged_with(Gutentag::Tag.find_by_name!('melbourne').id) }
-
-        it { expect(subject.count).to eq 2 }
-        it { is_expected.to include melbourne_article, melbourne_oregon_article }
-        it { is_expected.not_to include oregon_article }
-        it { expect(subject.to_sql).not_to include 'gutentag_tags' }
-      end
-
-      context 'given multiple tag objects' do
-        subject { Article.tagged_with(Gutentag::Tag.where(name: %w(melbourne oregon))) }
-
-        it { expect(subject.count).to eq 3 }
-        it { is_expected.to include melbourne_article, oregon_article, melbourne_oregon_article }
-        it { expect(subject.to_sql).not_to include 'gutentag_tags' }
-      end
-
-      context 'chaining where clause' do
-        subject { Article.tagged_with(%w(melbourne oregon)).where(title: 'Overview') }
-
-        it { expect(subject.count).to eq 1 }
-        it { is_expected.to include melbourne_article }
-        it { is_expected.not_to include oregon_article, melbourne_oregon_article }
-      end
-    end
   end
 end