Всем привет!

Прошло уже около года с момента опубликования крайнего видео на моем канале. За все это время на канал подписывались люди, были запросы на новые уроки. Это очень приятно, что вы заинтересованы в том что я делаю, и я решил что стоит продолжить эту затею. Сейчас в курсе по Ruby обсуждается работа с Linux и так как эта тема все-таки выпадает из обучения языку программирования, я решил что было бы правильнее вынести это в отдельный курс, который называется Демонический Linux. Я запишу несколько уроков в этом курсе, которые необходимы для продолжения обучения Ruby, и дальше продолжу снимать уроки по Ruby. Спасибо за поддержку, за ваши пальцы вверх, чем вас больше тем выше моя мотивация.

Подписывайтесь на канал и до встречи )

Float#round

Изменилось поведение метода round. Разработчики добавили возможность указать в какую сторону необходимо округлять, передав в этот метод дополнительный параметр :half, который может принимать значения: :even, :up, :down. Для примера:

1
2

(3.5).round(half: :up)
=> 4

Эти изменения касаются также таких методов как: floor, ceil, truncate. В них можно передать эту опцию.

IO#gets

Напомню что метод gets используется для получения пользовательского ввода в вашем скрипте. Вы наверняка использовали его в задачках по Ruby. Так вот, если пользователь вводил какие либо данные, к вам в результате приходила строка с переносом \n Чтобы его убрать использовался метод chomp. Теперь мы можем указать опцию chomp в методе gets

1
2
3
4
5
6

# 2.3
input_string = gets
=> 'tratata\n'
# 2.4
input_string = gets(chomp: true)
=> 'tratata'

Dir, File, Pathname #empty?

Поздравляю теперь мы можем передать путь в метод empty? и выяснить содержит ли папка/файл/путь что-то внутри Метод File.empty? эквивалентен методу File.zero?, который уже давно был в библиотеке для работы с файлами.

Hash#transform_values

Как по мне довольно удобный метод добавили в класс Hash. Теперь мы можем изменять значения hash в итераторе. Например вот так:

1
2
3
4

# 2.4
data = {x: 1, y: 2, z: 3}
data.transform_values{|value| value * 2 }
=> {x: 2, y: 4, z: 6}

Kernel#clone

При использовании clone или dup, можно теперь передать дополнительный аргумент, в котором указать будет ли объект freeze(недоступным для изменения).

1
2
3
4
5
6

# 2.4
frozen_string = "frozen".freeze
dup = frozen_string.clone(freeze: false)

dup.frozen?
=> false

Binding#irb

Есть такой замечательный gem pry. Достаточно в любом месте кода поместить binding.pry и у вас появляется возможность использовать консоль pry для дебага вашего приложения. В Ruby 2.4 добавлена похожая фича, только нужно указать binding.irb.

Regexp#match?

Для регулярок добавили новый метод match? который работает аж в 3 раза быстрее чем методы match, ===, =~. При использовании медленных методов, руби создавал объект класса MatchData, а в новом методе он не создается, за счет этого повышенная скорость работы.

1
2
3
4
5
6
7
8

/^foo (\w+)$/ =~ 'foo bar'      # => 0
                                # => #<MatchData "foo bar" 1:"bar">

/^foo (\w+)$/.match('foo baz')  # => #<MatchData "foo baz" 1:"baz">
                                # => #<MatchData "foo baz" 1:"baz">

/^foo (\w+)$/ === 'foo qux'     # => true
                                # => #<MatchData "foo qux" 1:"qux">

1
2
3

# 2.4
/^foo (\w+)$/.match?('foo wow') # => true
                                # => nil

Regexp#named_captures

Довольно забавная фича. Позволяет сделать именованные группы в регулярном выражении, и в последствии преобразовать это все в hash с результатами. Лучше один раз увидеть.

1
2
3

# 2.4
pattern = /(?<name1>\w+) (?<name2>\w+)/
pattern.match('Herr Kresken').named_captures # => { "name1" => "Herr", "name2" => "Kresken" }

Также для похожих целей можно использовать метод values_at, который также теперь можно применять к отматченному результату

1
2
3

# 2.4
pattern = /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/
pattern.match('2016-02-01').values_at(:year, :month) # => ["2016", "02"]

Кроме именованных ключей, вы можете передать индексы групп, например 1, 3

1
2
3

# 2.4
pattern = /(\d{4})-(\d{2})-(\d{2})$/
pattern.match('2016-07-18').values_at(1, 3) # => ["2016", "18"]

Integer#digits

Как получить массив чисел составляющих число? Раньше это можно было сделать так Преобразовать число в строку, вызвать метод chars, через map сделать to_i

1

123.to_s.chars.map(&:to_i).reverse # => [3, 2, 1]

Теперь стало проще:

1
2

# 2.4
123.digits                  # => [3, 2, 1]

Array#min, max

Array класс обзавелся своими методами min, max, который работают практически в 2 раза быстрее чем соответствующие методы Enumerable

Обьединение Bignum Fixnum в Integer

Довольно серьезное изменение структуры языка. В Ruby 2.4 убрали классы Fixnum и Bignum и объединили их в один Integer

1
2
3
4
5

