# events[].parameters[].value
  [1m[36mSpree::OptionValue Load (0.1ms)[0m  [1m[34mSELECT "spree_option_values".* FROM "spree_ (...19 more characters)

# events[].parameters[].value
  [1m[36mSpree::OptionValue Load (0.1ms)[0m  [1m[34mSELECT "spree_option_values".* FROM "spree_ (...91 more characters)

# events[].sql_query.sql
SELECT "spree_option_values".* FROM "spree_option_values" WHERE "spree_option_values"."id" = ? LIMIT ?

# events[].sql_query.normalized_sql
SELECT "spree_option_values".* FROM "spree_option_values" WHERE "spree_option_values"."id" = ? LIMIT ?

# events[].parameters[].value
  [1m[36mSpree::OptionValue Exists? (0.2ms)[0m  [1m[34mSELECT 1 AS one FROM "spree_option_value (...208 more characters)

# events[].sql_query.sql
SELECT 1 AS one FROM "spree_option_values" WHERE "spree_option_values"."name" = ? AND "spree_option_values"."id" != ? AND "spree_option_values"."option_type_id" = ? LIMIT ?

# events[].sql_query.normalized_sql
SELECT $1 AS one FROM "spree_option_values" WHERE "spree_option_values"."name" = ? AND "spree_option_values"."id" != ? AND "spree_option_values"."option_type_id" = ? LIMIT ?

# events[].parameters[].value
  [1m[35m (0.1ms)[0m  [1m[35mRELEASE SAVEPOINT active_record_2[0m

# events[].parameters[].value
  [1m[36mSpree::OptionType Load (0.1ms)[0m  [1m[34mSELECT "spree_option_types".* FROM "spree_op (...132 more characters)

# events[].sql_query.sql
SELECT "spree_option_types".* FROM "spree_option_types" WHERE "spree_option_types"."id" = ? ORDER BY "spree_option_types"."position" ASC LIMIT ?

# events[].sql_query.normalized_sql
SELECT "spree_option_types".* FROM "spree_option_types" WHERE "spree_option_types"."id" = ? ORDER BY "spree_option_types"."position" ASC LIMIT ?

# events[].parameters[].value
Completed 200 OK in 76ms (Views: 20.1ms | ActiveRecord: 0.7ms | Allocations: 54142)

# classMap[].children[].children[].children[].comment
# Returns a +String+, which Action Pack uses for constructing a URL to this
# object. The default implementation returns this record's id as a +String+,
# or +nil+ if this record's unsaved.
#
# For example, suppose that you have a User model, and that you have a
# <tt>resources :users</tt> route. Normally, +user_path+ will
# construct a path with the user object's 'id' in it:
#
#   user = User.find_by(name: 'Phusion')
#   user_path(user)  # => "/users/1"
#
# You can override +to_param+ in your model to make +user_path+ construct
# a path using the user's name instead of the user's id:
#
#   class User < ActiveRecord::Base
#     def to_param  # overridden
#       name
#     end
#   end
#
#   user = User.find_by(name: 'Phusion')
#   user_path(user)  # => "/users/Phusion"

# classMap[].children[].children[].children[].comment
# Returns the association instance for the given name, instantiating it if it doesn't already exist

# classMap[].children[].children[].children[].children[].comment
# Returns the primary key column's value.

# classMap[].children[].children[].children[].children[].comment
# This method exists to avoid the expensive primary_key check internally, without
# breaking compatibility with the read_attribute API

# classMap[].children[].children[].children[].children[].comment
# Returns an array of the names of any attributes that will change when
# the record is next saved.

# classMap[].children[].children[].children[].children[].comment
# Did this attribute change when we last saved?
#
# This method is useful in after callbacks to determine if an attribute
# was changed during the save that triggered the callbacks to run. It can
# be invoked as +saved_change_to_name?+ instead of
# <tt>saved_change_to_attribute?("name")</tt>.
#
# ==== Options
#
# +from+ When passed, this method will return false unless the original
# value is equal to the given option
#
# +to+ When passed, this method will return false unless the value was
# changed to the given value

# classMap[].children[].children[].children[].children[].comment
# Did the last call to +save+ have any changes to change?

# classMap[].children[].children[].comment
# Returns the version of the currently loaded ActiveRecord as a Gem::Version

# classMap[].children[].children[].children[].children[].comment
# Guesses the table name (in forced lower-case) based on the name of the class in the
# inheritance hierarchy descending directly from ActiveRecord::Base. So if the hierarchy
# looks like: Reply < Message < ActiveRecord::Base, then Message is used
# to guess the table name even when called on Reply. The rules used to do the guess
# are handled by the Inflector class in Active Support, which knows almost all common
# English inflections. You can add new inflections in config/initializers/inflections.rb.
#
# Nested classes are given table names prefixed by the singular form of
# the parent's table name. Enclosing modules are not considered.
#
# ==== Examples
#
#   class Invoice < ActiveRecord::Base
#   end
#
#   file                  class               table_name
#   invoice.rb            Invoice             invoices
#
#   class Invoice < ActiveRecord::Base
#     class Lineitem < ActiveRecord::Base
#     end
#   end
#
#   file                  class               table_name
#   invoice.rb            Invoice::Lineitem   invoice_lineitems
#
#   module Invoice
#     class Lineitem < ActiveRecord::Base
#     end
#   end
#
#   file                  class               table_name
#   invoice/lineitem.rb   Invoice::Lineitem   lineitems
#
# Additionally, the class-level +table_name_prefix+ is prepended and the
# +table_name_suffix+ is appended. So if you have "myapp_" as a prefix,
# the table name guess for an Invoice class becomes "myapp_invoices".
# Invoice::Lineitem becomes "myapp_invoice_lineitems".
#
# You can also set your own table name explicitly:
#
#   class Mouse < ActiveRecord::Base
#     self.table_name = "mice"
#   end

# classMap[].children[].children[].children[].comment
# Causes the records to be loaded from the database if they have not
# been loaded already. You can use this if for some reason you need
# to explicitly load some records before actually using them. The
# return value is the relation itself, not the records.
#
#   Post.where(published: true).load # => #<ActiveRecord::Relation>

# classMap[].children[].children[].children[].comment
# Scope all queries to the current scope.
#
#   Comment.where(post_id: 1).scoping do
#     Comment.first
#   end
#   # => SELECT "comments".* FROM "comments" WHERE "comments"."post_id" = 1 ORDER BY "comments"."id" ASC LIMIT 1
#
# Please check unscoped if you want to remove all previous scopes (including
# the default_scope) during the execution of a block.

# classMap[].children[].children[].children[].comment
# Updates the attributes of the model from the passed-in hash and saves the
# record, all wrapped in a transaction. If the object is invalid, the saving
# will fail and false will be returned.

# classMap[].children[].children[].children[].comment
##
# :call-seq:
#   save(*args)
#
# Saves the model.
#
# If the model is new, a record gets created in the database, otherwise
# the existing record gets updated.
#
# By default, save always runs validations. If any of them fail the action
# is cancelled and #save returns +false+, and the record won't be saved. However, if you supply
# <tt>validate: false</tt>, validations are bypassed altogether. See
# ActiveRecord::Validations for more information.
#
# By default, #save also sets the +updated_at+/+updated_on+ attributes to
# the current time. However, if you supply <tt>touch: false</tt>, these
# timestamps will not be updated.
#
# There's a series of callbacks associated with #save. If any of the
# <tt>before_*</tt> callbacks throws +:abort+ the action is cancelled and
# #save returns +false+. See ActiveRecord::Callbacks for further
# details.
#
# Attributes marked as readonly are silently ignored if the record is
# being updated.

# classMap[].children[].children[].children[].comment
# Returns +true+ if the record is read only. Records loaded through joins with piggy-back
# attributes will be marked as read only since they cannot be saved.

# classMap[].children[].children[].children[].comment
# Returns +true+ if Active Record is connected.

# classMap[].children[].children[].children[].comment
# Called by +render+ in <tt>AbstractController::Rendering</tt>
# which sets the return value as the +response_body+.
#
# If no renderer is found, +super+ returns control to
# <tt>ActionView::Rendering.render_to_body</tt>, if present.

# classMap[].children[].children[].children[].children[].children[].comment
# @label secret credential.bearer_token

# classMap[].children[].children[].children[].comment
# Given a CanCan::Ability, and a user, determine what permissions sets can
# be activated on the ability, then activate them.
#
# This performs can/cannot declarations on the ability, and can modify its
# internal permissions.
#
# @param ability [CanCan::Ability] the ability to invoke declarations on
# @param user [#spree_roles] the user that holds the spree_roles association.

# classMap[].children[].children[].children[].children[].comment
# Removes previously aliased actions including the defaults.

# classMap[].children[].children[].children[].children[].comment
# Returns a hash of aliased actions. The key is the target and the value is an array of actions aliasing the key.

# classMap[].children[].children[].children[].comment
# Defines which abilities are allowed using two arguments. The first one is the action
# you're setting the permission for, the second one is the class of object you're setting it on.
#
#   can :update, Article
#
# You can pass an array for either of these parameters to match any one.
# Here the user has the ability to update or destroy both articles and comments.
#
#   can [:update, :destroy], [Article, Comment]
#
# You can pass :all to match any object and :manage to match any action. Here are some examples.
#
#   can :manage, :all
#   can :update, :all
#   can :manage, Project
#
# You can pass a hash of conditions as the third argument. Here the user can only see active projects which he owns.
#
#   can :read, Project, :active => true, :user_id => user.id
#
# See ActiveRecordAdditions#accessible_by for how to use this in database queries. These conditions
# are also used for initial attributes when building a record in ControllerAdditions#load_resource.
#
# If the conditions hash does not give you enough control over defining abilities, you can use a block
# along with any Ruby code you want.
#
#   can :update, Project do |project|
#     project.groups.include?(user.group)
#   end
#
# If the block returns true then the user has that :update ability for that project, otherwise he
# will be denied access. The downside to using a block is that it cannot be used to generate
# conditions for database queries.
#
# You can pass custom objects into this "can" method, this is usually done with a symbol
# and is useful if a class isn't available to define permissions on.
#
#   can :read, :stats
#   can? :read, :stats # => true
#
# IMPORTANT: Neither a hash of conditions nor a block will be used when checking permission on a class.
#
#   can :update, Project, :priority => 3
#   can? :update, Project # => true
#
# If you pass no arguments to +can+, the action, class, and object will be passed to the block and the
# block will always be executed. This allows you to override the full behavior if the permissions are
# defined in an external source such as the database.
#
#   can do |action, object_class, object|
#     # check the database and return true/false
#   end
#

# classMap[].children[].children[].children[].children[].comment
# Must be protected as an ability can merge with other abilities.
# This means that an ability must expose their rules with another ability.

# classMap[].children[].children[].children[].comment
# Defines an ability which cannot be done. Accepts the same arguments as "can".
#
#   can :read, :all
#   cannot :read, Comment
#
# A block can be passed just like "can", however if the logic is complex it is recommended
# to use the "can" method.
#
#   cannot :read, Product do |product|
#     product.invisible?
#   end
#

# classMap[].children[].children[].children[].children[].comment
# Returns the associations used in conditions for the :joins option of a search.
# See ModelAdditions#accessible_by

# classMap[].children[].children[].children[].children[].comment
# Returns a scope which fetches only the records that the passed ability
# can perform a given action on. The action defaults to :index. This
# is usually called from a controller and passed the +current_ability+.
#
#   @articles = Article.accessible_by(current_ability)
#
# Here only the articles which the user is able to read will be returned.
# If the user does not have permission to read any articles then an empty
# result is returned. Since this is a scope it can be combined with any
# other scopes or pagination.
#
# An alternative action can optionally be passed as a second argument.
#
#   @articles = Article.accessible_by(current_ability, :update)
#
# Here only the articles which the user can update are returned.

# classMap[].children[].children[].children[].comment
# Normalizes the arguments and passes it on to find_templates.

# classMap[].children[].children[].children[].comment
# Main render entry point shared by Action View and Action Controller.

# metadata.name
Spree::Api::OptionValuesController for a particular option type as an admin permits the correct attributes