• assert that it has #changed
• call #notify_observers

Public Instance Methods

• add_observer(observer, func=:update)

How it works

require 'observer'
class Bike
  include Observable
  attr_reader :mileage,:service
  def initialize(mileage =0, service = 3000)
    @mileage,@service = mileage, service
    add_observer(Notifier.new)
  end
  def log(miles)
    @mileage += miles
    notify_observers(self, miles)
  end
end

class Notifier
  def update(bike, miles)
    puts "The bike has logged #{miles} miles, totaling #{bike.mileage} miles traveled."
    puts "The bike needs to be taken in for a service!" if bike.service <= bike.mileage
  end
end

By running the code we can see

bike = Bike.new(2300, 3000)
bike.log(100)
=> "The bike has logged 100 miles, totaling 2400 miles traveled."
bike.log(600)
=> "The bike has logged 300 miles, totaling 3000 miles traveled."
=> "The bike needs to be taken in for service!"

First, we create an instance of the Bike class with 2300 miles, and we set that it needs to be taken for service when it reaches 3000 miles.

I hope this example helps you understand ruby observer design pattern better.

References

• https://ruby-doc.org/stdlib-2.3.2/libdoc/observer/rdoc/Observable.html#module-Observable-label-Mechanism
• https://cbabhusal.wordpress.com/2015/10/03/gang-of-four-observer-design-pattern-in-ruby/

file = File.new("file.txt", "w")

Opening Existing Files

file = File.open("temp.txt")

file.close

Reading and Writing Files

sysread Method:

file = File.new("input.txt", "r")
if file
   content = file.sysread(10)
   puts content
else
  puts "cannot open the file"
end

syswrite Method:

file = File.new("input.txt", "r+")
if file
   file.syswrite("Hello")
else
   puts "Unable to open file!"
end

each_byte Method:

file = File.new("input.txt", "r+")
if file
   file.syswrite("ABCDEF")
   file.each_byte {|ch| putc ch }
else
   puts "Unable to open file!"
end

IO.readlines Method:

arr = IO.readlines("input.txt")
puts arr[0]
puts arr[1]

IO.foreach Method:

IO.foreach("input.txt"){|block| puts block}

Renaming and Deleting Files

File.new("tempfile.txt", "w")
=> #<File:tempfile.txt>
File.rename("tempfile.txt", "newfile.txt")
=> 0
File.delete("newfile.txt")
=> 1

References

• https://www.tutorialspoint.com/ruby/ruby_input_output.html
• http://www.techotopia.com/index.php/Working_with_Files_in_Ruby
• https://ruby-doc.org/core-2.2.2/File.html

$ rails generate
Usage: rails generate GENERATOR [args] [options]
...........
Rails:
assets
channel
controller
generator
helper
integration_test
jbuilder
job
mailer
migration
model
resource
responders_controller
scaffold
scaffold_controller
task
.............

• controller: The Rails controller coordinates the interaction between the user, the views, and the model.
• helper: Code in helpers is included in the corresponding view. We can move big loops, method calls or other logic into a method in the helper.
• mailer: It allows for sending and receiving emails from and to your application.
• migration: Rails Migration allows you to use Ruby to define changes to your database schema.
• model: It is Ruby class that talk to the database, store and validate data, perform the business logic.
• scaffold: It refers to the auto-generation of a simple set of a model, views and controller usually for a single table.

-h, [–help] # Print generator’s options and usage -p, [–pretend] # Run but do not make any changes -f, [–force] # Overwrite files that already exist -s, [–skip] # Skip files that already exist -q, [–quiet] # Suppress status output

Generators

• rails generate model ModellName

It generates the model and the associated database table. For example, we can add a new model to the app called User with fields name and age as,

Eg:  rails g model User name: string age: integer

• rails generate controller ListController show edit

It generates controller. It is used if you are creating static views or non-CRUD related features. Let’s create a user controller that will manage the data flow and view for each users.

Eg:  rails g controller users

• rails generate scaffold ModelName ControllerName

Generates Scaffold. Let’s create a scaffold User with edit and view actions.

Eg:  rails g scaffold User edit view

• rails generate migration AddNewTable

Generates Table to migrate. We can create migration for adding a table as

Eg:  rails g migration User

• rails generate plugin PluginName

Generates Plugin.

Eg:  rails g plugin rails_plugin

• rails generate integration_test TestName

Generates Integration Test.

Eg:  rails generate integration_test User

• rails generate session_migration

Generates Session Migration.

Creating Generators with Generators