# 2.3:
numerics # => [Complex, Rational, Bignum, Float, Fixnum, Integer, BigDecimal]

# 2.4:
numerics # => [Complex, Rational, Float, Integer, BigDecimal]

Использование в условиях мультиприсвоения

Теперь в условиях можно использовать множественное присвоение

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

# 2.4
branch1 =
  if (foo, bar = %w[foo bar])
    'true'
  else
    'false'
  end

branch2 =
  if (foo, bar = nil)
    'true'
  else
    'false'
  end

branch1 # => "true"
branch2 # => "false"

Заключение

Неплохие добавочки в язык, точно знаю что использовал бы transform_values, недавно был случай когда нужно было проверить папку на наличие в ней файлов, здесь бы пригодился метод empty?. Вижу применение для named_captures. Остальное также может пригодиться, но лично для меня реже. Помимо добавления функционала были улучшения производительности. Но это уже совсем другая история. На этом все. Подписывайтесь на канал, скоро выйдет новая порция уроков. Добавляйте в закладки

Ссылки к статье

• Релиз Ruby 2.4
• Gem pry

Для организации файлов служат методы - load и require, а для организации кода - include и extend

load или require

load метод, позволяет включить файл в другой файл, при этом загрузка этого файла, будет происходить каждый раз в момент вызова кода где указано подключение. Это полезно для разработки, когда вам нужно видеть результат изменений вживую.

Для примера код ниже. Есть какой-то модуль, в отдельном файле, и мы хотим его подключить в другой файл.

1
2
3
4
5

module TestModule
  def some_method
    # ...
  end
end

1
2
3
4
5
6

load 'test_module.rb'
class TestClass
  def some_method
    # ...
  end
end

Метод require работает по-другому. При его использовании, подключаемый файл, загружается единоразово в память, и используется в дальнейшем из памяти. Очевидно что при использовании такого способа подключения, программа будет работать быстрее. Но при разработке, вам придется постоянно перезапукать программу, чтобы видеть изменения.

Используется он также как и load, require 'test_module'. При этом мы можем не указывать расширение .rb. Этот метод прекрасно сработает и без него.

include или extend

При организации кода внутри программы, нужно использовать методы - include или extend Если вы видите повторяющийся код в вашей программе, его можно вынести в отдельный модуль, и подключать его внутрь с использованием include. Например вот так:

1
2
3
4
5
6
7
8
9
10
11
12
13

module TestModule
  def some_method
    "Some method of #{self.class}"
  end
end

class TestClass
  include TestModule
  # ...
end

puts TestClass.new.some_method
=> 'Some method of TestClass'

C помощью include методы модуля становятся доступными для выполнения в классе TestClass. Т.е. таким образом мы можем избавиться от дублирования кода, перенся его в модуль и подключив там где нам это необходимо. Мы расширили класс, внедрив в него новые методы объекта.

При использовании extend, мы можем также внедрить новые методы, но это уже будут методы класса, а не объекта.

1
2
3
4
5
6
7
8
9
10
11
12
13

module TestModule
  def some_method
    "Some method of #{self.class}"
  end
end

class TestClass
  extend TestModule
  # ...
end

puts TestClass.some_method
=> 'Some method of Class'

Поэтому используйте extend если хотите расширить функционал класса и include для добавления функционала к объекту класса.

Рассмотрим пример:

1
2
3
4
5
6
7
8

# app/controllers/pages_controller.rb
class PagesController < ApplicationController
  def about
  end
end

# app/views/pages/about.html.erb
<h1>О нас</h1>

Есть контроллер Pages, в нем action about, который рендерит страницу ‘О нас’ нашего сайта. Посмотрим на логи нашего приложения:

1
2
3

Processing by PagesController#about as HTML
  Rendered pages/about.html.erb within layouts/application (1.3ms)
Completed 200 OK in 224ms (Views: 212.4ms | ActiveRecord: 0.0ms)

Видно что рендеринг страницы занимает 212.4ms. Это довольно много, видимо на странице много контента. Попробуем использовать http_cache_forever.

1
2
3
4
5
6

# app/controllers/pages_controller.rb
class PagesController < ApplicationController
  def about
    http_cache_forever(public: true, version: 'v1') {}
  end
end

Этот метод в качестве первого аргумента принимает список опций, а вторым блок, который может быть записан также с помощью do end Используя этот метод, мы устанавливаем заголовки ответа, которые указывают браузеру, что ответ не изменился и можно использовать закэшированную версию страницы. И в логах теперь будет следующее:

1
2
3
4
5
6
7
8
9
10

# Первый запрос

Processing by PagesController#about as HTML
  Rendered pages/about.html.erb within layouts/application (1.3ms)
Completed 200 OK in 224ms (Views: 212.4ms | ActiveRecord: 0.0ms)

# Последующий запрос

Processing by PagesController#about as HTML
Completed 304 Not Modified in 2ms (ActiveRecord: 0.0ms)

Происходит первый запрос, во втором браузеру отправляется заголовок ответа “304 Not Modified”, и мы видим кэшированную страницу

Подробнее о http_cache_forever

Рассмотрим опции которые передаются в этот метод. Если мы не укажем public: true, то кэширование будет работать только для браузера, в противном случае, кэширование включится также и для проксированных запросов.

