はてなブックマーク

Image blobs can have variants that are the result of a set of transformations applied to the original. These variants are used to create thumbnails, fixed-size avatars, or any other derivative image from the original. Variants rely on MiniMagick for the actual transformations of the file, so you must add gem "mini_magick" to your Gemfile if you wish to use variants. Note that to create a variant i

Ruby on Rails 5.2.8.1 Class ActiveSupport::MessageVerifier < Object activesupport/lib/active_support/message_verifier.rb MessageVerifier makes it easy to generate and verify messages which are signed to prevent tampering. This is useful for cases like remember-me tokens and auto-unsubscribe links where the session store isn't suitable or available. Remember Me: cookies[:remember_me] = @verifier.ge

D deep_dup E excluding, extract!, extract_options! F fifth, forty_two, fourth, from I in_groups, in_groups_of, including, inquiry S second, second_to_last, split T third, third_to_last, to, to_formatted_s, to_fs, to_param, to_query, to_sentence, to_xml W without, wrap Class Public methods Wraps its argument in an array unless it is already an array (or array-like). Specifically: If the argument is

Ruby on Rails 7.2.1.2 Module ActiveRecord::ReadonlyAttributes::ClassMethods activerecord/lib/active_record/readonly_attributes.rb Attributes listed as readonly will be used to create a new record. Assigning a new value to a readonly attribute on a persisted record raises an error. By setting config.active_record.raise_on_assign_to_attr_readonly to false, it will not raise. The value will change in

Ruby on Rails 7.2.1.2 Class ActiveRecord::Associations::CollectionProxy < Relation activerecord/lib/active_record/associations/collection_proxy.rb Active Record Collection Proxy Collection proxies in Active Record are middlemen between an association, and its target result set. For example, given class Blog < ActiveRecord::Base has_many :posts end blog = Blog.first The collection proxy returned by

Accepts a hash of SQL conditions and replaces those attributes that correspond to a #composed_of relationship with their expanded aggregate attribute values. Given: class Person < ActiveRecord::Base composed_of :address, class_name: "Address", mapping: [%w(address_street street), %w(address_city city)] end Then: { address: Address.new("813 abc st.", "chicago") } # => { address_street: "813 abc st.

Accepts an array of conditions. The array has each value sanitized and interpolated into the SQL statement. If using named bind variables in SQL statements where a colon is required verbatim use a backslash to escape. sanitize_sql_array(["name=? and group_id=?", "foo'bar", 4]) # => "name='foo''bar' and group_id=4" sanitize_sql_array(["name=:name and group_id=:group_id", name: "foo'bar", group_id:

Form helpers are designed to make working with resources much easier compared to using vanilla HTML. Typically, a form designed to create or update a resource reflects the identity of the resource in several ways: (i) the url that the form is sent to (the form element's action attribute) should result in a request being routed to the appropriate controller action (with the appropriate :id paramete

Action Controller Parameters Allows you to choose which attributes should be whitelisted for mass updating and thus prevent accidentally exposing that which shouldn't be exposed. Provides two methods for this purpose: require and permit. The former is used to mark parameters as required. The latter is used to set the parameter as permitted and limit which attributes should be allowed for mass upda

Ruby on Rails 7.2.2 Class ActiveRecord::ConnectionAdapters::AbstractAdapter < Object activerecord/lib/active_record/connection_adapters/abstract_adapter.rb Active Record Abstract Adapter Active Record supports multiple database systems. AbstractAdapter and related classes form the abstraction layer which makes this possible. An AbstractAdapter represents a connection to a database, and provides an

Enable the query cache within the block if Active Record is configured. If it’s not, it will execute the given block. # File activerecord/lib/active_record/query_cache.rb, line 9 def cache(&block) if connected? || !configurations.empty? pool = connection_pool was_enabled = pool.query_cache_enabled begin pool.enable_query_cache(&block) ensure pool.clear_query_cache unless was_enabled end else yield

Set.new([:where, :select, :group, :order, :lock, :limit, :offset, :joins, :left_outer_joins, :annotate, :includes, :eager_load, :preload, :from, :readonly, :having, :optimizer_hints, :with]) Returns a new relation, which is the logical intersection of this relation and the one passed as an argument. The two relations must be structurally compatible: they must be scoping the same model, and they mu

ActiveResource::Base is the main class for mapping RESTful resources as models in a Rails application. For an outline of what Active Resource is capable of, see its README. Automated mapping Active Resource objects represent your RESTful resources as manipulatable Ruby objects. To map resources to Ruby objects, Active Resource only needs a class name that corresponds to the resource name (e.g., th

# File activerecord/lib/active_record/secure_token.rb, line 61 def generate_unique_secure_token(length: MINIMUM_TOKEN_LENGTH) SecureRandom.base58(length) end Example using has_secure_token # Schema: User(token:string, auth_token:string) class User < ActiveRecord::Base has_secure_token has_secure_token :auth_token, length: 36 end user = User.new user.save user.token # => "pX27zsMN2ViQKta1bGfLmVJE"

Active Model Basic Model Allows implementing models similar to ActiveRecord::Base. Includes ActiveModel::API for the required interface for an object to interact with Action Pack and Action View, but can be extended with other functionalities. A minimal implementation could be: class Person include ActiveModel::Model attr_accessor :name, :age end person = Person.new(name: 'bob', age: '18') person.

redirect_back(fallback_location:, allow_other_host: _allow_other_host, **args) Link Soft deprecated alias for redirect_back_or_to where the fallback_location location is supplied as a keyword argument instead of the first positional argument. # File actionpack/lib/action_controller/metal/redirecting.rb, line 121 def redirect_back(fallback_location:, allow_other_host: _allow_other_host, **args) red

Ruby on Rails 7.2.2 Module ActionController::HttpAuthentication::Token actionpack/lib/action_controller/metal/http_authentication.rb HTTP Token authentication Simple Token example class PostsController < ApplicationController TOKEN = "secret" before_action :authenticate, except: [ :index ] def index render plain: "Everyone can see me!" end def edit render plain: "I'm only accessible if you know th

If you pass a single integer, returns a substring of one character at that position. The first character of the string is at position 0, the next at position 1, and so on. If a range is supplied, a substring containing characters at offsets given by the range is returned. In both cases, if an offset is negative, it is counted from the end of the string. Returns nil if the initial offset falls outs

Action Dispatch Routing UrlFor In config/routes.rb you define URL-to-controller mappings, but the reverse is also possible: a URL can be generated from one of your routing definitions. URL generation functionality is centralized in this module. See ActionDispatch::Routing for general information about routing and config/routes.rb. Tip: If you need to generate URLs from your models or some other pl

Single table inheritance Active Record allows inheritance by storing the name of the class in a column that by default is named “type” (can be changed by overwriting Base.inheritance_column). This means that an inheritance looking like this: class Company < ActiveRecord::Base; end class Firm < Company; end class Client < Company; end class PriorityClient < Client; end When you do Firm.create(name:

Ruby on Rails 7.2.2 Class ActiveSupport::HashWithIndifferentAccess < Hash activesupport/lib/active_support/hash_with_indifferent_access.rb Hash With Indifferent Access Implements a hash where keys :foo and "foo" are considered to be the same. rgb = ActiveSupport::HashWithIndifferentAccess.new rgb[:black] = '#000000' rgb[:black] # => '#000000' rgb['black'] # => '#000000' rgb['white'] = '#FFFFFF' rg

Action View Partials There’s also a convenience method for rendering sub templates within the current controller that depends on a single object (we call this kind of sub templates for partials). It relies on the fact that partials should follow the naming convention of being prefixed with an underscore – as to separate them from regular templates that could be rendered on their own. In a template

Declare an enum attribute where the values map to integers in the database, but can be queried by name. Example: class Conversation < ActiveRecord::Base enum :status, [ :active, :archived ] end # conversation.update! status: 0 conversation.active! conversation.active? # => true conversation.status # => "active" # conversation.update! status: 1 conversation.archived! conversation.archived? # => tru

Find by id - This can either be a specific id (ID), a list of ids (ID, ID, ID), or an array of ids ([ID, ID, ID]). ‘ID` refers to an “identifier”. For models with a single-column primary key, `ID` will be a single value, and for models with a composite primary key, it will be an array of values. If one or more records cannot be found for the requested ids, then ActiveRecord::RecordNotFound will be