giga-pure-kit 0.0.1

data/ransack-4.4.1/lib/ransack/translate.rb

@@ -0,0 +1,156 @@
+require 'i18n'
+
+I18n.load_path += Dir[
+  File.join(File.dirname(__FILE__), 'locale'.freeze, '*.yml'.freeze)
+]
+
+module Ransack
+  module Translate
+    class << self
+      def word(key, options = {})
+        I18n.translate(:"ransack.#{key}", default: key.to_s)
+      end
+
+      def predicate(key, options = {})
+        I18n.translate(:"ransack.predicates.#{key}", default: key.to_s)
+      end
+
+      def attribute(key, options = {})
+        unless context = options.delete(:context)
+          raise ArgumentError, "A context is required to translate attributes"
+        end
+
+        original_name = key.to_s
+        base_class = context.klass
+        base_ancestors = base_class.ancestors.select {
+          |x| x.respond_to?(:model_name)
+        }
+        attributes_str = original_name.dup # will be modified by ⬇
+        predicate = Predicate.detect_and_strip_from_string!(attributes_str)
+        attribute_names = attributes_str.split(/_and_|_or_/)
+        combinator = attributes_str =~ /_and_/ ? :and : :or
+        defaults = base_ancestors.map do |klass|
+          "ransack.attributes.#{i18n_key(klass)}.#{original_name}".to_sym
+        end
+        defaults << options.delete(:default) if options[:default]
+
+        translated_names = attribute_names.map do |name|
+          attribute_name(context, name, options[:include_associations])
+        end
+
+        interpolations = {
+          attributes: translated_names.join(" #{Translate.word(combinator)} ")
+        }
+
+        if predicate
+          defaults << "%{attributes} %{predicate}".freeze
+          interpolations[:predicate] = Translate.predicate(predicate)
+        else
+          defaults << "%{attributes}".freeze
+        end
+
+        options.reverse_merge! count: 1, default: defaults
+        I18n.translate(defaults.shift, **options.merge(interpolations))
+      end
+
+      def association(key, options = {})
+        unless context = options.delete(:context)
+          raise ArgumentError, "A context is required to translate associations"
+        end
+
+        defaults =
+          if key.blank?
+            [:"ransack.models.#{i18n_key(context.klass)}",
+             :"#{context.klass.i18n_scope}.models.#{i18n_key(context.klass)}"]
+          else
+            [:"ransack.associations.#{i18n_key(context.klass)}.#{key}"]
+          end
+        defaults << context.traverse(key).model_name.human
+        options = { count: 1, default: defaults }
+        I18n.translate(defaults.shift, **options)
+      end
+
+      private
+
+      def attribute_name(context, name, include_associations = nil)
+        @context, @name = context, name
+        @assoc_path = context.association_path(name)
+        @attr_name = @name.sub(/^#{@assoc_path}_/, ''.freeze)
+        associated_class = @context.traverse(@assoc_path) if @assoc_path.present?
+        @include_associated = include_associations && associated_class
+
+        defaults = default_attribute_name << fallback_args
+        options = { count: 1, default: defaults }
+        interpolations = build_interpolations(associated_class)
+
+        I18n.translate(defaults.shift, **options.merge(interpolations))
+      end
+
+      def default_attribute_name
+        ["ransack.attributes.#{i18n_key(@context.klass)}.#{@name}".to_sym]
+      end
+
+      def fallback_args
+        if @include_associated
+          '%{association_name} %{attr_fallback_name}'.freeze
+        else
+          '%{attr_fallback_name}'.freeze
+        end
+      end
+
+      def build_interpolations(associated_class)
+        {
+          attr_fallback_name: attr_fallback_name(associated_class),
+          association_name: association_name
+        }.reject { |_, value| value.nil? }
+      end
+
+      def attr_fallback_name(associated_class)
+        I18n.t(
+          :"ransack.attributes.#{fallback_class(associated_class)}.#{@attr_name}",
+          default: default_interpolation(associated_class)
+        )
+      end
+
+      def fallback_class(associated_class)
+        i18n_key(associated_class || @context.klass)
+      end
+
+      def association_name
+        association(@assoc_path, context: @context) if @include_associated
+      end
+
+      def default_interpolation(associated_class)
+        [
+          associated_attribute(associated_class),
+          ".attributes.#{@attr_name}".to_sym,
+          @attr_name.humanize
+        ].flatten
+      end
+
+      def associated_attribute(associated_class)
+        if associated_class
+          translated_attribute(associated_class)
+        else
+          translated_ancestor_attributes
+        end
+      end
+
+      def translated_attribute(associated_class)
+        key = "#{associated_class.i18n_scope}.attributes.#{
+        i18n_key(associated_class)}.#{@attr_name}"
+        ["#{key}.one".to_sym, key.to_sym]
+      end
+
+      def translated_ancestor_attributes
+        @context.klass.ancestors
+          .select { |ancestor| ancestor.respond_to?(:model_name) }
+          .map { |ancestor| translated_attribute(ancestor) }
+      end
+
+      def i18n_key(klass)
+        klass.model_name.i18n_key
+      end
+    end
+  end
+end

