metka 0.1.2 → 2.0.0

data/bin/setup

@@ -5,5 +5,4 @@ set -e
 gem install bundler --conservative
 bundle check || bundle install
 
-RAILS_ENV=test bundle exec rake dummy:db:create
-RAILS_ENV=test bundle exec rake dummy:db:schema:load
+RAILS_ENV=test bundle exec rake dummy:db:migrate:reset

data/gemfiles/rails5.gemfile

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

data/gemfiles/rails52.gemfile

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

data/gemfiles/rails6.gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+gem 'rails', '~>6.0'
+gem 'activerecord', '~> 6.0'
+
+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,16 +40,23 @@ 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
-            "create_#{view_name}_view"
+            "create_#{view_name}_materialized_view"
           end
 
           def migration_class_name

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

@@ -3,38 +3,52 @@
 class <%= @migration_class_name %> < ActiveRecord::Migration<%= ActiveRecord::VERSION::MAJOR < 5 ? '' : '[5.0]' %>
   def up
     execute <<-SQL
-    CREATE 
-      OR REPLACE FUNCTION metka_refresh_<%= view_name %>_materialized_view RETURNS TRIGGER LANGUAGE plpgsql AS $$
+    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 %>;
-        ELSIF TG_OP = 'UPDATE' AND OLD.<%= source_column_name %> IS NOT NULL AND NEW.<%= source_column_name %> IS NOT NULL THEN
-          REFRESH MATERIALIZED VIEW CONCURRENTLY <%= view_name %>;
-        ELSIF TG_OP = 'DELETE' AND OLD.<%= source_column_name %> IS NOT NULL THEN
+        END IF;
+
+        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;
 
-      RETURN NULL;
-    END $$;
+        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;
+      END $$;
 
-    CREATE OR REPLACE MATERIALZIED VIEW <%= view_name %> AS
+    DROP MATERIALIZED VIEW IF EXISTS <%= view_name %>;
+    CREATE MATERIALIZED VIEW <%= view_name %> AS
+      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;
 
-    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;
+    CREATE UNIQUE INDEX idx_<%= source_table_name %>_<%= source_columns_names %> ON <%= view_name %>(tag_name);
 
-    CREATE TRIGGER metka_on_<%= source_table_name %>
-    BEFORE UPDATE OR INSERT OR DELETE ON <%= source_table_name %> FOR EACH ROW
-    EXECUTE PROCEDURE metka_refresh_<%= view_name %>_materialized_view();    
+    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
   end
 
   def down
     execute <<-SQL
-      DROP VIEW <%= view_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
   end
 end

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,15 +12,45 @@ 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
         when String
-          tag_list.merge value.split(',').map(&:strip).reject(&:empty?)
+          value = value.to_s.dup
+          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?)
         when Enumerable
           tag_list.merge value.reject(&:empty?)
         end
       end
     end
+
+    private
+
+    def gsub_quote_pattern!(tag_list, value, pattern)
+      value.gsub!(pattern) {
+        tag_list.add(Regexp.last_match[2])
+        ''
+      }
+    end
+
+    def delimiter
+      Metka.delimiter
+    end
+
+    def single_quote_pattern
+     @single_quote_pattern[delimiter] ||= /(\A|#{delimiter})\s*'(.*?)'\s*(?=#{delimiter}\s*|\z)/
+    end
+
+    def double_quote_pattern
+      @double_quote_pattern[delimiter] ||= /(\A|#{delimiter})\s*"(.*?)"\s*(?=#{delimiter}\s*|\z)/
+    end
   end
 end

data/lib/metka/model.rb

@@ -1,33 +1,88 @@
 # frozen_string_literal: true
 
-require 'active_support/concern'
+require 'arel'
 
 module Metka
-  # Extends AR model with methods to use tags
-  module Model
-    extend ActiveSupport::Concern
+  OR = Arel::Nodes::Or
+  AND = Arel::Nodes::And
 
-    included do
-      scope :tagged_with, ->(tags, options = {}) do
-        tag_list = Metka.config.parser.instance.call(tags)
-        options = options.dup
+  def self.Model(column: nil, columns: nil, **options)
+    columns = [column, *columns].uniq.compact
+    raise ArgumentError, 'Columns not specified' unless columns.present?
 
-        return none if tag_list.empty?
+    Metka::Model.new(columns: columns, **options)
+  end
 
-        where(::Metka::QueryBuilder.new.call(self, 'tags', tag_list, options))
-      end
+  class Model < Module
+    def initialize(columns:, **options)
+      @columns = columns.dup.freeze
+      @options = options.dup.freeze
     end
 
-    def tag_list=(v)
-      self.tags = Metka.config.parser.instance.call(v).to_a
-      self.tags = nil if tags.empty?
-    end
+    def included(base)
+      columns = @columns
+      parser = ->(tags) {
+        @options[:parser] ? @options[:parser].call(tags) : Metka.config.parser.instance.call(tags)
+      }
 
-    def tag_list
-      Metka.config.parser.instance.call(tags)
-    end
+      # @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)
+
+        return model.none if parsed_tag_list.empty?
 
-    module ClassMethods # :nodoc:
+        request = ::Metka::QueryBuilder.new.call(model, cols, parsed_tag_list, options)
+        model.where(request)
+      }
+
+      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) }
+        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_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
+
+      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

data/lib/metka/query_builder.rb

@@ -1,19 +1,68 @@
 # frozen_string_literal: true
 
-require_relative 'query_builder/exclude_tags_query'
+require 'arel'
+require_relative 'query_builder/base_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)
+    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?
-        ExcludeTagsQuery.new(taggable_model, tag_model, tagging_model, tag_list, options).build
-      elsif options[:any].present?
-        AnyTagsQuery.instance.call(taggable_model, column, tag_list)
+        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