$ rails generate generator initializer
 create lib/generators/initializer
 create lib/generators/initializer/initializer_generator.rb
 create lib/generators/initializer/USAGE
 create lib/generators/initializer/templates

class InitializerGenerator < Rails::Generators::NamedBase
  source_root File.expand_path("../templates", __FILE__)
end

First, notice that we are inheriting from Rails::Generators::NamedBase instead of Rails::Generators::Base. This means that our generator expects at least one argument, which will be the name of the initializer.

Customizing Rails generators

config.generators do |g|
  g.orm :active_record
  g.template_engine :erb
  g.test_framework :test_unit, fixture: false
  g.stylesheets false
  g.javascripts false
end

References

• https://learn.co/lessons/rails-generators-readme
• https://www.tutorialspoint.com/ruby-on-rails/rails-generators.htm
• http://www.agmprojects.com/blog/building-a-rails-generator-and-packing-it-into-a-gem

• Parallel execution of sequential scans, joins and aggregates.
• Avoid scanning pages unnecessarily during vacuum freeze operations.
• Synchronous replication now allows multiple standby servers for increased reliability.
• Full-text search can now search for phrases (multiple adjacent words).
• postgres_fdw now supports remote joins, sorts, UPDATEs, and DELETEs.
• Substantial performance improvements, especially in the area of scalability on multi-CPU-socket servers.

Parallel execution of sequential scans, joins and aggregates

Avoid scanning pages unnecessarily during vacuum freeze operations

Synchronous replication now allows multiple standby servers for increased reliability

Full-text search can now search for phrases (multiple adjacent words)

postgres_fdw now supports remote joins, sorts, UPDATEs, and DELETEs

1. Install the postgres_fdw extension using CREATE EXTENSION.
2. Create a foreign server object, using CREATE SERVER, to represent each remote database you want to connect to. Specify connection information, except user and password, as options of the server object.
3. Create a user mapping, using CREATE USER MAPPING, for each database user you want to allow to access each foreign server. Specify the remote username and password to use as user and password options of the user mapping.
4. Create a foreign table, using CREATE FOREIGN TABLE, for each remote table you want to access. The columns of the foreign table must match the referenced remote table. You can, however, use table and/or column names different from the remote table’s, if you specify the correct remote names as options of the foreign table object.

 psql

psql mydb

Backups

References

• https://www.postgresql.org/docs/9.6/static/release-9-6.html
• http://www.craigkerstiens.com/2015/12/29/my-postgres-top-10-for-2016/
• https://wiki.postgresql.org/wiki/NewIn96
• https://momjian.us/main/writings/pgsql/features.pdf

Concurrency Abstractions

• Async (Concurrent::Async): A mixin module that provides simple asynchronous behavior to a class, turning it into a simple actor.
• Future (Concurrent::Future): An asynchronous operation that produces a value. It represents a promise to complete an action at some time in the future.
  • Dataflow: Built on Futures, Dataflow allows you to create a task that will be scheduled when all of its data dependencies are available.
• Promise (Concurrent::Promise): Similar to Futures, with more features. It represents the eventual value returned from the single completion of an operation.
• ScheduledTask (Concurrent::ScheduledTask): Like a Future scheduled for a specific future time.
• TimerTask (Concurrent::TimerTask): A Thread that periodically wakes up to perform work at regular intervals.

Installation

gem install concurrent-ruby

gem 'concurrent-ruby', require: 'concurrent'

Edge Gem Installation

gem install concurrent-ruby-edge

gem 'concurrent-ruby-edge', require: 'concurrent-edge'

Usage

require 'concurrent'

require 'concurrent-edge'

require 'concurrent-edge'
class Hello
  def greet
    sleep 3
    "Hello, #{Time.now}"
  end
end
all_promises = Concurrent::Promises.zip(
  Concurrent::Promises.future { Hello.new.greet },
  Concurrent::Promises.future { Hello.new.greet }
)
all_promises.then { |*values| puts values.inspect }.value

Hello, 2016-12-09 08:56:51 +0530
Hello, 2016-12-09 08:56:54 +0530

References

• https://github.com/ruby-concurrency/concurrent-ruby
• https://blog.engineyard.com/2013/ruby-concurrency
• https://github.com/ruby-concurrency/concurrent-ruby/blob/master/doc/thread_pools.md

CREATE YOUR CUSTOM LOGGER

# lib/custom_logger.rb
class CustomLogger < Logger
  def format_message(severity, timestamp, progname, msg)
    "#{msg}\n"
  end
