nano-max-tool 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 12be2e253491b0f5f52de412784a49a4674b2bd890de68f50e9a1674bbb5e7e4
+  data.tar.gz: d46a31f512e27ea5bec7e95ac95333673751ef71b491b1fda3d66176413eaec6
+SHA512:
+  metadata.gz: 5b50a2916ee3034e5dc3ae9430c2ee4c1af07620be90475c1d8c8d1e8b18a8413c57c6718b6e7b7e90434477f6f51ba816a6f766d57d827e9325dc8bb34ae46a
+  data.tar.gz: f9a2dd2a81b54695b0591c7c1d960b642d982014f2117705eba4c4e67ae4dd307749deaaf8875f7337cb79b5cbbcde7ec48c99e66bd570a461ad88d0a84e83d4

data/acts-as-taggable-on-13.0.0/LICENSE.md

@@ -0,0 +1,20 @@
+__Copyright (c) 2007 Michael Bleigh and Intridea Inc.__
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/acts-as-taggable-on-13.0.0/db/migrate/1_acts_as_taggable_on_migration.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+class ActsAsTaggableOnMigration < ActiveRecord::Migration[6.0]
+  def self.up
+    create_table ActsAsTaggableOn.tags_table do |t|
+      t.string :name
+      t.timestamps
+    end
+
+    create_table ActsAsTaggableOn.taggings_table do |t|
+      t.references :tag, foreign_key: { to_table: ActsAsTaggableOn.tags_table }
+
+      # You should make sure that the column created is
+      # long enough to store the required class names.
+      t.references :taggable, polymorphic: true
+      t.references :tagger, polymorphic: true
+
+      # Limit is created to prevent MySQL error on index
+      # length for MyISAM table type: http://bit.ly/vgW2Ql
+      t.string :context, limit: 128
+
+      t.datetime :created_at
+    end
+
+    add_index ActsAsTaggableOn.taggings_table, %i[taggable_id taggable_type context],
+              name: 'taggings_taggable_context_idx'
+  end
+
+  def self.down
+    drop_table ActsAsTaggableOn.taggings_table
+    drop_table ActsAsTaggableOn.tags_table
+  end
+end

data/acts-as-taggable-on-13.0.0/db/migrate/2_add_missing_unique_indices.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+class AddMissingUniqueIndices < ActiveRecord::Migration[6.0]
+  def self.up
+    add_index ActsAsTaggableOn.tags_table, :name, unique: true
+
+    remove_index ActsAsTaggableOn.taggings_table, :tag_id if index_exists?(ActsAsTaggableOn.taggings_table, :tag_id)
+    remove_index ActsAsTaggableOn.taggings_table, name: 'taggings_taggable_context_idx'
+    add_index ActsAsTaggableOn.taggings_table,
+              %i[tag_id taggable_id taggable_type context tagger_id tagger_type],
+              unique: true, name: 'taggings_idx'
+  end
+
+  def self.down
+    remove_index ActsAsTaggableOn.tags_table, :name
+
+    remove_index ActsAsTaggableOn.taggings_table, name: 'taggings_idx'
+
+    add_index ActsAsTaggableOn.taggings_table, :tag_id unless index_exists?(ActsAsTaggableOn.taggings_table, :tag_id)
+    add_index ActsAsTaggableOn.taggings_table, %i[taggable_id taggable_type context],
+              name: 'taggings_taggable_context_idx'
+  end
+end

data/acts-as-taggable-on-13.0.0/db/migrate/3_add_taggings_counter_cache_to_tags.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+class AddTaggingsCounterCacheToTags < ActiveRecord::Migration[6.0]
+  def self.up
+    add_column ActsAsTaggableOn.tags_table, :taggings_count, :integer, default: 0
+
+    ActsAsTaggableOn::Tag.reset_column_information
+    ActsAsTaggableOn::Tag.find_each do |tag|
+      ActsAsTaggableOn::Tag.reset_counters(tag.id, ActsAsTaggableOn.taggings_table)
+    end
+  end
+
+  def self.down
+    remove_column ActsAsTaggableOn.tags_table, :taggings_count
+  end
+end

