metka 1.0.3 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e3c0565e7e049ea911c9039ef193104c7bf7e7213a12bbd3ca804fa0f3a3ce9f
-  data.tar.gz: 11e33a74f78aca7fa1942702fd2dd550c232dde0bdab414ec2cbe3ddec8ffaa0
+  metadata.gz: 9add2168156651d369dc1cbb040481d55d2e83fdeee318e065153063746036eb
+  data.tar.gz: 055e9db64b595b512440a58db7c971d3d7ecd4ba87e52fbb05563133aec3774d
 SHA512:
-  metadata.gz: 76749d9965518aaacc8e592a569c9a4a57885647b99b6df4aecd7574536658c5d8e2259a9b344bb2bfe44cdd506eff95a73530f775778151253d92e3e081d531
-  data.tar.gz: e29dea73313396cf64d120b5cbdde93b42902442962243925ae25c541b9b7fab361d4be7b81ccc83e946d03f34c7995475d37d6c869ad54d50b2981b6544f322
+  metadata.gz: ac957fdb84eecbbf711c9ac03f068a15e7b8e40e99e9f255a5ba6fa1ef438681d8c1cab877513174921a7f0a514233fa513e2c2fd5bdd0893ebf628e26105d3a
+  data.tar.gz: d3fc6a6474c316249c38b8a5eb5344fe27beb425b8979368402c6bfbe015e8aeed1083d16348d312fdbef12cae70259a087eeb2d4804e6e12439f69f4d6d6a73

data/.travis.yml

@@ -22,7 +22,6 @@ before_install:
   - sudo service postgresql restart 11
 
 before_script:
-  # - gem update --system
   - psql -c 'CREATE ROLE travis SUPERUSER LOGIN CREATEDB;' -U postgres
   - ./bin/setup
 

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    metka (1.0.3)
+    metka (1.0.2)
       dry-configurable (>= 0.8)
       rails (>= 5.1)
 
@@ -53,11 +53,11 @@ GEM
     ast (2.4.0)
     builder (3.2.3)
     coderay (1.1.2)
-    concurrent-ruby (1.1.5)
+    concurrent-ruby (1.1.6)
     crass (1.0.5)
     database_cleaner (1.7.0)
     diff-lcs (1.3)
-    dry-configurable (0.11.3)
+    dry-configurable (0.11.5)
       concurrent-ruby (~> 1.0)
       dry-core (~> 0.4, >= 0.4.7)
       dry-equalizer (~> 0.2)
@@ -198,4 +198,4 @@ DEPENDENCIES
   timecop (>= 0.9)
 
 BUNDLED WITH
-   2.0.2
+   2.1.4

data/README.md

