match 'profiles', to: 'users#index', via: 'get'

match 'profiles', to: 'users#index', via: 'get'
get 'profiles', to: 'users#index', via: 'get'
resources :users
resource :users, path: 'profiles'

  resources :saved_filters
  match "/404" => "errors#error404", via: [ :get, :post, :patch, :delete ], as: 'error404'
  devise_for :saas_admins
  mount RailsAdmin::Engine => '/saas_admin', :as => 'rails_admin'
  %w(about privacy benefits compliance onboarding payroll time_off terms contact aca-compliance).each do |page|
    get page => "content##{page.underscore}"
  end
  get "/not_authorized", to: 'errors#not_authorized'
  post '/broker_sign_in_path', to: 'application#broker_sign_in_domain', as: 'broker_sign_in_domain'
  post '/employer_sign_in_path', to: 'application#employer_sign_in_domain', as: 'employer_sign_in_domain'
  post '/messages/reply_from_external_user',to: 'messages#reply_from_external_user',as: '/messages/reply_from_external_user'
  # Routes for the public site

resources :users

resource :users, only: [:create, :update, :show, :destroy]

resources :posts do
  resources :comments
end

resources :users do
  member do
    match 'de_activate', to: 'user#de_activate', via: 'get'
  end
  collection do
    match 'search', to: 'user#search', via: 'post'
  end
end

def my_method
  puts "Hello World"
end

my_method { puts 'Hello Reader' }

def my_method
  puts 'Hello World'
  yield
end

Hello World.
Hello Reader.

def my_method
  puts 'Hello World'
  yield if block_given?
end

def gen_times(factor)
  return Proc.new {|n| n*factor }
end
times3 = gen_times(3)
times5 = gen_times(5)
times3.call(12)               #=> 36
times5.call(5)                #=> 25
times3.call(times5.call(4))   #=> 60

Proc.new {|a,b| [a,b] }.call(1,2,3)
=> [1,2]

