sequel 4.13.0 → 4.14.0

data/lib/sequel/plugins/json_serializer.rb

@@ -18,17 +18,17 @@ module Sequel
     #   album.to_json(:only=>:name)
     #   album.to_json(:except=>[:id, :artist_id])
     #   # => '{"json_class"="Album","name"=>"RF"}'
-    #
+    #   
     #   album.to_json(:include=>:artist)
     #   # => '{"json_class":"Album","id":1,"name":"RF","artist_id":2,
-    #          "artist":{"json_class":"Artist","id":2,"name":"YJM"}}'
+    #   #      "artist":{"json_class":"Artist","id":2,"name":"YJM"}}'
     # 
     # You can use a hash value with <tt>:include</tt> to pass options
     # to associations:
     #
     #   album.to_json(:include=>{:artist=>{:only=>:name}})
     #   # => '{"json_class":"Album","id":1,"name":"RF","artist_id":2,
-    #          "artist":{"json_class":"Artist","name":"YJM"}}'
+    #   #      "artist":{"json_class":"Artist","name":"YJM"}}'
     #
     # You can specify the <tt>:root</tt> option to nest the JSON under the
     # name of the model:

data/lib/sequel/plugins/lazy_attributes.rb

@@ -53,13 +53,15 @@ module Sequel
         
         private
 
-        # Add a lazy attribute getter method to the lazy_attributes_module
-        def define_lazy_attribute_getter(a)
+        # Add a lazy attribute getter method to the lazy_attributes_module. Options:
+        # :dataset :: The base dataset to use for the lazy attribute lookup
+        # :table :: The table name to use to qualify the attribute and primary key columns.
+        def define_lazy_attribute_getter(a, opts=OPTS)
           include(self.lazy_attributes_module ||= Module.new) unless lazy_attributes_module
           lazy_attributes_module.class_eval do
             define_method(a) do
               if !values.has_key?(a) && !new?
-                lazy_attribute_lookup(a)
+                lazy_attribute_lookup(a, opts)
               else
                 super()
               end
@@ -75,10 +77,22 @@ module Sequel
         # attribute for all of those objects.  If not, query the database for
         # the attribute for just the current object.  Return the value of
         # the attribute for the current object.
-        def lazy_attribute_lookup(a)
-          selection = Sequel.qualify(model.table_name, a)
+        def lazy_attribute_lookup(a, opts=OPTS)
+          unless table = opts[:table]
+            table = model.table_name
+          end
+
+          if base_ds = opts[:dataset]
+            ds = base_ds.where(model.qualified_primary_key_hash(pk, table))
+          else
+            base_ds = model.dataset
+            ds = this
+          end
+
+          selection = Sequel.qualify(table, a)
+
           if frozen?
-            return this.dup.get(selection)
+            return ds.dup.get(selection)
           end
 
           if retrieved_with
@@ -86,15 +100,15 @@ module Sequel
             composite_pk = true if primary_key.is_a?(Array)
             id_map = {}
             retrieved_with.each{|o| id_map[o.pk] = o unless o.values.has_key?(a) || o.frozen?}
-            predicate_key = composite_pk ? primary_key.map{|k| Sequel.qualify(model.table_name, k)} : Sequel.qualify(model.table_name, primary_key)
-            model.select(*(Array(primary_key).map{|k| Sequel.qualify(model.table_name, k)} + [selection])).where(predicate_key=>id_map.keys).naked.each do |row|
+            predicate_key = composite_pk ? primary_key.map{|k| Sequel.qualify(table, k)} : Sequel.qualify(table, primary_key)
+            base_ds.select(*(Array(primary_key).map{|k| Sequel.qualify(table, k)} + [selection])).where(predicate_key=>id_map.keys).naked.each do |row|
               obj = id_map[composite_pk ? row.values_at(*primary_key) : row[primary_key]]
               if obj && !obj.values.has_key?(a)
                 obj.values[a] = row[a]
               end
             end
           end
-          values[a] = this.get(selection) unless values.has_key?(a)
+          values[a] = ds.get(selection) unless values.has_key?(a)
           values[a]
         end
       end

data/lib/sequel/plugins/many_through_many.rb

@@ -20,9 +20,9 @@ module Sequel
     #
     # This argument is an array of arrays with three elements.  Each entry in the main array represents a JOIN in SQL:
     #