data/ransack-4.4.1/lib/ransack/version.rb

@@ -0,0 +1,3 @@
+module Ransack
+  VERSION = '4.4.1'
+end

data/ransack-4.4.1/lib/ransack/visitor.rb

@@ -0,0 +1,87 @@
+module Ransack
+  class Visitor
+
+    def accept(object)
+      visit(object)
+    end
+
+    def can_accept?(object)
+      respond_to? DISPATCH[object.class]
+    end
+
+    def visit_Array(object)
+      object.map { |o| accept(o) }.compact
+    end
+
+    def visit_Ransack_Nodes_Condition(object)
+      object.arel_predicate if object.valid?
+    end
+
+    def visit_Ransack_Nodes_Grouping(object)
+      if object.combinator == Constants::OR
+        visit_or(object)
+      else
+        visit_and(object)
+      end
+    end
+
+    def visit_and(object)
+      nodes = object.values.map { |o| accept(o) }.compact
+      return nil unless nodes.size > 0
+
+      if nodes.size > 1
+        Arel::Nodes::Grouping.new(Arel::Nodes::And.new(nodes))
+      else
+        nodes.first
+      end
+    end
+
+    def visit_or(object)
+      nodes = object.values.map { |o| accept(o) }.compact
+      nodes.inject(&:or)
+    end
+
+    def quoted?(object)
+      case object
+      when Arel::Nodes::SqlLiteral, Bignum, Fixnum
+        false
+      else
+        true
+      end
+    end
+
+    def visit(object)
+      send(DISPATCH[object.class], object)
+    end
+
+    def visit_Ransack_Nodes_Sort(object)
+      if object.valid?
+        if object.attr.is_a?(Arel::Attributes::Attribute)
+          object.attr.send(object.dir)
+        else
+          ordered(object)
+        end
+      else
+        scope_name = :"sort_by_#{object.name}_#{object.dir}"
+        scope_name if object.context.object.respond_to?(scope_name)
+      end
+    end
+
+    DISPATCH = Hash.new do |hash, klass|
+      hash[klass] = "visit_#{
+        klass.name.gsub(Constants::TWO_COLONS, Constants::UNDERSCORE)
+        }"
+    end
+
+    private
+
+      def ordered(object)
+        case object.dir
+        when 'asc'.freeze
+          Arel::Nodes::Ascending.new(object.attr)
+        when 'desc'.freeze
+          Arel::Nodes::Descending.new(object.attr)
+        end
+      end
+  end
+end

data/ransack-4.4.1/lib/ransack.rb

@@ -0,0 +1,33 @@
+require 'active_support/dependencies/autoload'
+require 'active_support/deprecation'
+require 'active_support/deprecator'
+
+require 'active_support/core_ext'
+require 'ransack/configuration'
+require 'polyamorous/polyamorous'
+
+module Ransack
+  extend Configuration
+  class UntraversableAssociationError < StandardError; end
+end
+
+Ransack.configure do |config|
+  Ransack::Constants::AREL_PREDICATES.each do |name|
+    config.add_predicate name, arel_predicate: name
+  end
+  Ransack::Constants::DERIVED_PREDICATES.each do |args|
+    config.add_predicate(*args)
+  end
+end
+
+require 'ransack/search'
+require 'ransack/ransacker'
+require 'ransack/translate'
+require 'ransack/active_record'
+require 'ransack/context'
+require 'ransack/version'
+
+ActiveSupport.on_load(:action_controller) do
+  require 'ransack/helpers'
+  ActionController::Base.helper Ransack::Helpers::FormHelper
+end

