# events[].parameters[].value
  [1m[36mSpree::LegacyUser Create (0.1ms)[0m  [1m[32mINSERT INTO "spree_users" ("email", "creat (...173 more characters)

# events[].sql_query.sql
INSERT INTO "spree_users" ("email", "created_at", "updated_at") VALUES (?, ?, ?)

# events[].sql_query.normalized_sql
INSERT INTO "spree_users" ("email", "created_at", "updated_at") VALUES (?, ?, ?)

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

# events[].parameters[].value
  [1m[36mSpree::State Load (0.1ms)[0m  [1m[34mSELECT "spree_states".* FROM "spree_states" INNER (...191 more characters)

# events[].sql_query.sql
SELECT "spree_states".* FROM "spree_states" INNER JOIN "spree_countries" ON "spree_countries"."id" = "spree_states"."country_id" WHERE (spree_countries.iso = ('US')) AND "spree_states"."abbr" = ? LIMIT ?

# events[].sql_query.normalized_sql
SELECT "spree_states".* FROM "spree_states" INNER JOIN "spree_countries" ON "spree_countries"."id" = "spree_states"."country_id" WHERE (spree_countries.iso = ($1)) AND "spree_states"."abbr" = ? LIMIT ?

# events[].parameters[].value
  [1m[36mSpree::Country Load (0.1ms)[0m  [1m[34mSELECT "spree_countries".* FROM "spree_countrie (...80 more characters)

# events[].sql_query.sql
SELECT "spree_countries".* FROM "spree_countries" WHERE "spree_countries"."iso" = ? LIMIT ?

# events[].sql_query.normalized_sql
SELECT "spree_countries".* FROM "spree_countries" WHERE "spree_countries"."iso" = ? LIMIT ?

# events[].parameters[].value
  [1m[36mSpree::Country Create (0.1ms)[0m  [1m[32mINSERT INTO "spree_countries" ("iso_name", "i (...295 more characters)

# events[].sql_query.sql
INSERT INTO "spree_countries" ("iso_name", "iso", "iso3", "name", "numcode", "updated_at", "created_at") VALUES (?, ?, ?, ?, ?, ?, ?)

# events[].sql_query.normalized_sql
INSERT INTO "spree_countries" ("iso_name", "iso", "iso3", "name", "numcode", "updated_at", "created_at") VALUES (?, ?, ?, ?, ?, ?, ?)

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

# events[].parameters[].value
  [1m[36mSpree::State Create (0.1ms)[0m  [1m[32mINSERT INTO "spree_states" ("name", "abbr", "co (...216 more characters)

# events[].sql_query.sql
INSERT INTO "spree_states" ("name", "abbr", "country_id", "updated_at", "created_at") VALUES (?, ?, ?, ?, ?)

# events[].sql_query.normalized_sql
INSERT INTO "spree_states" ("name", "abbr", "country_id", "updated_at", "created_at") VALUES (?, ?, ?, ?, ?)

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

# events[].parameters[].value
  [1m[36mSpree::Address Create (0.2ms)[0m  [1m[32mINSERT INTO "spree_addresses" ("firstname", " (...567 more characters)

# events[].sql_query.sql
INSERT INTO "spree_addresses" ("firstname", "lastname", "address1", "address2", "city", "zipcode", "phone", "alternative_phone", "company", "state_id", "country_id", "created_at", "updated_at") VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)

# events[].sql_query.normalized_sql
INSERT INTO "spree_addresses" ("firstname", "lastname", "address1", "address2", "city", "zipcode", "phone", "alternative_phone", "company", "state_id", "country_id", "created_at", "updated_at") VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)

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

# events[].parameters[].value
  [1m[36mSpree::State Load (0.1ms)[0m  [1m[34mSELECT "spree_states".* FROM "spree_states" INNER (...191 more characters)

# events[].sql_query.sql
SELECT "spree_states".* FROM "spree_states" INNER JOIN "spree_countries" ON "spree_countries"."id" = "spree_states"."country_id" WHERE (spree_countries.iso = ('US')) AND "spree_states"."abbr" = ? LIMIT ?

# events[].sql_query.normalized_sql
SELECT "spree_states".* FROM "spree_states" INNER JOIN "spree_countries" ON "spree_countries"."id" = "spree_states"."country_id" WHERE (spree_countries.iso = ($1)) AND "spree_states"."abbr" = ? LIMIT ?

# events[].parameters[].value
  [1m[36mSpree::Country Load (0.1ms)[0m  [1m[34mSELECT "spree_countries".* FROM "spree_countrie (...75 more characters)

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

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

# events[].parameters[].value
  [1m[36mSpree::Address Create (0.1ms)[0m  [1m[32mINSERT INTO "spree_addresses" ("firstname", " (...572 more characters)

# events[].sql_query.sql
INSERT INTO "spree_addresses" ("firstname", "lastname", "address1", "address2", "city", "zipcode", "phone", "alternative_phone", "company", "state_id", "country_id", "created_at", "updated_at") VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)

# events[].sql_query.normalized_sql
INSERT INTO "spree_addresses" ("firstname", "lastname", "address1", "address2", "city", "zipcode", "phone", "alternative_phone", "company", "state_id", "country_id", "created_at", "updated_at") VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)

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

# events[].parameters[].value
  [1m[36mSpree::Store Exists? (0.1ms)[0m  [1m[34mSELECT 1 AS one FROM "spree_stores" WHERE "spr (...74 more characters)

# events[].sql_query.sql
SELECT 1 AS one FROM "spree_stores" WHERE "spree_stores"."code" = ? LIMIT ?

# events[].sql_query.normalized_sql
SELECT $1 AS one FROM "spree_stores" WHERE "spree_stores"."code" = ? LIMIT ?

# events[].parameters[].value
  [1m[35m (0.1ms)[0m  [1m[34mSELECT COUNT(*) FROM "spree_stores" WHERE "spree_stores"."default" (...27 more characters)

# events[].sql_query.sql
SELECT COUNT(*) FROM "spree_stores" WHERE "spree_stores"."default" = ?

# events[].sql_query.normalized_sql
SELECT COUNT(*) FROM "spree_stores" WHERE "spree_stores"."default" = ?

# events[].return_value.value
[name, url, mail_from_address, code, default, created_at, updated_at]

# events[].parameters[].value
  [1m[36mSpree::Store Create (0.1ms)[0m  [1m[32mINSERT INTO "spree_stores" ("name", "url", "mai (...342 more characters)

# events[].sql_query.sql
INSERT INTO "spree_stores" ("name", "url", "mail_from_address", "code", "default", "created_at", "updated_at") VALUES (?, ?, ?, ?, ?, ?, ?)

# events[].sql_query.normalized_sql
INSERT INTO "spree_stores" ("name", "url", "mail_from_address", "code", "default", "created_at", "updated_at") VALUES (?, ?, ?, ?, ?, ?, ?)

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

# events[].parameters[].value
  [1m[36mSpree::Country Load (0.1ms)[0m  [1m[34mSELECT "spree_countries".* FROM "spree_countrie (...67 more characters)

# events[].sql_query.sql
SELECT "spree_countries".* FROM "spree_countries" ORDER BY "spree_countries"."id" ASC LIMIT ?

# events[].sql_query.normalized_sql
SELECT "spree_countries".* FROM "spree_countries" ORDER BY "spree_countries"."id" ASC LIMIT ?

# events[].parameters[].value
  [1m[36mSpree::State Load (0.1ms)[0m  [1m[34mSELECT "spree_states".* FROM "spree_states" WHERE (...115 more characters)

# events[].sql_query.sql
SELECT "spree_states".* FROM "spree_states" WHERE "spree_states"."country_id" = ? ORDER BY "spree_states"."name" ASC LIMIT ?

# events[].sql_query.normalized_sql
SELECT "spree_states".* FROM "spree_states" WHERE "spree_states"."country_id" = ? ORDER BY "spree_states"."name" ASC LIMIT ?

# events[].parameters[].value
  [1m[36mSpree::StockLocation Load (0.2ms)[0m  [1m[34mSELECT "spree_stock_locations".* FROM "sp (...165 more characters)

# events[].sql_query.sql
SELECT "spree_stock_locations".* FROM "spree_stock_locations" WHERE (1 = 1) AND ("spree_stock_locations"."position" IS NOT NULL) ORDER BY "spree_stock_locations"."position" DESC LIMIT ?

# events[].sql_query.normalized_sql
SELECT "spree_stock_locations".* FROM "spree_stock_locations" WHERE ($1 = $2) AND ("spree_stock_locations"."position" IS NOT NULL) ORDER BY "spree_stock_locations"."position" DESC LIMIT ?

# events[].parameters[].value
  [1m[36mSpree::StockLocation Create (0.1ms)[0m  [1m[32mINSERT INTO "spree_stock_locations" ("n (...502 more characters)

# events[].sql_query.sql
INSERT INTO "spree_stock_locations" ("name", "created_at", "updated_at", "address1", "city", "state_id", "country_id", "zipcode", "phone", "backorderable_default", "position") VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)

# events[].sql_query.normalized_sql
INSERT INTO "spree_stock_locations" ("name", "created_at", "updated_at", "address1", "city", "state_id", "country_id", "zipcode", "phone", "backorderable_default", "position") VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)

# events[].parameters[].value
  [1m[36mSpree::Variant Load (0.1ms)[0m  [1m[34mSELECT "spree_variants".* FROM "spree_variants" (...111 more characters)

# events[].sql_query.sql
SELECT "spree_variants".* FROM "spree_variants" WHERE "spree_variants"."deleted_at" IS NULL ORDER BY "spree_variants"."id" ASC LIMIT ?

# events[].sql_query.normalized_sql
SELECT "spree_variants".* FROM "spree_variants" WHERE "spree_variants"."deleted_at" IS NULL ORDER BY "spree_variants"."id" ASC LIMIT ?

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

# events[].parameters[].value
  [1m[36mSpree::ShippingCategory Load (0.1ms)[0m  [1m[34mSELECT "spree_shipping_categories".* F (...106 more characters)

# events[].parameters[].value
  [1m[36mSpree::ShippingCategory Create (0.1ms)[0m  [1m[32mINSERT INTO "spree_shipping_categori (...192 more characters)

# events[].sql_query.sql
INSERT INTO "spree_shipping_categories" ("name", "created_at", "updated_at") VALUES (?, ?, ?)

# events[].sql_query.normalized_sql
INSERT INTO "spree_shipping_categories" ("name", "created_at", "updated_at") VALUES (?, ?, ?)

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

# events[].parameters[].value
  [1m[36mSpree::TaxCategory Load (0.1ms)[0m  [1m[34mSELECT "spree_tax_categories".* FROM "spree (...136 more characters)

# events[].parameters[].value
  [1m[36mSpree::TaxCategory Exists? (0.1ms)[0m  [1m[34mSELECT 1 AS one FROM "spree_tax_categori (...154 more characters)

# events[].sql_query.sql
SELECT 1 AS one FROM "spree_tax_categories" WHERE "spree_tax_categories"."name" = ? AND "spree_tax_categories"."deleted_at" IS NULL LIMIT ?

# events[].sql_query.normalized_sql
SELECT $1 AS one FROM "spree_tax_categories" WHERE "spree_tax_categories"."name" = ? AND "spree_tax_categories"."deleted_at" IS NULL LIMIT ?

# events[].parameters[].value
  [1m[36mSpree::TaxCategory Create (0.1ms)[0m  [1m[32mINSERT INTO "spree_tax_categories" ("name (...229 more characters)

# events[].sql_query.sql
INSERT INTO "spree_tax_categories" ("name", "created_at", "updated_at", "tax_code") VALUES (?, ?, ?, ?)

# events[].sql_query.normalized_sql
INSERT INTO "spree_tax_categories" ("name", "created_at", "updated_at", "tax_code") VALUES (?, ?, ?, ?)

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

# events[].parameters[].value
  [1m[35m (0.1ms)[0m  [1m[34mSELECT COUNT(*) FROM "spree_stock_locations"[0m

# events[].parameters[].value
  [1m[36mSpree::Product Exists? (0.1ms)[0m  [1m[34mSELECT 1 AS one FROM "spree_products" INNER  (...301 more characters)

# events[].sql_query.sql
SELECT 1 AS one FROM "spree_products" INNER JOIN "friendly_id_slugs" ON "friendly_id_slugs"."sluggable_type" = ? AND "friendly_id_slugs"."sluggable_id" = "spree_products"."id" WHERE "spree_products"."id" IS NOT NULL AND "spree_products"."slug" = ? LIMIT ?

# events[].sql_query.normalized_sql
SELECT $1 AS one FROM "spree_products" INNER JOIN "friendly_id_slugs" ON "friendly_id_slugs"."sluggable_type" = ? AND "friendly_id_slugs"."sluggable_id" = "spree_products"."id" WHERE "spree_products"."id" IS NOT NULL AND "spree_products"."slug" = ? LIMIT ?

# events[].parameters[].value
  [1m[36mSpree::Product Exists? (0.1ms)[0m  [1m[34mSELECT 1 AS one FROM "spree_products" INNER  (...351 more characters)

# events[].sql_query.sql
SELECT 1 AS one FROM "spree_products" INNER JOIN "friendly_id_slugs" ON "friendly_id_slugs"."sluggable_type" = ? AND "friendly_id_slugs"."sluggable_id" = "spree_products"."id" WHERE "spree_products"."id" IS NOT NULL AND "friendly_id_slugs"."sluggable_type" = 'Spree::Product' AND "friendly_id_slugs"."slug" = 'product-1888-9011' LIMIT ?

# events[].sql_query.normalized_sql
SELECT $1 AS one FROM "spree_products" INNER JOIN "friendly_id_slugs" ON "friendly_id_slugs"."sluggable_type" = ? AND "friendly_id_slugs"."sluggable_id" = "spree_products"."id" WHERE "spree_products"."id" IS NOT NULL AND "friendly_id_slugs"."sluggable_type" = $2 AND "friendly_id_slugs"."slug" = $3 LIMIT ?

# events[].parameters[].value
  [1m[36mSpree::TaxRate Exists? (0.1ms)[0m  [1m[34mSELECT 1 AS one FROM "spree_tax_rates" INNER (...339 more characters)

# events[].sql_query.sql
SELECT 1 AS one FROM "spree_tax_rates" INNER JOIN "spree_tax_rate_tax_categories" ON "spree_tax_rates"."id" = "spree_tax_rate_tax_categories"."tax_rate_id" WHERE "spree_tax_rates"."deleted_at" IS NULL AND "spree_tax_rate_tax_categories"."tax_category_id" = ? AND "spree_tax_rates"."included_in_price" = ? LIMIT ?

# events[].parameters[].value
  [1m[36mSpree::Variant Exists? (0.1ms)[0m  [1m[34mSELECT 1 AS one FROM "spree_variants" WHERE  (...118 more characters)

# events[].sql_query.sql
SELECT 1 AS one FROM "spree_variants" WHERE "spree_variants"."sku" = ? AND "spree_variants"."deleted_at" IS NULL LIMIT ?

# events[].sql_query.normalized_sql
SELECT $1 AS one FROM "spree_variants" WHERE "spree_variants"."sku" = ? AND "spree_variants"."deleted_at" IS NULL LIMIT ?

# events[].parameters[].value
  [1m[36mSpree::TaxRate Exists? (0.1ms)[0m  [1m[34mSELECT 1 AS one FROM "spree_tax_rates" INNER (...339 more characters)

# events[].sql_query.sql
SELECT 1 AS one FROM "spree_tax_rates" INNER JOIN "spree_tax_rate_tax_categories" ON "spree_tax_rates"."id" = "spree_tax_rate_tax_categories"."tax_rate_id" WHERE "spree_tax_rates"."deleted_at" IS NULL AND "spree_tax_rate_tax_categories"."tax_category_id" = ? AND "spree_tax_rates"."included_in_price" = ? LIMIT ?

# events[].parameters[].value
  [1m[36mSpree::Variant Exists? (0.1ms)[0m  [1m[34mSELECT 1 AS one FROM "spree_variants" WHERE  (...118 more characters)

# events[].sql_query.sql
SELECT 1 AS one FROM "spree_variants" WHERE "spree_variants"."sku" = ? AND "spree_variants"."deleted_at" IS NULL LIMIT ?

# events[].sql_query.normalized_sql
SELECT $1 AS one FROM "spree_variants" WHERE "spree_variants"."sku" = ? AND "spree_variants"."deleted_at" IS NULL LIMIT ?

# events[].parameters[].value
  [1m[36mSpree::Product Exists? (0.1ms)[0m  [1m[34mSELECT 1 AS one FROM "spree_products" WHERE  (...129 more characters)

# events[].sql_query.sql
SELECT 1 AS one FROM "spree_products" WHERE "spree_products"."slug" = ? AND "spree_products"."deleted_at" IS NULL LIMIT ?

# events[].sql_query.normalized_sql
SELECT $1 AS one FROM "spree_products" WHERE "spree_products"."slug" = ? AND "spree_products"."deleted_at" IS NULL LIMIT ?

# events[].parameters[].value
  [1m[36mSpree::Product Create (0.2ms)[0m  [1m[32mINSERT INTO "spree_products" ("name", "descri (...434 more characters)

# events[].sql_query.sql
INSERT INTO "spree_products" ("name", "description", "available_on", "slug", "tax_category_id", "shipping_category_id", "created_at", "updated_at") VALUES (?, ?, ?, ?, ?, ?, ?, ?)

# events[].sql_query.normalized_sql
INSERT INTO "spree_products" ("name", "description", "available_on", "slug", "tax_category_id", "shipping_category_id", "created_at", "updated_at") VALUES (?, ?, ?, ?, ?, ?, ?, ?)

# events[].parameters[].value
  [1m[36mSpree::Variant Load (0.2ms)[0m  [1m[34mSELECT "spree_variants".* FROM "spree_variants" (...176 more characters)

# events[].sql_query.sql
SELECT "spree_variants".* FROM "spree_variants" WHERE "spree_variants"."product_id" = ? AND ("spree_variants"."position" IS NOT NULL) ORDER BY "spree_variants"."position" DESC LIMIT ?

# events[].sql_query.normalized_sql
SELECT "spree_variants".* FROM "spree_variants" WHERE "spree_variants"."product_id" = ? AND ("spree_variants"."position" IS NOT NULL) ORDER BY "spree_variants"."position" DESC LIMIT ?

# events[].parameters[].value
  [1m[36mSpree::Variant Create (0.2ms)[0m  [1m[32mINSERT INTO "spree_variants" ("sku", "is_mast (...343 more characters)

# events[].sql_query.sql
INSERT INTO "spree_variants" ("sku", "is_master", "product_id", "cost_price", "position", "cost_currency", "updated_at", "created_at") VALUES (?, ?, ?, ?, ?, ?, ?, ?)

# events[].sql_query.normalized_sql
INSERT INTO "spree_variants" ("sku", "is_master", "product_id", "cost_price", "position", "cost_currency", "updated_at", "created_at") VALUES (?, ?, ?, ?, ?, ?, ?, ?)

# events[].parameters[].value
  [1m[36mSpree::Price Create (0.1ms)[0m  [1m[32mINSERT INTO "spree_prices" ("variant_id", "amou (...225 more characters)

# events[].sql_query.sql
INSERT INTO "spree_prices" ("variant_id", "amount", "currency", "created_at", "updated_at") VALUES (?, ?, ?, ?, ?)

# events[].sql_query.normalized_sql
INSERT INTO "spree_prices" ("variant_id", "amount", "currency", "created_at", "updated_at") VALUES (?, ?, ?, ?, ?)

# events[].parameters[].value
  [1m[36mSpree::StockLocation Load (0.1ms)[0m  [1m[34mSELECT "spree_stock_locations".* FROM "sp (...117 more characters)

# events[].parameters[].value
  [1m[36mSpree::StockItem Exists? (0.1ms)[0m  [1m[34mSELECT 1 AS one FROM "spree_stock_items" W (...253 more characters)

# events[].sql_query.sql
SELECT 1 AS one FROM "spree_stock_items" WHERE "spree_stock_items"."variant_id" = ? AND "spree_stock_items"."deleted_at" IS NULL AND "spree_stock_items"."stock_location_id" = ? AND "spree_stock_items"."deleted_at" IS NULL LIMIT ?

# events[].sql_query.normalized_sql
SELECT $1 AS one FROM "spree_stock_items" WHERE "spree_stock_items"."variant_id" = ? AND "spree_stock_items"."deleted_at" IS NULL AND "spree_stock_items"."stock_location_id" = ? AND "spree_stock_items"."deleted_at" IS NULL LIMIT ?

# events[].parameters[].value
  [1m[36mSpree::StockItem Create (0.2ms)[0m  [1m[32mINSERT INTO "spree_stock_items" ("stock_loc (...258 more characters)

# events[].sql_query.sql
INSERT INTO "spree_stock_items" ("stock_location_id", "variant_id", "created_at", "updated_at", "backorderable") VALUES (?, ?, ?, ?, ?)

# events[].sql_query.normalized_sql
INSERT INTO "spree_stock_items" ("stock_location_id", "variant_id", "created_at", "updated_at", "backorderable") VALUES (?, ?, ?, ?, ?)

# events[].parameters[].value
  [1m[36mSpree::Variant Update (0.1ms)[0m  [1m[33mUPDATE "spree_variants" SET "updated_at" = ?  (...95 more characters)

# events[].sql_query.sql
UPDATE "spree_variants" SET "updated_at" = ? WHERE "spree_variants"."id" = ?

# events[].sql_query.normalized_sql
UPDATE "spree_variants" SET "updated_at" = ? WHERE "spree_variants"."id" = ?

# events[].parameters[].value
  [1m[35m (0.1ms)[0m  [1m[34mSELECT MAX("spree_variants"."position") FROM "spree_variants" WHER (...158 more characters)

# events[].sql_query.sql
SELECT MAX("spree_variants"."position") FROM "spree_variants" WHERE "spree_variants"."deleted_at" IS NULL AND "spree_variants"."product_id" = ? AND "spree_variants"."is_master" = ?

# events[].sql_query.normalized_sql
SELECT MAX("spree_variants"."position") FROM "spree_variants" WHERE "spree_variants"."deleted_at" IS NULL AND "spree_variants"."product_id" = ? AND "spree_variants"."is_master" = ?

# events[].parameters[].value
  [1m[36mSpree::Variant Update (0.1ms)[0m  [1m[33mUPDATE "spree_variants" SET "position" = ? WH (...64 more characters)

# events[].sql_query.sql
UPDATE "spree_variants" SET "position" = ? WHERE "spree_variants"."id" = ?

# events[].sql_query.normalized_sql
UPDATE "spree_variants" SET "position" = ? WHERE "spree_variants"."id" = ?

# events[].parameters[].value
  [1m[36mFriendlyId::Slug Load (0.1ms)[0m  [1m[34mSELECT "friendly_id_slugs".* FROM "friendly_i (...225 more characters)

# events[].sql_query.sql
SELECT "friendly_id_slugs".* FROM "friendly_id_slugs" WHERE "friendly_id_slugs"."sluggable_id" = ? AND "friendly_id_slugs"."sluggable_type" = ? ORDER BY "friendly_id_slugs"."id" DESC LIMIT ?

# events[].sql_query.normalized_sql
SELECT "friendly_id_slugs".* FROM "friendly_id_slugs" WHERE "friendly_id_slugs"."sluggable_id" = ? AND "friendly_id_slugs"."sluggable_type" = ? ORDER BY "friendly_id_slugs"."id" DESC LIMIT ?

# events[].parameters[].value
  [1m[36mFriendlyId::Slug Exists? (0.1ms)[0m  [1m[34mSELECT 1 AS one FROM "friendly_id_slugs" W (...242 more characters)

# events[].sql_query.sql
SELECT 1 AS one FROM "friendly_id_slugs" WHERE "friendly_id_slugs"."sluggable_id" = ? AND "friendly_id_slugs"."sluggable_type" = ? AND "friendly_id_slugs"."slug" = ? LIMIT ?

# events[].sql_query.normalized_sql
SELECT $1 AS one FROM "friendly_id_slugs" WHERE "friendly_id_slugs"."sluggable_id" = ? AND "friendly_id_slugs"."sluggable_type" = ? AND "friendly_id_slugs"."slug" = ? LIMIT ?

# events[].parameters[].value
  [1m[36mFriendlyId::Slug Create (0.2ms)[0m  [1m[32mINSERT INTO "friendly_id_slugs" ("slug", "s (...271 more characters)

# events[].sql_query.sql
INSERT INTO "friendly_id_slugs" ("slug", "sluggable_id", "sluggable_type", "created_at", "updated_at") VALUES (?, ?, ?, ?, ?)

# events[].sql_query.normalized_sql
INSERT INTO "friendly_id_slugs" ("slug", "sluggable_id", "sluggable_type", "created_at", "updated_at") VALUES (?, ?, ?, ?, ?)

# events[].parameters[].value
  [1m[36mSpree::Taxon Load (0.1ms)[0m  [1m[34mSELECT "spree_taxons".* FROM "spree_taxons" INNER (...162 more characters)

# events[].parameters[].value
  [1m[36mSpree::Variant Update (0.1ms)[0m  [1m[33mUPDATE "spree_variants" SET "updated_at" = ?  (...95 more characters)

# events[].sql_query.sql
UPDATE "spree_variants" SET "updated_at" = ? WHERE "spree_variants"."id" = ?

# events[].sql_query.normalized_sql
UPDATE "spree_variants" SET "updated_at" = ? WHERE "spree_variants"."id" = ?

# events[].parameters[].value
  [1m[36mSpree::Product Update (0.1ms)[0m  [1m[33mUPDATE "spree_products" SET "updated_at" = ?  (...95 more characters)

# events[].sql_query.sql
UPDATE "spree_products" SET "updated_at" = ? WHERE "spree_products"."id" = ?

# events[].sql_query.normalized_sql
UPDATE "spree_products" SET "updated_at" = ? WHERE "spree_products"."id" = ?

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

# events[].parameters[].value
  [1m[36mSpree::Order Exists? (0.1ms)[0m  [1m[34mSELECT 1 AS one FROM "spree_orders" WHERE "spr (...78 more characters)

# events[].sql_query.sql
SELECT 1 AS one FROM "spree_orders" WHERE "spree_orders"."number" = ? LIMIT ?

# events[].sql_query.normalized_sql
SELECT $1 AS one FROM "spree_orders" WHERE "spree_orders"."number" = ? LIMIT ?

# events[].parameters[].value
  [1m[36mSpree::Order Exists? (0.1ms)[0m  [1m[34mSELECT 1 AS one FROM "spree_orders" WHERE "spr (...78 more characters)

# events[].sql_query.sql
SELECT 1 AS one FROM "spree_orders" WHERE "spree_orders"."number" = ? LIMIT ?

# events[].sql_query.normalized_sql
SELECT $1 AS one FROM "spree_orders" WHERE "spree_orders"."number" = ? LIMIT ?

# events[].parameters[].value
  [1m[36mSpree::Order Exists? (0.1ms)[0m  [1m[34mSELECT 1 AS one FROM "spree_orders" WHERE "spr (...100 more characters)

# events[].sql_query.sql
SELECT 1 AS one FROM "spree_orders" WHERE "spree_orders"."guest_token" = ? LIMIT ?

# events[].sql_query.normalized_sql
SELECT $1 AS one FROM "spree_orders" WHERE "spree_orders"."guest_token" = ? LIMIT ?

# events[].parameters[].value
  [1m[36mSpree::Order Create (0.3ms)[0m  [1m[32mINSERT INTO "spree_orders" ("number", "state",  (...490 more characters)

# events[].sql_query.sql
INSERT INTO "spree_orders" ("number", "state", "user_id", "bill_address_id", "ship_address_id", "email", "created_at", "updated_at", "currency", "guest_token", "store_id") VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)

# events[].sql_query.normalized_sql
INSERT INTO "spree_orders" ("number", "state", "user_id", "bill_address_id", "ship_address_id", "email", "created_at", "updated_at", "currency", "guest_token", "store_id") VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)

# events[].parameters[].value
  [1m[36mSpree::LineItem Create (0.1ms)[0m  [1m[32mINSERT INTO "spree_line_items" ("variant_id" (...342 more characters)

# events[].sql_query.sql
INSERT INTO "spree_line_items" ("variant_id", "order_id", "quantity", "price", "created_at", "updated_at", "cost_price", "tax_category_id") VALUES (?, ?, ?, ?, ?, ?, ?, ?)

# events[].sql_query.normalized_sql
INSERT INTO "spree_line_items" ("variant_id", "order_id", "quantity", "price", "created_at", "updated_at", "cost_price", "tax_category_id") VALUES (?, ?, ?, ?, ?, ?, ?, ?)

# events[].parameters[].value
  [1m[36mSpree::Order Update (0.1ms)[0m  [1m[33mUPDATE "spree_orders" SET "updated_at" = ? WHER (...89 more characters)

# events[].sql_query.sql
UPDATE "spree_orders" SET "updated_at" = ? WHERE "spree_orders"."id" = ?

# events[].sql_query.normalized_sql
UPDATE "spree_orders" SET "updated_at" = ? WHERE "spree_orders"."id" = ?

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

# events[].parameters[].value
  [1m[36mSpree::LineItem Load (0.1ms)[0m  [1m[34mSELECT "spree_line_items".* FROM "spree_line_i (...143 more characters)

# events[].parameters[].value
  [1m[36mSpree::Shipment Exists? (0.1ms)[0m  [1m[34mSELECT 1 AS one FROM "spree_shipments" WHER (...89 more characters)

# events[].sql_query.sql
SELECT 1 AS one FROM "spree_shipments" WHERE "spree_shipments"."number" = ? LIMIT ?

# events[].sql_query.normalized_sql
SELECT $1 AS one FROM "spree_shipments" WHERE "spree_shipments"."number" = ? LIMIT ?

# events[].return_value.value
[tracking, number, cost, order_id, state, created_at, updated_at, stock_location_id]

# events[].parameters[].value
  [1m[36mSpree::Shipment Create (0.2ms)[0m  [1m[32mINSERT INTO "spree_shipments" ("tracking", " (...351 more characters)

# events[].sql_query.sql
INSERT INTO "spree_shipments" ("tracking", "number", "cost", "order_id", "state", "created_at", "updated_at", "stock_location_id") VALUES (?, ?, ?, ?, ?, ?, ?, ?)

# events[].sql_query.normalized_sql
INSERT INTO "spree_shipments" ("tracking", "number", "cost", "order_id", "state", "created_at", "updated_at", "stock_location_id") VALUES (?, ?, ?, ?, ?, ?, ?, ?)

# events[].parameters[].value
  [1m[36mSpree::Order Update (0.1ms)[0m  [1m[33mUPDATE "spree_orders" SET "updated_at" = ? WHER (...89 more characters)

# events[].sql_query.sql
UPDATE "spree_orders" SET "updated_at" = ? WHERE "spree_orders"."id" = ?

# events[].sql_query.normalized_sql
UPDATE "spree_orders" SET "updated_at" = ? WHERE "spree_orders"."id" = ?

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

# events[].parameters[].value
  [1m[36mSpree::Zone Load (0.1ms)[0m  [1m[34mSELECT "spree_zones".* FROM "spree_zones" WHERE "s (...75 more characters)

# events[].sql_query.sql
SELECT "spree_zones".* FROM "spree_zones" WHERE "spree_zones"."name" = ? LIMIT ?

# events[].sql_query.normalized_sql
SELECT "spree_zones".* FROM "spree_zones" WHERE "spree_zones"."name" = ? LIMIT ?

# events[].parameters[].value
  [1m[36mSpree::Zone Load (0.1ms)[0m  [1m[34mSELECT "spree_zones".* FROM "spree_zones" WHERE "s (...75 more characters)

# events[].sql_query.sql
SELECT "spree_zones".* FROM "spree_zones" WHERE "spree_zones"."name" = ? LIMIT ?

# events[].sql_query.normalized_sql
SELECT "spree_zones".* FROM "spree_zones" WHERE "spree_zones"."name" = ? LIMIT ?

# events[].parameters[].value
  [1m[36mSpree::Country Load (0.1ms)[0m  [1m[34mSELECT "spree_countries".* FROM "spree_countrie (...7 more characters)

# events[].parameters[].value
  [1m[36mSpree::Zone Exists? (0.1ms)[0m  [1m[34mSELECT 1 AS one FROM "spree_zones" WHERE "spree (...71 more characters)

# events[].sql_query.sql
SELECT 1 AS one FROM "spree_zones" WHERE "spree_zones"."name" = ? LIMIT ?

# events[].sql_query.normalized_sql
SELECT $1 AS one FROM "spree_zones" WHERE "spree_zones"."name" = ? LIMIT ?

# events[].parameters[].value
  [1m[36mSpree::Zone Create (0.1ms)[0m  [1m[32mINSERT INTO "spree_zones" ("name", "created_at", (...154 more characters)

# events[].sql_query.sql
INSERT INTO "spree_zones" ("name", "created_at", "updated_at") VALUES (?, ?, ?)

# events[].sql_query.normalized_sql
INSERT INTO "spree_zones" ("name", "created_at", "updated_at") VALUES (?, ?, ?)

# events[].parameters[].value
  [1m[36mSpree::ZoneMember Create (0.1ms)[0m  [1m[32mINSERT INTO "spree_zone_members" ("zoneabl (...257 more characters)

# events[].sql_query.sql
INSERT INTO "spree_zone_members" ("zoneable_type", "zoneable_id", "zone_id", "created_at", "updated_at") VALUES (?, ?, ?, ?, ?)

# events[].sql_query.normalized_sql
INSERT INTO "spree_zone_members" ("zoneable_type", "zoneable_id", "zone_id", "created_at", "updated_at") VALUES (?, ?, ?, ?, ?)

# events[].parameters[].value
  [1m[36mSpree::Zone Update All (0.1ms)[0m  [1m[33mUPDATE "spree_zones" SET "zone_members_count (...115 more characters)

# events[].sql_query.sql
UPDATE "spree_zones" SET "zone_members_count" = COALESCE("zone_members_count", 0) + ? WHERE "spree_zones"."id" = ?

# events[].sql_query.normalized_sql
UPDATE "spree_zones" SET "zone_members_count" = COALESCE("zone_members_count", $1) + ? WHERE "spree_zones"."id" = ?

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

# events[].parameters[].value
  [1m[36mSpree::Zone Exists? (0.1ms)[0m  [1m[34mSELECT 1 AS one FROM "spree_zones" WHERE "spree (...110 more characters)

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

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

# events[].parameters[].value
  [1m[36mSpree::ZoneMember Load (0.1ms)[0m  [1m[34mSELECT "spree_zone_members".* FROM "spree_zo (...138 more characters)

# events[].sql_query.sql
SELECT "spree_zone_members".* FROM "spree_zone_members" WHERE "spree_zone_members"."zone_id" = ? AND (zoneable_id IS NULL OR zoneable_type != 'Spree::Country')

# events[].sql_query.normalized_sql
SELECT "spree_zone_members".* FROM "spree_zone_members" WHERE "spree_zone_members"."zone_id" = ? AND (zoneable_id IS NULL OR zoneable_type != $1)

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

# events[].parameters[].value
  [1m[36mSpree::ShippingCategory Load (0.1ms)[0m  [1m[34mSELECT "spree_shipping_categories".* F (...106 more characters)

# events[].parameters[].value
  [1m[36mSpree::Zone Exists? (0.1ms)[0m  [1m[34mSELECT 1 AS one FROM "spree_zones" WHERE "spree (...110 more characters)

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

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

# events[].parameters[].value
  [1m[36mSpree::ShippingMethod Create (0.1ms)[0m  [1m[32mINSERT INTO "spree_shipping_methods" ( (...297 more characters)

# events[].sql_query.sql
INSERT INTO "spree_shipping_methods" ("name", "created_at", "updated_at", "code", "carrier", "service_level") VALUES (?, ?, ?, ?, ?, ?)

# events[].sql_query.normalized_sql
INSERT INTO "spree_shipping_methods" ("name", "created_at", "updated_at", "code", "carrier", "service_level") VALUES (?, ?, ?, ?, ?, ?)

# events[].return_value.value
---
:amount: !ruby/object:BigDecimal 18:0.1e3
:currency: USD

# events[].parameters[].value
---
:amount: !ruby/object:BigDecimal 18:0.1e3
:currency: USD

# events[].return_value.value
---
:amount: !ruby/object:BigDecimal 18:0.1e3
:currency: USD

# events[].parameters[].value
  [1m[36mSpree::Calculator::Shipping::FlatRate Create (0.1ms)[0m  [1m[32mINSERT INTO "spree_cal (...426 more characters)

# events[].sql_query.sql
INSERT INTO "spree_calculators" ("type", "calculable_type", "calculable_id", "created_at", "updated_at", "preferences") VALUES (?, ?, ?, ?, ?, ?)

# events[].sql_query.normalized_sql
INSERT INTO "spree_calculators" ("type", "calculable_type", "calculable_id", "created_at", "updated_at", "preferences") VALUES (?, ?, ?, ?, ?, ?)

# events[].return_value.value
---
:amount: !ruby/object:BigDecimal 18:0.1e3
:currency: USD

# events[].parameters[].value
  [1m[36mSpree::ShippingMethodCategory Create (0.1ms)[0m  [1m[32mINSERT INTO "spree_shipping_me (...266 more characters)

# events[].parameters[].value
  [1m[36mSpree::ShippingMethodZone Create (0.1ms)[0m  [1m[32mINSERT INTO "spree_shipping_method (...231 more characters)

# events[].sql_query.sql
INSERT INTO "spree_shipping_method_zones" ("shipping_method_id", "zone_id", "created_at", "updated_at") VALUES (?, ?, ?, ?)

# events[].sql_query.normalized_sql
INSERT INTO "spree_shipping_method_zones" ("shipping_method_id", "zone_id", "created_at", "updated_at") VALUES (?, ?, ?, ?)

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

# events[].parameters[].value
  [1m[36mSpree::ShippingRate Create (0.1ms)[0m  [1m[32mINSERT INTO "spree_shipping_rates" ("shi (...286 more characters)

# events[].sql_query.sql
INSERT INTO "spree_shipping_rates" ("shipment_id", "shipping_method_id", "selected", "cost", "created_at", "updated_at") VALUES (?, ?, ?, ?, ?, ?)

# events[].sql_query.normalized_sql
INSERT INTO "spree_shipping_rates" ("shipment_id", "shipping_method_id", "selected", "cost", "created_at", "updated_at") VALUES (?, ?, ?, ?, ?, ?)

# events[].parameters[].value
  [1m[36mSpree::Shipment Update (0.1ms)[0m  [1m[33mUPDATE "spree_shipments" SET "updated_at" =  (...98 more characters)

# events[].sql_query.sql
UPDATE "spree_shipments" SET "updated_at" = ? WHERE "spree_shipments"."id" = ?

# events[].sql_query.normalized_sql
UPDATE "spree_shipments" SET "updated_at" = ? WHERE "spree_shipments"."id" = ?

# events[].parameters[].value
  [1m[36mSpree::Order Update (0.1ms)[0m  [1m[33mUPDATE "spree_orders" SET "updated_at" = ? WHER (...89 more characters)

# events[].sql_query.sql
UPDATE "spree_orders" SET "updated_at" = ? WHERE "spree_orders"."id" = ?

# events[].sql_query.normalized_sql
UPDATE "spree_orders" SET "updated_at" = ? WHERE "spree_orders"."id" = ?

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

# events[].parameters[].value
  [1m[36mSpree::LineItem Load (0.1ms)[0m  [1m[34mSELECT "spree_line_items".* FROM "spree_line_i (...79 more characters)

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

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

# events[].parameters[].value
  [1m[36mSpree::Variant Load (0.1ms)[0m  [1m[34mSELECT "spree_variants".* FROM "spree_variants" (...72 more characters)

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

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

# events[].parameters[].value
  [1m[36mSpree::InventoryUnit Create (0.2ms)[0m  [1m[32mINSERT INTO "spree_inventory_units" ("s (...286 more characters)

# events[].sql_query.sql
INSERT INTO "spree_inventory_units" ("state", "variant_id", "shipment_id", "created_at", "updated_at", "line_item_id") VALUES (?, ?, ?, ?, ?, ?)

# events[].sql_query.normalized_sql
INSERT INTO "spree_inventory_units" ("state", "variant_id", "shipment_id", "created_at", "updated_at", "line_item_id") VALUES (?, ?, ?, ?, ?, ?)

# events[].parameters[].value
  [1m[36mSpree::Shipment Update (0.1ms)[0m  [1m[33mUPDATE "spree_shipments" SET "updated_at" =  (...98 more characters)

# events[].sql_query.sql
UPDATE "spree_shipments" SET "updated_at" = ? WHERE "spree_shipments"."id" = ?

# events[].sql_query.normalized_sql
UPDATE "spree_shipments" SET "updated_at" = ? WHERE "spree_shipments"."id" = ?

# events[].parameters[].value
  [1m[36mSpree::Order Update (0.1ms)[0m  [1m[33mUPDATE "spree_orders" SET "updated_at" = ? WHER (...89 more characters)

# events[].sql_query.sql
UPDATE "spree_orders" SET "updated_at" = ? WHERE "spree_orders"."id" = ?

# events[].sql_query.normalized_sql
UPDATE "spree_orders" SET "updated_at" = ? WHERE "spree_orders"."id" = ?

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

# events[].parameters[].value
  [1m[36mSpree::Shipment Load (0.1ms)[0m  [1m[34mSELECT "spree_shipments".* FROM "spree_shipmen (...66 more characters)

# events[].parameters[].value
  [1m[36mSpree::ShippingRate Load (0.1ms)[0m  [1m[34mSELECT "spree_shipping_rates".* FROM "spre (...134 more characters)

# events[].parameters[].value
  [1m[36mSpree::Payment Load (0.1ms)[0m  [1m[34mSELECT "spree_payments".* FROM "spree_payments" (...162 more characters)

# events[].sql_query.sql
SELECT "spree_payments".* FROM "spree_payments" WHERE "spree_payments"."order_id" = ? AND "spree_payments"."state" = ? ORDER BY "spree_payments"."created_at" ASC

# events[].sql_query.normalized_sql
SELECT "spree_payments".* FROM "spree_payments" WHERE "spree_payments"."order_id" = ? AND "spree_payments"."state" = ? ORDER BY "spree_payments"."created_at" ASC

# events[].parameters[].value
  [1m[36mSpree::Adjustment Load (0.1ms)[0m  [1m[34mSELECT "spree_adjustments".* FROM "spree_adj (...170 more characters)

# events[].parameters[].value
  [1m[36mSpree::Adjustment Load (0.1ms)[0m  [1m[34mSELECT "spree_adjustments".* FROM "spree_adj (...170 more characters)

# events[].parameters[].value
  [1m[36mSpree::Adjustment Load (0.1ms)[0m  [1m[34mSELECT "spree_adjustments".* FROM "spree_adj (...213 more characters)

# events[].parameters[].value
  [1m[36mSpree::TaxRate Load (0.2ms)[0m  [1m[34mSELECT DISTINCT "spree_tax_rates".* FROM "spree (...436 more characters)

# events[].sql_query.normalized_sql
SELECT DISTINCT "spree_tax_rates".* FROM "spree_tax_rates" INNER JOIN "spree_zones" ON "spree_zones"."id" = "spree_tax_rates"."zone_id" INNER JOIN "spree_zone_members" ON "spree_zone_members"."zone_id" = "spree_zones"."id" WHERE "spree_tax_rates"."deleted_at" IS NULL AND ("spree_zone_members"."zoneable_type" = $1 AND "spree_zone_members"."zoneable_id" IN ($2) OR "spree_zone_members"."zoneable_type" = $3 AND "spree_zone_members"."zoneable_id" IN ($4))

# events[].parameters[].value
  [1m[36mSpree::Order Exists? (0.1ms)[0m  [1m[34mSELECT 1 AS one FROM "spree_orders" WHERE "spr (...118 more characters)

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

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

# events[].parameters[].value
  [1m[36mSpree::Order Update (0.1ms)[0m  [1m[33mUPDATE "spree_orders" SET "item_total" = ?, "to (...246 more characters)

# events[].sql_query.sql
UPDATE "spree_orders" SET "item_total" = ?, "total" = ?, "updated_at" = ?, "shipment_total" = ?, "item_count" = ? WHERE "spree_orders"."id" = ?

# events[].sql_query.normalized_sql
UPDATE "spree_orders" SET "item_total" = ?, "total" = ?, "updated_at" = ?, "shipment_total" = ?, "item_count" = ? WHERE "spree_orders"."id" = ?

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

# events[].parameters[].value
  [1m[36mSpree::Order Exists? (0.1ms)[0m  [1m[34mSELECT 1 AS one FROM "spree_orders" WHERE "spr (...118 more characters)

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

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

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

# events[].parameters[].value
  [1m[36mSpree::Taxon Load (0.1ms)[0m  [1m[34mSELECT "spree_taxons".* FROM "spree_taxons" INNER (...194 more characters)

# events[].parameters[].value
  [1m[35m (0.1ms)[0m  [1m[34mSELECT "spree_taxons"."id" FROM "spree_taxons" WHERE "spree_taxons (...59 more characters)

# events[].sql_query.sql
SELECT "spree_taxons"."id" FROM "spree_taxons" WHERE "spree_taxons"."lft" >= 3 AND "spree_taxons"."lft" < 4 ORDER BY lft

# events[].sql_query.normalized_sql
SELECT "spree_taxons"."id" FROM "spree_taxons" WHERE "spree_taxons"."lft" >= $1 AND "spree_taxons"."lft" < $2 ORDER BY lft

# events[].parameters[].value
  [1m[36mSpree::Taxon Exists? (0.2ms)[0m  [1m[34mSELECT 1 AS one FROM "spree_taxons" INNER JOIN (...559 more characters)

# events[].sql_query.sql
SELECT 1 AS one FROM "spree_taxons" INNER JOIN "spree_products_taxons" ON "spree_products_taxons"."taxon_id" = "spree_taxons"."id" INNER JOIN "spree_products" ON "spree_products"."deleted_at" IS NULL AND "spree_products"."id" = "spree_products_taxons"."product_id" INNER JOIN "spree_variants" ON "spree_variants"."deleted_at" IS NULL AND "spree_variants"."product_id" = "spree_products"."id" INNER JOIN "spree_line_items" ON "spree_line_items"."variant_id" = "spree_variants"."id" WHERE "spree_line_items"."order_id" = ? AND "spree_taxons"."id" = ? LIMIT ?

# events[].sql_query.normalized_sql
SELECT $1 AS one FROM "spree_taxons" INNER JOIN "spree_products_taxons" ON "spree_products_taxons"."taxon_id" = "spree_taxons"."id" INNER JOIN "spree_products" ON "spree_products"."deleted_at" IS NULL AND "spree_products"."id" = "spree_products_taxons"."product_id" INNER JOIN "spree_variants" ON "spree_variants"."deleted_at" IS NULL AND "spree_variants"."product_id" = "spree_products"."id" INNER JOIN "spree_line_items" ON "spree_line_items"."variant_id" = "spree_variants"."id" WHERE "spree_line_items"."order_id" = ? AND "spree_taxons"."id" = ? LIMIT ?

# classMap[].children[].children[].children[].children[].comment
# Determines if one of the attributes passed in is the inheritance column,
# and if the inheritance column is attr accessible, it initializes an
# instance of the given subclass instead of the base class.

# 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
# ActiveRecord::RecordInvalid gets raised, 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! raises ActiveRecord::RecordNotSaved. See
# ActiveRecord::Callbacks for further details.
#
# Attributes marked as readonly are silently ignored if the record is
# being updated.
#
# Unless an error is raised, returns true.

# classMap[].children[].children[].children[].comment
# Returns true if this object hasn't been saved yet -- that is, a record
# for the object doesn't exist in the database yet; otherwise, returns false.

# classMap[].children[].children[].children[].comment
# Returns true if the record is persisted, i.e. it's not a new record and it was
# not destroyed, otherwise returns false.

# classMap[].children[].children[].children[].comment
# Saves the record with the updated_at/on attributes set to the current time
# or the time specified.
# Please note that no validation is performed and only the +after_touch+,
# +after_commit+ and +after_rollback+ callbacks are executed.
#
# This method can be passed attribute names and an optional time argument.
# If attribute names are passed, they are updated along with updated_at/on
# attributes. If no time argument is passed, the current time is used as default.
#
#   product.touch                         # updates updated_at/on with current time
#   product.touch(time: Time.new(2015, 2, 16, 0, 0, 0)) # updates updated_at/on with specified time
#   product.touch(:designed_at)           # updates the designed_at attribute and updated_at/on
#   product.touch(:started_at, :ended_at) # updates started_at, ended_at and updated_at/on attributes
#
# If used along with {belongs_to}[rdoc-ref:Associations::ClassMethods#belongs_to]
# then +touch+ will invoke +touch+ method on associated object.
#
#   class Brake < ActiveRecord::Base
#     belongs_to :car, touch: true
#   end
#
#   class Car < ActiveRecord::Base
#     belongs_to :corporation, touch: true
#   end
#
#   # triggers @brake.car.touch and @brake.car.corporation.touch
#   @brake.touch
#
# Note that +touch+ must be used on a persisted object, or else an
# ActiveRecordError will be thrown. For example:
#
#   ball = Ball.new
#   ball.touch(:updated_at)   # => raises ActiveRecordError
#

# 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[].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 the last call to +save+ have any changes to change?

# classMap[].children[].children[].children[].children[].comment
# Returns a hash containing all the changes that will be persisted during
# the next save.

# classMap[].children[].children[].children[].children[].comment
# Updates the attribute identified by <tt>attr_name</tt> with the
# specified +value+. Empty strings for Integer and Float columns are
# turned into +nil+.

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

# 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 the value of the attribute identified by <tt>attr_name</tt> after
# it has been typecast (for example, "2004-12-12" in a date column is cast
# to a date object, like Date.new(2004, 12, 12)).

# classMap[].children[].children[].children[].comment
# Updates the attribute identified by <tt>attr_name</tt> with the specified +value+.
# (Alias for the protected #write_attribute method).
#
#   class Person < ActiveRecord::Base
#   end
#
#   person = Person.new
#   person[:age] = '22'
#   person[:age] # => 22
#   person[:age].class # => Integer

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

# classMap[].children[].children[].children[].comment
# Returns +true+ if the given attribute is in the attributes hash, otherwise +false+.
#
#   class Person < ActiveRecord::Base
#   end
#
#   person = Person.new
#   person.has_attribute?(:name)    # => true
#   person.has_attribute?('age')    # => true
#   person.has_attribute?(:nothing) # => false

# classMap[].children[].children[].children[].children[].comment
# Cast a +value+ to a type that the database understands. For example,
# SQLite does not understand dates, so this method will convert a Date
# to a String.

# 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
# Returns the association instance for the given name, instantiating it if it doesn't already exist

# classMap[].children[].children[].children[].children[].comment
# Has the \target been already \loaded?

# classMap[].children[].children[].children[].children[].comment
# Returns the class for the macro.
#
# <tt>composed_of :balance, class_name: 'Money'</tt> returns the Money class
# <tt>has_many :clients</tt> returns the Client class
#
#   class Company < ActiveRecord::Base
#     has_many :clients
#   end
#
#   Company.reflect_on_association(:clients).klass
#   # => Client
#
# <b>Note:</b> Do not call +klass.new+ or +klass.create+ to instantiate
# a new association object. Use +build_association+ or +create_association+
# instead. This allows plugins to hook into association object creation.

# classMap[].children[].children[].children[].children[].comment
# Returns whether or not the association should be validated as part of
# the parent's validation.
#
# Unless you explicitly disable validation with
# <tt>validate: false</tt>, validation will take place when:
#
# * you explicitly enable validation; <tt>validate: true</tt>
# * you use autosave; <tt>autosave: true</tt>
# * the association is a +has_many+ association

# classMap[].children[].children[].children[].comment
# Returns a new relation, which is the result of filtering the current relation
# according to the conditions in the arguments.
#
# #where accepts conditions in one of several formats. In the examples below, the resulting
# SQL is given as an illustration; the actual query generated may be different depending
# on the database adapter.
#
# === string
#
# A single string, without additional arguments, is passed to the query
# constructor as an SQL fragment, and used in the where clause of the query.
#
#    Client.where("orders_count = '2'")
#    # SELECT * from clients where orders_count = '2';
#
# Note that building your own string from user input may expose your application
# to injection attacks if not done properly. As an alternative, it is recommended
# to use one of the following methods.
#
# === array
#
# If an array is passed, then the first element of the array is treated as a template, and
# the remaining elements are inserted into the template to generate the condition.
# Active Record takes care of building the query to avoid injection attacks, and will
# convert from the ruby type to the database type where needed. Elements are inserted
# into the string in the order in which they appear.
#
#   User.where(["name = ? and email = ?", "Joe", "joe@example.com"])
#   # SELECT * FROM users WHERE name = 'Joe' AND email = 'joe@example.com';
#
# Alternatively, you can use named placeholders in the template, and pass a hash as the
# second element of the array. The names in the template are replaced with the corresponding
# values from the hash.
#
#   User.where(["name = :name and email = :email", { name: "Joe", email: "joe@example.com" }])
#   # SELECT * FROM users WHERE name = 'Joe' AND email = 'joe@example.com';
#
# This can make for more readable code in complex queries.
#
# Lastly, you can use sprintf-style % escapes in the template. This works slightly differently
# than the previous methods; you are responsible for ensuring that the values in the template
# are properly quoted. The values are passed to the connector for quoting, but the caller
# is responsible for ensuring they are enclosed in quotes in the resulting SQL. After quoting,
# the values are inserted using the same escapes as the Ruby core method +Kernel::sprintf+.
#
#   User.where(["name = '%s' and email = '%s'", "Joe", "joe@example.com"])
#   # SELECT * FROM users WHERE name = 'Joe' AND email = 'joe@example.com';
#
# If #where is called with multiple arguments, these are treated as if they were passed as
# the elements of a single array.
#
#   User.where("name = :name and email = :email", { name: "Joe", email: "joe@example.com" })
#   # SELECT * FROM users WHERE name = 'Joe' AND email = 'joe@example.com';
#
# When using strings to specify conditions, you can use any operator available from
# the database. While this provides the most flexibility, you can also unintentionally introduce
# dependencies on the underlying database. If your code is intended for general consumption,
# test with multiple database backends.
#
# === hash
#
# #where will also accept a hash condition, in which the keys are fields and the values
# are values to be searched for.
#
# Fields can be symbols or strings. Values can be single values, arrays, or ranges.
#
#    User.where({ name: "Joe", email: "joe@example.com" })
#    # SELECT * FROM users WHERE name = 'Joe' AND email = 'joe@example.com'
#
#    User.where({ name: ["Alice", "Bob"]})
#    # SELECT * FROM users WHERE name IN ('Alice', 'Bob')
#
#    User.where({ created_at: (Time.now.midnight - 1.day)..Time.now.midnight })
#    # SELECT * FROM users WHERE (created_at BETWEEN '2012-06-09 07:00:00.000000' AND '2012-06-10 07:00:00.000000')
#
# In the case of a belongs_to relationship, an association key can be used
# to specify the model if an ActiveRecord object is used as the value.
#
#    author = Author.find(1)
#
#    # The following queries will be equivalent:
#    Post.where(author: author)
#    Post.where(author_id: author)
#
# This also works with polymorphic belongs_to relationships:
#
#    treasure = Treasure.create(name: 'gold coins')
#    treasure.price_estimates << PriceEstimate.create(price: 125)
#
#    # The following queries will be equivalent:
#    PriceEstimate.where(estimate_of: treasure)
#    PriceEstimate.where(estimate_of_type: 'Treasure', estimate_of_id: treasure)
#
# === Joins
#
# If the relation is the result of a join, you may create a condition which uses any of the
# tables in the join. For string and array conditions, use the table name in the condition.
#
#    User.joins(:posts).where("posts.created_at < ?", Time.now)
#
# For hash conditions, you can either use the table name in the key, or use a sub-hash.
#
#    User.joins(:posts).where({ "posts.published" => true })
#    User.joins(:posts).where({ posts: { published: true } })
#
# === no argument
#
# If no argument is passed, #where returns a new instance of WhereChain, that
# can be chained with #not to return a new relation that negates the where clause.
#
#    User.where.not(name: "Jon")
#    # SELECT * FROM users WHERE name != 'Jon'
#
# See WhereChain for more details on #not.
#
# === blank condition
#
# If the condition is any blank-ish object, then #where is a no-op and returns
# the current relation.

# classMap[].children[].children[].children[].children[].comment
# @todo Remove this from the public API if possible.
# @return [true] whether or not the address requires a zipcode to be valid

# classMap[].children[].children[].children[].children[].comment
# @todo Remove this from the public API if possible.
# @return [true] whether or not the address requires a phone number to be
#   valid

# classMap[].children[].children[].children[].children[].comment
# @return [String] the full name on this address

# classMap[].children[].children[].children[].children[].comment
# This is set in order to preserve immutability of Addresses. Use #dup to create
# new records as required, but it probably won't be required as often as you think.
# Since addresses do not change, you won't accidentally alter historical data.

# classMap[].children[].children[].children[].children[].comment
# @return [Spree::TaxCategory] tax category for this product, or the default tax category

# classMap[].children[].children[].children[].children[].comment
# Sets this price's amount to a new value, parsing it if the new value is
# a string.
#
# @param price [String, #to_d] a new amount

# classMap[].children[].children[].children[].children[].comment
# Sets the cost_price for the variant.
#
# @param price [Any] the price to set
# @return [Bignum]

# classMap[].children[].children[].children[].children[].comment
# @return [Spree::TaxCategory] the variant's tax category
#
# This returns the product's tax category if the tax category ID on the variant is nil. It looks
# like an association, but really is an override.
#

# classMap[].children[].children[].children[].children[].comment
# Wrapper for creating a new stock item respecting the backorderable config

# classMap[].children[].children[].children[].children[].comment
# Is this a free order in which case the payment step should be skipped

# classMap[].children[].children[].children[].children[].comment
# Returns the address for taxation based on configuration

# classMap[].children[].children[].children[].children[].comment
# Only verify inventory for completed orders (as orders in frontend checkout
# have inventory assigned via +order.create_proposed_shipment+) or when
# shipment is explicitly passed
#
# In case shipment is passed the stock location should only unstock or
# restock items if the order is completed. That is so because stock items
# are always unstocked when the order is completed through +shipment.finalize+

# classMap[].children[].children[].children[].children[].comment
# This is a multi-purpose method for processing logic related to changes in the Order.
# It is meant to be called from various observers so that the Order is aware of changes
# that affect totals and other values stored in the Order.
#
# This method should never do anything to the Order that results in a save call on the
# object with callbacks (otherwise you will end up in an infinite recursion as the
# associations try to save and then in turn try to call +update!+ again.)

# classMap[].children[].children[].children[].children[].comment
# @return [BigDecimal] the amount of this line item, which is the line
#   item's price multiplied by its quantity.

# classMap[].children[].children[].children[].children[].comment
# Picks the best promotion from this set of adjustments, all others are
# marked as ineligible.
#
# @return [BigDecimal] The amount of the best adjustment

# classMap[].children[].children[].children[].children[].comment
# Apply taxes to the order.
#
# This method will create or update adjustments on all line items and
# shipments in the order to reflect the appropriate taxes passed in. It
# will also remove any now inapplicable tax adjustments.
#
# @param [Spree::Tax::OrderTax] taxes the taxes to apply to the order
# @return [void]

# classMap[].children[].children[].children[].children[].children[].children[].comment
# The pricing options represent "given circumstances" for a price: The currency
# we need and the country that the price applies to.
# Every price selector is designed to work with a particular set of pricing options
# embodied in it's pricing options class.
#

# classMap[].children[].children[].children[].children[].children[].children[].comment
# When editing variants in the admin, this is the standard price the admin interacts with:
# The price in the admin's globally configured currency, for the admin's globally configured
# country. These options get merged with any options the user provides when instantiating
# new pricing options.
# @see Spree::Config.default_pricing_options
# @see #initialize
# @return [Hash] The attributes that admin prices usually have
#

# classMap[].children[].children[].children[].children[].children[].children[].comment
# Creates tax adjustments for all taxable items (shipments and line items)
# in the given order.

# classMap[].children[].children[].children[].children[].children[].children[].comment
# Calculate taxes for an order.
#
# @return [Spree::Tax::OrderTax] the calculated taxes for the order

# classMap[].children[].children[].children[].comment
# Find a region by code.
#
# code - The String code to search for
#
# Returns a region with the supplied code, or nil if none is found.

# classMap[].children[].children[].children[].children[].children[].comment
# Get a preference
# @param name [#to_sym] name of preference
# @return [Object] The value of preference +name+
# @label provider.preferences

# classMap[].children[].children[].children[].children[].children[].comment
# Raises an exception if the +name+ preference is not defined on this class
# @param name [#to_sym] name of preference

# classMap[].children[].children[].children[].children[].children[].comment
# @param name [#to_sym] name of preference
# @return [Boolean] if preference exists on this class

# classMap[].children[].children[].children[].children[].children[].comment
# @return [Array<Symbol>] All preferences defined on this class

# classMap[].children[].children[].children[].children[].children[].comment
# @return [Hash{Symbol => Object}] Default for all preferences defined on this class

# classMap[].children[].children[].children[].children[].children[].comment
# @param name [#to_sym] name of preference
# @return [Object] The default for preference +name+

# classMap[].children[].children[].children[].children[].comment
# cache_key will be nil for new objects, then if we check if there
# is a pending preference before going to default

# classMap[].children[].children[].children[].children[].comment
# cache_key will be nil for new objects, then if we check if there
# is a pending preference before going to default

# classMap[].children[].children[].children[].children[].comment
# cache_key will be nil for new objects, then if we check if there
# is a pending preference before going to default

# classMap[].children[].children[].children[].children[].comment
# cache_key will be nil for new objects, then if we check if there
# is a pending preference before going to default

# classMap[].children[].children[].children[].children[].comment
# cache_key will be nil for new objects, then if we check if there
# is a pending preference before going to default

# classMap[].children[].children[].children[].children[].comment
# cache_key will be nil for new objects, then if we check if there
# is a pending preference before going to default

# classMap[].children[].children[].children[].children[].comment
# cache_key will be nil for new objects, then if we check if there
# is a pending preference before going to default

# classMap[].children[].children[].children[].children[].comment
# cache_key will be nil for new objects, then if we check if there
# is a pending preference before going to default

# classMap[].children[].children[].children[].children[].children[].children[].comment
# cache_key will be nil for new objects, then if we check if there
# is a pending preference before going to default

# classMap[].children[].children[].children[].comment
# Shortcut for the default pricing options
# @return [variant_price_selector_class] An instance of the pricing options class with default desired
#   attributes

# classMap[].children[].children[].children[].comment
# Shortcut for getting the variant price selector's pricing options class
#
# @return [Class] The pricing options class to be used

# classMap[].children[].children[].children[].comment
# Given a string, strips all non-price-like characters from it,
# taking into account locale settings. Returns the input given anything
# else.
#
# @param number [String, anything] the number to be parsed or anything else
# @return [BigDecimal, anything] the number parsed from the string passed
#   in, or whatever you passed in

# classMap[].children[].children[].children[].comment
# Allows to trigger events that can be subscribed using #subscribe. An
# optional block can be passed that will be executed immediately. The
# actual code implementation is delegated to the adapter.
#
# @param [String] event_name the name of the event. The suffix ".spree"
#  will be added automatically if not present
# @param [Hash] opts a list of options to be passed to the triggered event
#
# @example Trigger an event named 'order_finalized'
#   Spree::Event.fire 'order_finalized', order: @order do
#     @order.finalize!
#   end

# classMap[].children[].children[].children[].comment
# The adapter used by Spree::Event, defaults to
# Spree::Event::Adapters::ActiveSupportNotifications
#
# @example Change the adapter
#   Spree::Config.events.adapter = "Spree::EventBus.new"
#
# @see Spree::AppConfiguration

# classMap[].children[].children[].children[].children[].children[].children[].children[].comment
# Normalizes the event name according to this specific adapter rules.
#  When the event name is a string or a symbol, if the suffix is missing, then
#  it is added automatically.
#  When the event name is a regexp, due to the huge variability of regexps, adding
#  or not the suffix is developer's responsibility (if you don't, you will subscribe
#  to all internal rails events as well).
#  When the event type is not supported, an error is raised.
#
# @param [String, Symbol, Regexp] event_name the event name, with or without the
#  suffix (Spree::Config.events.suffix defaults to `.spree`).

# classMap[].children[].children[].children[].children[].children[].children[].children[].comment
# The suffix used for namespacing event names, defaults to
# `.spree`
#
# @see Spree::Event::Configuration#suffix

# classMap[].children[].children[].comment
###
# call-seq:
#   Psych.dump(o)               -> string of yaml
#   Psych.dump(o, options)      -> string of yaml
#   Psych.dump(o, io)           -> io object passed in
#   Psych.dump(o, io, options)  -> io object passed in
#
# Dump Ruby object +o+ to a YAML string.  Optional +options+ may be passed in
# to control the output format.  If an IO object is passed in, the YAML will
# be dumped to that IO object.
#
# Currently supported options are:
#
# [<tt>:indentation</tt>]   Number of space characters used to indent.
#                           Acceptable value should be in <tt>0..9</tt> range,
#                           otherwise option is ignored.
#
#                           Default: <tt>2</tt>.
# [<tt>:line_width</tt>]    Max character to wrap line at.
#
#                           Default: <tt>0</tt> (meaning "wrap at 81").
# [<tt>:canonical</tt>]     Write "canonical" YAML form (very verbose, yet
#                           strictly formal).
#
#                           Default: <tt>false</tt>.
# [<tt>:header</tt>]        Write <tt>%YAML [version]</tt> at the beginning of document.
#
#                           Default: <tt>false</tt>.
#
# Example:
#
#   # Dump an array, get back a YAML string
#   Psych.dump(['a', 'b'])  # => "---\n- a\n- b\n"
#
#   # Dump an array to an IO object
#   Psych.dump(['a', 'b'], StringIO.new)  # => #<StringIO:0x000001009d0890>
#
#   # Dump an array with indentation set
#   Psych.dump(['a', ['b']], indentation: 3) # => "---\n- a\n-  - b\n"
#
#   # Dump an array to an IO with indentation set
#   Psych.dump(['a', ['b']], StringIO.new, indentation: 3)

# classMap[].children[].children[].comment
###
# Load +yaml+ in to a Ruby data structure.  If multiple documents are
# provided, the object contained in the first document will be returned.
# +filename+ will be used in the exception message if any exception
# is raised while parsing.  If +yaml+ is empty, it returns
# the specified +fallback+ return value, which defaults to +false+.
#
# Raises a Psych::SyntaxError when a YAML syntax error is detected.
#
# Example:
#
#   Psych.load("--- a")             # => 'a'
#   Psych.load("---\n - a\n - b")   # => ['a', 'b']
#
#   begin
#     Psych.load("--- `", filename: "file.txt")
#   rescue Psych::SyntaxError => ex
#     ex.file    # => 'file.txt'
#     ex.message # => "(file.txt): found character that cannot start any token"
#   end
#
# When the optional +symbolize_names+ keyword argument is set to a
# true value, returns symbols for keys in Hash objects (default: strings).
#
#   Psych.load("---\n foo: bar")                         # => {"foo"=>"bar"}
#   Psych.load("---\n foo: bar", symbolize_names: true)  # => {:foo=>"bar"}
#
# Raises a TypeError when `yaml` parameter is NilClass
#

# classMap[].children[].children[].comment
###
# Parse a YAML string in +yaml+.  Returns the Psych::Nodes::Document.
# +filename+ is used in the exception message if a Psych::SyntaxError is
# raised.
#
# Raises a Psych::SyntaxError when a YAML syntax error is detected.
#
# Example:
#
#   Psych.parse("---\n - a\n - b") # => #<Psych::Nodes::Document:0x00>
#
#   begin
#     Psych.parse("--- `", filename: "file.txt")
#   rescue Psych::SyntaxError => ex
#     ex.file    # => 'file.txt'
#     ex.message # => "(file.txt): found character that cannot start any token"
#   end
#
# See Psych::Nodes for more information about YAML AST.

# classMap[].children[].children[].comment
###
# Parse a YAML string in +yaml+.  Returns the Psych::Nodes::Stream.
# This method can handle multiple YAML documents contained in +yaml+.
# +filename+ is used in the exception message if a Psych::SyntaxError is
# raised.
#
# If a block is given, a Psych::Nodes::Document node will be yielded to the
# block as it's being parsed.
#
# Raises a Psych::SyntaxError when a YAML syntax error is detected.
#
# Example:
#
#   Psych.parse_stream("---\n - a\n - b") # => #<Psych::Nodes::Stream:0x00>
#
#   Psych.parse_stream("--- a\n--- b") do |node|
#     node # => #<Psych::Nodes::Document:0x00>
#   end
#
#   begin
#     Psych.parse_stream("--- `", filename: "file.txt")
#   rescue Psych::SyntaxError => ex
#     ex.file    # => 'file.txt'
#     ex.message # => "(file.txt): found character that cannot start any token"
#   end
#
# Raises a TypeError when NilClass is passed.
#
# See Psych::Nodes for more information about YAML AST.

# metadata.name
Spree::Promotion::Rules::Taxon #eligible?(order) with any match policy when order does not have any prefered taxon sets an error code