Including MongoDB in CI build system

services:
- mongo:latest

Add the MONGODB_URI variable

variables:
MONGODB_URI: mongodb://mongo:27017/test_db

Add config/mongoid.yml ile

test:
  clients:
    default:
      uri: <%= ENV['MONGODB_URI'] %>

Override config/mongoid.yml with config/mongoid.yml.gitlab

before_script:
  - cp config/database.yml.gitlab config/database.yml

Summary

image: starefossen/ruby-node:latest
services:
  - mongo:latest
variables:
  MONGODB_URI: mongodb://mongo:27017/test_db
before_script:
  - RAILS_ENV=test bundle install --jobs $(nproc) "${FLAGS[@]}"
  - cp config/mongoid.yml.gitlab config/mongoid.yml
  - RAILS_ENV=test bundle exec rake db:create db:migrate
test:
  script:
    - bundle exec rspec

development:
  clients:
    default:
      database: dev_db
      hosts:
        - localhost:27017
      options:
        read:
          mode: :primary
        max_pool_size: 10
production:
  clients:
    default:
      uri: <%= ENV['MONGODB_URI'] %>
      pool_size: <%= ENV['DB_POOL_SIZE'] %>
test:
  clients:
    default:
      database: test_db
      hosts:
        - localhost:27017
      options:
        read:
          mode: :primary
        max_pool_size: 1

test:
  clients:
    default:
      uri: <%= ENV['MONGODB_URI'] %>

hash = { a: 1, b: 2 }
=> {:a=>1, :b=>2}
hash.transform_keys { |k| k.to_s }
=> {"a"=>1, "b"=>2}
hash
=> {:a=>1, :b=>2}

hash = { a: 1, b: 2 }
=> {:a=>1, :b=>2}
hash.transform_keys! { |k| k.to_s } 
=> {"a"=>1, "b"=>2}
hash
=> {"a"=>1, "b"=>2}

• Array#prepend and Array#append

>> a = ["hello"]
=> ["hello"]
>> a.append "world"
=> ["hello", "world"]
>> a.prepend "Hi"
=> ["Hi", "hello", "world"]

• Added yield_self method

"Hello".yield_self { |obj| obj + " World"}
=> "Hello World"
"Hello".tap { |obj| obj + " World" }
 => "Hello"

• rescue/else/ensure are allowed inside do/end blocks without begin/end

[1].each do |n|
  n / 0
rescue
  # rescue
else
  # else
ensure
  # ensure
end

• String#delete_prefix/delete_suffix

'HelloWorld'.delete_prefix('Hello')
=> "World" 
'HelloWorld'.delete_suffix('World')
=> "Hello"

• Ruby 2.5 has removed top-level constant lookup

class Book;
end
class Seller;
end
 
Book::Seller

Book::Seller
#=> NameError: uninitialized constant Book::Seller
#   Did you mean?  Seller

• New method to ERB to allow assigning the local variables from a hash

require 'erb'
require 'ostruct'
 
namespace = OpenStruct.new(a: 10, b: 3)
template = 'Result: <%= a * b %>'
ERB.new(template).result(namespace.instance_eval { binding })
#=> "Result: 30"

require 'erb'
result = 'Result: <%= a * b %>'
ERB.new(result).result_with_hash(a: 10, b: 3)
#=> "Result: 30"

• Dir.children and Dir.each_child

Dir.entries("/home")
=> ["..", "user", "."]

Dir.foreach("/home") { |child| puts child }
..
user
.

Dir.children("/home")
=> ["user"]

Dir.each_child("/home") { |child| puts child }
user

• Imported features from ActiveSupport library

{a: 1, b: 2, c: 3}.slice(:a, :b)
#=> {:a=>1, :b=>2}

Further changes

References

• https://github.com/ruby/ruby/blob/v2_5_0/NEWS
• https://www.ruby-lang.org/en/news/2017/12/25/ruby-2-5-0-released/

Client libraries are developed by API developer or the community.

There are several HTTP client libraries in Ruby such as:

• HTTParty

• Faraday

• Built-in Net::HTTP

• Rest-Client

• HTTPClient

Among them, the favorite of mine is Faraday gem. Faraday has adapters for popular libraries like Net::HTTP. It is simple, flexible and supports multiple backends and embraces the concept of Rack middleware when processing the request/response cycle. Also, it’s possible to customize its behavior with middleware. We will use a connection object to start with Faraday as it’s more flexible way than a simple getrequest.

conn = Faraday.new
response = conn.get 'http://localhost:3000/tasks'

Using this connection object, we make HTTP requests.

params = {:title => 'Faraday gem', :created_by => 'blog'}
conn.post('http://localhost:3000/tasks',params)