data/ransack-4.4.1/spec/console.rb

@@ -0,0 +1,13 @@
+Bundler.setup
+require 'factory_bot'
+require 'faker'
+require 'ransack'
+
+Dir[File.expand_path('../../spec/{helpers,support,factories}/*.rb', __FILE__)]
+.each do |f|
+  require f
+end
+
+Faker::Config.random = Random.new(0)
+
+Schema.create

data/ransack-4.4.1/spec/factories/articles.rb

@@ -0,0 +1,7 @@
+FactoryBot.define do
+  factory :article do
+    association :person
+    title { Faker::Lorem.sentence }
+    body { Faker::Lorem.paragraph }
+  end
+end

data/ransack-4.4.1/spec/factories/comments.rb

@@ -0,0 +1,7 @@
+FactoryBot.define do
+  factory :comment do
+    association :article
+    association :person
+    body { Faker::Lorem.paragraph }
+  end
+end

data/ransack-4.4.1/spec/factories/notes.rb

@@ -0,0 +1,13 @@
+FactoryBot.define do
+  factory :note do
+    note { Faker::Lorem.words(number: 7).join(' ') }
+    
+    trait :for_person do
+      association :notable, factory: :person
+    end
+    
+    trait :for_article do
+      association :notable, factory: :article
+    end
+  end
+end

data/ransack-4.4.1/spec/factories/people.rb

@@ -0,0 +1,10 @@
+FactoryBot.define do
+  factory :person do
+    name { Faker::Name.name }
+    email { "test@example.com" }
+    sequence(:salary) { |n| 30000 + (n * 1000) }
+    only_sort { Faker::Lorem.words(number: 3).join(' ') }
+    only_search { Faker::Lorem.words(number: 3).join(' ') }
+    only_admin { Faker::Lorem.words(number: 3).join(' ') }
+  end
+end

data/ransack-4.4.1/spec/factories/tags.rb

@@ -0,0 +1,5 @@
+FactoryBot.define do
+  factory :tag do
+    name { Faker::Lorem.words(number: 3).join(' ') }
+  end
+end

data/ransack-4.4.1/spec/helpers/polyamorous_helper.rb

@@ -0,0 +1,13 @@
+module PolyamorousHelper
+  def new_join_association(reflection, children, klass)
+    Polyamorous::JoinAssociation.new reflection, children, klass
+  end
+
+  def new_join_dependency(klass, associations = {})
+    Polyamorous::JoinDependency.new klass, klass.arel_table, associations, Polyamorous::InnerJoin
+  end
+
+  def new_join(name, type = Polyamorous::InnerJoin, klass = nil)
+    Polyamorous::Join.new name, type, klass
+  end
+end

data/ransack-4.4.1/spec/helpers/ransack_helper.rb

@@ -0,0 +1,9 @@
+module RansackHelper
+  def quote_table_name(table)
+    ActiveRecord::Base.connection.quote_table_name(table)
+  end
+
+  def quote_column_name(column)
+    ActiveRecord::Base.connection.quote_column_name(column)
+  end
+end

data/ransack-4.4.1/spec/polyamorous/activerecord_compatibility_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+module Polyamorous
+  describe "ActiveRecord Compatibility" do
+    it 'works with self joins and includes' do
+      trade_account = Account.create!
+      Account.create!(trade_account: trade_account)
+
+      accounts = Account.joins(:trade_account).includes(:trade_account, :agent_account)
+      account = accounts.first
+
+      expect(account.agent_account).to be_nil
+    end
+  end
+end

data/ransack-4.4.1/spec/polyamorous/join_association_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+module Polyamorous
+  describe JoinAssociation do
+    let(:join_dependency) { new_join_dependency Note, {} }
+    let(:reflection) { Note.reflect_on_association(:notable) }
+    let(:parent) { join_dependency.send(:join_root) }
+    let(:join_association) {
+      new_join_association(reflection, parent.children, Article)
+    }
+
+    subject { new_join_association(reflection, parent.children, Person) }
+
+    it 'leaves the original reflection intact for thread safety' do
+      reflection.instance_variable_set(:@klass, Article)
+      join_association
+      .swapping_reflection_klass(reflection, Person) do |new_reflection|
+        expect(new_reflection.options).not_to equal reflection.options
+        expect(new_reflection.options).not_to have_key(:polymorphic)
+        expect(new_reflection.klass).to eq(Person)
+        expect(reflection.klass).to eq(Article)
+      end
+    end
+
+    it 'sets the polymorphic option to true after initializing' do
+      expect(join_association.reflection.options[:polymorphic]).to be true
+    end
+  end
+end

