ng config cli.packageManager cnpm 
# regular expression.
\pattern\ 
%r{pattern} 

# blocks.
animals = %w( ant bee cat dog elk )
animals.each{|animal| puts animal}

3.times{print "hello"}

# & capture a passed block as a named parameter.
def wrap &b
  3.times(&b)
end
wrap{print "hello"}

# Exceptions.
begin
  content = load_blog_data(file_name)
rescue BlogDataNotFound
  STDERR.puts "File #{file_name} not found"
end

# Idioms.
count ||= 0 # gives count the value 0 if count is nil or false.
creat! # ! means change.

#### console ###

# after a new migration (rake db:migrate).
reload! 

# not show sql sequence.
ActiveRecord::Base.logger= nil 

# save to DB.
rake db:seed 

# database console.
rails dbconsole 

# unit test.
rails test:models

# system test.
rails test:system

# turn on cache
rails dev:cache

# clear logs of test
rails log:clear LOGS=test

# webpacker rerun
rails webpacker:compile

# emails
rails generate mailer Order received shipped

# active job
rails generate job charge_order

# reset id
ActiveRecord::Base.connection.reset_pk_sequence!('table_name')

### code ###

# in config/environments/development.rb add this to allow access in deployment
config.action_cable.disable_request_forgery_protection = true

# donot put passwd into log
config.filter_parameters += [ :credit_card_number ]