data/acts-as-taggable-on-13.0.0/db/migrate/4_add_missing_taggable_index.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+class AddMissingTaggableIndex < ActiveRecord::Migration[6.0]
+  def self.up
+    add_index ActsAsTaggableOn.taggings_table, %i[taggable_id taggable_type context],
+              name: 'taggings_taggable_context_idx'
+  end
+
+  def self.down
+    remove_index ActsAsTaggableOn.taggings_table, name: 'taggings_taggable_context_idx'
+  end
+end

data/acts-as-taggable-on-13.0.0/db/migrate/5_change_collation_for_tag_names.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+# This migration is added to circumvent issue #623 and have special characters
+# work properly
+
+class ChangeCollationForTagNames < ActiveRecord::Migration[6.0]
+  def up
+    if ActsAsTaggableOn::Utils.using_mysql?
+      execute("ALTER TABLE #{ActsAsTaggableOn.tags_table} MODIFY name varchar(255) CHARACTER SET utf8 COLLATE utf8_bin;")
+    end
+  end
+end

data/acts-as-taggable-on-13.0.0/db/migrate/6_add_missing_indexes_on_taggings.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+class AddMissingIndexesOnTaggings < ActiveRecord::Migration[6.0]
+  def change
+    add_index ActsAsTaggableOn.taggings_table, :tag_id unless index_exists? ActsAsTaggableOn.taggings_table, :tag_id
+    add_index ActsAsTaggableOn.taggings_table, :taggable_id unless index_exists? ActsAsTaggableOn.taggings_table,
+                                                                                 :taggable_id
+    add_index ActsAsTaggableOn.taggings_table, :taggable_type unless index_exists? ActsAsTaggableOn.taggings_table,
+                                                                                   :taggable_type
+    add_index ActsAsTaggableOn.taggings_table, :tagger_id unless index_exists? ActsAsTaggableOn.taggings_table,
+                                                                               :tagger_id
+    add_index ActsAsTaggableOn.taggings_table, :context unless index_exists? ActsAsTaggableOn.taggings_table, :context
+
+    unless index_exists? ActsAsTaggableOn.taggings_table, %i[tagger_id tagger_type]
+      add_index ActsAsTaggableOn.taggings_table, %i[tagger_id tagger_type]
+    end
+
+    unless index_exists? ActsAsTaggableOn.taggings_table, %i[taggable_id taggable_type tagger_id context],
+                         name: 'taggings_idy'
+      add_index ActsAsTaggableOn.taggings_table, %i[taggable_id taggable_type tagger_id context],
+                name: 'taggings_idy'
+    end
+  end
+end