data/ransack-4.4.1/spec/polyamorous/join_dependency_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+module Polyamorous
+  describe JoinDependency do
+    context 'with symbol joins' do
+      subject { new_join_dependency Person, articles: :comments }
+
+      specify { expect(subject.send(:join_root).drop(1).size)
+        .to eq(2) }
+      specify { expect(subject.send(:join_root).drop(1).map(&:join_type).uniq)
+        .to eq [Polyamorous::InnerJoin] }
+    end
+
+    context 'with has_many :through association' do
+      subject { new_join_dependency Person, :authored_article_comments }
+
+      specify { expect(subject.send(:join_root).drop(1).size)
+        .to eq 1 }
+      specify { expect(subject.send(:join_root).drop(1).first.table_name)
+        .to eq 'comments' }
+    end
+
+    context 'with outer join' do
+      subject { new_join_dependency Person, new_join(:articles, :outer) }
+
+      specify { expect(subject.send(:join_root).drop(1).size)
+        .to eq 1 }
+      specify { expect(subject.send(:join_root).drop(1).first.join_type)
+        .to eq Polyamorous::OuterJoin }
+    end
+
+    context 'with nested outer joins' do
+      subject { new_join_dependency Person,
+        new_join(:articles, :outer) => new_join(:comments, :outer) }
+
+      specify { expect(subject.send(:join_root).drop(1).size)
+        .to eq 2 }
+      specify { expect(subject.send(:join_root).drop(1).map(&:join_type))
+        .to eq [Polyamorous::OuterJoin, Polyamorous::OuterJoin] }
+      specify { expect(subject.send(:join_root).drop(1).map(&:join_type).uniq)
+        .to eq [Polyamorous::OuterJoin] }
+    end
+
+    context 'with polymorphic belongs_to join' do
+      subject { new_join_dependency Note, new_join(:notable, :inner, Person) }
+
+      specify { expect(subject.send(:join_root).drop(1).size)
+        .to eq 1 }
+      specify { expect(subject.send(:join_root).drop(1).first.join_type)
+        .to eq Polyamorous::InnerJoin }
+      specify { expect(subject.send(:join_root).drop(1).first.table_name)
+        .to eq 'people' }
+    end
+
+    context 'with polymorphic belongs_to join and nested symbol join' do
+      subject { new_join_dependency Note,
+        new_join(:notable, :inner, Person) => :comments }
+
+      specify { expect(subject.send(:join_root).drop(1).size)
+        .to eq 2 }
+      specify { expect(subject.send(:join_root).drop(1).map(&:join_type).uniq)
+        .to eq [Polyamorous::InnerJoin] }
+      specify { expect(subject.send(:join_root).drop(1).first.table_name)
+        .to eq 'people' }
+      specify { expect(subject.send(:join_root).drop(1)[1].table_name)
+        .to eq 'comments' }
+    end
+
+    context 'with polymorphic belongs_to join and nested join' do
+      subject { new_join_dependency Note,
+        new_join(:notable, :outer, Person) => :comments }
+      specify { expect(subject.send(:join_root).drop(1).size).to eq 2 }
+      specify { expect(subject.send(:join_root).drop(1).map(&:join_type)).to eq [Polyamorous::OuterJoin, Polyamorous::InnerJoin] }
+      specify { expect(subject.send(:join_root).drop(1).first.table_name)
+        .to eq 'people' }
+      specify { expect(subject.send(:join_root).drop(1)[1].table_name)
+        .to eq 'comments' }
+    end
+  end
+end

data/ransack-4.4.1/spec/polyamorous/join_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+module Polyamorous
+  describe Join do
+    it 'is a tree node' do
+      join = new_join(:articles, :outer)
+      expect(join).to be_kind_of(TreeNode)
+    end
+
+    it 'can be added to a tree' do
+      join = new_join(:articles, :outer)
+
+      tree_hash = {}
+      join.add_to_tree(tree_hash)
+
+      expect(tree_hash[join]).to be {}
+    end
+  end
+end