-    # * The first element in each array represents the name of the table to join.
-    # * The second element in each array represents the column used to join to the previous table.
-    # * The third element in each array represents the column used to join to the next table.
+    # first element :: represents the name of the table to join.
+    # second element :: represents the column used to join to the previous table.
+    # third element :: represents the column used to join to the next table.
     #
     # So the "Artist.many_through_many :tags" is translated into something similar to:
     #
@@ -180,21 +180,21 @@ module Sequel
 
       module ClassMethods
         # Create a many_through_many association.  Arguments:
-        # * name - Same as associate, the name of the association.
-        # * through - The tables and keys to join between the current table and the associated table.
-        #   Must be an array, with elements that are either 3 element arrays, or hashes with keys :table, :left, and :right.
-        #   The required entries in the array/hash are:
-        #   :table (first array element) :: The name of the table to join.
-        #   :left (middle array element) :: The key joining the table to the previous table. Can use an
-        #                                   array of symbols for a composite key association.
-        #   :right (last array element) :: The key joining the table to the next table. Can use an
-        #                                  array of symbols for a composite key association.
-        #   If a hash is provided, the following keys are respected when using eager_graph:
-        #   :block :: A proc to use as the block argument to join.
-        #   :conditions :: Extra conditions to add to the JOIN ON clause.  Must be a hash or array of two pairs.
-        #   :join_type :: The join type to use for the join, defaults to :left_outer.
-        #   :only_conditions :: Conditions to use for the join instead of the ones specified by the keys.
-        # * opts - The options for the associaion.  Takes the same options as many_to_many.
+        # name :: Same as associate, the name of the association.
+        # through :: The tables and keys to join between the current table and the associated table.
+        #            Must be an array, with elements that are either 3 element arrays, or hashes with keys :table, :left, and :right.
+        #            The required entries in the array/hash are:
+        #            :table (first array element) :: The name of the table to join.
+        #            :left (middle array element) :: The key joining the table to the previous table. Can use an
+        #                                            array of symbols for a composite key association.
+        #            :right (last array element) :: The key joining the table to the next table. Can use an
+        #                                           array of symbols for a composite key association.
+        #            If a hash is provided, the following keys are respected when using eager_graph:
+        #            :block :: A proc to use as the block argument to join.
+        #            :conditions :: Extra conditions to add to the JOIN ON clause.  Must be a hash or array of two pairs.
+        #            :join_type :: The join type to use for the join, defaults to :left_outer.
+        #            :only_conditions :: Conditions to use for the join instead of the ones specified by the keys.
+        # opts :: The options for the associaion.  Takes the same options as many_to_many.
         def many_through_many(name, through, opts=OPTS, &block)
           associate(:many_through_many, name, opts.merge(through.is_a?(Hash) ? through : {:through=>through}), &block)
         end
@@ -257,14 +257,14 @@ module Sequel
                 select_all(egds.first_source).
                 select_append(*associated_key_array)
               egds = opts.apply_eager_graph_limit_strategy(egls, egds)
-              ds.graph(egds, associated_key_array.map{|v| v.alias}.zip(Array(lpkcs)) + conditions, :qualify=>:deep, :table_alias=>eo[:table_alias], :implicit_qualifier=>iq, :join_type=>eo[:join_type]||join_type, :from_self_alias=>eo[:from_self_alias], :select=>select||orig_egds.columns, &graph_block)
+              ds.graph(egds, associated_key_array.map{|v| v.alias}.zip(Array(lpkcs)) + conditions, :qualify=>:deep, :table_alias=>eo[:table_alias], :implicit_qualifier=>iq, :join_type=>eo[:join_type]||join_type, :join_only=>eo[:join_only], :from_self_alias=>eo[:from_self_alias], :select=>select||orig_egds.columns, &graph_block)
             else
               opts.edges.each do |t|