Используйте опцию version, когда вы изменили страничку, и хотите инвалидировать кэш. Указав версию отличную от предыдущей, вы заставите браузер обновить пересоздать кэш страницы. Например version: 'v2' Посмотреть на реализацию, можно заглянув на гитхаб, в этот коммит.

Рассмотрим пример, в котором обработаем ошибку ActionController::RedirectBackError и заставим наше приложение редиректить на root_url в случае отсутствия заголовка HTTP_REFERER:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

class PostsController < ApplicationController

  rescue_from ActionController::RedirectBackError, with: :redirect_to_default

  def publish
    post = Post.find params[:id]
    post.publish!
    redirect_to :back
  end

  private

  def redirect_to_default
    redirect_to root_path
  end

end

В случае возникновения ошибки, сработает приватный метод redirect_to_default, который отредиректит на корневой path.

Rails 5

В Rails 5, redirect_to :back считается deprecated, и вместо него появился новый метод который называется - redirect_back. В нем в качестве дополнительной опции можно передать fallback_location, и таким образом избавиться от тех костылей которые мы реализовывали выше.

Изменим наш пример для Rails 5

1
2
3
4
5
6
7
8
9

class PostsController < ApplicationController

  def publish
    post = Post.find params[:id]
    post.publish!
    redirect_back(fallback_location: root_path)
  end

end

Как видите все стало намного прозрачнее и проще!

Рассмотрим пример:

1
2
3
4
5
6
7
8
9
10
11
12

class User < ApplicationRecord
end

class Post < ApplicationRecord
  belongs_to :user
end

post = Post.create(title: 'Hi')
  => <Post id: nil, title: "Hi", user_id: nil, created_at: nil, updated_at: nil>

post.errors.full_messages.to_sentence
  => "User must exist"

В Rails 4.x добиться такого поведения можно, указав дополнительную опцию в вызов метода

1
2
3
4
5
6
7
8
9
10
11
12

class User < ActiveRecord::Base
end

class Post < ActiveRecord::Base
  belongs_to :user, required: true
end

post = Post.create(title: 'Hi')
=> <Post id: nil, title: "Hi", user_id: nil, created_at: nil, updated_at: nil>

post.errors.full_messages.to_sentence
=> "User must exist"

Вернуть дефолтное поведение в Rails 5 можно, передав опцию optional: true в вызове метода

1
2
3
4
5
6

class Post < ApplicationRecord
  belongs_to :user, optional: true
end

post = Post.create(title: 'Hi')
=> <Post id: 2, title: "Hi", user_id: nil>

Для того чтобы вернуть старое поведение для всего проекта, идем в папку initializers нашего проекта, и видим что в Rails 5 появился новый файл под названием active_record_belongs_to_required_by_default.rb И именно в нем видим настройку, которая отвечает за новое поведение. Мы можем установить ее в false, чтобы отключить его.

1

Rails.application.config.active_record.belongs_to_required_by_default = false

Напомню, что данный файл создается при новой установке Rails 5, в том случае если вы обновляете Rails до версии 5, создайте его вручную.

В Rails 5 много нововведений, одним из них является ActiveRecord Attributes. Эта фича позволяет добавлять аттрибут в модель Rails и обработать его согласно указанному типу. Посмотрим насколько полезен этот новый функционал.

Рассмотрим пример. У нас есть модель пользователей - User. Миграция и сама модель описаны ниже.

1
2
3
4
5
6
7
8
9
10
11
12
13

class CreateUsers < ActiveRecord::Migration
  def change
    create_table :users do |t|
      t.string :name
      t.integer :age
      t.string :male
      t.timestamps(null: false)
    end
  end
end

class User < ActiveRecord::Base
end

Обратите внимание на колонку male, мы могли бы вполне сделать ее с типом boolean, но в данном примере это сделано специально, чтобы показать как мы сможем использовать Attributes.

Хотя бывают и реальные случаи, когда изначально в архитектуре проекта был неверно выбран тип данных, и по прошествии времени, изменение типа будет болезненным.

Давайте воспользуемся нововведением. Укажем колонку male как аттрибут, с типом boolean

1
2
3

class User < ActiveRecord::Base
  attribute :male, :boolean
end

Теперь мы можем использовать колонку так, как будто ее тип boolean, например:

1
2
3
4
5
6
7
8
9
10
11

user = User.new(male: 'yes')
user.male
# => true

user = User.new(male: 'f')
user.male
# => false

user = User.new(male: 0)
user.male
# => false

Вот так легко теперь можно решить проблему несовместимости типов данных указанных в таблице БД и требований согласно бизнес логике. ActiveRecord Attributes поддерживает основные типы данных, ниже список:

• :big_integer
• :binary
• :boolean
• :date
• :date_time
• :decimal
• :float
• :integer
• :string
• :text
• :time

Аттрибут не обязательно может быть колонкой в таблице, можно применять его и для обычных аттрибутов модели. Добавим для модели User аттрибут confirmed_at, и укажем тип данных :date_time, и все будет корректно обрабатываться. При этом мы не указываем аттрибут через attr_accessor.

1
2
3
4
5
6
7
8
9
10
11
12
13

class User
  attribute :confirmed_at, :date_time
