From 08035482858a56963c7694bc7b92308f59272b28 Mon Sep 17 00:00:00 2001 From: Francesco Rodriguez Date: Fri, 21 Sep 2012 20:49:56 -0500 Subject: update AR::Associations::CollectionProxy#loaded? documentation [ci skip] --- activerecord/lib/active_record/associations/collection_proxy.rb | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) (limited to 'activerecord/lib') diff --git a/activerecord/lib/active_record/associations/collection_proxy.rb b/activerecord/lib/active_record/associations/collection_proxy.rb index c113957faa..cd3cb1fba0 100644 --- a/activerecord/lib/active_record/associations/collection_proxy.rb +++ b/activerecord/lib/active_record/associations/collection_proxy.rb @@ -42,6 +42,11 @@ module ActiveRecord @association.load_target end + # Returns +true+ if the association has been loaded, otherwise +false+. + # + # person.pets.loaded? # => false + # person.pets + # person.pets.loaded? # => true def loaded? @association.loaded? end @@ -889,7 +894,7 @@ module ActiveRecord end # Returns a new array of objects from the collection. If the collection - # hasn't been loaded, it fetches the records from the database. + # hasn't been loaded, it fetches the records from the database. # # class Person < ActiveRecord::Base # has_many :pets -- cgit v1.2.3 From e216b00a5ef6038ba227faf3207891c403fb8d1c Mon Sep 17 00:00:00 2001 From: Francesco Rodriguez Date: Fri, 21 Sep 2012 22:17:32 -0500 Subject: fix AR::Associations::CollectionProxy#delete broken documentation [ci skip] --- .../active_record/associations/collection_proxy.rb | 25 ++-------------------- 1 file changed, 2 insertions(+), 23 deletions(-) (limited to 'activerecord/lib') diff --git a/activerecord/lib/active_record/associations/collection_proxy.rb b/activerecord/lib/active_record/associations/collection_proxy.rb index cd3cb1fba0..e73f940334 100644 --- a/activerecord/lib/active_record/associations/collection_proxy.rb +++ b/activerecord/lib/active_record/associations/collection_proxy.rb @@ -51,7 +51,6 @@ module ActiveRecord @association.loaded? end - ## # Works in two ways. # # *First:* Specify a subset of fields to be selected from the result set. @@ -109,9 +108,8 @@ module ActiveRecord @association.select(select, &block) end - ## # Finds an object in the collection responding to the +id+. Uses the same - # rules as +ActiveRecord::Base.find+. Returns +ActiveRecord::RecordNotFound++ + # rules as ActiveRecord::Base.find. Returns ActiveRecord::RecordNotFound # error if the object can not be found. # # class Person < ActiveRecord::Base @@ -140,7 +138,6 @@ module ActiveRecord @association.find(*args, &block) end - ## # Returns the first record, or the first +n+ records, from the collection. # If the collection is empty, the first form returns +nil+, and the second # form returns an empty array. @@ -171,7 +168,6 @@ module ActiveRecord @association.first(*args) end - ## # Returns the last record, or the last +n+ records, from the collection. # If the collection is empty, the first form returns +nil+, and the second # form returns an empty array. @@ -202,7 +198,6 @@ module ActiveRecord @association.last(*args) end - ## # Returns a new object of the collection type that has been instantiated # with +attributes+ and linked to this object, but have not yet been saved. # You can pass an array of attributes hashes, this will return an array @@ -231,7 +226,6 @@ module ActiveRecord @association.build(attributes, &block) end - ## # Returns a new object of the collection type that has been instantiated with # attributes, linked to this object and that has already been saved (if it # passes the validations). @@ -262,7 +256,6 @@ module ActiveRecord @association.create(attributes, &block) end - ## # Like +create+, except that if the record is invalid, raises an exception. # # class Person @@ -279,7 +272,6 @@ module ActiveRecord @association.create!(attributes, &block) end - ## # Add one or more records to the collection by setting their foreign keys # to the association's primary key. Since << flattens its argument list and # inserts each record, +push+ and +concat+ behave identically. Returns +self+ @@ -308,7 +300,6 @@ module ActiveRecord @association.concat(*records) end - ## # Replace this collection with +other_array+. This will perform a diff # and delete/add only records that have changed. # @@ -335,7 +326,6 @@ module ActiveRecord @association.replace(other_array) end - ## # Deletes all the records from the collection. For +has_many+ associations, # the deletion is done according to the strategy specified by the :dependent # option. Returns an array with the deleted records. @@ -428,7 +418,6 @@ module ActiveRecord @association.delete_all end - ## # Deletes the records of the collection directly from the database. # This will _always_ remove the records ignoring the +:dependent+ # option. @@ -455,7 +444,6 @@ module ActiveRecord @association.destroy_all end - ## # Deletes the +records+ supplied and removes them from the collection. For # +has_many+ associations, the deletion is done according to the strategy # specified by the :dependent option. Returns an array with the @@ -519,7 +507,7 @@ module ActiveRecord # Pet.find(1, 3) # # => ActiveRecord::RecordNotFound: Couldn't find all Pets with IDs (1, 3) # - # If it is set to :delete_all, all the +records+ are deleted + # If it is set to :delete_all, all the +records+ are deleted # *without* calling their +destroy+ method. # # class Person < ActiveRecord::Base @@ -574,7 +562,6 @@ module ActiveRecord @association.delete(*records) end - ## # Destroys the +records+ supplied and removes them from the collection. # This method will _always_ remove record from the database ignoring # the +:dependent+ option. Returns an array with the removed records. @@ -647,7 +634,6 @@ module ActiveRecord @association.destroy(*records) end - ## # Specifies whether the records should be unique or not. # # class Person < ActiveRecord::Base @@ -666,7 +652,6 @@ module ActiveRecord @association.uniq end - ## # Count all records using SQL. # # class Person < ActiveRecord::Base @@ -684,7 +669,6 @@ module ActiveRecord @association.count(column_name, options) end - ## # Returns the size of the collection. If the collection hasn't been loaded, # it executes a SELECT COUNT(*) query. # @@ -709,7 +693,6 @@ module ActiveRecord @association.size end - ## # Returns the size of the collection calling +size+ on the target. # If the collection has been already loaded, +length+ and +size+ are # equivalent. @@ -733,7 +716,6 @@ module ActiveRecord @association.length end - ## # Returns +true+ if the collection is empty. # # class Person < ActiveRecord::Base @@ -751,7 +733,6 @@ module ActiveRecord @association.empty? end - ## # Returns +true+ if the collection is not empty. # # class Person < ActiveRecord::Base @@ -785,7 +766,6 @@ module ActiveRecord @association.any?(&block) end - ## # Returns true if the collection has more than one record. # Equivalent to collection.size > 1. # @@ -824,7 +804,6 @@ module ActiveRecord @association.many?(&block) end - ## # Returns +true+ if the given object is present in the collection. # # class Person < ActiveRecord::Base -- cgit v1.2.3 From 7e538e81541f4c756cf465d7240b85cfe290676a Mon Sep 17 00:00:00 2001 From: Francesco Rodriguez Date: Fri, 21 Sep 2012 22:31:02 -0500 Subject: fix AR::AttributeMethods::Dirty :nodoc: [ci skip] --- activerecord/lib/active_record/attribute_methods/dirty.rb | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) (limited to 'activerecord/lib') diff --git a/activerecord/lib/active_record/attribute_methods/dirty.rb b/activerecord/lib/active_record/attribute_methods/dirty.rb index 60e5b0e2bb..ba32f1ec51 100644 --- a/activerecord/lib/active_record/attribute_methods/dirty.rb +++ b/activerecord/lib/active_record/attribute_methods/dirty.rb @@ -7,7 +7,7 @@ module ActiveRecord end module AttributeMethods - module Dirty + module Dirty # :nodoc: extend ActiveSupport::Concern include ActiveModel::Dirty @@ -21,7 +21,7 @@ module ActiveRecord end # Attempts to +save+ the record and clears changed attributes if successful. - def save(*) #:nodoc: + def save(*) if status = super @previously_changed = changes @changed_attributes.clear @@ -30,7 +30,7 @@ module ActiveRecord end # Attempts to save! the record and clears changed attributes if successful. - def save!(*) #:nodoc: + def save!(*) super.tap do @previously_changed = changes @changed_attributes.clear @@ -38,7 +38,7 @@ module ActiveRecord end # reload the record and clears changed attributes. - def reload(*) #:nodoc: + def reload(*) super.tap do @previously_changed.clear @changed_attributes.clear -- cgit v1.2.3 From fe78e1dad6af88a08715abcad0e6e4e2d5c9b262 Mon Sep 17 00:00:00 2001 From: Steve Klabnik Date: Sat, 22 Sep 2012 06:31:14 +0300 Subject: Better docs for overriding inheretance column --- activerecord/lib/active_record/model.rb | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) (limited to 'activerecord/lib') diff --git a/activerecord/lib/active_record/model.rb b/activerecord/lib/active_record/model.rb index 16d9d404e3..f059840f4d 100644 --- a/activerecord/lib/active_record/model.rb +++ b/activerecord/lib/active_record/model.rb @@ -108,12 +108,9 @@ module ActiveRecord # The default inheritance column name is +type+, which means it's a # reserved word inside Active Record. To be able to use single-table # inheritance with another column name, or to use the column +type+ in - # your own model for something else, you can override this method to - # return a different name: + # your own model for something else, you can set +inheritance_column+: # - # def self.inheritance_column - # 'zoink' - # end + # self.inheritance_column = 'zoink' def inheritance_column 'type' end -- cgit v1.2.3 From c57064a8ab22906cc3f5b4cc6845ac5e1e1a384d Mon Sep 17 00:00:00 2001 From: Francesco Rodriguez Date: Fri, 21 Sep 2012 22:47:08 -0500 Subject: update AR/attribute_methods documentation [ci skip] --- .../active_record/attribute_methods/primary_key.rb | 26 +++++++++++++--------- .../lib/active_record/attribute_methods/read.rb | 12 +++++----- .../attribute_methods/serialization.rb | 19 +++++++++------- .../lib/active_record/attribute_methods/write.rb | 5 +++-- 4 files changed, 36 insertions(+), 26 deletions(-) (limited to 'activerecord/lib') diff --git a/activerecord/lib/active_record/attribute_methods/primary_key.rb b/activerecord/lib/active_record/attribute_methods/primary_key.rb index aa6704d5c9..0857b02c8e 100644 --- a/activerecord/lib/active_record/attribute_methods/primary_key.rb +++ b/activerecord/lib/active_record/attribute_methods/primary_key.rb @@ -5,28 +5,29 @@ module ActiveRecord module PrimaryKey extend ActiveSupport::Concern - # Returns this record's primary key value wrapped in an Array if one is available + # Returns this record's primary key value wrapped in an Array if one is + # available. def to_key key = self.id [key] if key end - # Returns the primary key value + # Returns the primary key value. def id read_attribute(self.class.primary_key) end - # Sets the primary key value + # Sets the primary key value. def id=(value) write_attribute(self.class.primary_key, value) if self.class.primary_key end - # Queries the primary key value + # Queries the primary key value. def id? query_attribute(self.class.primary_key) end - # Returns the primary key value before type cast + # Returns the primary key value before type cast. def id_before_type_cast read_attribute_before_type_cast(self.class.primary_key) end @@ -52,14 +53,16 @@ module ActiveRecord super && !ID_ATTRIBUTE_METHODS.include?(method_name) end - # Defines the primary key field -- can be overridden in subclasses. Overwriting will negate any effect of the - # primary_key_prefix_type setting, though. + # Defines the primary key field -- can be overridden in subclasses. + # Overwriting will negate any effect of the +primary_key_prefix_type+ + # setting, though. def primary_key @primary_key = reset_primary_key unless defined? @primary_key @primary_key end - # Returns a quoted version of the primary key name, used to construct SQL statements. + # Returns a quoted version of the primary key name, used to construct + # SQL statements. def quoted_primary_key @quoted_primary_key ||= connection.quote_column_name(primary_key) end @@ -92,16 +95,17 @@ module ActiveRecord # Sets the name of the primary key column. # # class Project < ActiveRecord::Base - # self.primary_key = "sysid" + # self.primary_key = 'sysid' # end # - # You can also define the primary_key method yourself: + # You can also define the +primary_key+ method yourself: # # class Project < ActiveRecord::Base # def self.primary_key - # "foo_" + super + # 'foo_' + super # end # end + # # Project.primary_key # => "foo_id" def primary_key=(value) @primary_key = value && value.to_s diff --git a/activerecord/lib/active_record/attribute_methods/read.rb b/activerecord/lib/active_record/attribute_methods/read.rb index 1a4cb25dd7..6213b5dcd5 100644 --- a/activerecord/lib/active_record/attribute_methods/read.rb +++ b/activerecord/lib/active_record/attribute_methods/read.rb @@ -14,9 +14,10 @@ module ActiveRecord end module ClassMethods - # +cache_attributes+ allows you to declare which converted attribute values should - # be cached. Usually caching only pays off for attributes with expensive conversion - # methods, like time related columns (e.g. +created_at+, +updated_at+). + # +cache_attributes+ allows you to declare which converted attribute + # values should be cached. Usually caching only pays off for attributes + # with expensive conversion methods, like time related columns (e.g. + # +created_at+, +updated_at+). def cache_attributes(*attribute_names) cached_attributes.merge attribute_names.map { |attr| attr.to_s } end @@ -65,8 +66,9 @@ module ActiveRecord ActiveRecord::Model.attribute_types_cached_by_default = ATTRIBUTE_TYPES_CACHED_BY_DEFAULT - # Returns the value of the attribute identified by attr_name after it has been typecast (for example, - # "2004-12-12" in a data column is cast to a date object, like Date.new(2004, 12, 12)). + # Returns the value of the attribute identified by attr_name after + # it has been typecast (for example, "2004-12-12" in a data column is cast + # to a date object, like Date.new(2004, 12, 12)). def read_attribute(attr_name) return unless attr_name name_sym = attr_name.to_sym diff --git a/activerecord/lib/active_record/attribute_methods/serialization.rb b/activerecord/lib/active_record/attribute_methods/serialization.rb index bdda5bc009..d2cfcbbaf8 100644 --- a/activerecord/lib/active_record/attribute_methods/serialization.rb +++ b/activerecord/lib/active_record/attribute_methods/serialization.rb @@ -4,17 +4,19 @@ module ActiveRecord extend ActiveSupport::Concern included do - # Returns a hash of all the attributes that have been specified for serialization as - # keys and their class restriction as values. + # Returns a hash of all the attributes that have been specified for + # serialization as keys and their class restriction as values. class_attribute :serialized_attributes, instance_accessor: false self.serialized_attributes = {} end module ClassMethods - # If you have an attribute that needs to be saved to the database as an object, and retrieved as the same object, - # then specify the name of that attribute using this method and it will be handled automatically. - # The serialization is done through YAML. If +class_name+ is specified, the serialized object must be of that - # class on retrieval or SerializationTypeMismatch will be raised. + # If you have an attribute that needs to be saved to the database as an + # object, and retrieved as the same object, then specify the name of that + # attribute using this method and it will be handled automatically. The + # serialization is done through YAML. If +class_name+ is specified, the + # serialized object must be of that class on retrieval or + # SerializationTypeMismatch will be raised. # # ==== Parameters # @@ -22,7 +24,8 @@ module ActiveRecord # * +class_name+ - Optional, class name that the object type should be equal to. # # ==== Example - # # Serialize a preferences attribute + # + # # Serialize a preferences attribute. # class User < ActiveRecord::Base # serialize :preferences # end @@ -60,7 +63,7 @@ module ActiveRecord end end - class Attribute < Struct.new(:coder, :value, :state) + class Attribute < Struct.new(:coder, :value, :state) # :nodoc: def unserialized_value state == :serialized ? unserialize : value end diff --git a/activerecord/lib/active_record/attribute_methods/write.rb b/activerecord/lib/active_record/attribute_methods/write.rb index 5a39cb0125..6eb9e25fd9 100644 --- a/activerecord/lib/active_record/attribute_methods/write.rb +++ b/activerecord/lib/active_record/attribute_methods/write.rb @@ -20,8 +20,9 @@ module ActiveRecord end end - # Updates the attribute identified by attr_name with the specified +value+. Empty strings - # for fixnum and float columns are turned into +nil+. + # Updates the attribute identified by attr_name with the + # specified +value+. Empty strings for fixnum and float columns are + # turned into +nil+. def write_attribute(attr_name, value) attr_name = attr_name.to_s attr_name = self.class.primary_key if attr_name == 'id' && self.class.primary_key -- cgit v1.2.3 From 64298519a560cdbdbc80fa50704b211589d37960 Mon Sep 17 00:00:00 2001 From: Francesco Rodriguez Date: Fri, 21 Sep 2012 22:48:33 -0500 Subject: fix AR::Coders::YAMLColumn nodoc [ci skip] --- activerecord/lib/active_record/coders/yaml_column.rb | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) (limited to 'activerecord/lib') diff --git a/activerecord/lib/active_record/coders/yaml_column.rb b/activerecord/lib/active_record/coders/yaml_column.rb index f17e7158de..f6cdc67b4d 100644 --- a/activerecord/lib/active_record/coders/yaml_column.rb +++ b/activerecord/lib/active_record/coders/yaml_column.rb @@ -1,9 +1,8 @@ require 'yaml' module ActiveRecord - # :stopdoc: - module Coders - class YAMLColumn + module Coders # :nodoc: + class YAMLColumn # :nodoc: RESCUE_ERRORS = [ ArgumentError, Psych::SyntaxError ] attr_accessor :object_class @@ -41,5 +40,4 @@ module ActiveRecord end end end - # :startdoc end -- cgit v1.2.3 From 0eea22bdea4df3ec89ea65157a6a0e85cb048bca Mon Sep 17 00:00:00 2001 From: Francesco Rodriguez Date: Fri, 21 Sep 2012 22:51:04 -0500 Subject: add :nodoc: directive to AR::Fixtures::File [ci skip] --- activerecord/lib/active_record/fixtures/file.rb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'activerecord/lib') diff --git a/activerecord/lib/active_record/fixtures/file.rb b/activerecord/lib/active_record/fixtures/file.rb index a9cabf5a7b..0f6ab3e396 100644 --- a/activerecord/lib/active_record/fixtures/file.rb +++ b/activerecord/lib/active_record/fixtures/file.rb @@ -3,7 +3,7 @@ require 'yaml' module ActiveRecord class Fixtures - class File + class File # :nodoc: include Enumerable ## -- cgit v1.2.3 From 6dec7535fd26b8abea0211313ef2936d28ed1637 Mon Sep 17 00:00:00 2001 From: Francesco Rodriguez Date: Fri, 21 Sep 2012 23:25:52 -0500 Subject: update AR::Scoping documentation [ci skip] --- activerecord/lib/active_record/scoping/default.rb | 55 ++++++----- activerecord/lib/active_record/scoping/named.rb | 113 +++++++++------------- 2 files changed, 77 insertions(+), 91 deletions(-) (limited to 'activerecord/lib') diff --git a/activerecord/lib/active_record/scoping/default.rb b/activerecord/lib/active_record/scoping/default.rb index a2a85d4b96..6835d0e01b 100644 --- a/activerecord/lib/active_record/scoping/default.rb +++ b/activerecord/lib/active_record/scoping/default.rb @@ -5,17 +5,17 @@ module ActiveRecord extend ActiveSupport::Concern included do - # Stores the default scope for the class + # Stores the default scope for the class. class_attribute :default_scopes, instance_writer: false self.default_scopes = [] end module ClassMethods - # Returns a scope for the model without the default_scope. + # Returns a scope for the model without the +default_scope+. # # class Post < ActiveRecord::Base # def self.default_scope - # where :published => true + # where published: true # end # end # @@ -23,16 +23,16 @@ module ActiveRecord # Post.unscoped.all # Fires "SELECT * FROM posts" # # This method also accepts a block. All queries inside the block will - # not use the default_scope: + # not use the +default_scope+: # # Post.unscoped { # Post.limit(10) # Fires "SELECT * FROM posts LIMIT 10" # } # # It is recommended that you use the block form of unscoped because - # chaining unscoped with scope does not work. Assuming that - # published is a scope, the following two statements - # are equal: the default_scope is applied on both. + # chaining unscoped with +scope+ does not work. Assuming that + # +published+ is a +scope+, the following two statements + # are equal: the +default_scope+ is applied on both. # # Post.unscoped.published # Post.published @@ -50,35 +50,37 @@ module ActiveRecord # the model. # # class Article < ActiveRecord::Base - # default_scope { where(:published => true) } + # default_scope { where(published: true) } # end # # Article.all # => SELECT * FROM articles WHERE published = true # - # The default_scope is also applied while creating/building a record. It is not - # applied while updating a record. + # The +default_scope+ is also applied while creating/building a record. + # It is not applied while updating a record. # # Article.new.published # => true # Article.create.published # => true # - # (You can also pass any object which responds to call to the default_scope - # macro, and it will be called when building the default scope.) + # (You can also pass any object which responds to +call+ to the + # +default_scope+ macro, and it will be called when building the + # default scope.) # - # If you use multiple default_scope declarations in your model then they will - # be merged together: + # If you use multiple +default_scope+ declarations in your model then + # they will be merged together: # # class Article < ActiveRecord::Base - # default_scope { where(:published => true) } - # default_scope { where(:rating => 'G') } + # default_scope { where(published: true) } + # default_scope { where(rating: 'G') } # end # # Article.all # => SELECT * FROM articles WHERE published = true AND rating = 'G' # - # This is also the case with inheritance and module includes where the parent or module - # defines a default_scope and the child or including class defines a second one. + # This is also the case with inheritance and module includes where the + # parent or module defines a +default_scope+ and the child or including + # class defines a second one. # - # If you need to do more complex things with a default scope, you can alternatively - # define it as a class method: + # If you need to do more complex things with a default scope, you can + # alternatively define it as a class method: # # class Article < ActiveRecord::Base # def self.default_scope @@ -100,7 +102,7 @@ module ActiveRecord self.default_scopes = default_scopes + [scope] end - def build_default_scope #:nodoc: + def build_default_scope # :nodoc: if !Base.is_a?(method(:default_scope).owner) # The user has defined their own default scope method, so call that evaluate_default_scope { default_scope } @@ -117,17 +119,18 @@ module ActiveRecord end end - def ignore_default_scope? #:nodoc: + def ignore_default_scope? # :nodoc: Thread.current["#{self}_ignore_default_scope"] end - def ignore_default_scope=(ignore) #:nodoc: + def ignore_default_scope=(ignore) # :nodoc: Thread.current["#{self}_ignore_default_scope"] = ignore end - # The ignore_default_scope flag is used to prevent an infinite recursion situation where - # a default scope references a scope which has a default scope which references a scope... - def evaluate_default_scope + # The ignore_default_scope flag is used to prevent an infinite recursion + # situation where a default scope references a scope which has a default + # scope which references a scope... + def evaluate_default_scope # :nodoc: return if ignore_default_scope? begin diff --git a/activerecord/lib/active_record/scoping/named.rb b/activerecord/lib/active_record/scoping/named.rb index 75f31229b5..fb5f5b5be0 100644 --- a/activerecord/lib/active_record/scoping/named.rb +++ b/activerecord/lib/active_record/scoping/named.rb @@ -3,7 +3,7 @@ require 'active_support/core_ext/hash/except' require 'active_support/core_ext/kernel/singleton_class' module ActiveRecord - # = Active Record Named \Scopes + # = Active Record \Named \Scopes module Scoping module Named extend ActiveSupport::Concern @@ -16,11 +16,11 @@ module ActiveRecord # posts.each {|p| puts p.name } # Fires "select * from posts" and loads post objects # # fruits = Fruit.all - # fruits = fruits.where(:color => 'red') if options[:red_only] + # fruits = fruits.where(color: 'red') if options[:red_only] # fruits = fruits.limit(10) if limited? # - # You can define a \scope that applies to all finders using - # ActiveRecord::Base.default_scope. + # You can define a scope that applies to all finders using + # ActiveRecord::Base.default_scope. def all if current_scope current_scope.clone @@ -31,7 +31,6 @@ module ActiveRecord end end - ## # Collects attributes from scopes that should be applied when creating # an AR instance for the particular class this is called on. def scope_attributes # :nodoc: @@ -44,86 +43,70 @@ module ActiveRecord end end - ## # Are there default attributes associated with this scope? def scope_attributes? # :nodoc: current_scope || default_scopes.any? end - # Adds a class method for retrieving and querying objects. A \scope represents a narrowing of a database query, - # such as where(:color => :red).select('shirts.*').includes(:washing_instructions). + # Adds a class method for retrieving and querying objects. A \scope + # represents a narrowing of a database query, such as + # where(color: :red).select('shirts.*').includes(:washing_instructions). # # class Shirt < ActiveRecord::Base - # scope :red, where(:color => 'red') - # scope :dry_clean_only, joins(:washing_instructions).where('washing_instructions.dry_clean_only = ?', true) + # scope :red, -> { where(color: 'red') } + # scope :dry_clean_only, -> { joins(:washing_instructions).where('washing_instructions.dry_clean_only = ?', true) } # end # - # The above calls to scope define class methods Shirt.red and Shirt.dry_clean_only. Shirt.red, - # in effect, represents the query Shirt.where(:color => 'red'). + # The above calls to +scope+ define class methods Shirt.red and + # Shirt.dry_clean_only. Shirt.red, in effect, + # represents the query Shirt.where(color: 'red'). # - # Note that this is simply 'syntactic sugar' for defining an actual class method: + # You should always pass a callable object to the scopes defined + # with +scope+. This ensures that the scope is re-evaluated each + # time it is called. + # + # Note that this is simply 'syntactic sugar' for defining an actual + # class method: # # class Shirt < ActiveRecord::Base # def self.red - # where(:color => 'red') + # where(color: 'red') # end # end # - # Unlike Shirt.find(...), however, the object returned by Shirt.red is not an Array; it - # resembles the association object constructed by a has_many declaration. For instance, - # you can invoke Shirt.red.first, Shirt.red.count, Shirt.red.where(:size => 'small'). - # Also, just as with the association objects, named \scopes act like an Array, implementing Enumerable; - # Shirt.red.each(&block), Shirt.red.first, and Shirt.red.inject(memo, &block) - # all behave as if Shirt.red really was an Array. - # - # These named \scopes are composable. For instance, Shirt.red.dry_clean_only will produce - # all shirts that are both red and dry clean only. - # Nested finds and calculations also work with these compositions: Shirt.red.dry_clean_only.count - # returns the number of garments for which these criteria obtain. Similarly with - # Shirt.red.dry_clean_only.average(:thread_count). - # - # All \scopes are available as class methods on the ActiveRecord::Base descendant upon which - # the \scopes were defined. But they are also available to has_many associations. If, + # Unlike Shirt.find(...), however, the object returned by + # Shirt.red is not an Array; it resembles the association object + # constructed by a +has_many+ declaration. For instance, you can invoke + # Shirt.red.first, Shirt.red.count, + # Shirt.red.where(size: 'small'). Also, just as with the + # association objects, named \scopes act like an Array, implementing + # Enumerable; Shirt.red.each(&block), Shirt.red.first, + # and Shirt.red.inject(memo, &block) all behave as if + # Shirt.red really was an Array. + # + # These named \scopes are composable. For instance, + # Shirt.red.dry_clean_only will produce all shirts that are + # both red and dry clean only. Nested finds and calculations also work + # with these compositions: Shirt.red.dry_clean_only.count + # returns the number of garments for which these criteria obtain. + # Similarly with Shirt.red.dry_clean_only.average(:thread_count). + # + # All scopes are available as class methods on the ActiveRecord::Base + # descendant upon which the \scopes were defined. But they are also + # available to +has_many+ associations. If, # # class Person < ActiveRecord::Base # has_many :shirts # end # - # then elton.shirts.red.dry_clean_only will return all of Elton's red, dry clean - # only shirts. - # - # Named \scopes can also be procedural: - # - # class Shirt < ActiveRecord::Base - # scope :colored, lambda { |color| where(:color => color) } - # end - # - # In this example, Shirt.colored('puce') finds all puce shirts. - # - # On Ruby 1.9 you can use the 'stabby lambda' syntax: - # - # scope :colored, ->(color) { where(:color => color) } - # - # Note that scopes defined with \scope will be evaluated when they are defined, rather than - # when they are used. For example, the following would be incorrect: - # - # class Post < ActiveRecord::Base - # scope :recent, where('published_at >= ?', Time.current - 1.week) - # end - # - # The example above would be 'frozen' to the Time.current value when the Post - # class was defined, and so the resultant SQL query would always be the same. The correct - # way to do this would be via a lambda, which will re-evaluate the scope each time - # it is called: - # - # class Post < ActiveRecord::Base - # scope :recent, lambda { where('published_at >= ?', Time.current - 1.week) } - # end + # then elton.shirts.red.dry_clean_only will return all of + # Elton's red, dry clean only shirts. # - # Named \scopes can also have extensions, just as with has_many declarations: + # \Named scopes can also have extensions, just as with +has_many+ + # declarations: # # class Shirt < ActiveRecord::Base - # scope :red, where(:color => 'red') do + # scope :red, -> { where(color: 'red') } do # def dom_id # 'red_shirts' # end @@ -133,18 +116,18 @@ module ActiveRecord # Scopes can also be used while creating/building a record. # # class Article < ActiveRecord::Base - # scope :published, where(:published => true) + # scope :published, -> { where(published: true) } # end # # Article.published.new.published # => true # Article.published.create.published # => true # - # Class methods on your model are automatically available + # \Class methods on your model are automatically available # on scopes. Assuming the following setup: # # class Article < ActiveRecord::Base - # scope :published, where(:published => true) - # scope :featured, where(:featured => true) + # scope :published, -> { where(published: true) } + # scope :featured, -> { where(featured: true) } # # def self.latest_article # order('published_at desc').first -- cgit v1.2.3 From b21012bc3911d53eef6fc3bc3222c8e762664671 Mon Sep 17 00:00:00 2001 From: Francesco Rodriguez Date: Fri, 21 Sep 2012 23:38:18 -0500 Subject: nodoc AR::Railtie [ci skip] --- activerecord/lib/active_record/railtie.rb | 4 ++-- activerecord/lib/active_record/railties/controller_runtime.rb | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) (limited to 'activerecord/lib') diff --git a/activerecord/lib/active_record/railtie.rb b/activerecord/lib/active_record/railtie.rb index a9f80ccd5f..e293f641ee 100644 --- a/activerecord/lib/active_record/railtie.rb +++ b/activerecord/lib/active_record/railtie.rb @@ -10,7 +10,7 @@ require "action_controller/railtie" module ActiveRecord # = Active Record Railtie - class Railtie < Rails::Railtie + class Railtie < Rails::Railtie # :nodoc: config.active_record = ActiveSupport::OrderedOptions.new config.app_generators.orm :active_record, :migration => true, @@ -76,7 +76,7 @@ module ActiveRecord config.after_initialize do |app| ActiveSupport.on_load(:active_record) do filename = File.join(app.config.paths["db"].first, "schema_cache.dump") - + if File.file?(filename) cache = Marshal.load File.binread filename if cache.version == ActiveRecord::Migrator.current_version diff --git a/activerecord/lib/active_record/railties/controller_runtime.rb b/activerecord/lib/active_record/railties/controller_runtime.rb index c5db9b4625..7695eacbff 100644 --- a/activerecord/lib/active_record/railties/controller_runtime.rb +++ b/activerecord/lib/active_record/railties/controller_runtime.rb @@ -2,7 +2,7 @@ require 'active_support/core_ext/module/attr_internal' require 'active_record/log_subscriber' module ActiveRecord - module Railties + module Railties # :nodoc: module ControllerRuntime #:nodoc: extend ActiveSupport::Concern @@ -37,7 +37,7 @@ module ActiveRecord end end - module ClassMethods + module ClassMethods # :nodoc: def log_process_action(payload) messages, db_runtime = super, payload[:db_runtime] messages << ("ActiveRecord: %.1fms" % db_runtime.to_f) if db_runtime -- cgit v1.2.3 From d13cd2a7a9d766f450e9a8a7e01f5df54b3dc7b0 Mon Sep 17 00:00:00 2001 From: Francesco Rodriguez Date: Sat, 22 Sep 2012 18:26:00 -0500 Subject: update AR::Validations documentation [ci skip] --- activerecord/lib/active_record/core.rb | 2 +- activerecord/lib/active_record/validations.rb | 23 +++++++++++----------- .../lib/active_record/validations/associated.rb | 2 +- .../lib/active_record/validations/presence.rb | 17 ++++++++-------- .../lib/active_record/validations/uniqueness.rb | 12 +++++------ 5 files changed, 28 insertions(+), 28 deletions(-) (limited to 'activerecord/lib') diff --git a/activerecord/lib/active_record/core.rb b/activerecord/lib/active_record/core.rb index f97c363871..c01a472d76 100644 --- a/activerecord/lib/active_record/core.rb +++ b/activerecord/lib/active_record/core.rb @@ -1,4 +1,4 @@ -require 'active_support/core_ext/hash/indifferent_access' + require 'active_support/core_ext/hash/indifferent_access' require 'active_support/core_ext/object/duplicable' require 'thread' diff --git a/activerecord/lib/active_record/validations.rb b/activerecord/lib/active_record/validations.rb index ed561bfb3c..019290725d 100644 --- a/activerecord/lib/active_record/validations.rb +++ b/activerecord/lib/active_record/validations.rb @@ -10,8 +10,8 @@ module ActiveRecord # puts invalid.record.errors # end class RecordInvalid < ActiveRecordError - attr_reader :record - def initialize(record) + attr_reader :record # :nodoc: + def initialize(record) # :nodoc: @record = record errors = @record.errors.full_messages.join(", ") super(I18n.t(:"#{@record.class.i18n_scope}.errors.messages.record_invalid", :errors => errors, :default => :"errors.messages.record_invalid")) @@ -44,23 +44,24 @@ module ActiveRecord end end - # The validation process on save can be skipped by passing :validate => false. The regular Base#save method is - # replaced with this when the validations module is mixed in, which it is by default. + # The validation process on save can be skipped by passing validate: false. + # The regular Base#save method is replaced with this when the validations + # module is mixed in, which it is by default. def save(options={}) perform_validations(options) ? super : false end - # Attempts to save the record just like Base#save but will raise a +RecordInvalid+ exception instead of returning false - # if the record is not valid. + # Attempts to save the record just like Base#save but will raise a +RecordInvalid+ + # exception instead of returning +false+ if the record is not valid. def save!(options={}) perform_validations(options) ? super : raise(RecordInvalid.new(self)) end - # Runs all the validations within the specified context. Returns true if no errors are found, - # false otherwise. + # Runs all the validations within the specified context. Returns +true+ if + # no errors are found, +false+ otherwise. # - # If the argument is false (default is +nil+), the context is set to :create if - # new_record? is true, and to :update if it is not. + # If the argument is +false+ (default is +nil+), the context is set to :create if + # new_record? is +true+, and to :update if it is not. # # Validations with no :on option will run no matter the context. Validations with # some :on option will only run in the specified context. @@ -72,7 +73,7 @@ module ActiveRecord protected - def perform_validations(options={}) + def perform_validations(options={}) # :nodoc: perform_validation = options[:validate] != false perform_validation ? valid?(options[:context]) : true end diff --git a/activerecord/lib/active_record/validations/associated.rb b/activerecord/lib/active_record/validations/associated.rb index 1fa6629980..7f1972ccf9 100644 --- a/activerecord/lib/active_record/validations/associated.rb +++ b/activerecord/lib/active_record/validations/associated.rb @@ -38,7 +38,7 @@ module ActiveRecord # proc or string should return or evaluate to a +true+ or +false+ value. # * :unless - Specifies a method, proc or string to call to # determine if the validation should not occur (e.g. unless: :skip_validation, - # or unless: => Proc.new { |user| user.signup_step <= 2 }). The + # or unless: Proc.new { |user| user.signup_step <= 2 }). The # method, proc or string should return or evaluate to a +true+ or +false+ # value. def validates_associated(*attr_names) diff --git a/activerecord/lib/active_record/validations/presence.rb b/activerecord/lib/active_record/validations/presence.rb index 056527b512..81a3521d24 100644 --- a/activerecord/lib/active_record/validations/presence.rb +++ b/activerecord/lib/active_record/validations/presence.rb @@ -1,6 +1,6 @@ module ActiveRecord module Validations - class PresenceValidator < ActiveModel::Validations::PresenceValidator + class PresenceValidator < ActiveModel::Validations::PresenceValidator # :nodoc: def validate(record) super attributes.each do |attribute| @@ -29,7 +29,7 @@ module ActiveRecord # # If you want to validate the presence of a boolean field (where the real values # are true and false), you will want to use - # validates_inclusion_of :field_name, :in => [true, false]. + # validates_inclusion_of :field_name, in: [true, false]. # # This is due to the way Object#blank? handles boolean values: # false.blank? # => true. @@ -46,16 +46,15 @@ module ActiveRecord # validation contexts by default (+nil+), other options are :create # and :update. # * :if - Specifies a method, proc or string to call to determine if - # the validation should occur (e.g. :if => :allow_validation, or - # :if => Proc.new { |user| user.signup_step > 2 }). The method, proc - # or string should return or evaluate to a true or false value. + # the validation should occur (e.g. if: :allow_validation, or + # if: Proc.new { |user| user.signup_step > 2 }). The method, proc + # or string should return or evaluate to a +true+ or +false+ value. # * :unless - Specifies a method, proc or string to call to determine - # if the validation should not occur (e.g. :unless => :skip_validation, - # or :unless => Proc.new { |user| user.signup_step <= 2 }). The method, - # proc or string should return or evaluate to a true or false value. + # if the validation should not occur (e.g. unless: :skip_validation, + # or unless: Proc.new { |user| user.signup_step <= 2 }). The method, + # proc or string should return or evaluate to a +true+ or +false+ value. # * :strict - Specifies whether validation should be strict. # See ActiveModel::Validation#validates! for more information. - # def validates_presence_of(*attr_names) validates_with PresenceValidator, _merge_attributes(attr_names) end diff --git a/activerecord/lib/active_record/validations/uniqueness.rb b/activerecord/lib/active_record/validations/uniqueness.rb index c117872ac8..f3620c1324 100644 --- a/activerecord/lib/active_record/validations/uniqueness.rb +++ b/activerecord/lib/active_record/validations/uniqueness.rb @@ -2,7 +2,7 @@ require 'active_support/core_ext/array/prepend_and_append' module ActiveRecord module Validations - class UniquenessValidator < ActiveModel::EachValidator #:nodoc: + class UniquenessValidator < ActiveModel::EachValidator # :nodoc: def initialize(options) super(options.reverse_merge(:case_sensitive => true)) end @@ -199,7 +199,7 @@ module ActiveRecord # can catch it and restart the transaction (e.g. by telling the user # that the title already exists, and asking him to re-enter the title). # This technique is also known as optimistic concurrency control: - # http://en.wikipedia.org/wiki/Optimistic_concurrency_control + # http://en.wikipedia.org/wiki/Optimistic_concurrency_control. # # The bundled ActiveRecord::ConnectionAdapters distinguish unique index # constraint errors from other types of database errors by throwing an @@ -209,10 +209,10 @@ module ActiveRecord # # The following bundled adapters throw the ActiveRecord::RecordNotUnique exception: # - # * ActiveRecord::ConnectionAdapters::MysqlAdapter - # * ActiveRecord::ConnectionAdapters::Mysql2Adapter - # * ActiveRecord::ConnectionAdapters::SQLite3Adapter - # * ActiveRecord::ConnectionAdapters::PostgreSQLAdapter + # * ActiveRecord::ConnectionAdapters::MysqlAdapter. + # * ActiveRecord::ConnectionAdapters::Mysql2Adapter. + # * ActiveRecord::ConnectionAdapters::SQLite3Adapter. + # * ActiveRecord::ConnectionAdapters::PostgreSQLAdapter. def validates_uniqueness_of(*attr_names) validates_with UniquenessValidator, _merge_attributes(attr_names) end -- cgit v1.2.3 From a0457317183a7ab0add760cf6678b72c4e3c0e8f Mon Sep 17 00:00:00 2001 From: Francesco Rodriguez Date: Sat, 22 Sep 2012 18:29:37 -0500 Subject: remove added indentation from the last commit [ci skip] --- activerecord/lib/active_record/core.rb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'activerecord/lib') diff --git a/activerecord/lib/active_record/core.rb b/activerecord/lib/active_record/core.rb index c01a472d76..f97c363871 100644 --- a/activerecord/lib/active_record/core.rb +++ b/activerecord/lib/active_record/core.rb @@ -1,4 +1,4 @@ - require 'active_support/core_ext/hash/indifferent_access' +require 'active_support/core_ext/hash/indifferent_access' require 'active_support/core_ext/object/duplicable' require 'thread' -- cgit v1.2.3 From 5fef8c174ad45fd1a381975816debf8446d09db0 Mon Sep 17 00:00:00 2001 From: kennyj Date: Fri, 28 Sep 2012 00:09:21 +0900 Subject: Removing dead code. attribute_cast_code is not called. --- .../lib/active_record/attribute_methods/serialization.rb | 10 ---------- .../attribute_methods/time_zone_conversion.rb | 15 --------------- 2 files changed, 25 deletions(-) (limited to 'activerecord/lib') diff --git a/activerecord/lib/active_record/attribute_methods/serialization.rb b/activerecord/lib/active_record/attribute_methods/serialization.rb index bdda5bc009..6395f92b4b 100644 --- a/activerecord/lib/active_record/attribute_methods/serialization.rb +++ b/activerecord/lib/active_record/attribute_methods/serialization.rb @@ -98,16 +98,6 @@ module ActiveRecord attributes end - - private - - def attribute_cast_code(attr_name) - if serialized_attributes.include?(attr_name) - "v.unserialized_value" - else - super - end - end end def type_cast_attribute_for_write(column, value) diff --git a/activerecord/lib/active_record/attribute_methods/time_zone_conversion.rb b/activerecord/lib/active_record/attribute_methods/time_zone_conversion.rb index 9647d03be4..b9a69cdb0a 100644 --- a/activerecord/lib/active_record/attribute_methods/time_zone_conversion.rb +++ b/activerecord/lib/active_record/attribute_methods/time_zone_conversion.rb @@ -34,21 +34,6 @@ module ActiveRecord module ClassMethods protected - # The enhanced read method automatically converts the UTC time stored in the database to the time - # zone stored in Time.zone. - def attribute_cast_code(attr_name) - column = columns_hash[attr_name] - - if create_time_zone_conversion_attribute?(attr_name, column) - typecast = "v = #{super}" - time_zone_conversion = "v.acts_like?(:time) ? v.in_time_zone : v" - - "((#{typecast}) && (#{time_zone_conversion}))" - else - super - end - end - # Defined for all +datetime+ and +timestamp+ attributes when +time_zone_aware_attributes+ are enabled. # This enhanced write method will automatically convert the time passed to it to the zone stored in Time.zone. def define_method_attribute=(attr_name) -- cgit v1.2.3 From 144e8691cbfb8bba77f18cfe68d5e7fd48887f5e Mon Sep 17 00:00:00 2001 From: Jon Leighton Date: Fri, 28 Sep 2012 17:55:35 +0100 Subject: Support for partial inserts. When inserting new records, only the fields which have been changed from the defaults will actually be included in the INSERT statement. The other fields will be populated by the database. This is more efficient, and also means that it will be safe to remove database columns without getting subsequent errors in running app processes (so long as the code in those processes doesn't contain any references to the removed column). --- activerecord/lib/active_record/attribute_methods.rb | 10 +++++----- .../lib/active_record/attribute_methods/dirty.rb | 20 +++++++++++++++++--- .../abstract/database_statements.rb | 2 +- .../connection_adapters/abstract_mysql_adapter.rb | 8 ++++++++ .../lib/active_record/connection_adapters/column.rb | 4 ++++ .../connection_adapters/sqlite3_adapter.rb | 4 ---- activerecord/lib/active_record/persistence.rb | 4 ++-- 7 files changed, 37 insertions(+), 15 deletions(-) (limited to 'activerecord/lib') diff --git a/activerecord/lib/active_record/attribute_methods.rb b/activerecord/lib/active_record/attribute_methods.rb index ced15bc330..0aff2562b8 100644 --- a/activerecord/lib/active_record/attribute_methods.rb +++ b/activerecord/lib/active_record/attribute_methods.rb @@ -207,8 +207,8 @@ module ActiveRecord value end - def arel_attributes_with_values_for_create(pk_attribute_allowed) - arel_attributes_with_values(attributes_for_create(pk_attribute_allowed)) + def arel_attributes_with_values_for_create(attribute_names) + arel_attributes_with_values(attributes_for_create(attribute_names)) end def arel_attributes_with_values_for_update(attribute_names) @@ -242,9 +242,9 @@ module ActiveRecord # Filters out the primary keys, from the attribute names, when the primary # key is to be generated (e.g. the id attribute has no value). - def attributes_for_create(pk_attribute_allowed) - @attributes.keys.select do |name| - column_for_attribute(name) && (pk_attribute_allowed || !pk_attribute?(name)) + def attributes_for_create(attribute_names) + attribute_names.select do |name| + column_for_attribute(name) && !(pk_attribute?(name) && id.nil?) end end diff --git a/activerecord/lib/active_record/attribute_methods/dirty.rb b/activerecord/lib/active_record/attribute_methods/dirty.rb index 60e5b0e2bb..6204e4172d 100644 --- a/activerecord/lib/active_record/attribute_methods/dirty.rb +++ b/activerecord/lib/active_record/attribute_methods/dirty.rb @@ -64,15 +64,29 @@ module ActiveRecord end def update(*) + partial_updates? ? super(keys_for_partial_update) : super + end + + def create(*) if partial_updates? - # Serialized attributes should always be written in case they've been - # changed in place. - super(changed | (attributes.keys & self.class.serialized_attributes.keys)) + keys = keys_for_partial_update + + # This is an extremely bloody annoying necessity to work around mysql being crap. + # See test_mysql_text_not_null_defaults + keys.concat self.class.columns.select(&:explicit_default?).map(&:name) + + super keys else super end end + # Serialized attributes should always be written in case they've been + # changed in place. + def keys_for_partial_update + changed | (attributes.keys & self.class.serialized_attributes.keys) + end + def _field_changed?(attr, old, value) if column = column_for_attribute(attr) if column.number? && (changes_from_nil_to_empty_string?(column, old, value) || diff --git a/activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb b/activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb index 793f58d4d3..0d7046a705 100644 --- a/activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb +++ b/activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb @@ -299,7 +299,7 @@ module ActiveRecord end def empty_insert_statement_value - "VALUES(DEFAULT)" + "DEFAULT VALUES" end def case_sensitive_equality_operator diff --git a/activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb b/activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb index 1783b036a2..8c83c4f5db 100644 --- a/activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb +++ b/activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb @@ -30,6 +30,10 @@ module ActiveRecord super end + def explicit_default? + !null && (sql_type =~ /blob/i || type == :text) + end + # Must return the relevant concrete adapter def adapter raise NotImplementedError @@ -320,6 +324,10 @@ module ActiveRecord end end + def empty_insert_statement_value + "VALUES ()" + end + # SCHEMA STATEMENTS ======================================== def structure_dump #:nodoc: diff --git a/activerecord/lib/active_record/connection_adapters/column.rb b/activerecord/lib/active_record/connection_adapters/column.rb index 816b5e17c1..2028abf6f0 100644 --- a/activerecord/lib/active_record/connection_adapters/column.rb +++ b/activerecord/lib/active_record/connection_adapters/column.rb @@ -53,6 +53,10 @@ module ActiveRecord !default.nil? end + def explicit_default? + false + end + # Returns the Ruby class that corresponds to the abstract data type. def klass case type diff --git a/activerecord/lib/active_record/connection_adapters/sqlite3_adapter.rb b/activerecord/lib/active_record/connection_adapters/sqlite3_adapter.rb index 4a48812807..4d5cb72c67 100644 --- a/activerecord/lib/active_record/connection_adapters/sqlite3_adapter.rb +++ b/activerecord/lib/active_record/connection_adapters/sqlite3_adapter.rb @@ -490,10 +490,6 @@ module ActiveRecord alter_table(table_name, :rename => {column_name.to_s => new_column_name.to_s}) end - def empty_insert_statement_value - "VALUES(NULL)" - end - protected def select(sql, name = nil, binds = []) #:nodoc: exec_query(sql, name, binds) diff --git a/activerecord/lib/active_record/persistence.rb b/activerecord/lib/active_record/persistence.rb index 2eaad1d469..f81eb5f5d1 100644 --- a/activerecord/lib/active_record/persistence.rb +++ b/activerecord/lib/active_record/persistence.rb @@ -385,8 +385,8 @@ module ActiveRecord # Creates a record with values matching those of the instance attributes # and returns its id. - def create - attributes_values = arel_attributes_with_values_for_create(!id.nil?) + def create(attribute_names = @attributes.keys) + attributes_values = arel_attributes_with_values_for_create(attribute_names) new_id = self.class.unscoped.insert attributes_values self.id ||= new_id if self.class.primary_key -- cgit v1.2.3 From 9eb72ac78f15078c362cb4bc6cc42ddda182127b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rafael=20Mendon=C3=A7a=20Fran=C3=A7a?= Date: Fri, 28 Sep 2012 15:26:33 -0300 Subject: Fix syntax error with no US-ASCII char --- activerecord/lib/active_record/validations.rb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'activerecord/lib') diff --git a/activerecord/lib/active_record/validations.rb b/activerecord/lib/active_record/validations.rb index 019290725d..3706885881 100644 --- a/activerecord/lib/active_record/validations.rb +++ b/activerecord/lib/active_record/validations.rb @@ -10,7 +10,7 @@ module ActiveRecord # puts invalid.record.errors # end class RecordInvalid < ActiveRecordError - attr_reader :record # :nodoc: + attr_reader :record # :nodoc: def initialize(record) # :nodoc: @record = record errors = @record.errors.full_messages.join(", ") -- cgit v1.2.3 From f224b4f083963ef5148d93a4007c428e17ac5233 Mon Sep 17 00:00:00 2001 From: Angelo Capilleri Date: Sat, 29 Sep 2012 23:29:48 +0200 Subject: small refactoring of build_relation in uniqueness reflection init as 'if' stantment. column is always the same expression and depends from the changing of attributes --- activerecord/lib/active_record/validations/uniqueness.rb | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) (limited to 'activerecord/lib') diff --git a/activerecord/lib/active_record/validations/uniqueness.rb b/activerecord/lib/active_record/validations/uniqueness.rb index f3620c1324..5dece1cb36 100644 --- a/activerecord/lib/active_record/validations/uniqueness.rb +++ b/activerecord/lib/active_record/validations/uniqueness.rb @@ -64,14 +64,12 @@ module ActiveRecord end def build_relation(klass, table, attribute, value) #:nodoc: - reflection = klass.reflect_on_association(attribute) - if reflection - column = klass.columns_hash[reflection.foreign_key] + if reflection = klass.reflect_on_association(attribute) attribute = reflection.foreign_key value = value.attributes[reflection.primary_key_column.name] - else - column = klass.columns_hash[attribute.to_s] end + + column = klass.columns_hash[attribute.to_s] value = column.limit ? value.to_s[0, column.limit] : value.to_s if !value.nil? && column.text? if !options[:case_sensitive] && value && column.text? -- cgit v1.2.3 From 37852726c93541aa1adc014cfb862659c9bcf349 Mon Sep 17 00:00:00 2001 From: Brian Durand Date: Wed, 19 Sep 2012 16:00:28 -0700 Subject: Optimize log subscribers to check if the log level is sufficient before performing an operations. --- activerecord/lib/active_record/log_subscriber.rb | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) (limited to 'activerecord/lib') diff --git a/activerecord/lib/active_record/log_subscriber.rb b/activerecord/lib/active_record/log_subscriber.rb index a25f2c7bca..ca79950049 100644 --- a/activerecord/lib/active_record/log_subscriber.rb +++ b/activerecord/lib/active_record/log_subscriber.rb @@ -1,11 +1,13 @@ module ActiveRecord class LogSubscriber < ActiveSupport::LogSubscriber + IGNORE_PAYLOAD_NAMES = ["SCHEMA", "EXPLAIN"] + def self.runtime=(value) - Thread.current["active_record_sql_runtime"] = value + Thread.current[:active_record_sql_runtime] = value end def self.runtime - Thread.current["active_record_sql_runtime"] ||= 0 + Thread.current[:active_record_sql_runtime] ||= 0 end def self.reset_runtime @@ -24,9 +26,9 @@ module ActiveRecord payload = event.payload - return if 'SCHEMA' == payload[:name] + return if IGNORE_PAYLOAD_NAMES.include?(payload[:name]) - name = '%s (%.1fms)' % [payload[:name], event.duration] + name = "#{payload[:name]} (#{event.duration.round(1)}ms)" sql = payload[:sql].squeeze(' ') binds = nil -- cgit v1.2.3 From 6e56a03f834202af4e57c50a71cc74ea08303bfd Mon Sep 17 00:00:00 2001 From: lulalala Date: Tue, 2 Oct 2012 22:30:06 +0800 Subject: Fix reset_counters() crashing on has_many :through associations. The counter column name in the intermediate model need to be access via the through reflection. --- activerecord/lib/active_record/counter_cache.rb | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) (limited to 'activerecord/lib') diff --git a/activerecord/lib/active_record/counter_cache.rb b/activerecord/lib/active_record/counter_cache.rb index c877079b25..d28cd560d9 100644 --- a/activerecord/lib/active_record/counter_cache.rb +++ b/activerecord/lib/active_record/counter_cache.rb @@ -22,8 +22,13 @@ module ActiveRecord counters.each do |association| has_many_association = reflect_on_association(association.to_sym) - foreign_key = has_many_association.foreign_key.to_s - child_class = has_many_association.klass + if has_many_association.is_a? ActiveRecord::Reflection::ThroughReflection + foreign_key = has_many_association.through_reflection.foreign_key.to_s + child_class = has_many_association.through_reflection.klass + else + foreign_key = has_many_association.foreign_key.to_s + child_class = has_many_association.klass + end belongs_to = child_class.reflect_on_all_associations(:belongs_to) reflection = belongs_to.find { |e| e.foreign_key.to_s == foreign_key && e.options[:counter_cache].present? } counter_name = reflection.counter_cache_column -- cgit v1.2.3