# config lib
config.autoload_paths += %W(#{Rails.root}/lib)

# return a list of all the files in cwd
@files = Dir.glob('*') 

# build new line item relationship between the @cart object and the product.
@cart.line_items.build(product: product)

# display error message
puts @product.errors.full_messages

# add log.
logger.error "Attempt to access invalid cart #{params[:id]}"

# display the first n characters.
truncate() 

# remove the HTML tags.
trip_tags() 

# display HTML style.
sanitize()

# case generates the order or orders string
pluralize()

# button link
button_to

# generates an HTML <img> tag using its argument as the image source.
image_tag()

# generates a <link> tag, speed up page changes within an application.
stylesheet_link_tag()

# generates a <script> to load scripts.
javascript_pack_tag()

# sets up all the behind-the-scenes data needed to prevent cross-site request forgery attacks.
csrf_meta_tags()

# redirect
line_items_path(:product_id)

# skip before action
skip_before_action()

# format number
number_to_currency()

# confirm dialog.
data: { confirm: 'Are you sure?' } 

# validations.
validates :title, uniqueness: true
validates :title, :description, :image_url, presence: true
validates :price, numericality: { greater_than_or_equal_to: 0.01 }
validates :image_url, allow_blank: true, format: 
				{ with: %r{\.(gif|jpg|png)\z}i,
					message: 'must be a URL for GIF, JPG or PNG image.'
				}

# change root, store_index: tells Rails to create 
# store_index_path and store_index_url accessor methods.
root 'store#index', as: 'store_index' 

# cache
# <% cache @product do %>
#something
#<% end %>
  
# before action
before_action :set_cart, only: [:create]

# before destroy.
before destroy :some_thing

# converts Ruby string into a format acceptable as input to JavaScript.
j()

# broadcast by ActionCable
ActionCable.server.broadcast 'products',
html: render_to_string('store/index', layout: false)

### routing ###

# routing concerns.
concern :reviewable do 
  resources :reviews
end
resources :products, concern: :reviewable 
resources :users, concern: :reviewable

# shallow route nesting.
resources :products, shallow: true do 
  resources :reviews
end

# redirect.
redirect_to action: "display"
redirect_to("/help/order_entry.html")
redirect_to(:back)

# session
# if store model objects in a session, must add model declarations for them.

# flash
flash.now
flash.keep

### unit test ###

rails test:models

assert
assert_equal
assert_match
assert_select
assert_response
assert_difference
assert_redirected_to
assert_no_selector
assert_selector

errors()
invalid?()
any?()

assert product.invalid?
assert product.errors[:title].any?

assert product.invalid?
assert_equal ["must be greater than or equal to 0.01"], 
	product.errors[:price]

# redirect.
follow_redirect!

# in the expected results, instead of a redirect.
xhr 

ok.each do |image_url|
	assert new_product(image_url).valid?,
end

# fixture is a specification of the initial contents of a model.
class ProductTest < ActiveSupport::TestCase 
  fixtures :products # control which fixtures to load.
#...
end

test "product is not valid without a unique title" do 
  product = Product.new(title: products(:ruby).title,
    description: "yyy", price: 1, image_url: "fred.gif")
  assert product.invalid?
  assert_equal ["has already been taken"], product.errors[:title]
end

# debuge.
# <h4>Session</h4> <%= debug(session) %> 
# <h4>Params</h4> <%= debug(params) %> 
# <h4>Response</h4> <%= debug(response) %>

### system test ###

# edit test/application_system_test_case.rb
require "test_helper"
class ApplicationSystemTestCase < ActionDispatch::SystemTestCase 
  driven_by :selenium, using: :headless_chrome, screen_size: [1400, 1400]
end


visit
click_on
fill_in ' ', with: ' '

# before type cast.
Order.first.pay_type_before_type_cast

user = User.find_by(name: "Dave") 
if user.superuser?
  grant_privileges
end

# set primary key.
class LegacyBook < ApplicationRecord 
  self.primary_key = "isbn"
end

# create.
orders = Order.create(
	[{ name: "Dave Thomas",
		 email: "[email protected]", 
     address: "123 Main St", 
      pay_type: "check"
    },
	{ name: "Andy Hunt",
    email: "[email protected]", 
    address: "456 Gentle Drive", 
    pay_type: "po"
   }])

# read.
pos = Order.where(["name = ? and pay_type = 'po'", name])
pos = Order.where(name: params[:name], pay_type: params[:pay_type])
User.where("name like ?", params[:name]+"%")
orders = Order.where(name: 'Dave'). order("pay_type, shipped_at DESC")
orders = Order.where(name: 'Dave'). order("pay_type, shipped_at DESC"). limit(10)
def Order.find_on_page(page_num, page_size)
  order(:id).limit(page_size).offset(page_num*page_size)
end
list = Talk.select("title, speaker, recorded_on")
summary = LineItem.select("sku, sum(amount) as amount").group("sku")

# transaction.
Account.transaction do
  ac = Account.where(id: id).lock("LOCK IN SHARE MODE").first 
  ac.balance -= amount if ac.balance > amount
  ac.save
end

average = Product.average(:price) # average product price max = Product.maximum(:price)
min = Product.minimum(:price)
total = Product.sum(:price)
number = Product.count
Order.where("amount > 20").minimum(:amount)
result = Order.group(:state).maximum(:amount)

# scope.
class Order < ApplicationRecord
	scope :last_n_days, ->(days) { where('updated < ?' , days) }
end

# update.
order = Order.find(123) 
order.name = "Fred" 
order.save

result = Product.update_all("price = 1.1*price", "title like '%Java%'")

# • save returns true if the record was saved; it returns nil otherwise.
# • save! returns true if the save succeeded; it raises an exception otherwise.
# • create returns the Active Record object regardless of whether it was suc- cessfully saved.  
#   You’ll need to check the object for validation errors if you want to determine whether the 
#   data was written.
# • create! returns the Active Record object on success; it raises an exception otherwise.
# We have to define an empty placeholder to get after_find pro- cessing to take place.

# delete.
Order.delete(123)
User.delete([2,3,4,5])
Product.delete_all(["price > ?", @expensive_price])

order = Order.find_by(name: "Dave") 
order.destroy
Order.destroy_all(["shipped_at < ?", 30.days.ago])

# callbacks.
class CreditCardCallbacks
  # Normalize the credit card number
  def before_validation(model) 
    model.cc_number.gsub!(/[-\s]/, '')
  end 
end
class Order < ApplicationRecord 
  before_validation CreditCardCallbacks.new 
  # ...
end

# Do the same after finding an existing record.
alias_method :after_find, :after_save

force:true
# One-to-Many.
class Person < ActiveRecord::Base
  has_one :personal_info, dependent: :destroy
  has_many :jobs
  has_many :my_jobs, class_name: "Job"
end

class Job < ActiveRecord::Base
  belongs_to :person
end

# Many-to-Many.
rails g migration create_hobbies_people person:references, hobby:references

class Person < ActiveRecord::Base
  has_one :personal_info, dependent: :destroy
  has_many :jobs
  has_many :my_jobs, class_name: "Job"
  has_and_belongs_to_many :hobbies
end

class Hobby < ActiveRecord::Base
  has_and_belongs_to_many :people
end

# Rich Many-to-Many.
class Person < ActiveRecord::Base
  has_one :personal_info, dependent: :destroy
  has_many :jobs
  has_many :my_jobs, class_name: "Job"
  has_and_belongs_to_many :hobbies
  has_many :approx_salaries, through :jobs, source :salary_range
  
  def max_salary
    approx_salaries.maximum(:max_salary)
  end
end

class Job < ActiveRecord::Base
  belongs_to :person
  has_one :salary_range
end

class SalaryRange < ActiveRecord::Base
  belongs_to :job
end

class User
  has_many :events
  has_many :comments
  has_many :solutions
  has_many :submissions, dependent: :destroy
  has_and_belongs_to_many :auth_permissions
  has_many :groups, through :group_members
  has_many :problems, through :user_problems
end
  

class AuthPermissions
  has_and_belongs_to_many :users
end

class Group
  has_many :teams, dependent: :destroy
  has_many :contests
  has_many :users, through :group_users
end

class Team
  belongs_to :groups
end

class Event
  belongs_to :users
end

class Contest
  has_many :contest_announcements, dependent: :destroy
  has_many :submissions, dependent: :destroy
  belongs_to :groups
  has_many :team_contest_ranks
  has_many :acm_contest_ranks
  has_many :oi_contest_ranks
  has_and_belongs_to_many :problems
end

class TeamContestRank
  has_many :contests
end

class AcmContestRank
  has_many :contests
end

class OiContestRank
  has_many :contests
end

class ContestAnnouncement
  belongs_to :contests
end

class ProblemSet
  has_and_belongs_to_many :problems
end

class Problem
  has_many :comments, dependent: :destroy
  has_many :submissions, dependent: :destroy
  has_many :solutions, dependent: :destroy
  has__many :users, through :user_problems
  has_and_belongs_to_many :problem_sets
  has_and_belongs_to_many :contests
end

class Comment
  belongs_to :users
  belongs_to :problems
end

class Solution
  belongs_to :users
  belongs_to :problems
end

class Tag
  has_and_belongs_to_many :problems
end

class SubmissionRecord
  
end

class ContributeScore
  
end

class CostScore
  
end