end

user = User.new
user.confirmed_at = '2016-02-12 03:00'
user.confirmed_at
# => Fri, 12 Feb 2016 03:00:00 UTC +03:00

user = User.new
user.confirmed_at = '2016/02/12'
user.confirmed_at
# => Fri, 12 Feb 2016 00:00:00 UTC +03:00

Свой обработчик ActiveRecord Attributes

Допустим у нас есть модель Transaction, и в поле цена, к нам приходит строка в виде $100, а мы хотим сохранять в базу данных значение в центах, и цифрой, а также использовать строку в запросах.

Для решения этой задачи, нам необходимо добавить свой тип данных, и в этом Attributes нам поможет. Создадим класс MoneyType, и напишем свой метод type_cast, который используется для преобразования данных.

1
2
3
4
5
6
7
8
9
10

class MoneyType < ActiveRecord::Type::Integer
  def type_cast(value)
    if value.include?('$')
      price_in_dollars = value.gsub(/\$/, '').to_f
      price_in_dollars * 100
    else
      value.to_i
    end
  end
end

Укажем обработчик для колонки price

1
2
3

class Transaction < ActiveRecord::Base
  attribute :price, MoneyType.new
end

Если все сделали верно, то теперь мы можем делать вот такие запросы, и быть уверенными что все отработает как надо

1
2

Transaction.where(price: '$10.00')
# => SELECT * FROM transactions WHERE price = 1000

Как видите очень удобно и просто. Возьмите на заметку :)

Что из себя представляет кэширование коллекций

Рассмотрим пример, в котором нам нужно получить коллекцию пользователей с определенным именем.

1

@users = User.where(name: 'Михаил')

В переменной @users мы получим некую коллекцию записей, которая будет являться объектом класса ActiveRecord::Relation Результат нашего запроса не изменится если будут выполнены следующие условия:

• Мы будем искать также Михаила
• За время нашего запроса записи не были удалены
• За время нашего запроса не было добавлено новых записей

Rails комьюнити предложило реализовать кэширование для коллекций. Метод cache_key был добавлен в ActiveRecord::Relation, и он учитывает множество факторов, включая изменение запроса, updated_at для запроса, и значение счетчика записей в коллекции.

ActiveRecord::Relation#cache_key

Итак у нас есть коллекция пользователей, давайте вызовем у этой коллекции метод cache_key

1
2

@users.cache_key
 => "users/query-67sa32b36805c4b1ec1948b4eef8d58f-3-20160116111659084027"

Мы получим вот такую запись. Сейчас подробнее рассмотрим что она означает.

• users представляет название коллекции, основанной на модели User
• query- не меняющаяся часть, всегда будет присутствовать
• 67sa32b36805c4b1ec1948b4eef8d58f md5 сумма, котрая образуется из SQL. В нашем примере это MD5("SELECT "users".* FROM "users" WHERE "users"."name" = 'Михаил'")
• 3 размер коллекции
• 20160116111659084027 временная метка(timestamp). Это значение соответствует самому свежему updated_at в коллекции.

Как использовать?

Один из примеров, как можно применить cache_key

1
2
3
4
5
6
7

users = User.where(name: 'Михаил')

if users.cache_key == current_cache_key
 # не используем запрос, и возвращаем кешированную страницу
else
 # получаем данные из базы данных
end

В модели нет колонки :updated_at. Что делать?

По умолчанию, для создания timestamp, cache_key использует колонку :updated_at Это дефолтная реализация. Если у вас этой колонки нет, но есть другая, с названием отличным от стандартного, вы можете использовать ee, указав как аргумент в вызове метода cache_key

1
2
3

products = Product.where(category: 'cars')
 products.cache_key(:last_bought_at)
 => "products/query-211ae6b96ec456b8d7a24ad5fa2f8ad4-4-20160118080134697603"

Особенности использования

Использование limit в запросах

Рассмотрим 2 варианта. Если мы хотим получить 3 пользователя с именем ‘Михаил’, то cache_key корректно работает.

1
2
3

users = User.where(name: 'Михаил').limit(3)
users.cache_key
 => "users/query-67ed32b36805c4b1ec1948b4eef8d58f-3-20160116144936949365"

Но если мы вызовем cache_key не извлекая записи в @users, то получим следующую картину.

1
2

User.where(name: 'Алексей').limit(3).cache_key
 => "users/query-8dc512b1408302d7a51cf1177e478463-5-20160116144936949365"

В итоге мы получаем всех пользователей, и наш limit не учитывается. Это особенность реализации метода. ActiveRecord::Base#collection_cache_key.

Cache_key не меняется, при изменении порядка записей в коллекции

Например:

1
2
3

users1 = User.where(name: 'Михаил').order('id desc').limit(3)
users1.cache_key
 => "users/query-648522f6b3a53e0a7f7b63d5967afaf7-3-20160207084207845084"

В итоге мы получаем пользователей с ids - [5, 4, 3] Теперь попробуем удалить пользователя с id = 3

1
2
3
4
5

User.find(3).destroy

 users2 = User.where(name: 'Михаил').order('id desc').limit(3)
 users2.cache_key
 => "users/query-648522f6b3a53e0a7f7b63d5967afaf7-3-20160207084207845084"

