serrano-vk 0.1.0

data/examples/demo_crud/vendor/bundle/ruby/3.4.0/gems/sequel-5.102.0/lib/sequel/plugins/auto_validations.rb

@@ -0,0 +1,302 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The auto_validations plugin automatically sets up the following types of validations
+    # for your model columns:
+    #
+    # 1. type validations for all columns
+    # 2. not_null validations on NOT NULL columns (optionally, presence validations)
+    # 3. unique validations on columns or sets of columns with unique indexes
+    # 4. max length validations on string columns
+    # 5. no null byte validations on string columns
+    # 6. minimum and maximum values on columns
+    #
+    # To determine the columns to use for the type/not_null/max_length/no_null_byte/max_value/min_value validations,
+    # the plugin looks at the database schema for the model's table.  To determine
+    # the unique validations, Sequel looks at the indexes on the table.  In order
+    # for this plugin to be fully functional, the underlying database adapter needs
+    # to support both schema and index parsing.  Additionally, unique validations are
+    # only added for models that select from a simple table, they are not added for models
+    # that select from a subquery.
+    #
+    # This plugin uses the validation_helpers plugin underneath to implement the
+    # validations.  It does not allow for any per-column validation message
+    # customization, but you can alter the messages for the given type of validation
+    # on a per-model basis (see the validation_helpers documentation).
+    #
+    # You can skip certain types of validations from being automatically added via:
+    #
+    #   Model.skip_auto_validations(:not_null)
+    #
+    # If you want to skip all auto validations (only useful if loading the plugin
+    # in a superclass):
+    #
+    #   Model.skip_auto_validations(:all)
+    #
+    # It is possible to skip auto validations on a per-model-instance basis via:
+    #
+    #   instance.skip_auto_validations(:unique, :not_null) do
+    #     puts instance.valid?
+    #   end
+    #
+    # By default, the plugin uses a not_null validation for NOT NULL columns, but that
+    # can be changed to a presence validation using an option:
+    #
+    #   Model.plugin :auto_validations, not_null: :presence
+    #
+    # This is useful if you want to enforce that NOT NULL string columns do not
+    # allow empty values.
+    #
+    # You can also supply hashes to pass options through to the underlying validators:
+    #
+    #   Model.plugin :auto_validations, unique_opts: {only_if_modified: true}
+    #
+    # This works for unique_opts, max_length_opts, schema_types_opts, max_value_opts, min_value_opts, no_null_byte_opts,
+    # explicit_not_null_opts, and not_null_opts.
+    #
+    # If you only want auto_validations to add validations to columns that do not already
+    # have an error associated with them, you can use the skip_invalid option:
+    #
+    #   Model.plugin :auto_validations, skip_invalid: true
+    #
+    # Usage:
+    #
+    #   # Make all model subclass use auto validations (called before loading subclasses)
+    #   Sequel::Model.plugin :auto_validations
+    #
+    #   # Make the Album class use auto validations
+    #   Album.plugin :auto_validations
+    module AutoValidations
+      NOT_NULL_OPTIONS = {:from=>:values}.freeze
+      EXPLICIT_NOT_NULL_OPTIONS = {:from=>:values, :allow_missing=>true}.freeze
+      MAX_LENGTH_OPTIONS = {:from=>:values, :allow_nil=>true}.freeze
+      SCHEMA_TYPES_OPTIONS = NOT_NULL_OPTIONS
+      UNIQUE_OPTIONS = NOT_NULL_OPTIONS
+      NO_NULL_BYTE_OPTIONS = MAX_LENGTH_OPTIONS
+      MAX_VALUE_OPTIONS = {:from=>:values, :allow_nil=>true, :skip_invalid=>true}.freeze
+      MIN_VALUE_OPTIONS = MAX_VALUE_OPTIONS
+      AUTO_VALIDATE_OPTIONS = {
+        :no_null_byte=>NO_NULL_BYTE_OPTIONS,
+        :not_null=>NOT_NULL_OPTIONS,
+        :explicit_not_null=>EXPLICIT_NOT_NULL_OPTIONS,
+        :max_length=>MAX_LENGTH_OPTIONS,
+        :max_value=>MAX_VALUE_OPTIONS,
+        :min_value=>MIN_VALUE_OPTIONS,
+        :schema_types=>SCHEMA_TYPES_OPTIONS,
+        :unique=>UNIQUE_OPTIONS
+      }.freeze
+
+      EMPTY_ARRAY = [].freeze
+
+      def self.apply(model, opts=OPTS)
+        model.instance_exec do
+          plugin :validation_helpers
+          @auto_validate_presence = false
+          @auto_validate_no_null_byte_columns = []
+          @auto_validate_not_null_columns = []
+          @auto_validate_explicit_not_null_columns = []
+          @auto_validate_max_length_columns = []
+          @auto_validate_max_value_columns = []
+          @auto_validate_min_value_columns = []
+          @auto_validate_unique_columns = []
+          @auto_validate_types = true
+          @auto_validate_options = AUTO_VALIDATE_OPTIONS
+        end
+      end
+
+      # Setup auto validations for the model if it has a dataset.
+      def self.configure(model, opts=OPTS)
+        model.instance_exec do
+          setup_auto_validations if @dataset
+          if opts[:not_null] == :presence
+            @auto_validate_presence = true
+          end
+
+          h = @auto_validate_options.dup
+          [:not_null, :explicit_not_null, :max_length, :max_value, :min_value, :no_null_byte, :schema_types, :unique].each do |type|
+            if type_opts = opts[:"#{type}_opts"]
+              h[type] = h[type].merge(type_opts).freeze
+            end
+          end
+
+          if opts[:skip_invalid]
+            [:not_null, :explicit_not_null, :no_null_byte, :max_length, :schema_types].each do |type|
+              h[type] = h[type].merge(:skip_invalid=>true).freeze
+            end
+          end
+
+          @auto_validate_options = h.freeze
+        end
+      end
+
+      module ClassMethods
+        # The columns with automatic no_null_byte validations
+        attr_reader :auto_validate_no_null_byte_columns
+
+        # The columns with automatic not_null validations
+        attr_reader :auto_validate_not_null_columns
+
+        # The columns with automatic not_null validations for columns present in the values.
+        attr_reader :auto_validate_explicit_not_null_columns
+
+        # The columns or sets of columns with automatic max_length validations, as an array of
+        # pairs, with the first entry being the column name and second entry being the maximum length.
+        attr_reader :auto_validate_max_length_columns
+
+        # The columns with automatch max value validations, as an array of
+        # pairs, with the first entry being the column name and second entry being the maximum value.
+        attr_reader :auto_validate_max_value_columns
+
+        # The columns with automatch min value validations, as an array of
+        # pairs, with the first entry being the column name and second entry being the minimum value.
+        attr_reader :auto_validate_min_value_columns
+
+        # The columns or sets of columns with automatic unique validations
+        attr_reader :auto_validate_unique_columns
+
+        # Inherited options
+        attr_reader :auto_validate_options
+
+        Plugins.inherited_instance_variables(self,
+          :@auto_validate_presence=>nil,
+          :@auto_validate_types=>nil,
+          :@auto_validate_no_null_byte_columns=>:dup,
+          :@auto_validate_not_null_columns=>:dup,
+          :@auto_validate_explicit_not_null_columns=>:dup,
+          :@auto_validate_max_length_columns=>:dup,
+          :@auto_validate_max_value_columns=>:dup,
+          :@auto_validate_min_value_columns=>:dup,
+          :@auto_validate_unique_columns=>:dup,
+          :@auto_validate_options => :dup)
+        Plugins.after_set_dataset(self, :setup_auto_validations)
+
+        # Whether to use a presence validation for not null columns
+        def auto_validate_presence?
+          @auto_validate_presence
+        end
+
+        # Whether to automatically validate schema types for all columns
+        def auto_validate_types?
+          @auto_validate_types
+        end
+
+        # Freeze auto_validation settings when freezing model class.
+        def freeze
+          @auto_validate_no_null_byte_columns.freeze
+          @auto_validate_not_null_columns.freeze
+          @auto_validate_explicit_not_null_columns.freeze
+          @auto_validate_max_length_columns.freeze
+          @auto_validate_max_value_columns.freeze
+          @auto_validate_min_value_columns.freeze
+          @auto_validate_unique_columns.freeze
+
+          super
+        end
+
+        # Skip automatic validations for the given validation type
+        # (:not_null, :no_null_byte, :types, :unique, :max_length, :max_value, :min_value).
+        # If :all is given as the type, skip all auto validations.
+        #
+        # Skipping types validation automatically skips max_value and min_value validations,
+        # since those validations require valid types.
+        def skip_auto_validations(type)
+          case type
+          when :all
+            [:not_null, :no_null_byte, :types, :unique, :max_length, :max_value, :min_value].each{|v| skip_auto_validations(v)}
+          when :not_null
+            auto_validate_not_null_columns.clear
+            auto_validate_explicit_not_null_columns.clear
+          when :types
+            @auto_validate_types = false
+          else
+            public_send("auto_validate_#{type}_columns").clear
+          end
+        end
+
+        private
+
+        # Parse the database schema and indexes and record the columns to automatically validate.
+        def setup_auto_validations
+          not_null_cols, explicit_not_null_cols = db_schema.select{|col, sch| sch[:allow_null] == false}.partition{|col, sch| sch[:default].nil?}.map{|cs| cs.map{|col, sch| col}}
+          @auto_validate_not_null_columns = not_null_cols - Array(primary_key)
+          explicit_not_null_cols += Array(primary_key)
+          @auto_validate_explicit_not_null_columns = explicit_not_null_cols.uniq
+          @auto_validate_max_length_columns = db_schema.select{|col, sch| sch[:type] == :string && sch[:max_length].is_a?(Integer)}.map{|col, sch| [col, sch[:max_length]]}
+          @auto_validate_max_value_columns = db_schema.select{|col, sch| sch[:max_value]}.map{|col, sch| [col, sch[:max_value]]}
+          @auto_validate_min_value_columns = db_schema.select{|col, sch| sch[:min_value]}.map{|col, sch| [col, sch[:min_value]]}
+          @auto_validate_no_null_byte_columns = db_schema.select{|_, sch| sch[:type] == :string}.map{|col, _| col}
+          table = dataset.first_source_table
+          @auto_validate_unique_columns = if db.supports_index_parsing? && [Symbol, SQL::QualifiedIdentifier, SQL::Identifier, String].any?{|c| table.is_a?(c)}
+            db.indexes(table).select{|name, idx| idx[:unique] == true}.map{|name, idx| idx[:columns].length == 1 ? idx[:columns].first : idx[:columns]}
+          else
+            []
+          end
+        end
+      end
+
+      module InstanceMethods
+        # Skip the given types of auto validations on this instance inside the block.
+        def skip_auto_validations(*types)
+          types << :all if types.empty?
+          @_skip_auto_validations = types
+          yield
+        ensure
+          @_skip_auto_validations = nil
+        end
+
+        # Validate the model's auto validations columns
+        def validate
+          super
+          skip = @_skip_auto_validations || EMPTY_ARRAY
+          return if skip.include?(:all)
+          opts = model.auto_validate_options
+
+          unless skip.include?(:no_null_byte) || (no_null_byte_columns = model.auto_validate_no_null_byte_columns).empty?
+            validates_no_null_byte(no_null_byte_columns, opts[:no_null_byte])
+          end
+
+          unless skip.include?(:not_null)
+            not_null_method = model.auto_validate_presence? ? :validates_presence : :validates_not_null
+            unless (not_null_columns = model.auto_validate_not_null_columns).empty?
+              public_send(not_null_method, not_null_columns, opts[:not_null])
+            end
+            unless (not_null_columns = model.auto_validate_explicit_not_null_columns).empty?
+              public_send(not_null_method, not_null_columns, opts[:explicit_not_null])
+            end
+          end
+
+          unless skip.include?(:max_length) || (max_length_columns = model.auto_validate_max_length_columns).empty?
+            max_length_columns.each do |col, len|
+              validates_max_length(len, col, opts[:max_length])
+            end
+          end
+
+          unless skip.include?(:types) || !model.auto_validate_types?
+            validates_schema_types(keys, opts[:schema_types])
+
+            unless skip.include?(:max_value) || ((max_value_columns = model.auto_validate_max_value_columns).empty?)
+              max_value_columns.each do |col, max|
+                validates_max_value(max, col, opts[:max_value])
+              end
+            end
+
+            unless skip.include?(:min_value) || ((min_value_columns = model.auto_validate_min_value_columns).empty?)
+              min_value_columns.each do |col, min|
+                validates_min_value(min, col, opts[:min_value])
+              end
+            end
+          end
+
+          unless skip.include?(:unique)
+            unique_opts = Hash[opts[:unique]]
+            if model.respond_to?(:sti_dataset)
+              unique_opts[:dataset] = model.sti_dataset
+            end
+            model.auto_validate_unique_columns.each{|cols| validates_unique(cols, unique_opts)}
+          end
+        end
+      end
+    end
+  end
+end