This will POST  title = ‘Faraday gem’  and created by = ‘blog’ to http://localhost:3000/tasks. All HTTP verb methods can take an optional block that will yield aFaraday::Request object.

 conn.post do |req|
   req.url '/tasks'
   req.headers['Content-Type'] = 'application/json'
   req.body = '{"some": "content"}'
 end

Authentication

Basic and Token authentication are handled by Faraday::Request::BasicAuthentication and Faraday::Request::TokenAuthentication respectively. These can be added as middleware manually or through the helper methods.

conn.basic_auth('username', 'password')
conn.token_auth('token')

Proxies

To specify an HTTP proxy:

Faraday.new(:proxy => 'http://proxy.example.com:80/')

Using a different HTTP Adapter

Faraday provides an interface between our code and adapter. Sometimes we may want to use features that are not covered in Faraday’s interface. In such cases, we can have access to features specific to any of the adapters supported by Faraday, by passing a block when specifying the adapter to customize it. For example, you can switch to the HTTPClient adapter as below

 conn = Faraday.new do |builder|
   builder.adapter :httpclient do |client| # yields HTTPClient
     client.keep_alive_timeout = 20
   end
 end

Like this, we can switch to any of the supported adapters. The block parameters will change based on the adapters we are using.

Faraday::Connection object middlewares

A Faraday::Connection object has a list of middlewares, just like a Rack app. Faraday middlewares are passed as an env hash. It has request and response information.

conn = Faraday.new
conn.builder
=> #<Faraday::RackBuilder:0x0000000155d1f0 @handlers=[Faraday::Request::UrlEncoded,
   #Faraday::Adapter::NetHttp]>

Faraday::Builder is similar to Rack::Builder. A new Faraday::Connectionobject is initialized. It has middlewares Faraday::Request::UrlEncoded in front of an adapter Faraday::Adapter::NetHttp.  Like a Rack application, the adapter at the end of the builder chain is what actually executes the request. Middlewares are grouped into request middlewares, response middlewares, and adapters.

Faraday.new do |builder|
  builder.request :retry
  builder.request :basic_authentication, 'login', 'pass'
  builder.response :logger
  builder.adapter :net_http
end

Advanced Middleware Usage

The order in which middleware is stacked in Faraday is like in Rack. The first middleware on the list wraps all others, while the last middleware is the innermost one, so that’s usually the adapter.

conn = Faraday.new(:url => 'https://redpanthers.co/') do |builder|
  # POST/PUT params encoders:
  builder.request :multipart
  builder.request :url_encoded
  builder.adapter :net_http
end

Middlewares stack is manipulated by the Faraday::Builder instance. Each Faraday::Connection instance has a Faraday::Builder instance.

conn = Faraday.new
conn.builder.swap(1, Faraday::Adapter::HTTPClient)
# replace adapter
conn.builder.insert(0, MyCustomMiddleware)
# add middleware to beginning
conn.builder.delete(MyCustomMiddleware)

Writing middleware

Middlewares are classes that respond to call. When middleware is executing, it’s passed as an env hash that has request and response information. Middleware wrap the request/response cycle. The general interface for a middleware is:

class CustomizedMiddleware
  def call(env)
    # do something with the request
    @app.call(env).on_complete do |env|
    # do something with the response
    end
  end
end

All processing of the response should be done in the on-complete block. This enables middleware to work in parallel mode when many requests are occurring at the same time. After the on_complete block, env[:response] is filled in. Faraday::Response instance will be available only after `on_complete`.
faraday-middleware  is a collection of various Faraday middlewares for Faraday-based API wrappers.
For testing middleware, Faraday::Adapter::Test is an HTTP adapter middleware that lets you to fake responses.

References

• https://github.com/lostisland/faraday

]]>

• 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

It seems easy, right?

1. I’m happy to watch a new movie
2. I hate war

• I’m happy and excited to be going to watch a new movie

• I hate war and the violence it makes

• Ice cream shops are doing great even when the weather is bad

When SA turns hard

Using Natural Language Processing

• Spell check and grammar check
• Predictive text
• Auto summarization
• Machine translation
• Sentiment analysis

Some common approaches to sentiment analysis

Tools & Libraries

We too have tools……

Sentimental gem

gem install sentimental

 require "sentimental"
 analyzer = Sentimental.new
 analyzer.load_defaults
 sentiment = analyzer.sentiment 'Be the reason someone smiles today'
 score = analyzer.score 'Be the reason someone smiles today'
 puts sentiment, score

