metka 1.0.3 → 2.1.0

data/gemfiles/rails52.gemfile

@@ -1,6 +1,6 @@
 source "https://rubygems.org"
 
-gem 'rails', '~>5.2'
-gem 'activerecord', '~> 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/{rails5.gemfile → rails61.gemfile}

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

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, Arel.sql('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,70 @@
 # 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]) {
+        columns.map do |column|
+          build_query(strategy, model, column, tags)
+        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::Nodes::Node>, Arel::Nodes::Node]
+    # @return [Arel::Nodes::Node]
+    def join_or(nodes)
+      node_base_klass = defined?(::Arel::Nodes::Node) ? ::Arel::Nodes::Node : ::Arel::Node
+
+      case nodes
+      when node_base_klass
+        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