Обратите внимание, что cache_key совпадают в обоих примерах. Это происходит потому, что ни один из параметров, влияющих на ключ кэша не изменяется. Т.е. ни количество записей, ни запрос, ни метка времени последней записи.

Использование group в запросах

Также как и в случае с limit, cache_key ведет себя по-разному, в случаях когда записи уже есть в памяти и когда их еще нет. Допустим у нас есть несколько пользователей с одинаковыми именами:

1
2

User.select(:name, :updated_at).group(:name).cache_key
 => "users/query-1eabedee52c695b4c97f6d560211e970-3-20160207084207845084"

В результате мы получаем размер записей 3, в данном случае это будет количество записей в группе. Теперь посмотрим что будет, если коллекция будет загружена в память

1
2
3

@users = User.select(:name, :updated_at).group(:name)
@users.cache_key
 => "users/query-1eabedee52c695b4c97f6d560211e970-1-20160207084207845084"

Теперь размер коллекции составляет 1. Т.е кол-во групп. Эти особенности нужно учитывать, иначе они могут сыграть злую шутку.

API социальных сетей, платежных систем, и прочее прочее. Сейчас редко крупный проект обходится без привязки к внешним сервисам. Тестировать код, связанный со внешними сервисами не всегда легко, это издержки сети, медленное соединение. Лучше изолировать эти тесты с помощью заглушек.

Имитация сервиса на примере конвертера валют

Допустим у нас есть некая система, которая использует внешний сервис Fixer.io для получения курсов валют, и преобразования некой суммы в ту валюту, которую укажет клиент.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

class Converter
  def initialize(amount, source = "RUB", target = "USD")
    @amount = amount
    @target = target
    @source = source
  end

  def convert!
    body = get_exchange_rate_from_api
    rate = extract_exchange_rate(body)
    @amount * rate
  end

  private

  def extract_exchange_rate(body)
    JSON.parse(body)["rates"][@target]
  end

  def get_exchange_rate_from_api
    url = URI(api_url)
    Net::HTTP.get(url)
  end

  def api_url
    "http://api.fixer.io/latest?symbols=#{@target}&base=#{@source}"
  end
end

Наш код прекрасно работает на production сервере. Но мы не хотим, чтобы при тестировании приложения, отправлялись реальные запросы к сервису. Давайте посмотрим какие инструменты наиболее популярны для решения этой задачи.

Webmock

Webmock это библиотека для создания и использования заглушек HTTP запросов. Это довольно простой и удобный инструмент, и подходит для использования в связке с Rspec, Minitest, Test::Unit

Настройка Webmock проста. На странице проекта есть инструкция по установке. Она сводится к установке gem, и прописыванию библиотеки в spec_helper.rb или в test_helper.rb

1

require 'webmock/minitest'

1

require 'webmock/rspec'

Давайте посмотрим как будет выглядеть тест на Rspec, написанный с использованием Webmock

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

require 'rails_helper'

Rspec.describe Converter do

 before do
     stub_request(:get, "http://api.fixer.io/latest?symbols=USD&base=EUR").
          to_return(:body => %Q(
    {
    "base": "EUR",
    "date": "2016-01-29",
    "rates": {
    "USD": 2.0
    }
    }
    ))
 end

 it 'should convert eur to usd' do
    expect(Converter.new(2, "EUR", "USD").convert!).to_eq(4)
 end

end

Все довольно просто. Теперь когда наш код в тесте будет обращаться по url http://api.fixer.io/latest?symbols=USD&base=EUR , вызов сервиса будет заглушаться, и вместо реального запроса мы получим то, что указали в to_return.

Webmock позволяет легко создавать заглушки для сервиса, но есть и подводные камни. Если вдруг ответ реального сервера поменялся, например поменялось API, то мы не сможем отследить это изменение через тест.

VCR

Решить проблему, обозначенную выше помогает - VCR. Его отличие от Webmock в том, что VCR записывает реальный HTTP-ответ от сервиса и использует его потом изолированно в тестах. Запись производится в YAML файл.

Настройка и установка также простая. Установить gem, и добавить конфигурационные строчки в test_helper.rb или spec_helper.rb

1
2
3
4
5
6
7
8

require 'vcr'

VCR.configure do |config|
  # Указываем где будем хранить наши кассеты )
  config.cassette_library_dir = "fixtures/vcr_cassettes"
  # Интегрируемся с webmock 
  config.hook_into :webmock # or :fakeweb
end

Вот пример мини-теста с использованием VCR

1
2
3
4
5
6
7

class ConverterTest < Minitest::Test
  def it_converts_eur_to_usd
    VCR.use_cassette("eur_to_usd_conversion") do
      assert_equals 4, Converter.convert!(4.3932, "EUR", "USD")
    end
  end
end

Во время запуска этого теста, будет послан реальный запрос к сервису, а ответ записан в yml-файл c названием, которое было указано как аргумент в VCR.use_cassette.

Вот так примерно будет выглядеть ответ, записанный в файл:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