positive
0.225

 require "sentimental"
 analyzer = Sentimental.new
 analyzer.load_defaults
 sentiment = analyzer.sentiment 'Icecream shops are doing good even at bad weather'
 score = analyzer.score 'Icecream shops are doing good even at bad weather'
 puts sentiment, score

negative
-0.4194

Sentimentalizer gem

 gem install sentimentalizer

 require "sentimentalizer"
 Sentimentalizer.setup
 class Analyzer
   def initialize
     Sentimentalizer.setup
   end
   sentiment = Sentimentalizer.analyze('I love Ruby', true)
   puts sentiment
 end

 Training analyser with +ve sentiment
 +ve sentiment training complete
 Training analyser with -ve sentiment
 -ve sentiment training complete
 {"text":"I love Ruby","probability":0.8568115588520226,"sentiment":":)"}

Classifying with Bayesian and SVM classifiers

When we need more…

JRuby

Sentiment Analysis using Tensorflow Ruby API

Reference

• https://github.com/malavbhavsar/sentimentalizer
• https://github.com/7compass/sentimental
• https://github.com/diasks2/ruby-nlp

1. Database independent tests

class Student < ActiveRecord::Base
  .
  .
  def name
    first_name +" "+ last_name
  end
end

describe Student do
  let (:student) {create(:student, first_name: 'Red', last_name: 'Panther')}
  it 'should return name' do
    student.name.should == 'Red Panther'
  end
end

let(:student) {create(:student, first_name: 'Red', last_name: 'panther')}

