nano-max-tool 0.0.1

data/acts-as-taggable-on-13.0.0/lib/acts-as-taggable-on/taggable/related.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module ActsAsTaggableOn
+  module Taggable
+    module Related
+      def self.included(base)
+        base.extend ActsAsTaggableOn::Taggable::Related::ClassMethods
+        base.initialize_acts_as_taggable_on_related
+      end
+
+      module ClassMethods
+        def initialize_acts_as_taggable_on_related
+          tag_types.map(&:to_s).each do |tag_type|
+            class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def find_related_#{tag_type}(options = {})
+              related_tags_for('#{tag_type}', self.class, options)
+            end
+            alias_method :find_related_on_#{tag_type}, :find_related_#{tag_type}
+
+            def find_related_#{tag_type}_for(klass, options = {})
+              related_tags_for('#{tag_type}', klass, options)
+            end
+            RUBY
+          end
+        end
+
+        def acts_as_taggable_on(*args)
+          super(*args)
+          initialize_acts_as_taggable_on_related
+        end
+      end
+
+      def find_matching_contexts(search_context, result_context, options = {})
+        matching_contexts_for(search_context.to_s, result_context.to_s, self.class, options)
+      end
+
+      def find_matching_contexts_for(klass, search_context, result_context, options = {})
+        matching_contexts_for(search_context.to_s, result_context.to_s, klass, options)
+      end
+
+      def matching_contexts_for(search_context, result_context, klass, _options = {})
+        tags_to_find = tags_on(search_context).map(&:name)
+        related_where(klass,
+                      [
+                        "#{exclude_self(klass,
+                                        id)} #{klass.table_name}.#{klass.primary_key} = #{ActsAsTaggableOn::Tagging.table_name}.taggable_id AND #{ActsAsTaggableOn::Tagging.table_name}.taggable_type = '#{klass.base_class}' AND #{ActsAsTaggableOn::Tagging.table_name}.tag_id = #{ActsAsTaggableOn::Tag.table_name}.#{ActsAsTaggableOn::Tag.primary_key} AND #{ActsAsTaggableOn::Tag.table_name}.name IN (?) AND #{ActsAsTaggableOn::Tagging.table_name}.context = ?", tags_to_find, result_context
+                      ])
+      end
+
+      def related_tags_for(context, klass, options = {})
+        tags_to_ignore = Array.wrap(options[:ignore]).map(&:to_s) || []
+        tags_to_find = tags_on(context).map(&:name).reject { |t| tags_to_ignore.include? t }
+        related_where(klass,
+                      [
+                        "#{exclude_self(klass,
+                                        id)} #{klass.table_name}.#{klass.primary_key} = #{ActsAsTaggableOn::Tagging.table_name}.taggable_id AND #{ActsAsTaggableOn::Tagging.table_name}.taggable_type = '#{klass.base_class}' AND #{ActsAsTaggableOn::Tagging.table_name}.tag_id = #{ActsAsTaggableOn::Tag.table_name}.#{ActsAsTaggableOn::Tag.primary_key} AND #{ActsAsTaggableOn::Tag.table_name}.name IN (?) AND #{ActsAsTaggableOn::Tagging.table_name}.context = ?", tags_to_find, context
+                      ])
+      end
+
+      private
+
+      def exclude_self(klass, id)
+        "#{klass.arel_table[klass.primary_key].not_eq(id).to_sql} AND" if [self.class.base_class,
+                                                                           self.class].include? klass
+      end
+
+      def group_columns(klass)
+        if ActsAsTaggableOn::Utils.using_postgresql?
+          grouped_column_names_for(klass)
+        else
+          "#{klass.table_name}.#{klass.primary_key}"
+        end
+      end
+
+      def related_where(klass, conditions)
+        klass.select("#{klass.table_name}.*, COUNT(#{ActsAsTaggableOn::Tag.table_name}.#{ActsAsTaggableOn::Tag.primary_key}) AS count")
+             .from("#{klass.table_name}, #{ActsAsTaggableOn::Tag.table_name}, #{ActsAsTaggableOn::Tagging.table_name}")
+             .group(group_columns(klass))
+             .order('count DESC')
+             .where(conditions)
+      end
+    end
+  end
+end