-                ds = ds.graph(t[:table], t.fetch(:only_conditions, (Array(t[:right]).zip(Array(t[:left])) + t[:conditions])), :select=>false, :table_alias=>ds.unused_table_alias(t[:table]), :join_type=>eo[:join_type]||t[:join_type], :qualify=>:deep, :implicit_qualifier=>iq, :from_self_alias=>eo[:from_self_alias], &t[:block])
+                ds = ds.graph(t[:table], t.fetch(:only_conditions, (Array(t[:right]).zip(Array(t[:left])) + t[:conditions])), :select=>false, :table_alias=>ds.unused_table_alias(t[:table]), :join_type=>eo[:join_type]||t[:join_type], :join_only=>eo[:join_only], :qualify=>:deep, :implicit_qualifier=>iq, :from_self_alias=>eo[:from_self_alias], &t[:block])
                 iq = nil
               end
               fe = opts.final_edge
-              ds.graph(opts.associated_class, use_only_conditions ? only_conditions : (Array(opts.right_primary_key).zip(Array(fe[:left])) + conditions), :select=>select, :table_alias=>eo[:table_alias], :qualify=>:deep, :join_type=>eo[:join_type]||join_type, &graph_block)
+              ds.graph(opts.associated_class, use_only_conditions ? only_conditions : (Array(opts.right_primary_key).zip(Array(fe[:left])) + conditions), :select=>select, :table_alias=>eo[:table_alias], :qualify=>:deep, :join_type=>eo[:join_type]||join_type, :join_only=>eo[:join_only], &graph_block)
             end
           end
         end

data/lib/sequel/plugins/nested_attributes.rb

@@ -62,7 +62,7 @@ module Sequel
     #
     # Your web stack will probably parse that into a nested hash similar to:
     #
-    #   {:artist=>{:name=>?, :albums_attributes=>{0=>{:name=>?}, 1=>{:id=>?, :name=>?}}}}
+    #   {:artist=>{:name=>'Y', :albums_attributes=>{0=>{:name=>'X'}, 1=>{:id=>'2', :name=>'Z'}}}}
     #
     # Then you can do:
     #
@@ -218,6 +218,9 @@ module Sequel
             end
           end
           after_save_hook{obj.destroy} if opts[:destroy]
+          if reflection.returns_array?
+            associations[reflection[:name]].delete(obj)
+          end
           obj
         end
         
@@ -304,8 +307,9 @@ module Sequel
             # which will fail if we validate before saving the current object.  If there is
             # no value for the foreign key, set it to the current primary key value, or a dummy
             # value of 0 if we haven't saved the current object.
-            obj.values[key] = pk || 0
-            key = nil if pk
+            p_key = pk unless pk.is_a?(Array)
+            obj.values[key] = p_key || 0
+            key = nil if p_key
           end
           obj.errors.full_messages.each{|m| errors.add(association, m)} unless obj.valid?
           if key && !pk_val

data/lib/sequel/plugins/pg_row.rb

@@ -28,7 +28,7 @@ module Sequel
     #
     #   DB[:company].first
     #   # => {:name=>'MS', :address=>
-    #     Address.load(:street=>'123 Foo St', :city=>'Bar Town', :zip=>'12345')}
+    #   #  Address.load(:street=>'123 Foo St', :city=>'Bar Town', :zip=>'12345')}
     #
     # If you want a lot of your models to be used as row types, you can load the
     # plugin into Sequel::Model itself:

data/lib/sequel/plugins/rcte_tree.rb

@@ -66,10 +66,10 @@ module Sequel
     # You can override the options for any specific association by making
     # sure the plugin options contain one of the following keys:
     #
-    # * :parent - hash of options for the parent association
-    # * :children - hash of options for the children association
-    # * :ancestors - hash of options for the ancestors association
-    # * :descendants - hash of options for the descendants association
+    # :parent :: hash of options for the parent association
+    # :children :: hash of options for the children association
+    # :ancestors :: hash of options for the ancestors association
+    # :descendants :: hash of options for the descendants association
     #
     # Note that you can change the name of the above associations by specifying
     # a :name key in the appropriate hash of options above.  For example:
@@ -80,15 +80,15 @@ module Sequel
     # Any other keys in the main options hash are treated as options shared by
     # all of the associations.  Here's a few options that affect the plugin:
     #