data/acts-as-taggable-on-13.0.0/db/migrate/7_add_tenant_to_taggings.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class AddTenantToTaggings < ActiveRecord::Migration[6.0]
+  def self.up
+    add_column ActsAsTaggableOn.taggings_table, :tenant, :string, limit: 128
+    add_index ActsAsTaggableOn.taggings_table, :tenant unless index_exists? ActsAsTaggableOn.taggings_table, :tenant
+  end
+
+  def self.down
+    remove_index ActsAsTaggableOn.taggings_table, :tenant
+    remove_column ActsAsTaggableOn.taggings_table, :tenant
+  end
+end

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module ActsAsTaggableOn
+  ##
+  # Returns a new TagList using the given tag string.
+  #
+  # Example:
+  #   tag_list = ActsAsTaggableOn::DefaultParser.parse("One , Two,  Three")
+  #   tag_list # ["One", "Two", "Three"]
+  class DefaultParser < GenericParser
+    def parse
+      string = @tag_list
+
+      string = string.join(ActsAsTaggableOn.glue) if string.respond_to?(:join)
+      TagList.new.tap do |tag_list|
+        string = string.to_s.dup
+
+        string.gsub!(double_quote_pattern) do
+          # Append the matched tag to the tag list
+          tag_list << Regexp.last_match[2]
+          # Return the matched delimiter ($3) to replace the matched items
+          ''
+        end
+
+        string.gsub!(single_quote_pattern) do
+          # Append the matched tag ($2) to the tag list
+          tag_list << Regexp.last_match[2]
+          # Return an empty string to replace the matched items
+          ''
+        end
+
+        # split the string by the delimiter
+        # and add to the tag_list
+        tag_list.add(string.split(Regexp.new(delimiter)))
+      end
+    end
+
+    # private
+    def delimiter
+      # Parse the quoted tags
+      d = ActsAsTaggableOn.delimiter
+      # Separate multiple delimiters by bitwise operator
+      d = d.join('|') if d.is_a?(Array)
+      d
+    end
+
+    # (             # Tag start delimiter ($1)
+    # \A       |  # Either string start or
+    # #{delimiter}        # a delimiter
+    # )
+    # \s*"          # quote (") optionally preceded by whitespace
+    # (.*?)         # Tag ($2)
+    # "\s*          # quote (") optionally followed by whitespace
+    # (?=           # Tag end delimiter (not consumed; is zero-length lookahead)
+    # #{delimiter}\s*  |  # Either a delimiter optionally followed by whitespace or
+    # \z          # string end
+    # )
+    def double_quote_pattern
+      /(\A|#{delimiter})\s*"(.*?)"\s*(?=#{delimiter}\s*|\z)/
+    end
+
+    # (             # Tag start delimiter ($1)
+    # \A       |  # Either string start or
+    # #{delimiter}        # a delimiter
+    # )
+    # \s*'          # quote (') optionally preceded by whitespace
+    # (.*?)         # Tag ($2)
+    # '\s*          # quote (') optionally followed by whitespace
+    # (?=           # Tag end delimiter (not consumed; is zero-length lookahead)
+    # #{delimiter}\s*  | d # Either a delimiter optionally followed by whitespace or
+    # \z          # string end
+    # )
+    def single_quote_pattern
+      /(\A|#{delimiter})\s*'(.*?)'\s*(?=#{delimiter}\s*|\z)/
+    end
+  end
+end

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

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module ActsAsTaggableOn
+  class Engine < Rails::Engine
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module ActsAsTaggableOn
+  ##
+  # Returns a new TagList using the given tag string.
+  #
+  # Example:
+  # tag_list = ActsAsTaggableOn::GenericParser.new.parse("One , Two, Three")
+  # tag_list # ["One", "Two", "Three"]
+  class GenericParser
+    def initialize(tag_list)
+      @tag_list = tag_list
+    end
+
+    def parse
+      TagList.new.tap do |tag_list|
+        tag_list.add @tag_list.split(',').map(&:strip).reject(&:empty?)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module ActsAsTaggableOn
+  class Tag < ActsAsTaggableOn.base_class.constantize
+    self.table_name = ActsAsTaggableOn.tags_table
+
+    ### ASSOCIATIONS:
+
+    has_many :taggings, dependent: :destroy, class_name: '::ActsAsTaggableOn::Tagging'
+
+    ### VALIDATIONS:
+
+    validates_presence_of :name
+    validates_uniqueness_of :name, if: :validates_name_uniqueness?, case_sensitive: true
+    validates_length_of :name, maximum: 255
+
+    # monkey patch this method if don't need name uniqueness validation
+    def validates_name_uniqueness?
+      true
+    end
+
+    ### SCOPES:
+    scope :most_used, ->(limit = 20) { order('taggings_count desc').limit(limit) }
+    scope :least_used, ->(limit = 20) { order('taggings_count asc').limit(limit) }
+
+    def self.named(name)
+      if ActsAsTaggableOn.strict_case_match
+        where(["name = #{binary}?", name.to_s])
+      else
+        where(['LOWER(name) = LOWER(?)', name.to_s.downcase])
+      end
+    end
+
+    def self.named_any(list)
+      clause = list.map do |tag|
+        sanitize_sql_for_named_any(tag)
+      end.join(' OR ')
+      where(clause)
+    end
+
+    def self.named_like(name)
+      clause = ["name #{ActsAsTaggableOn::Utils.like_operator} ? ESCAPE '!'",
+                "%#{ActsAsTaggableOn::Utils.escape_like(name)}%"]
+      where(clause)
+    end
+
+    def self.named_like_any(list)
+      clause = list.map do |tag|
+        sanitize_sql(["name #{ActsAsTaggableOn::Utils.like_operator} ? ESCAPE '!'",
+                      "%#{ActsAsTaggableOn::Utils.escape_like(tag.to_s)}%"])
+      end.join(' OR ')
+      where(clause)
+    end
+
+    def self.for_context(context)
+      joins(:taggings)
+        .where(["#{ActsAsTaggableOn.taggings_table}.context = ?", context])
+        .select("DISTINCT #{ActsAsTaggableOn.tags_table}.*")
+    end
+
+    def self.for_tenant(tenant)
+      joins(:taggings)
+        .where("#{ActsAsTaggableOn.taggings_table}.tenant = ?", tenant.to_s)
+        .select("DISTINCT #{ActsAsTaggableOn.tags_table}.*")
+    end
+
+    ### CLASS METHODS:
+
+    def self.find_or_create_with_like_by_name(name)
+      if ActsAsTaggableOn.strict_case_match
+        find_or_create_all_with_like_by_name([name]).first
+      else
+        named_like(name).first || create(name: name)
+      end
+    end
+
+    def self.find_or_create_all_with_like_by_name(*list)
+      list = Array(list).flatten
+
+      return [] if list.empty?
+
+      existing_tags = named_any(list)
+      list.map do |tag_name|
+        tries ||= 3
+        comparable_tag_name = comparable_name(tag_name)
+        existing_tag = existing_tags.find { |tag| comparable_name(tag.name) == comparable_tag_name }
+        next existing_tag if existing_tag
+
+        transaction(requires_new: true) { create(name: tag_name) }
+      rescue ActiveRecord::RecordNotUnique
+        if (tries -= 1).positive?
+          existing_tags = named_any(list)
+          retry
+        end
+
+        raise DuplicateTagError, "'#{tag_name}' has already been taken"
+      end
+    end
+
+    ### INSTANCE METHODS:
+
+    def ==(other)
+      super || (other.is_a?(Tag) && name == other.name)
+    end
+
+    def to_s
+      name
+    end
+
+    def count
+      read_attribute(:count).to_i
+    end
+
+    class << self
+      private
+
+      def comparable_name(str)
+        if ActsAsTaggableOn.strict_case_match
+          str
+        else
+          str.to_s.downcase
+        end
+      end
+
+      def binary
+        ActsAsTaggableOn::Utils.using_mysql? ? 'BINARY ' : nil
+      end
+
+      def sanitize_sql_for_named_any(tag)
+        if ActsAsTaggableOn.strict_case_match
+          sanitize_sql(["name = #{binary}?", tag.to_s])
+        else
+          sanitize_sql(['LOWER(name) = LOWER(?)', tag.to_s.downcase])
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/module/delegation'
+
+module ActsAsTaggableOn
+  class TagList < Array
+    attr_accessor :owner, :parser
+
+    def initialize(*args)
+      @parser = ActsAsTaggableOn.default_parser
+      add(*args)
+    end
+
+    ##
+    # Add tags to the tag_list. Duplicate or blank tags will be ignored.
+    # Use the <tt>:parse</tt> option to add an unparsed tag string.
+    #
+    # Example:
+    #   tag_list.add("Fun", "Happy")
+    #   tag_list.add("Fun, Happy", :parse => true)
+    def add(*names)
+      extract_and_apply_options!(names)
+      concat(names)
+      clean!
+      self
+    end
+
+    # Append---Add the tag to the tag_list. This
+    # expression returns the tag_list itself, so several appends
+    # may be chained together.
+    def <<(obj)
+      add(obj)
+    end
+
+    # Concatenation --- Returns a new tag list built by concatenating the
+    # two tag lists together to produce a third tag list.
+    def +(other)
+      TagList.new.add(self).add(other)
+    end
+
+    # Appends the elements of +other_tag_list+ to +self+.
+    def concat(other_tag_list)
+      super(other_tag_list).send(:clean!)
+      self
+    end
+
+    ##
+    # Remove specific tags from the tag_list.
+    # Use the <tt>:parse</tt> option to add an unparsed tag string.
+    #
+    # Example:
+    #   tag_list.remove("Sad", "Lonely")
+    #   tag_list.remove("Sad, Lonely", :parse => true)
+    def remove(*names)
+      extract_and_apply_options!(names)
+      delete_if { |name| names.include?(name) }
+      self
+    end
+
+    ##
+    # Transform the tag_list into a tag string suitable for editing in a form.
+    # The tags are joined with <tt>TagList.delimiter</tt> and quoted if necessary.
+    #
+    # Example:
+    #   tag_list = TagList.new("Round", "Square,Cube")
+    #   tag_list.to_s # 'Round, "Square,Cube"'
+    def to_s
+      tags = frozen? ? dup : self
+      tags.send(:clean!)
+
+      tags.map do |name|
+        d = ActsAsTaggableOn.delimiter
+        d = Regexp.new d.join('|') if d.is_a? Array
+        name.index(d) ? "\"#{name}\"" : name
+      end.join(ActsAsTaggableOn.glue)
+    end
+
+    private
+
+    # Convert everything to string, remove whitespace, duplicates, and blanks.
+    def clean!
+      reject!(&:blank?)
+      map!(&:to_s)
+      map!(&:strip)
+      map! { |tag| tag.to_s.downcase } if ActsAsTaggableOn.force_lowercase
+      map!(&:parameterize) if ActsAsTaggableOn.force_parameterize
+
+      ActsAsTaggableOn.strict_case_match ? uniq! : uniq!(&:downcase)
+      self
+    end
+
+    def extract_and_apply_options!(args)
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      options.assert_valid_keys :parse, :parser
+
+      parser = options[:parser] || @parser
+
+      args.map! { |a| parser.new(a).parse } if options[:parse] || options[:parser]
+
+      args.flatten!
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module ActsAsTaggableOn
+  module Taggable
+    module Caching
+      extend ActiveSupport::Concern
+
+      included do
+        initialize_tags_cache
+        before_save :save_cached_tag_list
+      end
+
+      class_methods do
+        def initialize_tags_cache
+          tag_types.map(&:to_s).each do |tag_type|
+            define_singleton_method("caching_#{tag_type.singularize}_list?") do
+              caching_tag_list_on?(tag_type)
+            end
+          end
+        end
+
+        def acts_as_taggable_on(*args)
+          super(*args)
+          initialize_tags_cache
+        end
+
+        def caching_tag_list_on?(context)
+          column_names.include?("cached_#{context.to_s.singularize}_list")
+        end
+      end
+
+      def save_cached_tag_list
+        tag_types.map(&:to_s).each do |tag_type|
+          next unless self.class.respond_to?("caching_#{tag_type.singularize}_list?")
+          if self.class.send("caching_#{tag_type.singularize}_list?") && tag_list_cache_set_on(tag_type)
+            list = tag_list_cache_on(tag_type).to_a.flatten.compact.join("#{ActsAsTaggableOn.delimiter} ")
+            self["cached_#{tag_type.singularize}_list"] = list
+          end
+        end
+
+        true
+      end
+    end
+  end
+end
+