@@ -43,8 +43,7 @@ end
 
 ```ruby
 class Song < ActiveRecord::Base
-  include Metka::Model(column: 'tags')
-  include Metka::Model(column: 'genres')
+  include Metka::Model(columns: %w[genres tags])
 end
 
 @song = Song.new(title: 'Migrate tags in Rails to PostgreSQL')
@@ -93,7 +92,7 @@ Song.without_all_tags('top, 1990')
 => [#<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_genres('rock, pop')
 => [#<Song id: 1, title: 'Migrate tags in Rails to PostgreSQL', tags: ['top', 'chill'], genres: ['rock', 'jazz', 'pop']]
@@ -114,17 +113,65 @@ Song.without_any_genres('rock, pop')
 => []
 
 Song.without_any_genres('')
+=> []
+```
+
+### .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.tagged_with('top, 1990')
+=> []
+
+Song.tagged_with('')
+=> []
+
+Song.tagged_with('rock')
+=> [#<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.tagged_with('chill, 1980', any: true)
+=> [#<Song id: 1, title: 'Migrate tags in Rails to PostgreSQL', tags: ['top', 'chill'], genres: ['rock', 'jazz', 'pop']]
+
+Song.tagged_with('', any: true)
+=> []
+
+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.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.tagged_with('', exclude: true)
+=> []
+
+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.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 = [',', ' ', '\|']
+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
@@ -136,11 +183,10 @@ parsed_data.to_a
 
 ## Custom parser
 By default we use [generic_parser](lib/metka/generic_parser.rb "generic_parser")
-If you want use your custom parser you can do:
+If you want to use your custom parser you can do:
 ```ruby
 class Song < ActiveRecord::Base
-  include Metka::Model(column: 'tags', parser: Your::Custom::Parser.instance)
-  include Metka::Model(column: 'genres')
+  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
@@ -149,15 +195,35 @@ Custom parser must be a singleton class that has a `.call` method that accepts t
 
 There are several strategies to get tag statistics
 
+### ActiveRecord Strategy (Default)
+
+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]]
+genre_cloud = Book.co_author_cloud
+=> [["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]]
+```
+
 ### View Strategy
 
-Data about taggings will be agregated in SQL View. The easiest way to implement but the most slow on SELECT.
+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.
 
 ```bash
-rails g metka:strategies:view --source-table-name=NAME_OF_TABLE_WITH_TAGS
+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 to store aggregated data about tag in `NAME_OF_TABLE_WITH_TAGS` table.
+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.
+`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.
 
@@ -181,15 +247,18 @@ The result would be:
 class CreateTaggedNotesView < ActiveRecord::Migration[5.0]
   def up
     execute <<-SQL
-    CREATE OR REPLACE VIEW tagged_notes AS
-
-    SELECT UNNEST
-      ( tags ) AS tag_name,
-      COUNT ( * ) AS taggings_count
-    FROM
-      notes
-    GROUP BY
-      name;
+      CREATE OR REPLACE VIEW tagged_notes AS
+        SELECT
+          tag_name,
+          COUNT ( * ) AS taggings_count
+        FROM (
+          SELECT UNNEST
+            ( tags ) AS tag_name
+          FROM
+            view_posts
+        ) subquery
+        GROUP BY
+          tag_name;
     SQL
   end
 
@@ -215,33 +284,27 @@ Now you can create `TaggedNote` model and work with the view like you usually do
 
 ### Materialized View Strategy
 
-Similar to the strategy above, but the view will be Materialized and refreshed with the trigger
+Data about taggings will be aggregated in SQL Materialized View, that would be refreshed with the trigger on each change of the tagged column's data. Except for the another type of view being used, that strategy behaves the same way, as a View Strategy above.
 
 ```bash
-rails g metka:strategies:materialized_view --source-table-name=NAME_OF_TABLE_WITH_TAGS
+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
 ```
 
-The code above will generate a migration that creates view to store aggregated data about tag in `NAME_OF_TABLE_WITH_TAGS` table.
-
-Lets take a look at real example. We have a `notes` table with `tags` column.
-
-| Column | Type                | Default                           |
-|--------|---------------------|-----------------------------------|
-| id     | integer             | nextval('notes_id_seq'::regclass) |
-| body   | text                |                                   |
-| tags   | character varying[] | '{}'::character varying[]         |
-
-Now lets generate a migration.
+All of the options for that stategy's generation command are the same as for the View Strategy.
 
-```bash
-rails g metka:strategies:materialized_view --source-table-name=notes
-```
+The migration template can be seen [here](spec/dummy/db/migrate/06_create_tagged_materialized_view_posts_materialized_view.rb "here")
 
-The migration code you can see [here](spec/dummy/db/migrate/05_create_tagged_materialized_view_Songs_materialized_view.rb "here")
+With the same `notes` table with `tags` column the resulting view would have the same two columns
 
-Now lets take a look at `tagged_notes` materialized view.
+| tag_name | taggings_count |
+|----------|----------------|
+| Ruby     | 124056         |
+| React    | 30632          |
+| Rails    | 28696          |
+| Crystal  | 6566           |
+| Elixir   | 3475           |
 
-Now you can create `TaggedNote` model and work with the view like you usually do with Rails models.
+And you can also create `TaggedNote` model to work with the view as with a Rails model.
 
 ### Table Strategy with Triggers
 
@@ -254,6 +317,128 @@ TBD
 2. [ActsAsTaggableArrayOn](https://github.com/tmiyamon/acts-as-taggable-array-on)
 3. [TagColumns](https://github.com/hopsoft/tag_columns)
 
+## 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).
+
+```bash
+$ rake bench:all
+Deleted all MetkaSong
+Deleted all ActsAsTaggableOn::Tagging
+Deleted all ActsAsTaggableOn::Tag
+Deleted all ActsAsTaggableSong
+Deleted all ActsAsTaggableArraySong
+Deleted all TagColumnsSong
+Finished to clean
+
+###################################################################
+
+bench:write
+
+Time measurements:
+
+Rehearsal ----------------------------------------------------------
+Metka:                   2.192410   0.161092   2.353502 (  2.754766)
+ActsAsTaggableOn:       13.769918   0.554951  14.324869 ( 16.990127)
+ActsAsTaggableOnArray:   2.150441   0.154127   2.304568 (  2.700022)
+TagColumns:              2.202647   0.156162   2.358809 (  2.753400)
+------------------------------------------------ total: 21.341748sec
+
+                             user     system      total        real
+Metka:                   2.137315   0.154046   2.291361 (  2.643363)
+ActsAsTaggableOn:       11.302848   0.448674  11.751522 ( 14.019458)
+ActsAsTaggableOnArray:   2.143134   0.128655   2.271789 (  2.670797)
+TagColumns:              2.133780   0.125749   2.259529 (  2.653404)
+
+Memory measurements:
+
+Calculating -------------------------------------
+Metka:                   179.064M memsize (     0.000  retained)
+                           1.689M objects (     0.000  retained)
+                          50.000  strings (     0.000  retained)
+ActsAsTaggableOn:        843.949M memsize (     0.000  retained)
+                           8.550M objects (     0.000  retained)
+                          50.000  strings (     0.000  retained)
+ActsAsTaggableOnArray:   178.807M memsize (     0.000  retained)
+                           1.684M objects (     0.000  retained)
+                          50.000  strings (     0.000  retained)
+TagColumns:              180.009M memsize (     0.000  retained)
+                           1.699M objects (     0.000  retained)
+                          50.000  strings (     0.000  retained)
+
+###################################################################
+
+bench:read
+
+Time measurements:
+
+Rehearsal ----------------------------------------------------------
+Metka:                   0.479695   0.044399   0.524094 (  0.590616)
+ActsAsTaggableOn:        2.436328   0.140581   2.576909 (  3.096142)
+ActsAsTaggableOnArray:   0.515198   0.042127   0.557325 (  0.623205)
+TagColumns:              0.518363   0.042661   0.561024 (  0.626968)
+------------------------------------------------- total: 4.219352sec
+
+                             user     system      total        real
+Metka:                   0.446751   0.041886   0.488637 (  0.554018)
+ActsAsTaggableOn:        2.395166   0.164500   2.559666 (  3.069655)
+ActsAsTaggableOnArray:   0.439608   0.041682   0.481290 (  0.544679)
+TagColumns:              0.435404   0.041623   0.477027 (  0.540359)
+
+Memory measurements:
+
+Calculating -------------------------------------
+Metka:                    42.291M memsize (     0.000  retained)
+                         388.694k objects (     0.000  retained)
+                          50.000  strings (     0.000  retained)
+ActsAsTaggableOn:        178.664M memsize (     0.000  retained)
+                           1.812M objects (     0.000  retained)
+                          50.000  strings (     0.000  retained)
+ActsAsTaggableOnArray:    42.173M memsize (     0.000  retained)
+                         383.003k objects (     0.000  retained)
+                          50.000  strings (     0.000  retained)
+TagColumns:               41.948M memsize (     0.000  retained)
+                         383.003k objects (     0.000  retained)
+                          50.000  strings (     0.000  retained)
+
+###################################################################
+
+bench:find_by_tag
+
+Time measurements:
+
+Rehearsal ----------------------------------------------------------
+Metka:                   0.029961   0.000059   0.030020 (  0.030052)
+ActsAsTaggableOn:        0.067095   0.000068   0.067163 (  0.067205)
+ActsAsTaggableOnArray:   0.043156   0.000133   0.043289 (  0.043440)
+TagColumns:              0.056475   0.000143   0.056618 (  0.056697)
+------------------------------------------------- total: 0.197090sec
+
+                             user     system      total        real
+Metka:                   0.028291   0.000019   0.028310 (  0.028321)
+ActsAsTaggableOn:        0.065925   0.000036   0.065961 (  0.065989)
+ActsAsTaggableOnArray:   0.043214   0.000079   0.043293 (  0.043361)
+TagColumns:              0.056390   0.000160   0.056550 (  0.056666)
+
+Memory measurements:
+
+Calculating -------------------------------------
+Metka:                     4.752M memsize (     0.000  retained)
+                          43.000k objects (     0.000  retained)
+                           1.000  strings (     0.000  retained)
+ActsAsTaggableOn:          8.967M memsize (     0.000  retained)
+                          81.002k objects (     0.000  retained)
+                           9.000  strings (     0.000  retained)
+ActsAsTaggableOnArray:     5.211M memsize (     0.000  retained)
+                          57.003k objects (     0.000  retained)
+                           6.000  strings (     0.000  retained)
+TagColumns:                6.696M memsize (     0.000  retained)
+                          94.003k objects (     0.000  retained)
+                           8.000  strings (     0.000  retained)
+
+Finished all benchmarks
+```
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/lib/generators/metka/strategies/materialized_view/materialized_view_generator.rb

@@ -9,10 +9,15 @@ module Metka
       class MaterializedViewGenerator < ::Rails::Generators::Base # :nodoc:
         include Rails::Generators::Migration
 
+        DEFAULT_SOURCE_COLUMNS = ['tags'].freeze
+
         desc <<~LONGDESC
           Generates migration to implement view strategy for Metka
 
-          > $ rails g metka:strategies:materialized_view --source-table-name=NAME_OF_TABLE_WITH_TAGS
+          > $ rails g metka:strategies:materialized_view \
+          --source-table-name=NAME_OF_TABLE_WITH_TAGS \
+          --source-columns=NAME_OF_TAGGED_COLUMN_1 NAME_OF_TAGGED_COLUMN_2 \
+          --view-name=NAME_OF_VIEW
         LONGDESC
 
         source_root File.expand_path('templates', __dir__)
@@ -20,8 +25,11 @@ module Metka
         class_option :source_table_name, type: :string, required: true,
                                          desc: 'Name of the table that has a column with tags'
 
-        class_option :source_column_name, type: :string, default: 'tags',
-                                          desc: 'Name of the column with stored tags'
+        class_option :source_columns, type: :array, default: DEFAULT_SOURCE_COLUMNS,
+                                      desc: 'List of the tagged columns names'
+
+        class_option :view_name, type: :string,
+                                 desc: 'Custom name for the resulting view'
 
         def generate_migration
           migration_template 'migration.rb.erb', "db/migrate/#{migration_name}.rb"
@@ -32,12 +40,19 @@ module Metka
             options[:source_table_name]
           end
 
-          def source_column_name
-            options[:source_column_name]
+          def source_columns
+            options[:source_columns]
+          end
+
+          def source_columns_names
+            source_columns.join('_and_')
           end
 
           def view_name
-            "tagged_#{source_table_name}"
+            return options[:view_name] if options[:view_name]
+
+            columns_sequence = source_columns == DEFAULT_SOURCE_COLUMNS ? nil : "_with_#{source_columns_names}"
+            "tagged#{columns_sequence}_#{source_table_name}"
           end
 
           def migration_name

data/lib/generators/metka/strategies/materialized_view/templates/migration.rb.erb

@@ -5,15 +5,18 @@ class <%= @migration_class_name %> < ActiveRecord::Migration<%= ActiveRecord::VE
     execute <<-SQL
     CREATE OR REPLACE FUNCTION metka_refresh_<%= view_name %>_materialized_view() RETURNS trigger LANGUAGE plpgsql AS $$
       BEGIN
-        IF TG_OP = 'INSERT' AND NEW.<%= source_column_name %> IS NOT NULL THEN
+        IF TG_OP = 'INSERT' AND
+           (<%= source_columns.map { |column| "NEW.#{column} IS NOT NULL" }.join(' OR ') %>) THEN
           REFRESH MATERIALIZED VIEW CONCURRENTLY <%= view_name %>;
         END IF;
 
-        IF TG_OP = 'UPDATE' AND OLD.<%= source_column_name %> != NEW.<%= source_column_name %> THEN
+        IF TG_OP = 'UPDATE' AND
+           (<%= source_columns.map { |column| "OLD.#{column} IS DISTINCT FROM NEW.#{column}" }.join(' OR ') %>) THEN
           REFRESH MATERIALIZED VIEW CONCURRENTLY <%= view_name %>;
         END IF;
 
-        IF TG_OP = 'DELETE' AND OLD.<%= source_column_name %> IS NOT NULL THEN
+        IF TG_OP = 'DELETE' AND
+           (<%= source_columns.map { |column| "OLD.#{column} IS NOT NULL" }.join(' OR ') %>) THEN
           REFRESH MATERIALIZED VIEW CONCURRENTLY <%= view_name %>;
         END IF;
         RETURN NEW;
@@ -21,17 +24,21 @@ class <%= @migration_class_name %> < ActiveRecord::Migration<%= ActiveRecord::VE
 
     DROP MATERIALIZED VIEW IF EXISTS <%= view_name %>;
     CREATE MATERIALIZED VIEW <%= view_name %> AS
-      SELECT UNNEST
-        ( <%= source_column_name %> ) AS <%= source_column_name.singularize %>_name,
-        COUNT ( * ) AS taggings_count
-      FROM
-        <%= source_table_name %>
+      SELECT
+        tag_name,
+        COUNT(*) AS taggings_count
+      FROM (
+        SELECT UNNEST
+          (<%= source_columns.join(' || ') %>) AS tag_name
+        FROM
+          <%= source_table_name %>
+      ) subquery
       GROUP BY
-        <%= source_column_name.singularize %>_name;
+        tag_name;
 
-    CREATE UNIQUE INDEX idx_<%= source_table_name %>_<%= source_column_name %> ON <%= view_name %>(<%= source_column_name.singularize %>_name);
+    CREATE UNIQUE INDEX idx_<%= source_table_name %>_<%= source_columns_names %> ON <%= view_name %>(tag_name);
 
-    CREATE TRIGGER metka_on_<%= source_table_name %>
+    CREATE TRIGGER metka_on_<%= source_table_name %>_<%= source_columns_names %>
     AFTER UPDATE OR INSERT OR DELETE ON <%= source_table_name %> FOR EACH ROW
     EXECUTE PROCEDURE metka_refresh_<%= view_name %>_materialized_view();
     SQL
@@ -39,7 +46,7 @@ class <%= @migration_class_name %> < ActiveRecord::Migration<%= ActiveRecord::VE
 
   def down
     execute <<-SQL
-      DROP TRIGGER IF EXISTS metka_on_<%= source_table_name %> ON <%= source_table_name %>;
+      DROP TRIGGER IF EXISTS metka_on_<%= source_table_name %>_<%= source_columns_names %> ON <%= source_table_name %>;
       DROP FUNCTION IF EXISTS metka_refresh_<%= view_name %>_materialized_view;
       DROP MATERIALIZED VIEW IF EXISTS <%= view_name %>;
     SQL

data/lib/generators/metka/strategies/view/templates/migration.rb.erb

@@ -4,14 +4,17 @@ class <%= @migration_class_name %> < ActiveRecord::Migration<%= ActiveRecord::VE
   def up
     execute <<-SQL
     CREATE OR REPLACE VIEW <%= view_name %> AS
-
-    SELECT UNNEST
-      ( <%= source_column_name %> ) AS <%= source_column_name.singularize %>_name,
-      COUNT ( * ) AS taggings_count
-    FROM
-      <%= source_table_name %>
-    GROUP BY
-      <%= source_column_name.singularize %>_name;
+      SELECT
+        tag_name,
+        COUNT(*) AS taggings_count
+      FROM (
+        SELECT UNNEST
+          (<%= source_columns.join(' || ') %>) AS tag_name
+        FROM
+          <%= source_table_name %>
+      ) subquery
+      GROUP BY
+        tag_name;
     SQL
   end
 

data/lib/generators/metka/strategies/view/view_generator.rb

@@ -9,6 +9,8 @@ module Metka
       class ViewGenerator < ::Rails::Generators::Base # :nodoc:
         include Rails::Generators::Migration
 
+        DEFAULT_SOURCE_COLUMNS = ['tags'].freeze
+
         desc <<~LONGDESC
           Generates migration to implement view strategy for Metka
 
@@ -20,8 +22,11 @@ module Metka
         class_option :source_table_name, type: :string, required: true,
                                          desc: 'Name of the table that has a column with tags'
 
-        class_option :source_column_name, type: :string, default: 'tags',
-                                          desc: 'Name of the column with stored tags'
+        class_option :source_columns, type: :array, default: DEFAULT_SOURCE_COLUMNS,
+                                      desc: 'List of the tagged columns names'
+
+        class_option :view_name, type: :string,
+                                 desc: 'Custom name for the resulting view'
 
         def generate_migration
           migration_template 'migration.rb.erb', "db/migrate/#{migration_name}.rb"
@@ -32,12 +37,19 @@ module Metka
             options[:source_table_name]
           end
 
-          def source_column_name
-            options[:source_column_name]
+          def source_columns
+            options[:source_columns]
+          end
+
+          def source_columns_names
+            source_columns.join('_and_')
           end
 
           def view_name
-            "tagged_#{source_table_name}"
+            return options[:view_name] if options[:view_name]
+
+            columns_sequence = source_columns == DEFAULT_SOURCE_COLUMNS ? nil : "_with_#{source_columns_names}"
+            "tagged#{columns_sequence}_#{source_table_name}"
           end
 
           def migration_name

data/lib/metka.rb

@@ -16,5 +16,5 @@ module Metka
   extend Dry::Configurable
 
   setting :parser, Metka::GenericParser
-  setting :delimiter, ','
+  setting :delimiter, ',', reader: true
 end

data/lib/metka/generic_parser.rb

@@ -12,6 +12,11 @@ module Metka
   class GenericParser
     include Singleton
 
+    def initialize
+      @single_quote_pattern ||= {}
+      @double_quote_pattern ||= {}
+    end
+
     def call(value)
       TagList.new.tap do |tag_list|
         case value
@@ -20,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 joined_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
@@ -36,17 +41,16 @@ module Metka
       }
     end
 
-    def joined_delimiter
-      delimeter = Metka.config.delimiter
-      delimeter.is_a?(Array) ? delimeter.join('|') : delimeter
+    def delimiter
+      Metka.delimiter
     end
 
     def single_quote_pattern
-      /(\A|#{joined_delimiter})\s*'(.*?)'\s*(?=#{joined_delimiter}\s*|\z)/
+     @single_quote_pattern[delimiter] ||= /(\A|#{delimiter})\s*'(.*?)'\s*(?=#{delimiter}\s*|\z)/
     end
 
     def double_quote_pattern
-      /(\A|#{joined_delimiter})\s*"(.*?)"\s*(?=#{joined_delimiter}\s*|\z)/
+      @double_quote_pattern[delimiter] ||= /(\A|#{delimiter})\s*"(.*?)"\s*(?=#{delimiter}\s*|\z)/
     end
   end
 end

data/lib/metka/model.rb

@@ -1,47 +1,88 @@
 # frozen_string_literal: true
 
+require 'arel'
+
 module Metka
-  def self.Model(column:, **options)
-    Metka::Model.new(column: column, **options)
+  OR = Arel::Nodes::Or
+  AND = Arel::Nodes::And
+
+  def self.Model(column: nil, columns: nil, **options)
+    columns = [column, *columns].uniq.compact
+    raise ArgumentError, 'Columns not specified' unless columns.present?
+
+    Metka::Model.new(columns: columns, **options)
   end
 
   class Model < Module
-    def initialize(column: , **options)
-      @column = column
-      @options = options
+    def initialize(columns:, **options)
+      @columns = columns.dup.freeze
+      @options = options.dup.freeze
     end
 
     def included(base)
-      column = @column
+      columns = @columns
       parser = ->(tags) {
         @options[:parser] ? @options[:parser].call(tags) : Metka.config.parser.instance.call(tags)
       }
 
-      search_by_tags = ->(model, tags, column, **options) {
+      # @param model [ActiveRecord::Base] model on which to execute search
+      # @param tags [Object] list of tags, representation depends on parser used
+      # @param options [Hash] options
+      #   @option :join_operator [Metka::AND, Metka::OR]
+      #   @option :on [Array<String>] list of column names to include in query
+      # @returns ViewPost::ActiveRecord_Relation
+      tagged_with_lambda = ->(model, tags, **options) {
+        cols = options.delete(:on)
         parsed_tag_list = parser.call(tags)
-        if options[:without].present?
-          model.where.not(::Metka::QueryBuilder.new.call(model, column, parsed_tag_list, options))
-        else
-          return model.none if parsed_tag_list.empty?
-          model.where(::Metka::QueryBuilder.new.call(model, column, parsed_tag_list, options))
-        end
+
+        return model.none if parsed_tag_list.empty?
+
+        request = ::Metka::QueryBuilder.new.call(model, cols, parsed_tag_list, options)
+        model.where(request)
       }
 
       base.class_eval do
-        scope "with_all_#{column}", ->(tags) { search_by_tags.call(self, tags, column) }
-        scope "with_any_#{column}", ->(tags) { search_by_tags.call(self, tags, column, { any: true }) }
-        scope "without_all_#{column}", ->(tags) { search_by_tags.call(self, tags, column, { exclude_all: true, without: true }) }
-        scope "without_any_#{column}", ->(tags) { search_by_tags.call(self, tags, column, { exclude_any: true, without: true }) }
+        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) }
+        end
+
+        unless respond_to?(:tagged_with)
+          scope :tagged_with, ->(tags = '', options = {}) {
+            options[:join_operator] ||= ::Metka::OR
+            options = {any: false}.merge(options)
+            options[:on] ||= columns
+
+            tagged_with_lambda.call(self, tags, **options)
+          }
+        end
       end
 
-      base.define_method(column.singularize + '_list=') do |v|
-        self.write_attribute(column, parser.call(v).to_a)
-        self.write_attribute(column, nil) if self.send(column).empty?
+      base.define_singleton_method :metka_cloud do |*columns|
+        return [] if columns.blank?
+
+        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')
       end
 
-      base.define_method(column.singularize + '_list') do
-        parser.call(self.send(column))
+      columns.each do |column|
+        base.define_method(column.singularize + '_list=') do |v|
+          write_attribute(column, parser.call(v).to_a)
+          write_attribute(column, nil) if send(column).empty?
+        end
+
+        base.define_method(column.singularize + '_list') do
+          parser.call(send(column))
+        end
+
+        base.define_singleton_method :"#{column.singularize}_cloud" do
+          metka_cloud(column)
+        end
       end
     end
   end
-end
+end

data/lib/metka/query_builder.rb

@@ -1,23 +1,68 @@
 # frozen_string_literal: true
 
+require 'arel'
 require_relative 'query_builder/base_query'
-require_relative 'query_builder/exclude_all_tags_query'
-require_relative 'query_builder/exclude_any_tags_query'
 require_relative 'query_builder/any_tags_query'
 require_relative 'query_builder/all_tags_query'
 
 module Metka
   class QueryBuilder
-    def call(taggable_model, column, tag_list, options)
-      if options[:exclude_all].present?
-        ExcludeAllTagsQuery.instance.call(taggable_model, column, tag_list)
-      elsif options[:exclude_any].present?
-        ExcludeAnyTagsQuery.instance.call(taggable_model, column, tag_list)
-      elsif options[:any].present?
-        AnyTagsQuery.instance.call(taggable_model, column, tag_list)
+    def call(model, columns, tags, options)
+      strategy = options_to_strategy(options)
+
+      query = join(options[:join_operator]) do
+        columns.map do |column|
+          build_query(strategy, model, column, tags)
+        end
+      end
+
+      if options[:exclude].present?
+        Arel::Nodes::Not.new(query)
+      else
+        query
+      end
+    end
+
+    private
+
+    def options_to_strategy options
+      if options[:any].present?
+        AnyTagsQuery
       else
-        AllTagsQuery.instance.call(taggable_model, column, tag_list)
+        AllTagsQuery
+      end
+    end
+
+    def join(operator, &block)
+      nodes = block.call
+
+      if operator == ::Metka::AND
+        join_and(nodes)
+      elsif operator == ::Metka::OR
+        join_or(nodes)
+      end
+    end
+
+    # @param nodes [Array<Arel::Node>, Arel::Node]
+    # @return [Arel::Node]
+    def join_or(nodes)
+      case nodes
+      when ::Arel::Node
+        nodes
+      when Array
+        l, *r = nodes
+        return l if r.empty?
+
+        l.or(join_or(r))
       end
     end
+
+    def join_and(queries)
+      Arel::Nodes::And.new(queries)
+    end
+
+    def build_query(strategy, model, column, tags)
+      strategy.instance.call(model, column, tags)
+    end
   end
 end

data/lib/metka/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Metka
-  VERSION = '1.0.3'
+  VERSION = '2.0.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: metka
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 2.0.0
 platform: ruby
 authors:
 - Igor Alexandrov
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-02-28 00:00:00.000000000 Z
+date: 2020-05-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-configurable
@@ -228,8 +228,6 @@ files:
 - lib/metka/query_builder/all_tags_query.rb
 - lib/metka/query_builder/any_tags_query.rb
 - lib/metka/query_builder/base_query.rb
-- lib/metka/query_builder/exclude_all_tags_query.rb
-- lib/metka/query_builder/exclude_any_tags_query.rb
 - lib/metka/tag_list.rb
 - lib/metka/version.rb
 - metka.gemspec
@@ -252,7 +250,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Rails tagging system based on PostgreSQL arrays

data/lib/metka/query_builder/exclude_all_tags_query.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-module Metka
-  class ExcludeAllTagsQuery< BaseQuery
-    private
-
-    def infix_operator
-      '@>'
-    end
-  end
-end

data/lib/metka/query_builder/exclude_any_tags_query.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-module Metka
-  class ExcludeAnyTagsQuery< BaseQuery
-    private
-
-    def infix_operator
-      '&&'
-    end
-  end
-end