data/examples/demo_crud/vendor/bundle/ruby/3.4.0/gems/sequel-5.102.0/lib/sequel/plugins/auto_validations_constraint_validations_presence_message.rb

@@ -0,0 +1,68 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The auto_validations_constraint_validations_presence_message plugin provides
+    # integration for the auto_validations and constraint_validations plugins in
+    # the following situation:
+    #
+    # * A column has a NOT NULL constraint in the database
+    # * A constraint validation for presence exists on the column, with a :message
+    #   option to set a column-specific message, and with the :allow_nil option set
+    #   to true because the CHECK constraint doesn't need to check for NULL values
+    #   as the column itself is NOT NULL
+    # 
+    # In this case, by default the validation error message on the column will
+    # use the more specific constraint validation error message if the column
+    # has a non-NULL empty value, but will use the default auto_validations
+    # message if the column has a NULL value.  With this plugin, the column-specific
+    # constraint validation error message will be used in both cases.
+    #
+    # Usage:
+    #
+    #   # Make all model subclasses use this auto_validations/constraint_validations
+    #   # integration (called before loading subclasses)
+    #   Sequel::Model.plugin :auto_validations_constraint_validations_presence_message
+    #
+    #   # Make the Album class use this auto_validations/constraint_validations integration
+    #   Album.plugin :auto_validations_constraint_validations_presence_message
+    module AutoValidationsConstraintValidationsPresenceMessage
+      def self.apply(model)
+        model.plugin :auto_validations
+        model.plugin :constraint_validations
+      end
+
+      def self.configure(model, opts=OPTS)
+        model.send(:_adjust_auto_validations_constraint_validations_presence_message)
+      end
+
+      module ClassMethods
+        Plugins.after_set_dataset(self, :_adjust_auto_validations_constraint_validations_presence_message)
+
+        private
+
+        def _adjust_auto_validations_constraint_validations_presence_message
+          if @dataset &&
+             !@auto_validate_options[:not_null][:message] &&
+             !@auto_validate_options[:explicit_not_null][:message]
+
+            @constraint_validations.each do |array|
+              meth, column, opts = array
+
+              if meth == :validates_presence &&
+                 opts &&
+                 opts[:message] &&
+                 opts[:allow_nil] &&
+                 (@auto_validate_not_null_columns.include?(column) || @auto_validate_explicit_not_null_columns.include?(column))
+
+                @auto_validate_not_null_columns.delete(column)
+                @auto_validate_explicit_not_null_columns.delete(column)
+                array[2] = array[2].merge(:allow_nil=>false)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/examples/demo_crud/vendor/bundle/ruby/3.4.0/gems/sequel-5.102.0/lib/sequel/plugins/before_after_save.rb