let(:student) {build_stubbed(:student, first_name: 'Red', last_name: 'Panther')

group: production do
  gem 'activemerchent'
end
group :test, : development do
  gem 'capybara'
  gem 'rspec-rails'
  gem 'byebug'
end

before(:each) do
  @article = create(:article)
  @author = create(:author)
end

before(:all) do
  @article = create(:article)
  @author = create(:author)
end

FactoryGirl.build_stubbed(:student)

RSpec.configure do |config|
 
  config.before(:suite) do
    DatabaseCleaner.clean_with(:truncation)
  end
 
  config.before(:each) do
    DatabaseCleaner.strategy = :transaction
  end
 
  config.before(:each) do
    DatabaseCleaner.start
  end
 
  config.after(:each) do
    DatabaseCleaner.clean
  end
 
end

References

• https://github.com/grosser/parallel_tests
• https://github.com/thoughtbot/factory_girl
• https://circleci.com/
• https://github.com/DatabaseCleaner/database_cleaner

group :development, :test do
  gem "jasmine"
end

bundle install

rails generate jasmine:install

Run tests

1. In your browser
2. Continuous Integration Mode (CI)

Browser Mode

rake jasmine

http://localhost:8888/

rails generate jasmine:examples

Configurable Settings

Raise Exceptions

Stop Spec on Expectation Failure

Run Tests in Random Order

Continous Integration Mode

rake jasmine:ci

Jasmine.configure do |config|
   config.ci_port = 1234
end

Configuration

• jasmine.yml
• jasmine_helper.rb

Sample configuration:

# spec/javascripts/support/jasmine.yml
random: true
show_console_log: false
stop_spec_on_expectation_failure: true

# spec/javascripts/support/jasmine_helper.rb
Jasmine.configure do |config|
  config.random = false
  config.show_console_log = false
  config.stop_spec_on_expectation_failure: false
  config.show_full_stack_trace = false
  config.prevent_phantom_js_auto_install = false
end

Testing

Testing JavaScript

Plugins worth considering

• Jasmine-Jquery – this plugin provides a lot of jquery related matchers. Download it here
• Jasmine-Matchers – a tool to provide additional matchers. Download it here
• Jasmine-Fixture – a plugin that provides DOM creation using CSS selectors, therefore you can interact with the DOM much easier. Download it here

Write Beautiful Unit tests

Importance of Test Discipline

• Writing tests first gives you a clearer perspective on the ideal API design.
• Does the developer understand the problem enough to articulate in code all critical component requirements?
• Manual QA is error-prone. In my experience, it’s impossible for a developer to remember all features that need testing after making a change to refactor, add new features, or remove features.
• Continous Integration prevents failed builds from getting deployed to production.

Bug Report vs plain Unit Test

• What are you trying to test?
• What should it do?
• What is the real-time output (actual behavior)?
• What is the expected output (expected behavior)?

describe("CalculatorAddMethod", function() {
  var calculator = new Calculator();
  it("should return number", function() {
    const actual = typeof Calculator.add(5,10);
    const expected = 'number'
    expect(actual).toEqual(expected);
  });
});

• What are you trying to test?
  • -> Go for the test description. It is testing for the return type of the add method of Calculator().
• What should it do?
  • -> Again, look at the test description. It clearly says that it is testing for the return type of add method.
• What is the actual output?
  • -> There is a dedicated variable which holds the actual result and how you got the actual result. TWO FOR ONE!
• What is the expected output?
  • -> Again, there is a dedicated variable which holds the actual result. Straight as a ruler!

Make your tests even better

Easter Egg

Conclusion

• What are you trying to test?
• What should it do?
• What is the real-time output (actual behavior)?
• What is the expected output (expected behavior)?
• How can be the test reproduced?

Install Odyssey

gem 'odyssey'

Usage

require 'odyssey'
Odyssey.formula_name(text, all_stats)

require 'odyssey'
Odyssey.flesch_kincaid_re(text, all_stats)

url = "https://redpanthers.co/"
doc = Nokogiri::HTML(open(url))
# Get all the contents
paragraph = doc.css('p', 'article', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'a').map(&:text)
score = Odyssey.flesch_kincaid_re(para.join('. '), true)
p score

{
 "string_length"=>3024,
 "letter_count"=>2270,
 "syllable_count"=>808,
 "word_count"=>505,
 "sentence_count"=>75,
 "average_words_per_sentence"=>6.733333333333333,
 "average_syllables_per_word"=>1.6,
 "name"=>"Flesch-Kincaid Reading Ease",
 "formula"=>#<FleschKincaidRe:0x00000000c83548>,
 "score"=>64.6
}

url = "https://redpanthers.co/"
doc = Nokogiri::HTML(open(url))
para = doc.css('p', 'article', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'a').map(&:text)
score = Odyssey.analyze_multi(para.join('. ').gsub('\n', ' '),
          ['FleschKincaidRe', 'FleschKincaidGl', 'GunningFog', 'Smog','Ari','ColemanLiau'],
          true)

{
"string_length"=>19892,
 "letter_count"=>14932,
 "syllable_count"=>5079,
 "word_count"=>3325,
 "sentence_count"=>435,
 "average_words_per_sentence"=>7.64367816091954,
 "average_syllables_per_word"=>1.5275187969924813,
 "scores"=>
  {
   "FleschKincaidRe"=>69.8,
   "FleschKincaidGl"=>5.4,
   "GunningFog"=>3.1,
   "Smog"=>8.7,
   "Ari"=>3.5,
   "ColemanLiau"=>10.6
  }
}

Extending odyssey

class NewFormula < Formula
  def score(passage, stats)
    p passage
    p stats
  end
  def sentence
    "Red Panthers is a Ruby on Rails development studio,
     based in the beautiful city of Cochin."
  end
end

obj = NewFormula.new
Odyssey.new_formula(obj.sentence, false)

{
 "raw"=>"Red Panthers is a Ruby on Rails development studio,
        based in the beautiful city of Cochin.",
 "words"=>["Red", "Panthers", "is", "a", "Ruby", "on", "Rails",
           "development", "studio", "based", "in", "the",
           "beautiful", "city", "of", "Cochin"],
 "sentences"=>["Red Panthers is a Ruby on Rails development studio,
               based in the beautiful city of Cochin."],
 "syllables"=>[1, 2, 1, 1, 2, 1, 1, 4, 2, 1, 1, 1, 4, 2, 1, 2]
}

{
 "string_length"=>90,
 "letter_count"=>73,
 "word_count"=>16,
 "syllable_count"=>27,
 "sentence_count"=>1,
 "average_words_per_sentence"=>16.0,
 "average_syllables_per_word"=>1.6875
}

References

• http://www.rubydoc.info/gems/odyssey/0.1.8
• https://github.com/cameronsutter/odyssey

user = User.find(1)
user.to_json

• only – Only show column names in the output as specified in the list

  user.to_json(:only => [ :id, :email ])
  

• except – Show all column names except the ones specified in the list

  user.to_json(:except => [:id, :username])
  

render :json => { :sucess => true,
  :user => @user.to_json(:only => [:name]) }

as_json in Rails API

user.as_json(root: true)

user = User.find(1)
user.as_json

user.as_json(:only => [ :id, :email ])
user.as_json(:except => [:id, :username])

def as_json(options={})
 { :email => self.email }
end

from_json in Rails API

json = { user: { email: 'adone@gmail.com', username: 'adone'} }.to_json
user = User.new
user.from_json(json, true)
user.email                 #=> "adone@gmail.com"
user.username              #=> "adone"

References

• https://github.com/rails/rails/blob/master/activesupport/lib/active_support/core_ext/object/json.rb
• http://ruby-doc.org/stdlib-2.0.0/libdoc/json/rdoc/Regexp.html