metka 1.0.0

data/Rakefile

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+namespace :dummy do
+  require_relative 'spec/dummy/config/application'
+  Dummy::Application.load_tasks
+end
+
+task default: :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "metka"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/bin/sh
+
+set -e
+
+gem install bundler --conservative
+bundle check || bundle install
+
+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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'rails/generators'
+require 'rails/generators/active_record'
+
+module Metka
+  module Generators
+    module Strategies
+      class MaterializedViewGenerator < ::Rails::Generators::Base # :nodoc:
+        include Rails::Generators::Migration
+
+        desc <<~LONGDESC
+          Generates migration to implement view strategy for Metka
+
+          > $ rails g metka:strategies:materialized_view --source-table-name=NAME_OF_TABLE_WITH_TAGS
+        LONGDESC
+
+        source_root File.expand_path('templates', __dir__)
+
+        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'
+
+        def generate_migration
+          migration_template 'migration.rb.erb', "db/migrate/#{migration_name}.rb"
+        end
+
+        no_tasks do
+          def source_table_name
+            options[:source_table_name]
+          end
+
+          def source_column_name
+            options[:source_column_name]
+          end
+
+          def view_name
+            "tagged_#{source_table_name}"
+          end
+
+          def migration_name
+            "create_#{view_name}_materialized_view"
+          end
+
+          def migration_class_name
+            migration_name.classify
+          end
+        end
+
+        def self.next_migration_number(dir)
+          ::ActiveRecord::Generators::Base.next_migration_number(dir)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+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 $$
+      BEGIN
+        IF TG_OP = 'INSERT' AND NEW.<%= source_column_name %> IS NOT NULL THEN
+          REFRESH MATERIALIZED VIEW CONCURRENTLY <%= view_name %>;
+        END IF;
+
+        IF TG_OP = 'UPDATE' AND OLD.<%= source_column_name %> != NEW.<%= source_column_name %> THEN
+          REFRESH MATERIALIZED VIEW CONCURRENTLY <%= view_name %>;
+        END IF;
+
+        IF TG_OP = 'DELETE' AND OLD.<%= source_column_name %> IS NOT NULL THEN
+          REFRESH MATERIALIZED VIEW CONCURRENTLY <%= view_name %>;
+        END IF;
+        RETURN NEW;
+      END $$;
+
+    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 %>
+      GROUP BY
+        <%= source_column_name.singularize %>_name;
+
+    CREATE UNIQUE INDEX idx_<%= source_table_name %>_<%= source_column_name %> ON <%= view_name %>(<%= source_column_name.singularize %>_name);
+
+    CREATE TRIGGER metka_on_<%= source_table_name %>
+    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 TRIGGER IF EXISTS metka_on_<%= source_table_name %> 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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+class <%= @migration_class_name %> < ActiveRecord::Migration<%= ActiveRecord::VERSION::MAJOR < 5 ? '' : '[5.0]' %>
+  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;
+    SQL
+  end
+
+  def down
+    execute <<-SQL
+      DROP VIEW <%= view_name %>;
+    SQL
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'rails/generators'
+require 'rails/generators/active_record'
+
+module Metka
+  module Generators
+    module Strategies
+      class ViewGenerator < ::Rails::Generators::Base # :nodoc:
+        include Rails::Generators::Migration
+
+        desc <<~LONGDESC
+          Generates migration to implement view strategy for Metka
+
+          > $ rails g metka:strategies:view --source-table-name=NAME_OF_TABLE_WITH_TAGS
+        LONGDESC
+
+        source_root File.expand_path('templates', __dir__)
+
+        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'
+
+        def generate_migration
+          migration_template 'migration.rb.erb', "db/migrate/#{migration_name}.rb"
+        end
+
+        no_tasks do
+          def source_table_name
+            options[:source_table_name]
+          end
+
+          def source_column_name
+            options[:source_column_name]
+          end
+
+          def view_name
+            "tagged_#{source_table_name}"
+          end
+
+          def migration_name
+            "create_#{view_name}_view"
+          end
+
+          def migration_class_name
+            migration_name.classify
+          end
+        end
+
+        def self.next_migration_number(dir)
+          ::ActiveRecord::Generators::Base.next_migration_number(dir)
+        end
+      end
+    end
+  end
+end

data/lib/metka.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'metka/version'
+
+require 'active_support/core_ext/module'
+require 'dry-configurable'
+
+module Metka
+  require 'metka/tag_list'
+  require 'metka/generic_parser'
+  require 'metka/query_builder'
+  require 'metka/model'
+
+  class Error < StandardError; end
+
+  extend Dry::Configurable
+
+  setting :parser, Metka::GenericParser
+  setting :delimiter, ','
+end

data/lib/metka/generic_parser.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'singleton'
+
+module Metka
+  ##
+  # Returns a new Metka::TagList using the given tag string.
+  #
+  # Example:
+  # tag_list = Metka::GenericParser.instance.("One , Two, Three")
+  # tag_list # ["One", "Two", "Three"]
+  class GenericParser
+    include Singleton
+
+    def call(value)
+      TagList.new.tap do |tag_list|
+        case value
+        when String
+          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 joined_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 joined_delimiter
+      delimeter = Metka.config.delimiter
+      delimeter.is_a?(Array) ? delimeter.join('|') : delimeter
+    end
+
+    def single_quote_pattern
+      /(\A|#{joined_delimiter})\s*'(.*?)'\s*(?=#{joined_delimiter}\s*|\z)/
+    end
+
+    def double_quote_pattern
+      /(\A|#{joined_delimiter})\s*"(.*?)"\s*(?=#{joined_delimiter}\s*|\z)/
+    end
+  end
+end

data/lib/metka/model.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Metka
+  def self.Model(column:, **options)
+    Metka::Model.new(column: column, **options)
+  end
+
+  class Model < Module
+    def initialize(column: , **options)
+      @column = column
+      @options = options
+    end
+
+    def included(base)
+      column = @column
+      parser = ->(tags) {
+        @options[:parser] ? @options[:parser].call(tags) : Metka.config.parser.instance.call(tags)
+      }
+
+      search_by_tags = ->(model, tags, column, **options) {
+        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
+      }
+
+      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 }) }
+      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?
+      end
+
+      base.define_method(column.singularize + '_list') do
+        parser.call(self.send(column))
+      end
+    end
+  end
+end

data/lib/metka/query_builder.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+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)
+      else
+        AllTagsQuery.instance.call(taggable_model, column, tag_list)
+      end
+    end
+  end
+end

data/lib/metka/query_builder/all_tags_query.rb

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

data/lib/metka/query_builder/any_tags_query.rb

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

data/lib/metka/query_builder/base_query.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+require 'singleton'
+
+module Metka
+  class BaseQuery
+    include Singleton
+
+    def call(model, column_name, tag_list)
+      column_cast = Arel::Nodes::NamedFunction.new(
+        'CAST',
+        [model.arel_table[column_name].as('text[]')]
+      )
+
+      value = Arel::Nodes::SqlLiteral.new(
+        # In Rails 5.2 and above Sanitanization moved to public level, but still we have to support 4.2 and 5.0 and 5.1
+        ActiveRecord::Base.send(:sanitize_sql_for_conditions, ['ARRAY[?]', tag_list.to_a])
+      )
+
+      value_cast = Arel::Nodes::NamedFunction.new(
+        'CAST',
+        [value.as('text[]')]
+      )
+
+      Arel::Nodes::InfixOperation.new(infix_operator, column_cast, value_cast)
+    end
+  end
+end