data/acts-as-taggable-on-13.0.0/lib/acts-as-taggable-on/taggable/tag_list_type.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module ActsAsTaggableOn
+  module Taggable
+    class TagListType < ActiveModel::Type::Value
+    end
+  end
+end

data/acts-as-taggable-on-13.0.0/lib/acts-as-taggable-on/taggable/tagged_with_query/all_tags_query.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module ActsAsTaggableOn
+  module Taggable
+    module TaggedWithQuery
+      class AllTagsQuery < QueryBase
+        def build
+          taggable_model.joins(each_tag_in_list)
+                        .group(by_taggable)
+                        .having(tags_that_matches_count)
+                        .order(order_conditions)
+                        .readonly(false)
+        end
+
+        private
+
+        def each_tag_in_list
+          arel_join = taggable_arel_table
+
+          tag_list.each do |tag|
+            tagging_alias = tagging_arel_table.alias(tagging_alias(tag))
+            arel_join = arel_join
+                        .join(tagging_alias)
+                        .on(on_conditions(tag, tagging_alias))
+          end
+
+          if options[:match_all].present?
+            arel_join = arel_join
+                        .join(tagging_arel_table, Arel::Nodes::OuterJoin)
+                        .on(
+                          match_all_on_conditions
+                        )
+          end
+
+          arel_join.join_sources
+        end
+
+        def on_conditions(tag, tagging_alias)
+          on_condition = tagging_alias[:taggable_id].eq(taggable_arel_table[taggable_model.primary_key])
+                                                    .and(tagging_alias[:taggable_type].eq(taggable_model.base_class.name))
+                                                    .and(
+                                                      tagging_alias[:tag_id].in(
+                                                        tag_arel_table.project(tag_arel_table[:id]).where(tag_match_type(tag))
+                                                      )
+                                                    )
+
+          if options[:start_at].present?
+            on_condition = on_condition.and(tagging_alias[:created_at].gteq(options[:start_at]))
+          end
+
+          if options[:end_at].present?
+            on_condition = on_condition.and(tagging_alias[:created_at].lteq(options[:end_at]))
+          end
+
+          on_condition = on_condition.and(tagging_alias[:context].eq(options[:on])) if options[:on].present?
+
+          if (owner = options[:owned_by]).present?
+            on_condition = on_condition.and(tagging_alias[:tagger_id].eq(owner.id))
+                                       .and(tagging_alias[:tagger_type].eq(owner.class.base_class.to_s))
+          end
+
+          on_condition
+        end
+
+        def match_all_on_conditions
+          on_condition = tagging_arel_table[:taggable_id].eq(taggable_arel_table[taggable_model.primary_key])
+                                                         .and(tagging_arel_table[:taggable_type].eq(taggable_model.base_class.name))
+
+          if options[:start_at].present?
+            on_condition = on_condition.and(tagging_arel_table[:created_at].gteq(options[:start_at]))
+          end
+
+          if options[:end_at].present?
+            on_condition = on_condition.and(tagging_arel_table[:created_at].lteq(options[:end_at]))
+          end
+
+          on_condition = on_condition.and(tagging_arel_table[:context].eq(options[:on])) if options[:on].present?
+
+          on_condition
+        end
+
+        def by_taggable
+          return [] if options[:match_all].blank?
+
+          taggable_arel_table[taggable_model.primary_key]
+        end
+
+        def tags_that_matches_count
+          return [] if options[:match_all].blank?
+
+          taggable_model.find_by_sql(tag_arel_table.project(Arel.star.count).where(tags_match_type).to_sql)
+
+          tagging_arel_table[:taggable_id].count.eq(
+            tag_arel_table.project(Arel.star.count).where(tags_match_type)
+          )
+        end
+
+        def order_conditions
+          order_by = []
+          if options[:order_by_matching_tag_count].present? && options[:match_all].blank?
+            order_by << tagging_arel_table.project(tagging_arel_table[Arel.star].count.as('taggings_count')).order('taggings_count DESC').to_sql
+          end
+
+          order_by << options[:order] if options[:order].present?
+          order_by.join(', ')
+        end
+
+        def tagging_alias(tag)
+          alias_base_name = taggable_model.base_class.name.downcase
+          adjust_taggings_alias("#{alias_base_name[0..11]}_taggings_#{ActsAsTaggableOn::Utils.sha_prefix(tag)}")
+        end
+      end
+    end
+  end
+end