-    # * :key - The foreign key in the table that points to the primary key
-    #   of the parent (default: :parent_id)
-    # * :primary_key - The primary key to use (default: the model's primary key)
-    # * :key_alias - The symbol identifier to use for aliasing when eager
-    #   loading (default: :x_root_x)
-    # * :cte_name - The symbol identifier to use for the common table expression
-    #   (default: :t)
-    # * :level_alias - The symbol identifier to use when eagerly loading descendants
-    #   up to a given level (default: :x_level_x)
+    # :key :: The foreign key in the table that points to the primary key
+    #         of the parent (default: :parent_id)
+    # :primary_key :: The primary key to use (default: the model's primary key)
+    # :key_alias :: The symbol identifier to use for aliasing when eager
+    #               loading (default: :x_root_x)
+    # :cte_name :: The symbol identifier to use for the common table expression
+    #              (default: :t)
+    # :level_alias :: The symbol identifier to use when eagerly loading descendants
+    #                 up to a given level (default: :x_level_x)
     module RcteTree
       # Create the appropriate parent, children, ancestors, and descendants
       # associations for the model.

data/lib/sequel/plugins/sharding.rb

@@ -3,12 +3,12 @@ module Sequel
     # The sharding plugin augments Sequel's default model sharding support
     # in the following ways:
     #
-    # 1) It automatically sets model instances to be saved back to the
-    #    shard they were retreived from.
-    # 2) It makes model associations use the same shard as the model
-    #    object.
-    # 3) It adds a slightly nicer API for creating model instances on
-    #    specific shards.
+    # * It automatically sets model instances to be saved back to the
+    #   shard they were retreived from.
+    # * It makes model associations use the same shard as the model
+    #   object.
+    # * It adds a slightly nicer API for creating model instances on
+    #   specific shards.
     # 
     # Usage:
     #

data/lib/sequel/plugins/timestamps.rb

@@ -22,10 +22,10 @@ module Sequel
       # Configure the plugin by setting the available options.  Note that
       # if this method is run more than once, previous settings are ignored,
       # and it will just use the settings given or the default settings.  Options:
-      # * :create - The field to hold the create timestamp (default: :created_at)
-      # * :force - Whether to overwrite an existing create timestamp (default: false)
-      # * :update - The field to hold the update timestamp (default: :updated_at)
-      # * :update_on_create - Whether to set the update timestamp to the create timestamp when creating (default: false)
+      # :create :: The field to hold the create timestamp (default: :created_at)
+      # :force :: Whether to overwrite an existing create timestamp (default: false)
+      # :update :: The field to hold the update timestamp (default: :updated_at)
+      # :update_on_create :: Whether to set the update timestamp to the create timestamp when creating (default: false)
       def self.configure(model, opts=OPTS)
         model.instance_eval do
           @create_timestamp_field = opts[:create]||:created_at

data/lib/sequel/plugins/touch.rb

@@ -36,13 +36,13 @@ module Sequel
 
       # Set the touch_column and touched_associations variables for the model.
       # Options:
-      # * :associations - The associations to touch when a model instance is
-      #   updated or destroyed.  Can be a symbol for a single association,
-      #   a hash with association keys and column values, or an array of
-      #   symbols and/or hashes.  If a symbol is used, the column used
-      #   when updating the associated objects is the model's touch_column.
-      #   If a hash is used, the value is used as the column to update.
-      # * :column - The column to modify when touching a model instance.
+      # :associations :: The associations to touch when a model instance is
+      #                  updated or destroyed.  Can be a symbol for a single association,
+      #                  a hash with association keys and column values, or an array of
+      #                  symbols and/or hashes.  If a symbol is used, the column used
+      #                  when updating the associated objects is the model's touch_column.
+      #                  If a hash is used, the value is used as the column to update.
+      # :column :: The column to modify when touching a model instance.
       def self.configure(model, opts=OPTS)
         model.touch_column = opts[:column] || TOUCH_COLUMN_DEFAULT if opts[:column] || !model.touch_column
         model.touch_associations(opts[:associations]) if opts[:associations]

data/lib/sequel/plugins/tree.rb

@@ -70,7 +70,7 @@ module Sequel
         
         # Returns the dataset for retrieval of all root nodes
         #
-        #   TreeClass.roots_dataset => Sequel#Dataset
+        #   TreeClass.roots_dataset # => Sequel::Dataset instance
         def roots_dataset
           ds = where(Sequel.or(Array(parent_column).zip([])))
           ds = ds.order(*tree_order) if tree_order

data/lib/sequel/plugins/validation_class_methods.rb

@@ -116,8 +116,8 @@ module Sequel
         # :allow_nil is assumed to be true instead of false.
         #
         # Possible Options:
-        # * :accept - The value required for the object to be valid (default: '1')
-        # * :message - The message to use (default: 'is not accepted')
+        # :accept :: The value required for the object to be valid (default: '1')
+        # :message :: The message to use (default: 'is not accepted')
         def validates_acceptance_of(*atts)
           opts = {
             :message => 'is not accepted',
@@ -141,7 +141,7 @@ module Sequel
         # or email addresses on web forms.
         #
         # Possible Options:
-        # * :message - The message to use (default: 'is not confirmed')
+        # :message :: The message to use (default: 'is not confirmed')
         def validates_confirmation_of(*atts)
           opts = {
             :message => 'is not confirmed',
@@ -163,20 +163,20 @@ module Sequel
         #   end
         #
         # Possible Options:
-        # * :allow_blank - Whether to skip the validation if the value is blank. 
-        # * :allow_missing - Whether to skip the validation if the attribute isn't a key in the
-        #   values hash.  This is different from allow_nil, because Sequel only sends the attributes
-        #   in the values when doing an insert or update.  If the attribute is not present, Sequel
-        #   doesn't specify it, so the database will use the table's default value.  This is different
-        #   from having an attribute in values with a value of nil, which Sequel will send as NULL.
-        #   If your database table has a non NULL default, this may be a good option to use.  You
-        #   don't want to use allow_nil, because if the attribute is in values but has a value nil,
-        #   Sequel will attempt to insert a NULL value into the database, instead of using the
-        #   database's default.
-        # * :allow_nil - Whether to skip the validation if the value is nil.
-        # * :if - A symbol (indicating an instance_method) or proc (which is instance_evaled)
-        #   skipping this validation if it returns nil or false.
-        # * :tag - The tag to use for this validation.
+        # :allow_blank :: Whether to skip the validation if the value is blank. 
+        # :allow_missing :: Whether to skip the validation if the attribute isn't a key in the
+        #                   values hash.  This is different from allow_nil, because Sequel only sends the attributes
+        #                   in the values when doing an insert or update.  If the attribute is not present, Sequel
+        #                   doesn't specify it, so the database will use the table's default value.  This is different
+        #                   from having an attribute in values with a value of nil, which Sequel will send as NULL.
+        #                   If your database table has a non NULL default, this may be a good option to use.  You
+        #                   don't want to use allow_nil, because if the attribute is in values but has a value nil,
+        #                   Sequel will attempt to insert a NULL value into the database, instead of using the
+        #                   database's default.
+        # :allow_nil :: Whether to skip the validation if the value is nil.
+        # :if :: A symbol (indicating an instance_method) or proc (which is instance_evaled)
+        #        skipping this validation if it returns nil or false.
+        # :tag :: The tag to use for this validation.
         def validates_each(*atts, &block)
           opts = extract_options!(atts)
           blk = if (i = opts[:if]) || (am = opts[:allow_missing]) || (an = opts[:allow_nil]) || (ab = opts[:allow_blank])
@@ -205,8 +205,8 @@ module Sequel
         # value against the regular expression provided by the :with option.
         #
         # Possible Options:
-        # * :message - The message to use (default: 'is invalid')
-        # * :with - The regular expression to validate the value with (required).
+        # :message :: The message to use (default: 'is invalid')
+        # :with :: The regular expression to validate the value with (required).
         def validates_format_of(*atts)
           opts = {
             :message => 'is invalid',
@@ -227,16 +227,16 @@ module Sequel
         # Validates the length of an attribute.
         #
         # Possible Options:
-        # * :is - The exact size required for the value to be valid (no default)
-        # * :maximum - The maximum size allowed for the value (no default)
-        # * :message - The message to use (no default, overrides :nil_message, :too_long, :too_short, and :wrong_length
-        #   options if present)
-        # * :minimum - The minimum size allowed for the value (no default)
-        # * :nil_message - The message to use use if :maximum option is used and the value is nil (default: 'is not present')
-        # * :too_long - The message to use use if it the value is too long (default: 'is too long')
-        # * :too_short - The message to use use if it the value is too short (default: 'is too short')
-        # * :within - The array/range that must include the size of the value for it to be valid (no default)
-        # * :wrong_length - The message to use use if it the value is not valid (default: 'is the wrong length')
+        # :is :: The exact size required for the value to be valid (no default)
+        # :maximum :: The maximum size allowed for the value (no default)
+        # :message :: The message to use (no default, overrides :nil_message, :too_long, :too_short, and :wrong_length
+        #             options if present)
+        # :minimum :: The minimum size allowed for the value (no default)
+        # :nil_message :: The message to use use if :maximum option is used and the value is nil (default: 'is not present')
+        # :too_long :: The message to use use if it the value is too long (default: 'is too long')
+        # :too_short :: The message to use use if it the value is too short (default: 'is too short')
+        # :within :: The array/range that must include the size of the value for it to be valid (no default)
+        # :wrong_length :: The message to use use if it the value is not valid (default: 'is the wrong length')
         def validates_length_of(*atts)
           opts = {
             :nil_message  => 'is not present',
@@ -267,8 +267,8 @@ module Sequel
         # Validates whether an attribute is a number.
         #
         # Possible Options:
-        # * :message - The message to use (default: 'is not a number')
-        # * :only_integer - Whether only integers are valid values (default: false)
+        # :message :: The message to use (default: 'is not a number')
+        # :only_integer :: Whether only integers are valid values (default: false)
         def validates_numericality_of(*atts)
           opts = {
             :message => 'is not a number',
@@ -293,7 +293,7 @@ module Sequel
         # with false considered present instead of absent.
         #
         # Possible Options:
-        # * :message - The message to use (default: 'is not present')
+        # :message :: The message to use (default: 'is not present')
         def validates_presence_of(*atts)
           opts = {
             :message => 'is not present',
@@ -309,8 +309,8 @@ module Sequel
         # Validates that an attribute is within a specified range or set of values.
         #
         # Possible Options:
-        # * :in - An array or range of values to check for validity (required)
-        # * :message - The message to use (default: 'is not in range or set: <specified range>')
+        # :in :: An array or range of values to check for validity (required)
+        # :message :: The message to use (default: 'is not in range or set: <specified range>')
         def validates_inclusion_of(*atts)
           opts = extract_options!(atts)
           n = opts[:in]
@@ -331,7 +331,7 @@ module Sequel
         # time instead of at setter time. 
         #
         # Possible Options:
-        # * :message - The message to use (default: 'is not a valid (integer|datetime|etc.)')
+        # :message :: The message to use (default: 'is not a valid (integer|datetime|etc.)')
         def validates_schema_type(*atts)
           opts = {
             :tag => :schema_type,
@@ -362,7 +362,7 @@ module Sequel
         # database, as this suffers from a fairly obvious race condition.
         #
         # Possible Options:
-        # * :message - The message to use (default: 'is already taken')
+        # :message :: The message to use (default: 'is already taken')
         def validates_uniqueness_of(*atts)
           opts = {
             :message => 'is already taken',

data/lib/sequel/plugins/validation_helpers.rb

@@ -19,7 +19,7 @@ module Sequel
     # Options:
     # :allow_blank :: Whether to skip the validation if the value is blank.  You should
     #                 make sure all objects respond to blank if you use this option, which you can do by:
-    #     Sequel.extension :blank
+    #                     Sequel.extension :blank
     # :allow_missing :: Whether to skip the validation if the attribute isn't a key in the
     #                   values hash.  This is different from allow_nil, because Sequel only sends the attributes
     #                   in the values when doing an insert or update.  If the attribute is not present, Sequel
@@ -44,8 +44,7 @@ module Sequel
     #
     #   Sequel::Plugins::ValidationHelpers::DEFAULT_OPTIONS.merge!(
     #     :exact_length=>{:message=>lambda{|exact| I18n.t("errors.exact_length", :exact => exact)}},
-    #     :integer=>{:message=>lambda{I18n.t("errors.integer")}},
-    #     ...
+    #     :integer=>{:message=>lambda{I18n.t("errors.integer")}}
     #   )
     #
     # and then use something like this in your yaml translation file:
@@ -215,7 +214,7 @@ module Sequel
         # If you want to to a case insensitive uniqueness validation on a database that
         # is case sensitive by default, you can use:
         #
-        #   :where=>(proc do |ds, obj, cols|
+        #   validates_unique :column, :where=>(proc do |ds, obj, cols|
         #     ds.where(cols.map do |c|
         #       v = obj.send(c)
         #       v = v.downcase if v