@@ -0,0 +1,8 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    module BeforeAfterSave
+    end
+  end
+end

data/examples/demo_crud/vendor/bundle/ruby/3.4.0/gems/sequel-5.102.0/lib/sequel/plugins/blacklist_security.rb

@@ -0,0 +1,104 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The blacklist_security plugin contains blacklist-based support for
+    # mass assignment, specifying which columns to not allow mass assignment for,
+    # implicitly allowing mass assignment for columns not listed.  This is only
+    # for backwards compatibility, it should not be used by new code.
+    #
+    # Usage:
+    #
+    #   # Make all model subclasses support the blacklist security features. 
+    #   Sequel::Model.plugin :blacklist_security
+    #
+    #   # Make the Album class support the blacklist security features.
+    #   Album.plugin :blacklist_security
+    module BlacklistSecurity
+      # Special array subclass used for marking methods to be removed.
+      class ExceptionList < Array
+      end
+
+      module ClassMethods
+        # Which columns are specifically restricted in a call to set/update/new/etc.
+        # (default: not set).  Some columns are restricted regardless of
+        # this setting, such as the primary key column and columns in Model::RESTRICTED_SETTER_METHODS.
+        attr_reader :restricted_columns
+  
+        Plugins.inherited_instance_variables(self, :@restricted_columns=>:dup)
+
+        # Freeze restricted columns when freezing model class.
+        def freeze
+          @restricted_columns.freeze
+
+          super
+        end
+
+        # Set the columns to restrict when using mass assignment (e.g. +set+).  Using this means that
+        # attempts to call setter methods for the columns listed here will cause an
+        # exception or be silently skipped (based on the +strict_param_setting+ setting).
+        # If you have any virtual setter methods (methods that end in =) that you
+        # want not to be used during mass assignment, they need to be listed here as well (without the =).
+        #
+        # It's generally a bad idea to rely on a blacklist approach for security.  Using a whitelist
+        # approach such as the whitelist_security plugin or the set_fields methods
+        # is usually a better choice.  So use of this method is generally a bad idea.
+        #
+        #   Artist.set_restricted_columns(:records_sold)
+        #   Artist.set(name: 'Bob', hometown: 'Sactown') # No Error
+        #   Artist.set(name: 'Bob', records_sold: 30000) # Error
+        def set_restricted_columns(*cols)
+          clear_setter_methods_cache
+          @restricted_columns = cols
+        end
+
+        private
+
+        # If allowed_columns is not set but restricted_columns is, remove the
+        # restricted_columns.
+        def get_setter_methods
+          meths = super
+          if (!defined?(::Sequel::Plugins::WhitelistSecurity::ClassMethods) || !is_a?(::Sequel::Plugins::WhitelistSecurity::ClassMethods) || !allowed_columns) && restricted_columns
+            meths -= restricted_columns.map{|x| "#{x}="}
+          end
+          meths
+        end
+      end
+
+      module InstanceMethods
+        # Set all values using the entries in the hash, except for the keys
+        # given in except.  You should probably use +set_fields+
+        # instead of this method, as blacklist approaches to security are a bad idea.
+        #
+        #   artist.set_except({name: 'Jim'}, :hometown)
+        #   artist.name # => 'Jim'
+        def set_except(hash, *except)
+          set_restricted(hash, ExceptionList.new(except.flatten))
+        end
+    
+        # Update all values using the entries in the hash, except for the keys
+        # given in except.  You should probably use +update_fields+
+        # instead of this method, as blacklist approaches to security are a bad idea.
+        #
+        #   artist.update_except({name: 'Jim'}, :hometown) # UPDATE artists SET name = 'Jim' WHERE (id = 1)
+        def update_except(hash, *except)
+          update_restricted(hash, ExceptionList.new(except.flatten))
+        end
+
+        private
+
+        # If set_except or update_except was used, remove the related methods from the list.
+        def setter_methods(type)
+          if type.is_a?(ExceptionList)
+            meths = super(:all)
+            meths -= Array(primary_key).map{|x| "#{x}="} if primary_key && model.restrict_primary_key?
+            meths -= type.map{|x| "#{x}="}
+            meths
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/examples/demo_crud/vendor/bundle/ruby/3.4.0/gems/sequel-5.102.0/lib/sequel/plugins/boolean_readers.rb