lambda {|a,b| [a,b] }.call(1,2,3)
=>
ArgumentError: wrong number of arguments (3 for 2)
	from (irb):7:in `block in irb_binding'
	from (irb):7:in `call'
	from (irb):7
	from /home/dev1/.rvm/rubies/ruby-2.2.2/bin/irb:11:in `<main>'
2.2.2 :008 > Proc.new {|a,b| [a,b] }.call(1,2,3)

code = -> (x) { x*x }
code.call 4
=> 16

def lambda_method
  lambda { return puts 'lambda' }.call
  return 'method'
end
lambda_method
=> method

def proc_method
  Proc.new { return puts 'proc' }.call
  puts 'method'
end
proc_method
=> proc

def my_method
  yield 1, 2, 3
end
my_method { |x, y| puts "#{x} & #{y}" }
=> "1 & 2"

Proc.new { |x, y| puts "#{x} & #{y}" }.call(4, 5, 6)
=> "4 & 5"

def my_method
  yield
end
my_method { |x, y| puts "#{x} & #{y}" }

• Is in between the curly braces and in between do and end.
• No issue with number of arguments.
• Blocks are basically a proc without a name

• Similar behaviour as Block.
• Can be stored in a variable and move around.
• No issue with number of arguments.
• Return within the proc would exit the method from where it is called.

• Same as Proc, but closer to a method.
• Strict regarding the arguments it gets and it needs.
• Return within a lambda would exit it from the lambda and the method would continue executing.

[].each
[1, 3, 4].each
file.each
{}.each

fib = Enumerator.new do |y|
  a = b = 1
  loop do
    y << a
    a, b = b, a + b
  end
end

[1,2,3].map { |i| i*i }

foo.map { |i| i * * }

foo.lazy.map { |i| i * i }

fille = File.open('OurHugeFile.log')

file.each_line.lazy.take(3).to_a

 file.each_line.lazy.select { |line| line.match(/INFO/) }.first(2)

file.each_line.lazy.each_with_index.map { |l, i| "#{i}: #{l}" }.select { |i| match(/INFO/) }.first(3)

# app/controllers/application_controller.rb
around_action :set_time_zone, if: :current_user
private
def set_time_zone(&block)
  Time.use_zone(current_user.time_zone)
end

config.time_zone = 'Central Time (US & Canada)'

• System timezone
• Database timezone
• Rails applications own timezone

  * Time.now
  * Date.today
  * Date.today.to_time
  * Time.parse("2015-07-04 17:05:37")
  * Time.strptime(string, "%Y-%m-%dT%H:%M:%S%z")

* Time.current
* 2.hours.ago
* Time.zone.today
* Date.current
* 1.day.from_now
* Time.zone.parse("2015-07-04 17:05:37")
* Time.strptime(string, "%Y-%m-%dT%H:%M:%S%z").in_time_zone

• 1: destroy – run the destroy method on all the associated objects, there by also triggering the callbacks
• 2: delete_all – causes the associated methods to be deleted directly from DB, no callbacks triggered. This would be a faster, compared to :destroy, to delete the associated models.
• 3: nullify – sets the foreign key to be set to NULL. no callbacks triggered. We use it when we don’t want the children to be destroyed, and kept in our system. Usually done to keep history, or protect the associated objects referencing to the children.
• 4: restrict_with_exception – It will raise an exception if there are associated objects. Hence also prevent the destruction of the parent.
• 5: restrict_with_error- It will prevent the deletion of the parent, and will pass in the error that it has associated objects without raising the exception.

User.find(156).withdraw(1000)
User.find(157).deposit(1000)

User.transaction do
  User.find(156).withdraw(1000)
  User.find(157).deposit(1000)
end

@user.transaction do
end

User.transaction do
end

User.transaction do
  Order.create order_attributes
  Purchase.create purchase_attribute
end

User.transaction do
  User.create(username: 'Kotori')
  User.transaction do
    User.create(username: 'Nemu')
    raise ActiveRecord::Rollback
  end
end

after_create Is called after Base.save on new objects that haven‘t been saved yet (no record exists) after_save Is called after Base.save (regardless of whether it‘s a create or update save) after_commit Is called after the database transaction is completed.

User.transaction do
    # update company
    # update hr_department
    # update user_table
end

config.logger = Logger.new( Rails.root.join("log", Rails.env + ".log" ), 5 , 100 * 1024 * 1024 )

1. The file name, which would be production.log
2. The number of files you want to keep
3. The size of each file in bytes. (100 * 1024*1024 means 100 MB)

$ cat /etc/logrotate.d/myrailsapp-config
/var/www/myrailsapp/current/log/*.log {
  compress
  copytruncate
  daily
  dateext
  delaycompress
  missingok
  rotate 90
}

• compress – Compress logs using gzip
• copytruncate – Copy the log out of the way, and then truncate the existing logs
• daily – Rotate daily
• dateext – Add the date the logs were rotated as the extension instead of a number
• delaycompress – Skip compressing the log until the following day
• missingok – Do not raise an error when there is a missing log file
• rotate 90 – Keep up to 90 days worth of logs

config.generators do |g|
  g.helper false
  g.stylesheets false
  g.javascripts false
  g.view_specs false
end

          “God object: In object-oriented programming, is an object that knows too much or                  does too much.” 

– Source: Wikipedia

God class in OOP doesn’t stand for a good thing; here it’s called an anti-pattern. In Object Oriented Programming, we create a new class to define the properties and capabilities of an object. It is using these objects that we build our system, mimicking how it would work in the real world.

For example: Let’s assume that we are trying to build a software to manage the office of a school.

In a typical school office, there would be different departments to handle different parts of the administration. For example, the Purchase department for the purchases, the Accounts department for the accounts, the Records department for the records, the HR department to manage the staff. When one department wants something from another department, it would ask that department for the information. As per protocol, it shouldn’t take the files from the other department without the staff or the department lending it.