metka 2.0.3 → 2.3.1

data/README.md

@@ -1,11 +1,16 @@
 [![Gem Version](https://badge.fury.io/rb/metka.svg)](https://badge.fury.io/rb/metka)
-[![Build Status](https://travis-ci.org/jetrockets/metka.svg?branch=master)](https://travis-ci.org/jetrockets/metka)
+[![Build Status](https://github.com/jetrockets/metka/workflows/Specs/badge.svg?branch=master)](https://github.com/jetrockets/metka/actions)
 [![Open Source Helpers](https://www.codetriage.com/jetrockets/metka/badges/users.svg)](https://www.codetriage.com/jetrockets/metka)
 
 # Metka
 
 Rails gem to manage tags with PostgreSQL array columns.
 
+:exclamation: Requirements:
+
+* Ruby ~> 2.5
+* Rails >= 5.2 (for Rails 5.1 and 5.0 use version <2.1.0)
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -16,11 +21,15 @@ gem 'metka'
 
 And then execute:
 
-    $ bundle
+```bash
+bundle
+```
 
 Or install it yourself as:
 
-    $ gem install metka
+```bash
+gem install metka
+```
 
 ## Tag objects
 
@@ -32,9 +41,9 @@ rails g migration CreateSongs
 class CreateSongs < ActiveRecord::Migration[5.0]
   def change
     create_table :songs do |t|
-      t.string  :title
-      t.string  :tags, array: true
-      t.string  :genres, array: true
+      t.string :title
+      t.string :tags, array: true, default: [], index: { using: :gin }
+      t.string :genres, array: true, default: [], index: { using: :gin }
       t.timestamps
     end
   end
@@ -55,140 +64,167 @@ end
 ## Find tagged objects
 
 ### .with_all_#{column_name}
+
 ```ruby
 Song.with_all_tags('top')
-=> [#<Song id: 1, title: 'Migrate tags in Rails to PostgreSQL', tags: ['top', 'chill'], genres: ['rock', 'jazz', 'pop']]
+#=> [#<Song id: 1, title: 'Migrate tags in Rails to PostgreSQL', tags: ['top', 'chill'], genres: ['rock', 'jazz', 'pop']]
 
 Song.with_all_tags('top, 1990')
-=> []
+#=> []
 
 Song.with_all_tags('')
-=> []
+#=> [#<Song id: 1, title: 'Migrate tags in Rails to PostgreSQL', tags: ['top', 'chill'], genres: ['rock', 'jazz', 'pop']]
+
+Song.with_all_tags(nil)
+#=> [#<Song id: 1, title: 'Migrate tags in Rails to PostgreSQL', tags: ['top', 'chill'], genres: ['rock', 'jazz', 'pop']]
 
 Song.with_all_genres('rock')
-=> [#<Song id: 1, title: 'Migrate tags in Rails to PostgreSQL', tags: ['top', 'chill'], genres: ['rock', 'jazz', 'pop']]
+#=> [#<Song id: 1, title: 'Migrate tags in Rails to PostgreSQL', tags: ['top', 'chill'], genres: ['rock', 'jazz', 'pop']]
 ```
 
 ### .with_any_#{column_name}
+
 ```ruby
 Song.with_any_tags('chill')
-=> [#<Song id: 1, title: 'Migrate tags in Rails to PostgreSQL', tags: ['top', 'chill'], genres: ['rock', 'jazz', 'pop']]
+#=> [#<Song id: 1, title: 'Migrate tags in Rails to PostgreSQL', tags: ['top', 'chill'], genres: ['rock', 'jazz', 'pop']]
 
 Song.with_any_tags('chill, 1980')
-=> [#<Song id: 1, title: 'Migrate tags in Rails to PostgreSQL', tags: ['top', 'chill'], genres: ['rock', 'jazz', 'pop']]
+#=> [#<Song id: 1, title: 'Migrate tags in Rails to PostgreSQL', tags: ['top', 'chill'], genres: ['rock', 'jazz', 'pop']]
 
 Song.with_any_tags('')
-=> []
+#=> [#<Song id: 1, title: 'Migrate tags in Rails to PostgreSQL', tags: ['top', 'chill'], genres: ['rock', 'jazz', 'pop']]
+
+Song.with_any_tags(nil)
+#=> [#<Song id: 1, title: 'Migrate tags in Rails to PostgreSQL', tags: ['top', 'chill'], genres: ['rock', 'jazz', 'pop']]
 
 Song.with_any_genres('rock, rap')
-=> [#<Song id: 1, title: 'Migrate tags in Rails to PostgreSQL', tags: ['top', 'chill'], genres: ['rock', 'jazz', 'pop']]
+#=> [#<Song id: 1, title: 'Migrate tags in Rails to PostgreSQL', tags: ['top', 'chill'], genres: ['rock', 'jazz', 'pop']]
 ```
+
 ### .without_all_#{column_name}
+
 ```ruby
 Song.without_all_tags('top')
-=> []
+#=> []
 
 Song.without_all_tags('top, 1990')
-=> [#<Song id: 1, title: 'Migrate tags in Rails to PostgreSQL', tags: ['top', 'chill'], genres: ['rock', 'jazz', 'pop']]
+#=> [#<Song id: 1, title: 'Migrate tags in Rails to PostgreSQL', tags: ['top', 'chill'], genres: ['rock', 'jazz', 'pop']]
 
 Song.without_all_tags('')
-=> []
+#=> [#<Song id: 1, title: 'Migrate tags in Rails to PostgreSQL', tags: ['top', 'chill'], genres: ['rock', 'jazz', 'pop']]
+
+Song.without_all_tags(nil)
+#=> [#<Song id: 1, title: 'Migrate tags in Rails to PostgreSQL', tags: ['top', 'chill'], genres: ['rock', 'jazz', 'pop']]
 
 Song.without_all_genres('rock, pop')
-=> [#<Song id: 1, title: 'Migrate tags in Rails to PostgreSQL', tags: ['top', 'chill'], genres: ['rock', 'jazz', 'pop']]
+#=> [#<Song id: 1, title: 'Migrate tags in Rails to PostgreSQL', tags: ['top', 'chill'], genres: ['rock', 'jazz', 'pop']]
 
 Song.without_all_genres('rock')
-=> []
+#=> []
 ```
 
 ### .without_any_#{column_name}
+
 ```ruby
 Song.without_any_tags('top, 1990')
-=> []
+#=> []
 
 Song.without_any_tags('1990, 1980')
-=> [#<Song id: 1, title: 'Migrate tags in Rails to PostgreSQL', tags: ['top', 'chill'], genres: ['rock', 'jazz', 'pop']]
+#=> [#<Song id: 1, title: 'Migrate tags in Rails to PostgreSQL', tags: ['top', 'chill'], genres: ['rock', 'jazz', 'pop']]
 
 Song.without_any_genres('rock, pop')
-=> []
+#=> []
 
 Song.without_any_genres('')
-=> []
+#=> [#<Song id: 1, title: 'Migrate tags in Rails to PostgreSQL', tags: ['top', 'chill'], genres: ['rock', 'jazz', 'pop']]
+
+Song.without_any_genres(nil)
+#=> [#<Song id: 1, title: 'Migrate tags in Rails to PostgreSQL', tags: ['top', 'chill'], genres: ['rock', 'jazz', 'pop']]
 ```
 
 ### .tagged_with
+
 ```ruby
 Song.tagged_with('top')
-=> [#<Song id: 1, title: 'Migrate tags in Rails to PostgreSQL', tags: ['top', 'chill'], genres: ['rock', 'jazz', 'pop']]
+#=> [#<Song id: 1, title: 'Migrate tags in Rails to PostgreSQL', tags: ['top', 'chill'], genres: ['rock', 'jazz', 'pop']]
 
 Song.tagged_with('top, 1990')
-=> []
+#=> []
 
 Song.tagged_with('')
-=> []
+#=> [#<Song id: 1, title: 'Migrate tags in Rails to PostgreSQL', tags: ['top', 'chill'], genres: ['rock', 'jazz', 'pop']]
+
+Song.tagged_with(nil)
+#=> [#<Song id: 1, title: 'Migrate tags in Rails to PostgreSQL', tags: ['top', 'chill'], genres: ['rock', 'jazz', 'pop']]
 
 Song.tagged_with('rock')
-=> [#<Song id: 1, title: 'Migrate tags in Rails to PostgreSQL', tags: ['top', 'chill'], genres: ['rock', 'jazz', 'pop']]
+#=> [#<Song id: 1, title: 'Migrate tags in Rails to PostgreSQL', tags: ['top', 'chill'], genres: ['rock', 'jazz', 'pop']]
 
 Song.tagged_with('rock', join_operator: Metka::And)
-=> []
+#=> []
 
 Song.tagged_with('chill', any: true)
-=> [#<Song id: 1, title: 'Migrate tags in Rails to PostgreSQL', tags: ['top', 'chill'], genres: ['rock', 'jazz', 'pop']]
+#=> [#<Song id: 1, title: 'Migrate tags in Rails to PostgreSQL', tags: ['top', 'chill'], genres: ['rock', 'jazz', 'pop']]
 
 Song.tagged_with('chill, 1980', any: true)
-=> [#<Song id: 1, title: 'Migrate tags in Rails to PostgreSQL', tags: ['top', 'chill'], genres: ['rock', 'jazz', 'pop']]
+#=> [#<Song id: 1, title: 'Migrate tags in Rails to PostgreSQL', tags: ['top', 'chill'], genres: ['rock', 'jazz', 'pop']]
 
 Song.tagged_with('', any: true)
-=> []
+#=> [#<Song id: 1, title: 'Migrate tags in Rails to PostgreSQL', tags: ['top', 'chill'], genres: ['rock', 'jazz', 'pop']]
 
 Song.tagged_with('rock, rap', any: true, on: ['genres'])
-=> [#<Song id: 1, title: 'Migrate tags in Rails to PostgreSQL', tags: ['top', 'chill'], genres: ['rock', 'jazz', 'pop']]
+#=> [#<Song id: 1, title: 'Migrate tags in Rails to PostgreSQL', tags: ['top', 'chill'], genres: ['rock', 'jazz', 'pop']]
 
 Song.without_all_tags('top')
-=> []
+#=> []
 
 Song.tagged_with('top, 1990', exclude: true)
-=> [#<Song id: 1, title: 'Migrate tags in Rails to PostgreSQL', tags: ['top', 'chill'], genres: ['rock', 'jazz', 'pop']]
+#=> [#<Song id: 1, title: 'Migrate tags in Rails to PostgreSQL', tags: ['top', 'chill'], genres: ['rock', 'jazz', 'pop']]
 
 Song.tagged_with('', exclude: true)
-=> []
+#=> [#<Song id: 1, title: 'Migrate tags in Rails to PostgreSQL', tags: ['top', 'chill'], genres: ['rock', 'jazz', 'pop']]
 
 Song.tagged_with('top, 1990', any: true, exclude: true)
-=> []
+#=> []
 
 Song.tagged_with('1990, 1980', any: true, exclude: true)
-=> [#<Song id: 1, title: 'Migrate tags in Rails to PostgreSQL', tags: ['top', 'chill'], genres: ['rock', 'jazz', 'pop']]
+#=> [#<Song id: 1, title: 'Migrate tags in Rails to PostgreSQL', tags: ['top', 'chill'], genres: ['rock', 'jazz', 'pop']]
 
 Song.without_any_genres('rock, pop')
-=> []
+#=> []
 ```
 
 ## Custom delimiter
+
 By default, a comma is used as a delimiter to create tags from a string.
 You can make your own custom separator:
+
 ```ruby
 Metka.config.delimiter = '|'
 parsed_data = Metka::GenericParser.instance.call('cool, data|I have')
 parsed_data.to_a
-=>['cool, data', 'I have']
+#=>['cool, data', 'I have']
 ```
 
 ## Tags with quote
+
 ```ruby
 parsed_data = Metka::GenericParser.instance.call("'cool, data', code")
 parsed_data.to_a
-=> ['cool, data', 'code']
+#=> ['cool, data', 'code']
 ```
 
 ## Custom parser
+
 By default we use [generic_parser](lib/metka/generic_parser.rb "generic_parser")
 If you want to use your custom parser you can do:
+
 ```ruby
 class Song < ActiveRecord::Base
   include Metka::Model(columns: %w[genres tags], parser: Your::Custom::Parser.instance)
 end
 ```
+
 Custom parser must be a singleton class that has a `.call` method that accepts the tag string
 
 ## Tag Cloud Strategies
@@ -200,29 +236,30 @@ There are several strategies to get tag statistics
 Data about taggings is accessible via class methods of your model with `Metka::Model` attached. You can calculate a cloud for a single tagged column or multiple columns, the latter case would return to you a sum of taggings from multiple tagged columns, that are provided as arguments, for each tag present. ActiveRecord Strategy is an easiest way to implement, since it wouldn't require any additional code, but it's the slowest one on SELECT.
 
 ```ruby
+
 class Book < ActiveRecord::Base
   include Metka::Model(column: 'authors')
   include Metka::Model(column: 'co_authors')
 end
 
 tag_cloud = Book.author_cloud
-=> [["L.N. Tolstoy", 3], ["F.M. Dostoevsky", 6]]
+#=> [["L.N. Tolstoy", 3], ["F.M. Dostoevsky", 6]]
 genre_cloud = Book.co_author_cloud
-=> [["A.P. Chekhov", 5], ["N.V. Gogol", 8], ["L.N. Tolstoy", 2]]
+#=> [["A.P. Chekhov", 5], ["N.V. Gogol", 8], ["L.N. Tolstoy", 2]]
 summary_cloud = Book.metka_cloud('authors', 'co_authors')
-=> [["L.N. Tolstoy", 5], ["F.M. Dostoevsky", 6], ["A.P. Chekhov", 5], ["N.V. Gogol", 8]]
+#=> [["L.N. Tolstoy", 5], ["F.M. Dostoevsky", 6], ["A.P. Chekhov", 5], ["N.V. Gogol", 8]]
 ```
 
 ### View Strategy
 
-Data about taggings will be agregated in SQL View. Performance-wise that strategy has no benefits over ActiveRecord Strategy, but if you need to store tags aggregations in a distinct model, that's an easiest way to achieve it.
+Data about taggings will be aggregated in SQL View. Performance-wise that strategy has no benefits over ActiveRecord Strategy, but if you need to store tags aggregations in a distinct model, that's an easiest way to achieve it.
 
 ```bash
 rails g metka:strategies:view --source-table-name=NAME_OF_TABLE_WITH_TAGS [--source-columns=NAME_OF_COLUMN_1 NAME_OF_COLUMN_2] [--view-name=NAME_OF_RESULTING_VIEW]
 ```
 
 The code above will generate a migration that creates view with specified `NAME_OF_RESULTING_VIEW`, that would aggregate tags data from specified array of tagged columns [`NAME_OF_COLUMN_1`, `NAME_OF_COLUMN_2`, ...], that are present within specified table `NAME_OF_TABLE_WITH_TAGS`.
-If `source-columns` option is not provided, then `tags` column would be used as defaults. If array of multiple values would be provided to the option, then the aggregation would be made with the tags from multiple tagged columns, so if a single tag would be found within multiple tagged columns, the resulting aggregation inside the view would have a single row for that tag with a sum of it's occurences across all stated tagged columns.
+If `source-columns` option is not provided, then `tags` column would be used as defaults. If array of multiple values would be provided to the option, then the aggregation would be made with the tags from multiple tagged columns, so if a single tag would be found within multiple tagged columns, the resulting aggregation inside the view would have a single row for that tag with a sum of it's occurrences across all stated tagged columns.
 `view-name` option is also optional, it would just force the resulting view's name to the one of your choice. If it's not provided, then view name would be generated automatically, you could check it within generated migration.
 
 Lets take a look at real example. We have a `notes` table with `tags` column.
@@ -290,7 +327,7 @@ Data about taggings will be aggregated in SQL Materialized View, that would be r
 rails g metka:strategies:materialized_view --source-table-name=NAME_OF_TABLE_WITH_TAGS --source-columns=NAME_OF_COLUMN_1 NAME_OF_COLUMN_2 --view-name=NAME_OF_RESULTING_VIEW
 ```
 
-All of the options for that stategy's generation command are the same as for the View Strategy.
+All of the options for that strategy's generation command are the same as for the View Strategy.
 
 The migration template can be seen [here](spec/dummy/db/migrate/06_create_tagged_materialized_view_posts_materialized_view.rb "here")
 
@@ -308,15 +345,43 @@ And you can also create `TaggedNote` model to work with the view as with a Rails
 
 ### Table Strategy with Triggers
 
-
-
 TBD
 
 ## Inspired by
+
 1. [ActsAsTaggableOn](https://github.com/mbleigh/acts-as-taggable-on)
 2. [ActsAsTaggableArrayOn](https://github.com/tmiyamon/acts-as-taggable-array-on)
 3. [TagColumns](https://github.com/hopsoft/tag_columns)
 
+## Migration from ActsAsTaggable
+
+To migrate your data from `ActsAsTaggable` can be done with the following migration.
+
+```ruby
+class AddTagsToYourTable < ActiveRecord::Migration[6.0]
+  def change
+    add_column :your_table, :tags, :string, array: true
+    add_index :your_table, :tags, using: 'gin'
+
+    execute <<~SQL
+      UPDATE your_table
+      SET tags = tags.names
+      FROM (
+        SELECT taggings.taggable_id AS your_table_id,
+               array_agg(tags.name) as names
+        FROM tags
+        INNER JOIN taggings
+                ON tags.id = taggings.tag_id
+        WHERE
+          taggings.taggable_type = 'YouTableType'
+        GROUP BY taggings.taggable_id
+      ) as tags
+      WHERE your_table.id = tags.your_table_id
+    SQL
+  end
+end
+```
+
 ## Benchmark Comparison
 
 There are some results of benchmarking a performance of write, read and find operations for different gems, that provide solution for tagging. Keep in mind, that those results can't be used as a proof, that some solution is better than the others, since each of the benchmarked gems has their unique features. You could run the benchmarks yourself or check, what exact operations has been used for benchmarking, with [MetkaBench application](https://github.com/jetrockets/metka_bench).
@@ -447,9 +512,10 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/metka. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+Bug reports and pull requests are welcome on GitHub at [https://github.com/jetrockets/metka](https://github.com/jetrockets/metka). This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
 
 ## Credits
+
 ![JetRockets](https://media.jetrockets.pro/jetrockets-white.png)
 Metka is maintained by [JetRockets](http://www.jetrockets.ru).
 

data/forspell.dict

@@ -0,0 +1,7 @@
+# Format: one word per line. Empty lines and #-comments are supported too.
+# If you want to add word with its forms, you can write 'word: example' (without quotes) on the line,
+# where 'example' is existing word with the same possible forms (endings) as your word.
+# Example: deduplicate: duplicate
+Metka
+taggings
+benchmarked

data/gemfiles/rails52.gemfile

@@ -1,6 +1,6 @@
 source "https://rubygems.org"
 
-gem 'rails', '~>5.2'
+gem 'rails', '~> 5.2'
 gem 'activerecord', '~> 5.2.4.3'
 
 gemspec path: '..'

data/gemfiles/rails6.gemfile

@@ -1,6 +1,6 @@
 source "https://rubygems.org"
 
-gem 'rails', '~>6.0'
-gem 'activerecord', '~> 6.0'
+gem 'rails', '~> 6.0', ' < 6.1'
+gem 'activerecord', '~> 6.0', '< 6.1'
 
 gemspec path: '..'

data/gemfiles/rails61.gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+gem 'rails', '~> 6.1'
+gem 'activerecord', '~> 6.1'
+
+gemspec path: '..'

data/gemfiles/railsmain.gemfile

@@ -0,0 +1,5 @@
+source "https://rubygems.org"
+
+gem 'rails', github: 'rails/rails', branch: 'main'
+
+gemspec path: '..'

data/gemfiles/rubocop.gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org" do
+  gem "rubocop-md", "~> 1.0"
+  gem "jetrockets-standard"
+end

data/lib/metka/generic_parser.rb

@@ -25,7 +25,7 @@ module Metka
           gsub_quote_pattern!(tag_list, value, double_quote_pattern)
           gsub_quote_pattern!(tag_list, value, single_quote_pattern)
 
-          tag_list.merge value.split(Regexp.new delimiter).map(&:strip).reject(&:empty?)
+          tag_list.merge value.split(Regexp.new(delimiter)).map(&:strip).reject(&:empty?)
         when Enumerable
           tag_list.merge value.reject(&:empty?)
         end
@@ -46,7 +46,7 @@ module Metka
     end
 
     def single_quote_pattern
-     @single_quote_pattern[delimiter] ||= /(\A|#{delimiter})\s*'(.*?)'\s*(?=#{delimiter}\s*|\z)/
+      @single_quote_pattern[delimiter] ||= /(\A|#{delimiter})\s*'(.*?)'\s*(?=#{delimiter}\s*|\z)/
     end
 
     def double_quote_pattern

data/lib/metka/model.rb

@@ -35,7 +35,7 @@ module Metka
         cols = options.delete(:on)
         parsed_tag_list = parser.call(tags)
 
-        return model.none if parsed_tag_list.empty?
+        return model if parsed_tag_list.empty?
 
         request = ::Metka::QueryBuilder.new.call(model, cols, parsed_tag_list, options)
         model.where(request)
@@ -43,10 +43,10 @@ module Metka
 
       base.class_eval do
         columns.each do |column|
-          scope "with_all_#{column}",    ->(tags) { tagged_with(tags, on: [ column ]) }
-          scope "with_any_#{column}",    ->(tags) { tagged_with(tags, on: [ column ], any: true) }
-          scope "without_all_#{column}", ->(tags) { tagged_with(tags, on: [ column ], exclude: true) }
-          scope "without_any_#{column}", ->(tags) { tagged_with(tags, on: [ column ], any: true, exclude: true) }
+          scope "with_all_#{column}", ->(tags) { tagged_with(tags, on: [column]) }
+          scope "with_any_#{column}", ->(tags) { tagged_with(tags, on: [column], any: true) }
+          scope "without_all_#{column}", ->(tags) { tagged_with(tags, on: [column], exclude: true) }
+          scope "without_any_#{column}", ->(tags) { tagged_with(tags, on: [column], any: true, exclude: true) }
         end
 
         unless respond_to?(:tagged_with)
@@ -66,7 +66,7 @@ module Metka
         prepared_unnest = columns.map { |column| "#{table_name}.#{column}" }.join(' || ')
         subquery = all.select("UNNEST(#{prepared_unnest}) AS tag_name")
 
-        unscoped.from(subquery).group(:tag_name).pluck(:tag_name, 'COUNT(*) AS taggings_count')
+        unscoped.from(subquery).group(:tag_name).pluck(:tag_name, Arel.sql('COUNT(*) AS taggings_count'))
       end
 
       columns.each do |column|