data/acts-as-taggable-on-13.0.0/lib/acts-as-taggable-on/taggable/tagged_with_query/any_tags_query.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module ActsAsTaggableOn
+  module Taggable
+    module TaggedWithQuery
+      class AnyTagsQuery < QueryBase
+        def build
+          taggable_model.select(all_fields)
+                        .where(model_has_at_least_one_tag)
+                        .order(Arel.sql(order_conditions))
+                        .readonly(false)
+        end
+
+        private
+
+        def all_fields
+          taggable_arel_table[Arel.star]
+        end
+
+        def model_has_at_least_one_tag
+          tagging_arel_table.project(Arel.star).where(at_least_one_tag).exists
+        end
+
+        def at_least_one_tag
+          exists_contition = tagging_arel_table[:taggable_id].eq(taggable_arel_table[taggable_model.primary_key])
+                                                             .and(tagging_arel_table[:taggable_type].eq(taggable_model.base_class.name))
+                                                             .and(
+                                                               tagging_arel_table[:tag_id].in(
+                                                                 tag_arel_table.project(tag_arel_table[:id]).where(tags_match_type)
+                                                               )
+                                                             )
+
+          if options[:start_at].present?
+            exists_contition = exists_contition.and(tagging_arel_table[:created_at].gteq(options[:start_at]))
+          end
+
+          if options[:end_at].present?
+            exists_contition = exists_contition.and(tagging_arel_table[:created_at].lteq(options[:end_at]))
+          end
+
+          if options[:on].present?
+            exists_contition = exists_contition.and(tagging_arel_table[:context].eq(options[:on]))
+          end
+
+          if (owner = options[:owned_by]).present?
+            exists_contition = exists_contition.and(tagging_arel_table[:tagger_id].eq(owner.id))
+                                               .and(tagging_arel_table[:tagger_type].eq(owner.class.base_class.to_s))
+          end
+
+          exists_contition
+        end
+
+        def order_conditions
+          order_by = []
+          if options[:order_by_matching_tag_count].present?
+            order_by << "(SELECT count(*) FROM #{tagging_model.table_name} WHERE #{at_least_one_tag.to_sql}) desc"
+          end
+
+          order_by << options[:order] if options[:order].present?
+          order_by.join(', ')
+        end
+
+        def alias_name(tag_list)
+          alias_base_name = taggable_model.base_class.name.downcase
+          taggings_context = options[:on] ? "_#{options[:on]}" : ''
+
+          adjust_taggings_alias(
+            "#{alias_base_name[0..4]}#{taggings_context[0..6]}_taggings_#{ActsAsTaggableOn::Utils.sha_prefix(tag_list.join('_'))}"
+          )
+        end
+      end
+    end
+  end
+end