@@ -0,0 +1,59 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The boolean_readers plugin allows for the creation of attribute? methods
+    # for boolean columns, which provides a nicer API.  By default, the accessors
+    # are created for all columns of type :boolean.  However, you can provide a
+    # block to the plugin to change the criteria used to determine if a
+    # column is boolean.  The block is yielded with the column symbol for each
+    # column in the models dataset.
+    #
+    # Usage:
+    #
+    #   # Add boolean attribute? methods for all columns of type :boolean
+    #   # in all model subclasses (called before loading subclasses)
+    #   Sequel::Model.plugin :boolean_readers
+    #
+    #   # Add boolean readers for all tinyint columns in the Album class
+    #   Album.plugin(:boolean_readers){|c| db_schema[c][:db_type] =~ /\Atinyint/}
+    #
+    #   # Add a boolean reader for a specific columns in the Artist class
+    #   Artist.plugin(:boolean_readers){|c| [:column1, :column2, :column3].include?(c)}
+    module BooleanReaders
+      # Default proc for determining if given column is a boolean, which
+      # just checks that the :type is boolean.
+      DEFAULT_BOOLEAN_ATTRIBUTE_PROC = lambda{|c| s = db_schema[c] and s[:type] == :boolean}
+
+      # Add the boolean_attribute? class method to the model, and create
+      # attribute? boolean reader methods for the class's columns if the class has a dataset.
+      def self.configure(model, &block)
+        model.instance_exec do
+          define_singleton_method(:boolean_attribute?, &(block || DEFAULT_BOOLEAN_ATTRIBUTE_PROC))
+          send(:create_boolean_readers) if @dataset
+        end
+      end
+
+      module ClassMethods
+        Plugins.after_set_dataset(self, :create_boolean_readers)
+
+        private
+
+        # Add a attribute? method for the column to a module included in the class.
+        def create_boolean_reader(column)
+          overridable_methods_module.module_eval do
+            define_method("#{column}?"){model.db.typecast_value(:boolean, get_column_value(column))}
+          end
+        end
+
+        # Add attribute? methods for all of the boolean attributes for this model.
+        def create_boolean_readers
+          im = instance_methods.map(&:to_s)
+          if cs = check_non_connection_error(false){columns}
+            cs.each{|c| create_boolean_reader(c) if boolean_attribute?(c) && !im.include?("#{c}?")}
+          end
+        end
+      end
+    end
+  end
+end