end
logfile = File.open(RAILS_ROOT + '/log/custom.log', 'a') #create log file
logfile.sync = true #automatically flushes data to file
CUSTOM_LOGGER = CustomLogger.new(logfile) #constant accessible anywhere

• Severity of the log message
• Time instance representing when the message was logged
• progname configured or passed to the logger method
• Object the user passed to the log message.

LOAD CUSTOMLOGGER FROM ENVIRONMENT

#in any controller, view or model like,
CUSTOM_LOGGER.info("info from custom logger")
CUSTOM_LOGGER.add(Logger::FATAL) { 'Fatal error!' }
CUSTOM_LOGGER.fatal("Some arguments are not given.")
CUSTOM_LOGGER.error ("Argument #{@name} mismatch." )
CUSTOM_LOGGER.debug("This is a " + potentially + " expensive operation")

References

• https://ruby-doc.org/stdlib-2.1.0/libdoc/logger/rdoc/Logger.html

So how do we Create an Enumerator?

• A Block,
• An Enumerable,
• A Blockless Enumerable Method Call.

From a Block

enum = Enumerator.new do |yielder|
  yielder << "Red"
  yielder << "Panthers"
end
enum.next # "Red"
# StopIteration: when it reached an end

From an Enumerable

array = [1, 2, 3]
enum = array.to_enum
enum.each {|n| n * 2} # 2 4 6

From a Blockless Enumerable Method Call

array = [1, 2, 3, 4]
enum = array.select
enum.each {|n| n % 2 == 0} # [2, 4]

When do we use an Enumerator?

status =%w(active inactive).each
puts status.class # => Enumerator
puts status.next # => active
puts status.next # => inactive
puts status.next # raises StopIteration

Why are they so special?

• It provides enumeration functionality to objects without it.
• You can control the iteration process in an efficient way using different methods like .each, .select, .next, .peek etc.
• There is a feature called Lazy enumerator, which will prevent iterate over an infinite collection.
• It saves a lot of typing(see above example), which makes the programmer more efficient.

References

• https://robots.thoughtbot.com/whats-new-in-edge-rails-active-record-enum
• https://hackhands.com/ruby-on-enums-queries-and-rails-4-1/
• https://bendyworks.com/blog/rails-enum-sharp-knife

Setup

  gem install irbtools

gem 'irbtools', require: 'irbtools/binding'

Usage

require 'irbtools'

binding.irb

require 'irbtools/more'

gem 'irbtools-more', require: 'irbtools/binding'

Features

1. Colorized and output as comment by wirb and fancy_irb
2. Nice IRB prompt and IRB’s auto indention
3. Includes stdlib’s FileUtils: ls, cd, pwd, ln_s, rm, mkdir, touch, cat
4. Many debugging helpers:
   • ap – awesome_print
   • q –like p, but on one line
   • Object#m – ordered method list (takes integer parameter: level of nesting)
   • Objedt#d – puts the object, returns self (using tap)
5. “Magical” information constants: Info, OS, RubyVersion, RubyEngine
   • OS.windows?
   • RubyEngine.jruby?
   • RubyVersion.is.at_least? 1.9
6. Clipboard features: copy and paste
7. Call vim to edit a file, close it and it gets loaded into your current irb session, powered by interactive_editor
8. Highlight a string with colorize(‘string’) or a file with ray(‘path’), powered by coderay
9. Displays ActiveRecord database entries as tables with hirb
10. Restart irb with reset! or change the Ruby version with the use method and rvm!
11. Includes the current directory in the load path
12. Shorter requiring like this: rq:mathn
13. Access to a lot of more commands with boson – call commands to get started

Irbtools Methods

From every_day_irb

From irbtools in conjunction with the libraries

References

disable_ddl_transaction!()

# File activerecord/lib/active_record/migration.rb
  def disable_ddl_transaction!
    @disable_ddl_transaction = true
  end

class AddIndexToUserActive < ActiveRecord::Migration
  disable_ddl_transaction!
  def change
    add_index :users, :active, algorithm: :concurrently
  end
end

References

• http://doc.bccnsoft.com/docs/rails_5_0_0_api/classes/ActiveRecord/Migration.html
• http://stackoverflow.com/questions/16325957/disabling-transaction-in-rails-migration-how-do-i-include-a-ruby-variable-in-a
• http://apidock.com/rails/ActiveRecord/Migration/disable_ddl_transaction!/class
• https://robots.thoughtbot.com/how-to-create-postgres-indexes-concurrently-in