data/acts-as-taggable-on-13.0.0/lib/acts-as-taggable-on/taggable/tagged_with_query/exclude_tags_query.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module ActsAsTaggableOn
+  module Taggable
+    module TaggedWithQuery
+      class ExcludeTagsQuery < QueryBase
+        def build
+          taggable_model.joins(owning_to_tagger)
+                        .where(tags_not_in_list)
+                        .having(tags_that_matches_count)
+                        .readonly(false)
+        end
+
+        private
+
+        def tags_not_in_list
+          taggable_arel_table[:id].not_in(
+            tagging_arel_table
+              .project(tagging_arel_table[:taggable_id])
+              .join(tag_arel_table)
+              .on(
+                tagging_arel_table[:tag_id].eq(tag_arel_table[:id])
+                .and(tagging_arel_table[:taggable_type].eq(taggable_model.base_class.name))
+                .and(tags_match_type)
+              )
+          )
+
+          # FIXME: missing time scope, this is also missing in the original implementation
+        end
+
+        def owning_to_tagger
+          return [] if options[:owned_by].blank?
+
+          owner = options[:owned_by]
+
+          arel_join = taggable_arel_table
+                      .join(tagging_arel_table)
+                      .on(
+                        tagging_arel_table[:tagger_id].eq(owner.id)
+                        .and(tagging_arel_table[:tagger_type].eq(owner.class.base_class.to_s))
+                        .and(tagging_arel_table[:taggable_id].eq(taggable_arel_table[taggable_model.primary_key]))
+                        .and(tagging_arel_table[:taggable_type].eq(taggable_model.base_class.name))
+                      )
+
+          if options[:match_all].present?
+            arel_join = arel_join
+                        .join(tagging_arel_table, Arel::Nodes::OuterJoin)
+                        .on(
+                          match_all_on_conditions
+                        )
+          end
+
+          arel_join.join_sources
+        end
+
+        def match_all_on_conditions
+          on_condition = tagging_arel_table[:taggable_id].eq(taggable_arel_table[taggable_model.primary_key])
+                                                         .and(tagging_arel_table[:taggable_type].eq(taggable_model.base_class.name))
+
+          if options[:start_at].present?
+            on_condition = on_condition.and(tagging_arel_table[:created_at].gteq(options[:start_at]))
+          end
+
+          if options[:end_at].present?
+            on_condition = on_condition.and(tagging_arel_table[:created_at].lteq(options[:end_at]))
+          end
+
+          on_condition = on_condition.and(tagging_arel_table[:context].eq(options[:on])) if options[:on].present?
+
+          on_condition
+        end
+
+        def tags_that_matches_count
+          return [] if options[:match_all].blank?
+
+          taggable_model.find_by_sql(tag_arel_table.project(Arel.star.count).where(tags_match_type).to_sql)
+
+          tagging_arel_table[:taggable_id].count.eq(
+            tag_arel_table.project(Arel.star.count).where(tags_match_type)
+          )
+        end
+      end
+    end
+  end
+end

data/acts-as-taggable-on-13.0.0/lib/acts-as-taggable-on/taggable/tagged_with_query/query_base.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module ActsAsTaggableOn
+  module Taggable
+    module TaggedWithQuery
+      class QueryBase
+        def initialize(taggable_model, tag_model, tagging_model, tag_list, options)
+          @taggable_model = taggable_model
+          @tag_model      = tag_model
+          @tagging_model  = tagging_model
+          @tag_list       = tag_list
+          @options        = options
+        end
+
+        private
+
+        attr_reader :taggable_model, :tag_model, :tagging_model, :tag_list, :options
+
+        def taggable_arel_table
+          @taggable_arel_table ||= taggable_model.arel_table
+        end
+
+        def tag_arel_table
+          @tag_arel_table ||= tag_model.arel_table
+        end
+
+        def tagging_arel_table
+          @tagging_arel_table ||= tagging_model.arel_table
+        end
+
+        def tag_match_type(tag)
+          matches_attribute = tag_arel_table[:name]
+          matches_attribute = matches_attribute.lower unless ActsAsTaggableOn.strict_case_match
+
+          if options[:wild].present?
+            matches_attribute.matches(wildcard_escaped_tag(tag), '!', ActsAsTaggableOn.strict_case_match)
+          else
+            matches_attribute.matches(escaped_tag(tag), '!', ActsAsTaggableOn.strict_case_match)
+          end
+        end
+
+        def tags_match_type
+          matches_attribute = tag_arel_table[:name]
+          matches_attribute = matches_attribute.lower unless ActsAsTaggableOn.strict_case_match
+
+          if options[:wild].present?
+            matches_attribute.matches_any(tag_list.map do |tag|
+                                            wildcard_escaped_tag(tag)
+                                          end, '!', ActsAsTaggableOn.strict_case_match)
+          else
+            matches_attribute.matches_any(tag_list.map do |tag|
+                                            escaped_tag(tag).to_s
+                                          end, '!', ActsAsTaggableOn.strict_case_match)
+          end
+        end
+
+        def escaped_tag(tag)
+          tag = tag.downcase unless ActsAsTaggableOn.strict_case_match
+          ActsAsTaggableOn::Utils.escape_like(tag)
+        end
+
+        def wildcard_escaped_tag(tag)
+          case options[:wild]
+          when :suffix then "#{escaped_tag(tag)}%"
+          when :prefix then "%#{escaped_tag(tag)}"
+          when true then "%#{escaped_tag(tag)}%"
+          else escaped_tag(tag)
+          end
+        end
+
+        def adjust_taggings_alias(taggings_alias)
+          taggings_alias = "taggings_alias_#{Digest::SHA1.hexdigest(taggings_alias)}" if taggings_alias.size > 75
+          taggings_alias
+        end
+      end
+    end
+  end
+end