data/examples/demo_crud/vendor/bundle/ruby/3.4.0/gems/sequel-5.102.0/lib/sequel/plugins/boolean_subsets.rb

@@ -0,0 +1,64 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The boolean_subsets plugin allows for the automatic creation of subsets for
+    # for boolean columns, which can DRY up model classes that define such subsets
+    # manually.  By default, subsets are created for all columns of type :boolean,
+    # with the subset name being the same as column name, and the conditions being
+    # <tt>column IS TRUE</tt> (assuming the database supports that syntax).
+    #
+    # You can provide a block to the plugin, which will be called with column name
+    # symbol, and should return an array of arguments to pass to +dataset_module.where+.
+    # Using this, you can change the method name and arguments for each column.
+    # This block is executed in the context of the model class.
+    #
+    # Usage:
+    #
+    #   # Add boolean subset methods for all columns of type :boolean
+    #   # in all model subclasses (called before loading subclasses)
+    #   Sequel::Model.plugin :boolean_subsets
+    #
+    #   # Add subsets for all boolean columns in the Album class
+    #   Album.plugin(:boolean_subsets)
+    #
+    #   # Remove is_ from the front of the column name when creating the subset
+    #   # method name, and use (column = 'Y') as the filter conditions
+    #   Sequel::Model.plugin :boolean_subsets do |column|
+    #     [column.to_s.sub(/\Ais_/, ''), {column=>'Y'}]
+    #   end
+    module BooleanSubsets
+      # Create boolean subset methods for each boolean column.
+      def self.configure(model, &block)
+        model.instance_exec do
+          if block
+            define_singleton_method(:boolean_subset_args, &block)
+            singleton_class.send(:private, :boolean_subset_args)
+          end
+          create_boolean_subsets if @dataset
+        end
+      end
+
+      module ClassMethods
+        Plugins.after_set_dataset(self, :create_boolean_subsets)
+
+        private
+
+        # The arguments to use when automatically defining a boolean subset for the given column.
+        def boolean_subset_args(c)
+          [c, {c=>true}]
+        end
+
+        # Add subset methods for all of the boolean columns in this model.
+        def create_boolean_subsets
+          if cs = check_non_connection_error(false){columns}
+            cs = cs.select{|c| db_schema[c][:type] == :boolean}.map{|c| boolean_subset_args(c)}
+            dataset_module do
+              cs.each{|c| where(*c)}
+            end
+          end
+        end
+      end
+    end
+  end
+end