---
http_interactions:
- request:
    method: get
    uri: http://api.fixer.io/latest?base=EUR&symbols=USD
    body:
      encoding: US-ASCII
      string: ''
    headers:
      Accept-Encoding:
      - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
      Accept:
      - "*/*"
      User-Agent:
      - Ruby
      Host:
      - api.fixer.io
  response:
    status:
      code: 200
      message: OK
    headers:
      Server:
      - nginx/1.4.6 (Ubuntu)
      Date:
      - Fri, 29 Jan 2016 23:00:20 GMT
      Content-Type:
      - application/json
      Content-Length:
      - '56'
      Connection:
      - keep-alive
      Status:
      - 200 OK
      Last-Modified:
      - Wed, 28 Jan 2016 00:00:00 GMT
      X-Content-Type-Options:
      - nosniff
    body:
      encoding: UTF-8
      string: '{"base":"EUR","date":"2016-01-29","rates":{"USD":1.099}}'
    http_version:
  recorded_at: Fri, 29 Jan 2016 23:00:20 GMT
recorded_with: VCR 3.0.0

При последующем обращении к сервису, будет использоваться этот запрос, который записан в файл. Это довольно удобно, особенно когда нужно использовать один и тот же запрос в разных местах.

Внедрение зависимости (Dependency Injection)

Еще один из способов, состоит во внедрении паттерна проектирования Dependency Injection. Посмотрим на примере нашего конвертера, как можно использовать его.

1
2
3
4
5
6
7
8
9
10
11
12
13

class Converter
  def initialize(amount, source = "EUR", target = "USD", api = FixerAPI)
    @amount = amount
    @target = target
    @source = source
    @api    = api
  end

  def convert!
    rate = @api.get_exhange_rate(source: @source, target: @target)
    @amount * rate
  end
end

Итак, мы внедрили в конструктор класса Converter, FixerAPI класс, который представляет собой обертку для работы с сервисом Fixer. Вот так выглядит наш FixerAPI класс

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

class FixerAPI
  def self.get_exchange_rate(source: source, target: target)
    new.get_exhange_rate(source: source, target: target)
  end

  def get_exchange_rate(source: source, target: target)
    url = URI(api_url(source, target))
    body = Net::HTTP.get(url)
    JSON.parse(body)["rates"][target]
  end

  private

  def api_url(source, target)
    "http://api.fixer.io/latest?symbols=#{target}&base=#{source}"
  end
end

Мы вынесли работу с внешним сервисом в отдельный класс, и можем его включать в любом месте где захотим. И в этом состоит суть внедрения зависимости. Так как код стал изолирован, то и тестировать его можно, заменив например FixerAPI каким-нибудь FakeAPI.

1
2
3
4
5
6
7
8
9
10
11

class FakeAPI
  def self.get_exchange_rate(source: source, target: target)
    2
  end
end

class ConverterTest < Minitest::Test
  def it_converts_eur_to_usd
    assert_equals 4, Converter.convert!(2, "EUR", "USD", FakeAPI)
  end
end

Написать свой тестовый сервис

Я не буду долго рассматривать этот способ, так как считаю его очень сложным. Но он имеет место быть. Если коротко, то мы можем написать тестовый сервер, который будет работать например на Sinatra. Он будет возвращать нам нужные данные. Их мы и будем использовать в наших тестах.

1
2
3
4
5
6

require 'sinatra'

get '/latest' do
  content_type :json
  { base: "EUR", date: "2015-12-15", rates: { usd: 1.099 } }.to_json
end

Заключение

Проблема вполне решаема, разными способами, но лично я остановился бы на VCR. Но конечно нужно смотреть еще на целесообразность использования того или инструмента для облегчения тестирования внешних сервисов.

Если вы не знаете, что такое ActionCable, то это библиотека, которая позволяет интегрировать WebSocket-ы c вашим Rails-приложением Т.е мы имеем необходимый инструмент как на стороне клиента, так и на стороне сервера.

Итак, нам понадобится:

• Установленный Redis (для пользователей Ubuntu достаточно одной команды sudo apt-get install redis-server)
• Rails 4.2 +

Создаем костяк проекта

Назовем его chat, пропускаем установку gems, с помощью опции -B

1

rails new chat -B

Теперь о необходимых гемах для работы нашего чата, нам понадобится:

• Сервер приложения - Puma. Webrick тут не подходит так как ActionCable использует отдельный процесс нашего App сервера, и поэтому нам нужен многопоточный сервер Puma или Thin
• Шаблонизатор slim (просто привычка работать именно с ним)
• ActionCable

Ваш Gemfile должен выглядеть примерно вот так:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

source 'https://rubygems.org'
gem 'rails', '4.2.5'
gem 'sqlite3'
gem 'sass-rails', '~> 5.0'
gem 'uglifier', '>= 1.3.0'
gem 'coffee-rails', '~> 4.1.0'
gem 'jquery-rails'
gem 'turbolinks'
gem 'jbuilder', '~> 2.0'
gem 'sdoc', '~> 0.4.0', group: :doc

gem 'actioncable', github: 'rails/actioncable'
gem 'slim-rails'
gem 'puma'

group :development, :test do
  gem 'byebug'
end

group :development do
  gem 'web-console', '~> 2.0'
  gem 'spring'
end

Выполняем установку gems, bundle install

Структура проекта

В нашем проекте будут контроллеры:

• MessagesController - будет отвечать за вывод сообщений и их создание
• SessionsController - в нем мы создадим простую cookie-аутентификацию для пользователя

При создании контроллеров будем использовать дополнительные опции, –no-helper и –no-assets, чтобы не “плодить” лишние файлы.

Контроллеры и маршруты

Создаем контроллер Sessions

1

rails g controller Sessions --no-helper --no-assets

Добавляем create action

1
2
3
4
5
6
7
8

class SessionsController < ApplicationController

  def create
    cookies.signed[:username] = params[:session][:username]
    redirect_to messages_path
  end

end

Создаем контроллер Messages

1

rails g controller Messages --no-helper --no-assets

Action для index не обязателен, мы его опустим, создадим action create

1
2
3
4
5
6
7

class MessagesController < ApplicationController

  def create
    head :ok
  end

end

В нем мы возвращаем заголовок :ok для ajax запроса. Теперь пропишем маршруты для наших контроллеров в routes.rb

1
2
3
4
5
6

Rails.application.routes.draw do
  resources :messages, only: [:index, :create]
  resources :sessions, only: [:new, :create]

  root 'sessions#new'
end

Корень нашего чата будет вести на логин пользователя

Создаем View

Для начала создадим страничку new для SessionsController, в которой будет простая форма с одним инпутом

1
2
3
4
5
6

= form_for :session, url: sessions_path do |form|
  = form.label :username, 'Ваш никнейм'
  br
  = form.text_field :username
  br
  = form.submit 'Войти в чат'

Теперь создадим страницу на которой будут выводиться все сообщения и в ней будет находиться форма с созданием нового сообщения

1
2
3
4
5
6
7
8
9
10
11
12
13
14

p
  | Вы вошли как
  '
  b #{cookies.signed[:username]}

#messages
br

= form_for :message, url: messages_path, remote: true, id: 'messages-form' do |form|
  = form.label :body, 'Введите сообщение:'
  br
  = form.text_field :body
  br
  = form.submit 'Отправить сообщение'

Здесь мы выведем имя залогинившегося пользователя, и создадим контейнер для сообщений #messages

Настройка ActionCable(backend)

Для работы с ActionCable необходимо создать 2 класса Connection и Channel Создадим их в папке app/channels/application_cable Прописывать channels в autoloads не нужно, Rails подгрузит их по умолчанию

1
2
3
4

module ApplicationCable
  class Connection < ActionCable::Connection::Base
  end
end

1
2
3
4

module ApplicationCable
  class Channel < ActionCable::Channel::Base
  end
end

Настройка Redis

ActionCable использует Redis, добавим конфигурационный файл в config/redis/cable.yml. Настройки довольно стандартные для Redis.

1
2
3
4
5
6
7
8
9

default: &default
  url: redis://localhost:6379
  host: localhost
  port: 6379
  timeout: 1
  inline: true

development: *default
test: *default

Так как ActionCable использует отдельный процесс, то создадим rackup файл с конфигурацией cable/config.ru

1
2
3
4
5
6

require ::File.expand_path('../../config/environment',  __FILE__)
Rails.application.eager_load!

require 'action_cable/process/logging'

run ActionCable.server

Для удобства запуска нашего ActionCable сервера, давайте добавим sh скрипт в папку bin и назовем его cable

1
2

# /bin/bash
bundle exec puma -p 28080 cable/config.ru

Не забываем поставить этому файлу права на исполнение chmod +x bin/cable

Теперь создадим MessagesChannel, ответственный за подписку на стрим

1
2
3
4
5

class MessagesChannel < ApplicationCable::Channel
  def subscribed
    stream_from 'messages'
  end
end

Далее изменим наш action create в MessagesController, добавим функционал по отсылке сообщений

1
2
3
4
5
6
7
8
9
10
11
12
13
14

class MessagesController < ApplicationController
  def create
    ActionCable.server.broadcast 'messages',
                                 message: message_params[:body],
                                 username: cookies.signed[:username]
    head :ok
  end

  private

  def message_params
    params.require(:message).permit(:body)
  end
end

Настройка client-side

Создадим папку channels в app/assets/javascripts. Сначала необходимо создать соединение с нашим ActionCable сервером, создаем index.coffee

1
2
3
4
5
6

#= require cable
#= require_self
#= require_tree .

@App = {}
App.cable = Cable.createConsumer 'ws://127.0.0.1:28080'

Теперь подпишемся на MessagesChannel, создаем messages.coffee

1
2
3
4
5
6

App.messages = App.cable.subscriptions.create 'MessagesChannel',
  received: (data) ->
    $('#messages').append @renderMessage(data)

  renderMessage: (data) ->
    "<p><b>[#{data.username}]:</b> #{data.message}</p>"

Здесь в функции received мы получаем данные и вставляем отрендеренные сообщения в #messages контейнер