data/acts-as-taggable-on-13.0.0/lib/acts-as-taggable-on/taggable/tagged_with_query.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ActsAsTaggableOn
+  module Taggable
+    module TaggedWithQuery
+      def self.build(taggable_model, tag_model, tagging_model, tag_list, options)
+        if options[:exclude].present?
+          ExcludeTagsQuery.new(taggable_model, tag_model, tagging_model, tag_list, options).build
+        elsif options[:any].present?
+          AnyTagsQuery.new(taggable_model, tag_model, tagging_model, tag_list, options).build
+        else
+          AllTagsQuery.new(taggable_model, tag_model, tagging_model, tag_list, options).build
+        end
+      end
+    end
+  end
+end

data/acts-as-taggable-on-13.0.0/lib/acts-as-taggable-on/taggable.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module ActsAsTaggableOn
+  module Taggable
+    def taggable?
+      false
+    end
+
+    ##
+    # This is an alias for calling <tt>acts_as_taggable_on :tags</tt>.
+    #
+    # Example:
+    #   class Book < ActiveRecord::Base
+    #     acts_as_taggable
+    #   end
+    def acts_as_taggable
+      acts_as_taggable_on :tags
+    end
+
+    ##
+    # This is an alias for calling <tt>acts_as_ordered_taggable_on :tags</tt>.
+    #
+    # Example:
+    #   class Book < ActiveRecord::Base
+    #     acts_as_ordered_taggable
+    #   end
+    def acts_as_ordered_taggable
+      acts_as_ordered_taggable_on :tags
+    end
+
+    ##
+    # Make a model taggable on specified contexts.
+    #
+    # @param [Array] tag_types An array of taggable contexts
+    #
+    # Example:
+    #   class User < ActiveRecord::Base
+    #     acts_as_taggable_on :languages, :skills
+    #   end
+    def acts_as_taggable_on(*tag_types)
+      taggable_on(false, tag_types)
+    end
+
+    ##
+    # Make a model taggable on specified contexts
+    # and preserves the order in which tags are created
+    #
+    # @param [Array] tag_types An array of taggable contexts
+    #
+    # Example:
+    #   class User < ActiveRecord::Base
+    #     acts_as_ordered_taggable_on :languages, :skills
+    #   end
+    def acts_as_ordered_taggable_on(*tag_types)
+      taggable_on(true, tag_types)
+    end
+
+    def acts_as_taggable_tenant(tenant)
+      if taggable?
+      else
+        class_attribute :tenant_column
+      end
+      self.tenant_column = tenant
+
+      # each of these add context-specific methods and must be
+      # called on each call of taggable_on
+      include Core
+      include Collection
+      include Caching
+      include Ownership
+      include Related
+    end
+
+    private
+
+    # Make a model taggable on specified contexts
+    # and optionally preserves the order in which tags are created
+    #
+    # Separate methods used above for backwards compatibility
+    # so that the original acts_as_taggable_on method is unaffected
+    # as it's not possible to add another argument to the method
+    # without the tag_types being enclosed in square brackets
+    #
+    # NB: method overridden in core module in order to create tag type
+    #     associations and methods after this logic has executed
+    #
+    def taggable_on(preserve_tag_order, *tag_types)
+      tag_types = tag_types.to_a.flatten.compact.map(&:to_sym)
+
+      if taggable?
+        self.tag_types = (self.tag_types + tag_types).uniq
+        self.preserve_tag_order = preserve_tag_order
+      else
+        class_eval do
+          class_attribute :tag_types
+          class_attribute :preserve_tag_order
+          class_attribute :tenant_column
+          self.tag_types = tag_types
+          self.preserve_tag_order = preserve_tag_order
+
+          has_many :taggings, as: :taggable, dependent: :destroy, class_name: '::ActsAsTaggableOn::Tagging'
+          has_many :base_tags, through: :taggings, source: :tag, class_name: '::ActsAsTaggableOn::Tag'
+
+          def self.taggable?
+            true
+          end
+        end
+      end
+
+      # each of these add context-specific methods and must be
+      # called on each call of taggable_on
+      include Core
+      include Collection
+      include Caching
+      include Ownership
+      include Related
+    end
+  end
+end

data/acts-as-taggable-on-13.0.0/lib/acts-as-taggable-on/tagger.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module ActsAsTaggableOn
+  module Tagger
+    extend ActiveSupport::Concern
+
+    class_methods do
+      ##
+      # Make a model a tagger. This allows an instance of a model to claim ownership
+      # of tags.
+      #
+      # Example:
+      #   class User < ActiveRecord::Base
+      #     acts_as_tagger
+      #   end
+      def acts_as_tagger(opts = {})
+        class_eval do
+          owned_taggings_scope = opts.delete(:scope)
+
+          has_many :owned_taggings, owned_taggings_scope,
+                   **opts.merge(
+                     as: :tagger,
+                     class_name: '::ActsAsTaggableOn::Tagging',
+                     dependent: :destroy
+                   )
+
+          has_many :owned_tags, -> { distinct },
+                   class_name: '::ActsAsTaggableOn::Tag',
+                   source: :tag,
+                   through: :owned_taggings
+        end
+
+        include ActsAsTaggableOn::Tagger::InstanceMethods
+        extend ActsAsTaggableOn::Tagger::SingletonMethods
+      end
+
+      def tagger?
+        false
+      end
+
+      alias is_tagger? tagger?
+    end
+
+    module InstanceMethods
+      ##
+      # Tag a taggable model with tags that are owned by the tagger.
+      #
+      # @param taggable The object that will be tagged
+      # @param [Hash] options An hash with options. Available options are:
+      #               * <tt>:with</tt> - The tags that you want to
+      #               * <tt>:on</tt>   - The context on which you want to tag
+      #
+      # Example:
+      #   @user.tag(@photo, :with => "paris, normandy", :on => :locations)
+      def tag(taggable, opts = {})
+        opts.reverse_merge!(force: true)
+        skip_save = opts.delete(:skip_save)
+        return false unless taggable.respond_to?(:is_taggable?) && taggable.is_taggable?
+
+        raise 'You need to specify a tag context using :on' unless opts.key?(:on)
+        raise 'You need to specify some tags using :with' unless opts.key?(:with)
+        unless opts[:force] || taggable.tag_types.include?(opts[:on])
+          raise "No context :#{opts[:on]} defined in #{taggable.class}"
+        end
+
+        taggable.set_owner_tag_list_on(self, opts[:on].to_s, opts[:with])
+        taggable.save unless skip_save
+      end
+
+      def tagger?
+        self.class.is_tagger?
+      end
+
+      alias is_tagger? tagger?
+    end
+
+    module SingletonMethods
+      def tagger?
+        true
+      end
+
+      alias is_tagger? tagger?
+    end
+  end
+end