Теперь добавим наш js(//= require channels) в application.js

1
2
3
4
5

//= require jquery
//= require jquery_ujs
//= require turbolinks
//= require channels
//= require_tree .

Наш чат готов!

Запускаем наше rails приложение rails s, потом запускаем ./bin/cable. Открываем либо два браузера, либо запускаем вкладку в режиме инкогнито, переходим на http://localhost:3000 и проверяем работу чата.

Ставим ruby 2.3.0-preview1 через rvm, либо rbenv

1
2
3
4
5
6

# RVM
rvm install 2.3.0-preview1

# Rbenv
brew upgrade ruby-build --HEAD
rbenv install 2.3.0-preview1

~ Safe navigation operator ~

Появился новый оператор - &.. В Ruby on Rails есть замечательный метод try!, так вот этот оператор имеет схожую функциональность. Он выполняет проверку на nil до вызова метода у обьекта и возвращает его в случае если сам nil, в противном случае вызывается метод после оператора.

1
2
3
4
5
6
7
8
9

# Ruby <= 2.2
puts "User Admin" if user && user.admin?

# Ruby 2.3
puts "User Admin" if user&.admin?

# Important
user = false
user&.admin? # raise NoMethodError

Но будьте внимательны, если user у вас будет например false, то вы получите NoMethodError

~ Frozen string literals ~

До Ruby 2.2 строки были изменяемые, т.е мы могли взять и сделать что-то подобное str[1] = 'a'. Если нам было необходимо запретить изменение строки, то с помощью метода #freeze это прекрасно получалось

Планируется использование неизменных строк по умолчанию в Ruby 3.0, разработчики хотят увеличить производительность языка, уменьшив количество обьектов в памяти. В версии 2.3 можно включить этот режим, для этого в начало файла нужно поместить комментарий # frozen_string_literal: true

1
2
3
4
5
6
7

# frozen_string_literal: true

str = 'cat'
str[0] = 'b'

# frozen.rb:5:in `[]=': can't modify frozen String (RuntimeError)
#   from frozen.rb:5:in `<main>'

~ Array#dig и Hash#dig ~

Небольшие дополнения к стандартным библиотекам, которые позволяют выполнять такие вещи:

1
2
3
4
5
6
7
8
9
10

list = [
  [2, 3],
  [5, 7, 9],
  [ [11, 13], [17, 19] ]
]

list.dig(1, 2)    #=> 9
list.dig(2, 1, 0) #=> 17
list.dig(0, 3)    #=> nil
list.dig(4, 0)    #=> nil

1
2
3
4
5
6
7
8
9

dict = {
  a: { x: 23, y: 29 },
  b: { x: 31, z: 37 }
}

dict.dig(:a, :x) #=> 23
dict.dig(:b, :z) #=> 37
dict.dig(:b, :y) #=> nil
dict.dig(:c, :x) #=> nil

~ Did you mean? ~

Появилась удобная вещь, в виде подсказки, которая предлагает вам варианты правильного вызова метода, если вы вдруг опечатались

1
2
3
4
5

2.3.0-preview1 :001 > "string".downcaze

NoMethodError: undefined method `downcaze' for "string":String
Did you mean?  downcase
               downcase!

~ Сравнение Hash ~

Теперь можно сравнивать hash. Вот таким образом

1
2
3

{ x: 1, y: 2 } >= { x: 1 } #=> true
{ x: 1, y: 2 } >= { x: 2 } #=> false
{ x: 1 } >= { x: 1, y: 2 } #=> false

Также можно применять и другие операторы сравнения, более подробно здесь

~ Hash#to_proc ~

Hash можно преобразовать в proc обьект, причем вызвав у proc ключ из Hash вы получите значение

1
2
3
4
5
6

h = { foo: 1, bar: 2, baz: 3}
p = h.to_proc

p.call(:foo)  #=> 1
p.call(:bar)  #=> 2
p.call(:quux) #=> nil

Иногда приходится для получения определенных значений из Hash использовать сложную конструкцию, с использованием & это немного упрощается

1
2
3
4
5
6
7

h = { foo: 1, bar: 2, baz: 3}

# bad:
[:foo, :bar].map { |key| h[key] } #=> [1, 2]

# good:
[:foo, :bar].map(&h) #=> [1, 2]

~ Hash#fetch_values ~

Новый метод похож по своей функциональности на Hash#values_at. Он позволяет получить значения по списку ключей. Отличие fetch_values в том, что если ключа не найдется, то будет брошен exception KeyError, вместо возвращения nil, как это реализовано в values_at

1
2
3
4
5

h = { foo: 1, bar: 2, baz: 3}
h.fetch_values(:foo, :bar) #=> [1, 2]

h.values_at(:foo, :quux)    #=> [1, nil]
h.fetch_values(:foo, :quux) #=> raise KeyError

~ Enumerable#grep_v ~

Если вы знакомы с утилитой grep в linux системах, то в случае если мы применим опцию -v в вызове этой консольной утилиты, то в результате выполнения этой команды print "test" | grep t test -v мы ничего не получим на выходе. Эта опция позволяет вывести то что не подошло, т.е. она противоположна grep

1
2
3
4
5
6
7

list = %w(foo bar baz)

list.grep_v(/ba/)
#=> ['foo']

list.grep(/ba/)
#=> ['bar', 'baz']

~ Numeric#positive? и #negative? ~

Добавилось несколько методов из Rails. Названия интуитивно понятны, можно обойтись без примеров

Ссылки

https://www.ruby-lang.org/en/news/2015/11/11/ruby-2-3-0-preview1-released/