Anton Davydov

Five common issues with services and dry-monads

2020-05-19T00:00:00+00:00

Today I found the source code of a simple test task in GitHub. The code author used dry-monads, services, and other abstractions. I found some issues in that code and recalled that I have seen the same issues in other projects. That’s why I think that it’s a common problem and it will be a good idea to make a review and explain how we can improve our code. Also, I expect that this blog post can be useful for “junior/middle” developers and it could be boring for “senior” developers.

Important

This blog post based only on my personal experience and I don’t want to write the “best” code in the world. The main point which I want to provide - share my knowledge and experience for everyone else. Also, I don’t want to say that you need to use services or dry-monads. But if you use it you can potentially face issues that I tried to describe in this blog post.

I asked the code author about this publication and he allowed me to do it.

TLDR

Problems:

Naming based on implementation;
Redundancy of service objects;
Using of generic names;
State inside a class and mix of parameters and dependencie;
ActiveModel’s chain of calls in business logic;

Finnal result

Original code

The main operation (service) which we call from rails controller looks like this:

module Groups
  module Services
    class JoinUser < Service
      def initialize(params, record: ,
        input_validator: Users::Validators::NewUser.new,
        user_exists_check: Users::Services::CheckExists,
        user_creator: Users::Services::Create
      )
        @params = params
        @input_validator = input_validator
        @record = record
        @user_creator = user_creator
        @user_exists_check = user_exists_check
      end

      def call
        validated_params = yield input_validate
        yield business_validate(validated_params.to_h)
        save(validated_params.to_h)
      end

      private

      attr_reader :params, :record, :input_validator, :user_creator, :user_exists_check

      def input_validate
        input_validator.call(params[:group]).to_monad
      end

      def business_validate(validated_params)
        return Failure(:already_exists) if record.users.where(validated_params).exists?
        Success()
      end

      def save(validated_params)
        user_check_result = user_exists_check.new(validated_params[:email]).call
        if user_check_result == Success(:user_not_exists)
          user = yield user_creator.new(validated_params).call

          record.users << user
          return Success(:created)
        end

        record.users << user_check_result.value!

        Success(:created)
      end
    end
  end
end

Also, we use two dependencies, which look like this:

module Users
  module Service
    class CheckExists < Service
      def initialize(email, model: User)
        @email = email
        @model = model
      end

      def call
        return Success(model.find_by(email: email)) if model.where(email: email).exists?
        Success(:user_not_exists)
      end

      private

      attr_reader :email, :model
    end
  end
end

module Users
  module Services
    class Create < Service
      def initialize(params,
        input_validator: Users::Validators::NewUser.new,
        model: User
      )
        @params = params
        @input_validator = input_validator
        @model = model
      end

      def call
        yield input_validate
        save
      end

      private

      attr_reader :params, :model, :input_validator

      def input_validate
        input_validator.call(params).to_monad
      end

      def save
        Try() { model.create!(params) }
      end
    end
  end
end

Problems

After reading and understanding the original code I found five places which I want to describe:

Naming based on implementation;
Redundancy of service objects;
Using of generic names;
State inside a class and mix of parameters and dependencie;
ActiveModel’s chain of calls in business logic;

Let’s discuss each part.

Naming based on the implementation

I think a good starting point for refactoring this code is to remove “out of context” words from variables, objects, and services names.

Quick example: you can see save(validated_params.to_h) (Groups::Services::JoinUser service) line in the original code. After some research, I realized that the original context is enrolling users in groups. I mean that from the implementation perspective this line should update something in DB. But from business logic, the service has an absolutely different context. That’s why I think that #enroll will be better than #save here.

If you want to use implementation details in naming you should be ready to spend more time understanding the context of each method/service and thinking why we have this code here. But if you use naming based on business flow you provide a context that can answer the question “why?” and you can reduce time spent on understanding the source code. I think that domain-driven design (DDD in the future) is trying to give the same idea related to naming, that’s why if you want to read more about it - DDD books will be a good start (and event storming for understanding better all business events in the system).

Redundancy of service objects

I can see two global issues in the original source code:

The main service depend on a lot of different dependencies (like Users::Validators::NewUser.new, Users::Services::CheckExists, Users::Services::Create and direct model calls like record.users.where(validated_params).exists?);
Both called services implements only DB logic (checking for the existence of the record and saving data in DB);

Let’s start with DB request logic. It’s a great temptation is to make 2 separate services and put DB logic there, like the author of the original example did. I can understand it because you want to isolate parts of your service. But this way has a downside - your business logic looks complicated. For example, let’s check two lines in Groups::Services::JoinUser#save method:

def save(validated_params)
  user_check_result = user_exists_check.new(validated_params[:email]).call
  # We need to execute strange comparation logic with Result monad here
  # 
  # The logic is strange because the monad looks strange in current context. It's complicated to say why `user_not_found` is a success result.
  # We need bussines logic knowledge to say why it is
  if user_check_result == Success(:user_not_exists)

    # We need to use DO notations in the nested method in the current case.
    # That's why we'll get nesting and it can be possible to increase the complication of understanding the data flow in the system
    user = yield user_creator.new(validated_params).call

I can see that the author wrapped up the database operation into nested DO notation (which not important in this case) and thus inflated his own code. That’s why it looks like those same methods should be in model/repository (if you use repository pattern). Also, we come to the context issue based on the naming of methods, because the service names describe implementation details instead of business steps/logic.

Using of generic names

You can find a lot of base words in the example like record, user_exists_check, validated_params, business_validate, input_validate, params and others. I covered it in the first issue. It’s really hard to understand what these objects/methods do and why we need it without a full context of logic.

For example, read naming for two services and try to answer what each service do here:

Groups::Services::JoinUser
Groups::Services::EnrollUser

When I see JoinUser I expect that we take a user from data storage and just join them to a group. But in real world we need to enroll a user to a specific group.

State inside a class and mix of parameters and dependencie

In the original example, the author used dependency injection (DI in the future) for calling other services and validations. It’s a powerful technique with helps with testing and paintability of your project (I suggest to check posts or talks from solnic, Tim, and Luca if you don’t use or see it before).

As you can see the author puts data and dependencies inside the class constructor (#initialize) in each service.

def initialize(params, record:, # data
  input_validator: Users::Validators::NewUserContract.new, # dependency
  user_exists_check: Users::Services::CheckExists, # dependency
  user_creator: Users::Services::Create # dependency
)

def initialize(email, model: User)
  @email = email  # data
  @model = model # dependency
end

def initialize(params, # data
  input_validator: Users::Validators::NewUserContract.new, # dependency
  model: User # dependency
)

It’s not a problem in general. But if you use complicated dependencies with long time building (for example rom) or want to use DI in testing you’ll get a problem. Also, you’ll allocate new objects every action calls, but it’s not a critical.

The most critical part of this code states inside a class because you get two issues:

You’re losing pure objects conception. It means that you can possibly get bugs related to mutation of your state.

This solution is increasing maintainability of the code. For example, check these two methods from the service object:

def save(validated_params)
def save(record, validated_params)

In the first method, we see save method plus validated_params. Based on this knowledge I can say that the method just store something in the base and that’s all. In the second method, we see that method saves something related to the record. The problem here in that method really uses record data based on the state of the service inside self but we can’t understand it without reading the code.

ActiveModel’s chain of calls in business logic

I didn’t use rails last 3 years but I can understand that It’s a common approach in rails. I’m talking about lines with record.users.where(payload).exists? or something like this. I see two problems in this approach:

It’s hard to use unit tests for this because you need to mock a chain of methods. It’s not a problem if you’re using only integration testing but integration testing increases time for your test suite because you use DB calls every time.
The issue connected to the first point, you need to make transformation AR DSL to a specific context. For example, say what is better to understand record.users.where(payload).exists? or record.attendee?(payload).

Finnal result

module Cource
  module Services
    class EnrollUser < Core::Service
      attr_reader :model, :validator

      def initialize(model: User, validator: Users::Validators::NewUserContract.new)
        @model = model
        @validator = validator
      end

      def call(group, params)
        payload = yield validate_raw_data(params)
        yield group_attendee?(group, payload)

        user = yield find_or_create_by_email(payload[:email])

        success(group.enroll(user))
      end

    private

      def validate_raw_data(payload)
        # don't forget to enable monads extention
        #   Dry::Validation.load_extensions(:monads)
        #
        # https://dry-rb.org/gems/dry-validation/master/extensions/
        validator.call(payload).to_either
      end

      def group_attendee?(group, payload)
        group.attendee?(payload) ? failure(:group_attendee) : success()
      end

      def find_or_create_by_email(payload)
        Try() { model.find_or_create(payload) }.to_result
      end
    end
  end
end

class Group
  def attendee?(payload)
    users.where(payload).exists?
  end

  def enroll(user)
    self.users << user
    self
  end
end

class User
  def self.find_or_create(payload)
    find_by_email(payload[:email]) || create!(payload)
  end
end

You can see that I got a different code based on issues which I tried to describe on the top. In this code you can see business steps that you need to do to make something happen (validation -> user verification for specific source group -> enrolling user). Also, I dropped unnecessary services and move logic to models with context related names.

This code is not great, also, different developers will use different ways to write this logic and I’m not sure that “true” way exists here. But if you compare services you see that sometimes a better name is more than separate service and one more abstraction.

Also, you will get a code that can be covered by unit tests without any pain. For example, you can test business logic in #group_attendee? without any integration tests and complicated preparation of the data:

RSpec.describe Cource::Services::EnrollUser, type: :service do
  subject { service.call(group: group, params: params) }

  let(:service) { described_class.new(model: model, validator: validator) }

  let(:model) { ... }
  let(:validator) { ... }

  context 'when user is an attendee for a group' do
    let(:group) { instance_double('Group', attendee?: true) }

    # your tests for one case of logic
  end

  context 'when user is not an attendee for a group' do
    let(:group) { instance_double('Group', attendee?: false) }

    # your tests for other case of logic
  end

  context 'test case with real dependencies for test everythign together' do
    subject { service.call(...) }
    let(:service) { described_class.new }

    # some data preporation

    it { expect(subject).to be_success }
  end
end

Note to testing part: I’m thinking that you should use the unit and integration testing for full coverage. In my example, I’ll also add 1+ integration test for test all contracts between dependencies to be sure that everything is okay with real code and data.

Conclusions

Use context instead of implementation in your code. Context is really important from a maintainability perspective and your colleagues and you from the future say “thank you”. Also, you can skip unnecessary questions on PR/MR review process and make it faster;
Using a good naming is extremely hard. I spent more than 3 years to start writing something understandable for other developers. I can suggest some rules which help me every day;
- Imagine a real world process. For example in the original example try to imagine how this logic should work from a user perspective. Forget about CRUD or SQL implementation. Just write real steps on how a user can do something. In my case, I wrote, “as a user if I have valid data in my form or profile AND if I didn’t attend this course group I can attend”. Based on these words I found important steps and used this note for creating names for my methods/services;
- If you want to use common words like user_exists_check, input_validate, etc. make a pause and ask yourself what you want to explain from real world perspective;
- This approach takes some time and can be difficult. But it can be good practice for improving your skills as a developer. And knowing a domain can be useful in the future to understand tasks or communicate with colleagues better;
Sometimes is better to use models for DB logic instead of creating a new service object with common behavior;
It’s a good idea to split data and dependencies for each service object. In this case, you can avoid unnecessary allocation, cache some initializations and drop mutable state inside objects;
Using model methods instead of a chain of DSL methods can be profitable from two perspectives: adding a good name for each DB request instead of a “pure” SQL and simplify unit testing and avoiding mocking chain of methods;

Useful links

dry-monads and DO notations guide - if you never work with it and don’t know how it works;
Event storming - you can try to adopt this idea to get more context and information about your system;
Tim’s talk where he described dry-rb ideas and services with separated data and dependencies;

UPD

Added validate_raw_data method. Thanks mpak for mention it (from comments)

Profiling your SQL queries in hanami (or ROM)

2017-01-28T00:00:00+00:00

It just happened I had profile SQL query in my hanami application. And I want to save this knowledge that’s why I created this post.

If you are using ROM, this post will be helpful for you too, because hanami-module uses ROM. So, in hanami, you have a simple ability for profiling your SQL queries.

For that, you need to use some methods for Sequel::Dataset instance.

Fox example, if you want to get pure sql sting you can use #sql method:

>> puts UserRepository.new.users.where(admin: true).dataset.sql
SELECT * FROM "users" WHERE ("admin" IS TRUE) ORDER BY "users"."id"
=> nil

or if you need to call ANALYZE or EXPLAIN psql methods you can use similar methods:

>> puts UserRepository.new.users.where(admin: true).dataset.analyze
Sort  (cost=19.38..19.79 rows=165 width=213) (actual time=0.019..0.019 rows=1 loops=1)
  Sort Key: id
  Sort Method: quicksort  Memory: 25kB
  ->  Seq Scan on users  (cost=0.00..13.30 rows=165 width=213) (actual time=0.013..0.014 rows=1 loops=1)
        Filter: (admin IS TRUE)
        Rows Removed by Filter: 1
Planning time: 4.362 ms
Execution time: 0.039 ms
=> nil

>> puts UserRepository.new.users.where(admin: true).dataset.explain
Sort  (cost=19.38..19.79 rows=165 width=213)
  Sort Key: id
  ->  Seq Scan on users  (cost=0.00..13.30 rows=165 width=213)
        Filter: (admin IS TRUE)
=> nil

That’s all, happy profiling! 🚀

Ruby tips #2

2016-11-23T00:00:00+00:00

It’s a second part of my post series about ruby tips. Today you’ll learn more about:

Special values
Symbol
Array
Hash
Range

CAUTION: These tips are not equally feat to production. Lots of them are just interesting solutions which you’ll not find anywhere else. Use them at your own risk.

Special values

Safe Levels

Full description

In ruby you can find security levels for your code. The Ruby security level is represented by the $SAFE global variable. The value ranges from minimum value 0 to maximum value 4.

$SAFE	Constraints
0	No checking of the use of externally supplied (tainted) data is performed. This is Ruby’s default mode.
>= 1	Ruby disallows the use of tainted data by potentially dangerous operations.
>= 2	Ruby prohibits the loading of program files from globally writable locations.
>= 3	All newly created objects are considered tainted.
>= 4	Ruby effectively partitions the running program in two. Nontainted objects may not be modified. Typically, this will be used to create a sandbox: the program sets up an environment using a lower$SAFE level, then resets $SAFE to 4 to prevent subsequent changes to that environment.

Email Regexp

In ruby you can find regexp for emails. If you want to use it, you have to require uri library and call URI::MailTo::EMAIL_REGEXP constant.

DATA object

The global DATA variable in ruby allows us to access the text at the end of our file listed after the __END__ block. This can be surprisingly useful, for instance if we need to extract information from a rather large data blob.

# in one file
require "json"

puts JSON.load(DATA) # this DATA required text bellow __END__

__END__
{
  "records": [
    {
      "artist":"Iggy Pop",
      "title":"Lust for Life"
    },
    {
      "artist":"Television",
      "title":"Marquee Moon"
    },
    {
      "artist":"Talking Heads",
      "title":"Talking Heads: 77"
    }
  ]
}

Symbol

#all_symbols

Documentation

Return array with all symbols in env.

Symbol.all_symbols.size # => 5675

id2name

Documentation

Alias for #to_s (I don’t know why you need to use this but it’s a funny method I think).

:test.id2name   #=> "test"

slice

Documentation

Alias for sym.to_s[].

:hello_world.slice(0..4) #=> "hello"
:hello_world.[0..4]      #=> "hello"

Array

#bsearch

Documentation

ary = [0, 4, 7, 10, 12]
ary.bsearch {|x| x >=   4 } #=> 4
ary.bsearch {|x| x >=   6 } #=> 7
ary.bsearch {|x| x >=  -1 } #=> 0
ary.bsearch {|x| x >= 100 } #=> nil

Range to array

You can use * operator for converting range to array.

range = (1..10)

range.to_a == [*range] # => true

Hash

`**` method

You probably know already how to use * in method definition argument list. But ** is less known.

def method_name(value, *attr, **options)
  p attr
  p options
end

method_name('hello', 'cruel', 'world', collor: :red)
# => ['cruel', 'world']
# => { collor: :red }

Also you can call this method like [*attr]

hash = { a: :b, c: :d }

{ **hash, e: :f } # => {:a=>:b, :c=>:d, :e=>:f}

#gsub with hash args

str = "Help! All parentheses have been flipped )and I am sad(!"
str.gsub(/[\(\)]/, {"("=>")", ")"=>"("})
# => "Help! All parentheses have been flipped (and I am sad)!"

Non string and symbol keys

hash = { false => 'No', :to_s.to_proc => 'proc' }

hash[10 < 5]        # => "No"
hash[:to_s.to_proc] # => "proc"

Hash#assoc

This method returns a two element array [key, hash[key]]

{a: 1, b: 2}.assoc(:b) # => [:b, 2]

Range

#cover? and time

((Time.now - 1.hour)..(Time.now + 1.hour)).cover? (Time.now - 1.day) # => false
((Time.now - 1.hour)..(Time.now + 1.hour)).cover? Time.now           # => true

Ranges in case statements

age = 28

case age
when 01..17 then "Young"
when 18..50 then "Adult"
when 50..99 then "Old"
end

Conclusions

That’s all. I hope it’ll be useful for you. In next part we’re gonna talking about:

Tracing Ruby Code
memory usage
Enumerable
Compiler
Rspec
Rails

Happy hacking! 🚀

Ruby tips #1

2016-11-16T00:00:00+00:00

I’ve been collecting the ruby tips for a long time. And now I’m ready to share them all. Hope you’ll find some interesting solutions, tips and sugars for ruby.

And today we’re talking about:

Kernel
Class
Object
Proc (lambda)
Method

CAUTION: These tips are not equally feat to production. Lots of them are just interesting solutions which you’ll not find anywhere else. Use them at your own risk.

Kernel

Char

If you want to get string with only one char you can use ?* syntax. Also you can use this hack in various methods like ‘join’

?a == 'a' # => true

[1, 2, 3].join(?:) # => "1:2:3"
[1, 2, 3] * ?: # => "1:2:3"

callcc

You can find callcc method in any language. Ruby is no exception.

caller

Documentation

If you want to return the current execution stack you could use Kernel#caller method.

def a(skip)
  caller(skip)
end

def b(skip)
  a(skip)
end

def c(skip)
  b(skip)
end

c(0)   #=> ["prog:2:in `a'", "prog:5:in `b'", "prog:8:in `c'", "prog:10:in `<main>'"]
c(1)   #=> ["prog:5:in `b'", "prog:8:in `c'", "prog:11:in `<main>'"]
c(2)   #=> ["prog:8:in `c'", "prog:12:in `<main>'"]
c(3)   #=> ["prog:13:in `<main>'"]
c(4)   #=> []
c(5)   #=> nil

itself

Ruby went out and got itself an identity method. For those not familiar, an identity method returns the object it’s called on:

1.itself # => 1

`j` and `jj`

When you require json library you get two interesting methods. First is Kernel#j. This method outputs object to STDOUT as JSON strings in the shortest form, that is in one line.

require 'json'

h = { a: 1, b: 2 }
j(h)

And second is Kernel#jj This method outputs object to STDOUT as JSON strings in a pretty format, with indentation, and over many lines.

require 'json'

h = { a: 1, b: 2 }
jj(h)

Class

allocate

Documentation

Allocates space for a new object of class’s class and does not call initialize on the new instance. The returned object must be an instance of a class.

class Test
  def initialize
    @var = "new"
  end
end

Test.new      # => #<Test:0x007ff2a34965b8 @var="new">
Test.allocate # => #<Test:0x007ff2a34965b8>

Documentation

Usful blog post about refinements

Refinements are designed to reduce the impact of monkey patching on other users of the monkey-patched class. Refinements provide a way to extend a class locally.

module TimeExtensions
  refine Fixnum do
    def minutes; self * 60; end
  end
end

class MyApp
  using TimeExtensions

  def initialize
    p 2.minutes
  end
end

MyApp.new    # => 120
p 2.minutes  # => NoMethodError

Object

tap

Documentation

Yields x to the block, and than returns x.

(1..10)              .tap{ |x| puts "original: #{x.inspect}" }
  .to_a              .tap{ |x| puts "array:    #{x.inspect}" }
  .select{|x| x%2==0}.tap{ |x| puts "evens:    #{x.inspect}" }
  .map{ |x| x * x }  .tap{ |x| puts "squares:  #{x.inspect}" }

Proc (lambda)

curry

Documentation

Ruby defines curry for Method and Proc, allowing procs to return partially applied procs when they get called with fewer than the required number of arguments.

For example:

multiply = -> x,y { x * y }.curry
#=> #<Proc:0x007fed33851510 (lambda)>
multiply[2,3]
#=> 6
double = multiply[2]
#=> #<Proc:0x007fed35892888 (lambda)>
double[3]
#=> 6

Note: While Proc#curry has been around since Ruby 1.9, Method#curry was only added in Ruby 2.2.0. For versions before 2.2.0, you will first need to convert your method object to a proc via Method#to_proc.

#to_proc and #method

Documentation

If you need call method with args in to_proc you can use method method:

[:asd, :bsd].map{ |i| puts i }
# it's like as
[:asd, :bsd].map(&method(:puts))

All ways to call proc (lambda)

You can use 7 different ways to call lambda:

p = -> { "hello" }

p.call()
p::()
p.()
p[]
p.yield
p.===
p.send(:call)

Method

method

You can call some methods with method method. This method returns Method class. And after that you’re just calling this object like simple proc object:

# 'method' method
sin_method = Math.method(:sin)
(1..10).map(&sin_method)

# lambda style
sin_method = -> (x) { Math.sin(x) }
(1..10).map(&sin_method)

Block

Empty block

>> [1, 2, 3].map
# => #<Enumerator: [1, 2, 3]:map>

# or
>> [1, 2, 3].map(&nil)
# => #<Enumerator: [1, 2, 3]:map>

You can send &nil as an empty block.

Conclusions

That’s all. I hope it’ll be useful for you. In next part we’re gonna talking about:

Special values in ruby world
Symbol
Array
Hash
Range

Happy hacking! 🚀

Adding domain for your github project

2016-09-20T00:00:00+00:00

I have a problem. Each time I want add domain to my custom github project I forget what I should do exactly. That’s why I want to post this SO answer in my blog. I hope it would helpful not only for me.

To Setup a custom domain for your gh-pages project repo that handles www.yourdomain.com and yourdomain.com (assumes you already have a gh-pages branch on your repo) you need this:

From your project repo, gh-pages branch. Create a CNAME file with the contents yourdomain.com.
In your DNS manager, setup two CNAME records. One for the root apex (@) and one for www. Both point to YOURusername.github.io. If your DNS provider does NOT support ALIAS records on the root apex (@), simply create A records that point to 192.30.252.153 and 192.30.252.154.

After that wait til your name servers update:

dig yourdomain.com +nostats +nocomments +nocmd

Original link: stackoverflow.com/a/9123911

Preview hanami emails in browser

2016-05-21T00:00:00+00:00

Sometimes you need to preview your emails in development enviroment. For this you can use use letter_opener gem. Because hanami uses mail gem, letter_opener integration will be easy. Firstly you need add gem to your Gemfile:

gem "letter_opener", group: :development

Secondly you need add new delivery method to your lib/repository_name.rb file:

require "letter_opener"
Hanami::Mailer.configure do
  delivery do
    development LetterOpener::DeliveryMethod, location: Hanami.root.join('tmp/letter_opener')
  end
end.load!

After that when you deliver your email, letter_opener will generate html files that users will see in tmp/letter_opener directory.

Building your rails API with roda

2016-05-20T00:00:00+00:00

Introduction

Sometimes you need to build API serveice in your rails application. Of course you can use popular solutions as grape or rails-api gems. And also you can find real examples in gitlab or rubygems projects.

But today I’m going to tell you about other framework. It’s roda. Roda was created by Jeremy Evans and it’s fast and simple ruby routing framework. So why should you take a look on it?

There’s a list of advantages of this framework:

Fast;
Simple;
Roda provides simple way to working with big count of different plugins;
You can use any architecture with it;

So I mentioned that roda is fast. If you want to verify this, just check this benchmark repository and you’ll see that roda is really fast. For example, I run benchmarks on locally and get this result:

Framework            Requests/sec  % from best
----------------------------------------------
mustermann                9389.60       100.0%
roda                      9252.03       98.53%
rack                      9246.16       98.47%
hanami-router             6240.81       66.47%
sinatra                   2935.63       31.26%
grape                     2512.17       26.75%

Integration

Roda based on rack. That’s why this integration with rails will be very simple. Firstly you need to add roda gem to your gemfile:

gem 'roda'

Secondly you need to create simple roda application. Note that you need to use json and all_verbs plugins. The first one needs to JSON responce and the second one provides all REST methods for your application (like put, patch, etc). I puted my roda application in to lib/api/base.rb path but you can use whatever you waht.

# lib/api/base.rb
require 'roda'
require 'json'

module API
  class Base < Roda
    plugin :json
    plugin :all_verbs

    route do |r|
      r.on "v1" do
        r.get 'hello' do
          { hello: :world }
        end
      end
    end
  end
end

After that you need to mount your application in config/routes.rb. This is done as well as any other rack application:

# config/routes.rb
require './lib/api/base'
mount API::Base => '/api'

And the last part, we need to split our application to different modules with different logic and routes. For this we have to create required module. In an example I created Users module with all REST routes:

# lib/api/users.rb
module API
  class Users < Roda
    plugin :json
    plugin :all_verbs

    route do |r|
      r.is 'users' do
        r.get do
          { users: User.last(10) }
        end

        r.post do
          { user: User.new }
        end
      end

      r.is 'users/:id' do |id|
        user = User.find(id)

        r.get do
          { user: user}
        end

        r.patch do
          { user: 'updated' }
        end

        r.delete do
          { user: 'deleted' }
        end
      end
    end
  end
end

Finnaly you need to mount our module to roda application. It is very simple too.

# lib/api/base.rb
require 'roda'
require 'json'
require 'users'

module API
  class Base < Roda
    plugin :json
    plugin :all_verbs

    route do |r|
      r.on "v1" do
        r.run API::Users
      end
    end
  end
end

That’s all. Now we have a simple roda API application which integrated to our rails app.

Problems / future

In the last part I want to list problems and ideas what I want to solve in future.

Roda doesn’t have a swagger integrating from the box. Now I’m thinking about using swagger-block gem for it.
Also roda doesn’t typecast your params. I know that grape uses virtus gem for this. And this feature you should realize by youself too.

Conclusion

On this blog post I wanted to show you that you’re not limited only to popular API server gems. As you can see roda have amazing ideas and properties such as modulatiry, simplicity, speed and stability. Also this framework has a simple way to integration in to your rails application.

Happy hacking! emoji

Adding anchors to your middleman project

2016-05-14T00:00:00+00:00

All people love anchors. It’s helpful, cool and practical. If you want to add anchors to you middleman project you need to follow the following steps.

First: we need to create a new renderer class. In this class we’ll put <a> tag inside <h> tag. Also, we’ll realize anchor svg in guthub style:

require 'middleman-core/renderers/redcarpet'

class GithubStyleTitles < Middleman::Renderers::MiddlemanRedcarpetHTML
  def header(title, level)
    @headers ||= []
    permalink = title.gsub(/\W+/, '-')

    if @headers.include? permalink
      permalink += '_1'
      permalink = permalink.succ while @headers.include? permalink
    end
    @headers << permalink

    %(
      <h#{level} id=\"#{permalink}\" class="title">
        <a name="#{permalink}" class="anchor" href="##{permalink}"></a>
        #{title}
      </h#{level}>
    )
  end

private

  def anchor_svg
     <<-eos
       <svg aria-hidden="true" class="octicon octicon-link" height="16" version="1.1" viewBox="0 0 16 16" width="16">
       <path d="M4 9h1v1h-1c-1.5 0-3-1.69-3-3.5s1.55-3.5 3-3.5h4c1.45 0 3 1.69 3 3.5 0 1.41-0.91 2.72-2 3.25v-1.16c0.58-0.45 1-1.27 1-2.09 0-1.28-1.02-2.5-2-2.5H4c-0.98 0-2 1.22-2 2.5s1 2.5 2 2.5z m9-3h-1v1h1c1 0 2 1.22 2 2.5s-1.02 2.5-2 2.5H9c-0.98 0-2-1.22-2-2.5 0-0.83 0.42-1.64 1-2.09v-1.16c-1.09 0.53-2 1.84-2 3.25 0 1.81 1.55 3.5 3 3.5h4c1.45 0 3-1.69 3-3.5s-1.5-3.5-3-3.5z"></path>
       </svg>
     eos
  end
end

After that we need to call our renderer in :markdown configuration:

set :markdown, fenced_code_blocks: true, smartypants: true, renderer: GithubStyleTitles

And the last step: we need to stylize our anchor with css:

.anchor {
  padding-right: 2px;
  margin-left: -18px;
  display: none;
}
.title .anchor {
  display: inline-block;
}

After all this steps we’ll get something like this:

I hope it will be useful to you as well as for me at one time.

Happy hacking! 💚

Simplest way to authenticate user in hanami app

2016-03-16T00:00:00+00:00

If you need the simplest and easiest way to adding authentication logic in your hanami app (to admin app for example) you always can use Rack::Auth::Basic class.

For this you need to add following lines of code to your controller.prepare configuration block:

# apps/admin/application.rb

controller.prepare do
  # ...
  # some code

  use Rack::Auth::Basic, 'Message' do |username, password|
    username == 'admin' && password == 'password'
  end
end

Happy authenticating!

P.S.: also if you need something more complicated you can reed this thread on hanami forum.

Profiling minitest examples with Stackprof

2015-12-15T00:00:00+00:00

Today I read a nice blog post by Kir Shatrov about Profiling RSpec examples with Stackprof and I wondered if I could repeat this trick with minitest? This question is very important for me because I ofen use minitest for my job and OSS projects. Also a lot of cool projects use minitest (for example, sidekiq, rails, lotus, etc).

In reality, to do that in minitest as easy as in RSpec, and the only difference is that you need to install a separate gem.

Firstly you have to install minitest-around gem;
And secondly you have to add this block of code to your test_helper file;

# test/test_helper.rb
require 'stackprof'
require 'minitest/around/spec'

class Minitest::Test
  def around(&example)
    path = "path/to/repo/tmp/stackprof.dump"
    StackProf.run(mode: :object, out: path.to_s) do
      example.call
    end
  end
end

Happy profiling!

Rendering ruby block result in layout file

2015-12-13T00:00:00+00:00

If you want to render some result of ruby block in your layout file, you may run into some problems. For example, your result may be repeated on page or you can get something worse.

let’s assume we have these methods:

def add_to_head(&block)
  @head_html ||= []
  @head_html << block if block_given?
end

def display_custom_head
  return unless @head_html
  @head_html.map(&:call).join
end

Of cource you can use captire method from rails and sinatra-contrib librares. But what will you do if you can’t use these methods or you need something easier?

I faced a similar problem (for example, in sidekiq) and I used own capture method for layout files.

def capture(&block)
  block.call
  eval('', block.binding)
end

And after that we can update our display_custom_head method:

def display_custom_head
  return unless @head_html
  @head_html.map { |block| capture(&block) }.join
end

I hope it will be useful to you as well as for me at one time.

Happy hacking!

Ignore file lines in git

2015-11-14T00:00:00+00:00

For example, you have this code and you want to ignore in git lines which contain username and password values:

def ssh_connect
  username = "root" # ignore this line
  password = "password" # ignore this line too
  ip = "192.168.1.1"
  # ...
end

To ignore some special lines in git you need to:

Create a .gitattributes in your repository (remember that .gitattributes will be committed into the repository, if you don’t want that, add it to .git/info/attributes)
Add *.rb filter=ignoreline (run filter named ignoreline on all *.rb files)
Now, we need to define ignoreline filter in .gitconfig
git config --global filter.ignoreline.clean "sed '/#ignoreline$/'d" (delete theses lines)
git config --global filter.ignoreline.smudge cat (do nothing when pulling file from the repository)

And then, you can ignore some lines using #ignoreline comment:

def ssh_connect
  username = "root" #ignoreline
  password = "password" #ignoreline
  ip = "192.168.1.1"
  # ...
end

Happy hacking!

Write simple scheme interpreter on ruby

2015-11-01T00:00:00+00:00

TL;DR: github repo

Every developer has a moment in his life where he wants to write his own programming language. In this article, I want to show you how to do this for a simple lisp compiler.

Why scheme and lisp?

Firstly, lisp is very simple for create and for understanding. Lisp (LISt Processor) is a family of languages which is based on the idea of S-expressions. S-Expression are needed for data representation and may consist of atoms (numbers, symbols, boolean expressions) or are the expression of the form (x . y) where x and y are s-expressions. This expression may be formed as lists ((1 . ( 2 . 3)) this equals (1 2 3)) and trees (((1 . (2 . 3)) . (4 . 5))).

Secondly, after creating interpreter you can better understand the language (the author fully understood the environment idea). Also you can understand the main idea of compilers and interpreters.

Now let’s begin our journey into the world of compilers and interpreters so that we can write a simple scheme interpreter.

Main idea

Our language will contain two parts: a parser which translates the string to AST and eval function. This function will take the AST with envariement value and will return the result of the code.

Schematically, it looks like this:

code(string) => parse function => AST => eval function => result

First step. Parser.

To begin, let’s define what we want to get. For example, we have a string '(+ 1 1 1)'. What should our parser return? What kind of data structure should we receive? I think, that an array would be correct.

Let write simple test code:

program = '(+ 1 1 1)'
lisp = Lisp.new
lisp.parse(program) == [:+, 1, 1, 1]

As you can see, this is a simple code, so I just displayed parse method code:

class Lisp
  def parse(program)
    tokenize(program)
  end

  def tokenize(chars)
    chars
      .gsub(/\s\s+/, ' ')
      .gsub('(', ' ( ')
      .gsub(')', ' ) ')
      .split(' ')
      .map{ |token| atom(token) }
      .compact
  end

  def atom(token)
    if token[/\.\d+/]
      token.to_f
    elsif token == '(' || token == ')'
      nil
    elsif token[/\d+/]
      token.to_i
    else
      token.to_sym
    end
  end
end

As you know, in lisp you can write your code with nested operators, for example - (+ (* 2 2) (- 5 3)). And this code will return 6.

When we use our parser for this code, the result is not quite what we need, so let’s update our test code:

program = '(+ (* (1 2) 3) 4)'
lisp = Lisp.new
lisp.parse(program) == [:+, [:*, [1, 2], 3], 4]

As you might guess, the most obvious way to fix our code is to call parse method in recursion and all array elements from '(' to ')'. We will move to a nested array. The code will be look loke this:

class Lisp
  def parse(program)
    read_from_tokens(tokenize(program))
  end

  def tokenize(chars)
    chars
      .gsub(/\s\s+/, ' ')
      .gsub('(', ' ( ')
      .gsub(')', ' ) ')
      .split(' ')
  end

  def read_from_tokens(tokens)
    return if tokens.empty?

    token = tokens.shift

    if '(' == token
      list = []

      while tokens.first != ')'
        list << read_from_tokens(tokens)
      end
      tokens.shift

      list
    elsif ')' == token
      raise 'unexpected )'
    else
      atom(token)
    end
  end

  def atom(token)
    if token[/\.\d+/]
      token.to_f
    elsif token[/\d+/]
      token.to_i
    else
      token.to_sym
    end
  end
end

We did it! Let’s start to make eval method.

Eval method

As I said earlier, our interpreter consists of two parts: a parser and eval function.

The eval function will take two arguments: an expression, exp, that we want to evaluate, and an environment, env, in which to evaluate it. An environment is a mapping from variable names to their values. By default, eval will use a instance value that includes the names for a bunch of standard things.

let’s implement @env variable with car, cdr and cons functions:

env = {
  :car  => lambda { |*list| list[0] },
  :cdr  => lambda { |*list| list.drop 1 },
  :cons => lambda { |(e, cell), _| [e] + cell },
}

The next step is to make eval function which will look for a match on the first element of the input array

class Lisp
  def initialize(ext = {})
    @env = {
      :car   => lambda { |*list| list[0] },
      :cdr   => lambda { |*list| list.drop 1 },
      :cons  => lambda { |(e, cell), _| [e] + cell },
    }.merge(ext)
  end

  def eval(exp, env = @env)
    env[exp.first].(exp[1..-1])
  end

  # ...
end

Now we have a problem: what will happen when the first element of the array will be not be a symbol (integer for example) and what will be happen when we have nested functions? I think we can add a check to the element type like this:

class Lisp
  def initialize(ext = {})
    @env = {
      :car   => lambda { |*list| list[0] },
      :cdr   => lambda { |*list| list.drop 1 },
      :cons  => lambda { |(e, cell), _| [e] + cell },
    }.merge(ext)
  end

  def eval(exp, env = @env)
    if exp.is_a? Numeric
      exp
    elsif exp.is_a? Symbol
      env[exp]
    else
      code = eval(exp[0], env)
      args = exp[1..-1].map{ |arg| eval(arg, env) }
      code.(*args)
    end
  end

  # ...
end

Some (eg arithmetic), we can easily add to env variable, and some do not. Therefore, we need to extend the checking in eval function. We will add a check for function name. For example, the code below will demonstrate quote and if functions:

def eval(exp, env)
  # ...
  elsif exp[0] == :quote
    exp[1..-1]
  elsif exp[0] == :if
    _, test, conseq, alt = exp
    exp = eval(test, env) ? conseq : alt
    eval(exp, env)
  # ...
end

The next step is to initialize define and lambda functions. In scheme define function syntax is as follows:

(define name
  (expression))

And our code must create a new key-value pair in the env hash:

def eval(exp, env)
  # ...
  elsif exp[0] == :define
    _, var, e = exp
    env[var] = eval(e, env)
  # ...
end

The last function, lambda in scheme will have this syntax:

(lambda (arg1, arg2, ...)
  (block of code))

The first thing that comes to mind is to return the new lambda object with a new value inside env that will serve our code:

def eval(exp, env)
  # ...
  elsif exp[0] == :lambda
    _, params, e = exp
    lambda { |*args| self.eval(e, env.merge(Hash[params.zip(args)])) }
  # ...
end

As you can see, we made basic functionality of the our interpreter. I will leave learning how to do the implement the arithmetic methods and other methods such as true, false, list, etc up to the reader.

REPL

In main REPL have really simple idea repl takes single user inputs, evaluates them, and returns the result to the user. And all this is happens in an infinite loop:

def repl(prompt = 'lisp >> ')
  while true
    print prompt
    program = gets

    p eval(parse(program))
  end
end

As a result, you should get something like this:

lisp >> (define pi 3.14)
3.14
lisp >> (define circle-area (lambda (r) (* pi (* r r))))
#<Proc:0x007fa6140c6cc0@lib/rlisp.rb:86 (lambda)>
lisp >> (circle-area 11)
379.94

Conclusions

Right now, we have a simple scheme interpreter. It is easy to expand since we wrote a simple repl, and considered the basic idea of the interpreter. In this article, we did not consider such important concepts as macros, multithreading, code optimization, work with the system, and much more. These concepts will be discussed in future articles.

Get request with custom locale in your tests

2015-10-26T00:00:00+00:00

Sometimes in tests you have to set special locale for get request. For example you want to test selecting locale language. For this you have to set locale in 'HTTP_ACCEPT_LANGUAGE' variable in params hash.

it 'your test description' do
  rackenv = {'HTTP_ACCEPT_LANGUAGE' => 'ru,en'}
  get '/', {}, rackenv

  ...
end

Memory profiler tools for ruby

2015-04-05T00:00:00+00:00

Memory profiler tools for ruby It so happened that I was need know how much ruby objects created for each call sidekiq perform_async method (mperham/sidekiq#2288). That’s why I decided to create list with tools which helps you to know all required information.

1. Ruby GC

Sam Saffron has written great post, in which he talk about ruby garbage collector and wonderful GC.start method which returns data hash:

2.2.0:001 > GC.stat
# => {:count=>21, :heap_allocated_pages=>236, :heap_sorted_length=>237, :heap_allocatable_pages=>0, :heap_available_slots=>96193, :heap_live_slots=>95354, … }

Also author mentions a ObjectSpace module that lets you know information about object/memory management. For example you can easily know general number of created objects. For this you need write this code:

2.2.0:002 > ObjectSpace.count_objects[:TOTAL]
# => 96193

2. Ruby Memory Profiler

Also Sam wrote great tool (ruby-memory-profiler) which provide easily display all required information for any code in block. For this you will need call something like this (I called this code in my sidekiq reduce allocation PR):

MemoryProfiler.report{ 100.times{ HardWorker.perform_async } }.pretty_print

3. ruby-prof

General features:

display different reports;
fast;
easily profiles rails apps;

How to use:

require 'ruby-prof'

# Profile the code
RubyProf.start
# [code to profile]
RubyProf.pause
# [other code]
RubyProf.resume
# [code to profile]
result = RubyProf.stop

Conclusions

Profiling Ruby isn’t as difficult as it seems at first glance. There are a lot of great libraries. The only thing I was missing — profiling the code from a file, but I’m sure it will soon add (maybe it will add myself ☺ ).

Convert string to color hash

2015-03-29T00:00:00+00:00

So it happens that sometimes you need to convert string to color hash. I think that Digest::MD5 class is easiest way for this. For this you need call hexdigest method with necessary string.

Digest::MD5.hexdigest('My string')[0..5] # => 'a537d0'

And if you will create rgb color you need convert hex to decimal with to_i(16) method.

Digest::MD5.hexdigest(worker)[0..5]
  .scan(/../)
  .map{ |color| color.to_i(16) }

История vim

2014-03-16T00:00:00+00:00

Я свято верю, что перед тем, как изучать новую технологию, необходимо узнать, зачем и в каких условиях она была создана. Думаю, данные знания позволяют в будущем не только не забивать гвозди микроскопом, но и не спрашивать, почему они так плохо забиваются. Поэтому первую запись из цикла статей, связанных с vim-ом, я бы хотел начать с истории его становления и небольшого описания его функционала.

Представьте себе: 70тые годы, расцвет unix машин, на данный момент существует только текстовый редактор ed, который является командно-ориентированным, а за ним появляется редактор ex. Во времена первого никто не слышал о мониторах, поэтому использовали для ввода телетайпы, из-за чего ed имеет командно-ориентированный интерфейс. А ex, в свою очередь, являлся улучшеным ed. Поэтому в нем появились такие штуки как экранное редактирование и работа с несколькими файлами, что для тех времен является прорывом. В это время многие программисты начинают писать свои редакторы, и один из них, Билл Джой, придумывает логичную и простую концепцию поверх редактора ex. Во первых, было бы логично воспринимать текст как объект, к которому применяются команды редактирования. Во вторых, использование unix идеологии о простоте и взаимности комманд. Так, в 1976 году, появляется первая версия текстового редактора vi, сокращено от (visual). Давайте рассмотрим каждую из концепций отдельно.

Во первых, человек часто мыслит абстрактно, поэтому мы никогда не воспринимает набор последовательных символов как непосредственно набор последовательных символов. Наш разум создает абстракции, такие как слова, предложения, параграфы или абзацы и тому подобные. Так почему бы нам не реализовать эту же идею в текстовом редакторе? Думаю, этим же вопросом задался Билл Джой, и поэтому vi оперирует не просто с набором символов, как многие другие текстовые редакторы, а оперирует непосредственно объектами-абстракциями: словами, строками, параграфами.

Допустим, мы смогли реализовать такую идею внутри редактора, но теперь встает вопрос, что делать с этими объектами? Да собственно то же самое, что мы, доблестные воины клавиатуры и текста, делаем с ними каждый день - изменять их посредством передачи в функций. Кстати, часть функций можно позаимствовать из unix-а, например, sort и ему подобные. Поэтому на данный момент наше взаимодействие с редактором можно описать простым набором функций вида: [комманда] [объект].

А теперь самое интересное, как мы реализуем такое количество комманд и способов выбора объектов, и при этом нам надо как то печатать обычный текст. Думаю, многие понимают, что использовать все клавиши для комманд и для набора текста - не реально вообще никак. А тем более на такой клавиатуре, которую использовали в терминалах того времени.

Кстати, небольшой оффтоп, вы никогда не задумывались, откуда пошло, что символ ‘~’ в nix like системах обозначает home дирикторию? Посмотрите внимательно на клавиатуру выше, а именно на клавишу home ;)

Так вот, тут-то мы и приходим к модальному интерфейсу. Что же это значит? Это значит, что существует несколько режимов, в которых различные клавиши выполняют различные комманды. В vi было целых 2 режима: режим вставки, в котором пользователь мог набирать текст, и коммандный режим, в котором пользователь, посредством нажатия комбинаций клавиш, работает с текстом.

Вся прелесть данного текстового редактора была не только в его инновациях, но и в его открытости, что позволило в 1991 году Браму Мооленару создать первую версию vim, которая расшифровывается как Vi improved. В нем было очень много нового, например, визуальный режим, макросы, работа с кучей файлов одновременно, итеграция с ОС и так далее.

Так что же это все дает нам, обычным программистам? Во первых, мы можем приобщиться к истории, а если серьезно - ввиду того, что раньше не было мыши, то все комманды печатались на клавиатуре, и никакие Васи не тыкали мышкой в кнопочки на экране. Ну а так как тыкаться мышкой в интерфейсе дольше, чем использовать хоткеи, то мы получаем довольно сильный профит в скорости. Во вторых, интерфейс не перегружен излишней функциональностью, как во многих IDE или текстовых редакторах. Предлагаю вам сравнить скриншоты vim-а и какого-нибудь eclipse.

Сказать по правде, я давно хотел спросить, вы часто тыкаете во все эти кнопки в cтроке наверху?

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

Но для начала стоит вернуться к режимам. В vim-е их 4: нормальный, в котором вы посредством хоткеев выполняете операции над текстом; коммандный, в котором вы можете вводить комманды как в консоли(и, кстати, выполнять консольные комманды тоже); режим вставки, в котором вы можете набирать текст и оперировать им, как в обычном текстовом редакторе, а-ля sublime; ну и последний, визуальный, в котором вы можете выбирать текст для дальнейшего взаимодействия с ним. Стоит отметить, что визуальных режимов 3 - обычный, в котором вы выбираете текст посимвольно, строчный, в котором вы вы выбираете текст построчно, и блочный, в этом режиме вы задаете 2 точки прямоугольника, весь текст в котором выделяется и пригоден для взаимодействия. ( Сказать по правде, есть еще один режим, режим эмуляции ex редактора. Вызывается он с помощью Q, обязательно с шифтом, после чего вы попадаете в отдельное окно, в котором вы можете вводить комманды без префикса :. Чтобы выйти из этого режима достаточно набрать visual или vi. Для справки советую набрать :h Ex-mode в vim. )

Исходя из всего, что я написал выше - вам придется полностью изменить свое отношение к взаимодействию с текстом, что, в свою очередь, позволит вам увеличить вашу скорость редактирования/поиска текста. Скажу сразу, это непривычно, но с другой стороны, это как изучение нового языка программирования. Вы можете оставаться в собственной зоне комфорта, а можете сломать свой мозг, изучив какой-нибудь lisp или haskell. Тут то же самое, вы можете всю жизнь использовать привычный sublime, а можете попробовать что-то новое. Ну а в следующей записи мы более детально обсудим редактор и рассмотрим, как же он может облегчить нам жизнь.

Seed файл и вы

2014-03-10T00:00:00+00:00

Совсем недавно, на работе, потребовалось мне заполнить новый проект данными для дальнейшего тестирования и разработки. Конечно же, данные должны быть в любом виде, и первое, о чем я подумал, был seed файл, поэтому сегодня мы поговорим именно о нем. Как всем известно, данный файл служит для генерации данных в рельсовых приложениях. Вы пишите скрипт, выполняете rake db:seed и радуетесь жизни. В моем случае данные были типовыми, а именно, нужно было сгенерировать пользователей, посты и комментарии к этим постам. Я думаю все прекрасно понимают, как все взаимосвязанно, поэтому на этом останавливаться не вижу особого смысла.

Обычная практика многих людей - задать одинаковые данные для всех типов данных и наплодить их с десяток. Смотрится это обычно как-то так:

user = {
  name:  'Jon'
  email: 'my@email.org'
  password: '12345678',
  password_confirmation: '12345678'  
  }

post = {
  title:  'My Post'
  body:   'My body'
  }

comment = { body: 'comment' }

10.times do
  my_user = User.create(user)
  my_post = my_user.create_post(post)
  my_post.create_comment(user, comment)
end

Но согласитесь, это скучно, банально и задевает чувство прекрасного. Поэтому давайте плюнем на все и развлечемся, создав свой собственный, изменяющийся из раза в раз мир :)

ATTENTION: далее будет много рандома, благодаря которому поддерживать все это или искать ошибки становится все сложнее и сложнее. Поэтому, использование генераторов, основанных на рандоме не рекомендуется для продакшена. В крайнем, случае использовать аккуратно и с умом.

Для того, чтобы наш воображаемый мир существовал, нам, естественно, нужны пользователи. И наша цель - создать абсолютно разных пользователей, не похожих друг на друга. Конечно же, первое, что всплывает в голову - замечательный гем faker, который поможет нам генерировать произвольные имена и почтовые адресса для наших пользователей. Но при всем при этом, не будем забывать про нашего админа. Так же, давайте зададим рандомное количество записей в интервале от 18 до 25 штук (числа, как вы догадались, могут быть абсолютно любые):

user = {
  name:  admin
  email: admin@my_app.com
  password: '12345678',
  password_confirmation: '12345678'  
  }

rnd = Random.new
user_count = rnd.rand(18..23)
User.create(user)

user_count.times do
  user[:name]  = Faker::Name.name
  user[:email] = Faker::Internet.email  
  User.create(user)
end

Cобственно я уверен, faker поможет вам сгенерировать почти любую информацию, стоит только открыть доки. Ну а если вам не угодил этот гем, то существует достаточно много других data генераторов.

Не думаю, что тут что-то было сложно, поэтому пререйдем к постам. Сказать по правде, в нашем проекте посты состояли из строго заданных кусков html-a, поэтому тут ничего не оставалось, кроме как делать в лоб. Единственный момент, мы будем выбирать произвольно пользователя, чтобы от его имени создавать наш пост:

posts = [
  {
    title:  'My first Post'
    body:   'My body'
  },
  {
    title:  'My second Post'
    body:   'My body'    
  },
  # Еще какое-то количество данных для постов ...
]

def rnd_user(count, rnd)
  random_user_id = rnd.rand(1..(count))
  User.find(random_user_id)
end

posts.each do |post|
  rand_user = rnd_user user_count, rnd

  post[:user_id] = rand_user.id
  created_post = rand_user.create_post(post)
end

Настало время самого интересного и забавного, комментарии. В данном проекте мы использовали гем acts_as_commentable_with_threading. Он содержит 2ух уровневую структуру комментариев, поэтому работы нам немного прибавилось. Чтобы создать комментарий, нам необходимы 3 значения: пост, где будет этот комментарий, пользователь, оставивший комментарий, и непосредственно сам текст комментария. Смотрится все это примерно так:

post.build_comment(user_id, body)

Ну а для “подкомментария” нам так же необходимо знать родительский комментарий, от которого ветка и пойдет, т.е. создание подобного комментария будет выглядеть примерно так:

child_comment = post.build_comment(user_id, body)
child_comment.move_to_child_of(comment)

А теперь давайте создадим от 10 до 21 главных комментариев и до 9ти дочерних для каждого главного, при этом каждый комментарий будет оставлять рандомный пользователь:

posts.each do |post|
  rand_user = rnd_user user_count, rnd

  post[:user_id] = rand_user.id
  created_post = rand_user.create_post(post)

  rnd.rand(10..21).times do
    rand_user = rnd_user user_count, rnd
    comment = created_post.build_comment(rand_user.id, 'Comment body')
    comment.save!

    rnd.rand(9).times do
      rand_user = rnd_user user_count, rnd
      child_comment = created_post.build_comment(rand_user.id, 'Comment body')
      child_comment.save!
      child_comment.move_to_child_of(comment)
    end
  end
end

Хм, рандомное количество комментариев мы сделали, пользователей тоже разных назначили, но вот незадача, у нас body каждого комментария одно и тоже, а именно 'Comment body'.Что же делать и как нам быть? Раз уж мы договорились создать подобие “живого” приложения, то и комментарии у нас должны быть разные и тоже живые. Первое, что приходит в голову, - опять использовать массив данных, но я слишков ленив (да и не путь самурая это), чтобы все это набирать, пусть даже копипастить и тем более придумывать. Второе, что приходит на ум, генерировать рандомную строчку текста. Да, идея не плохая, как минимум, нам придется писать меньше кода, и он по-любому будет всегда разный. Но есть одно но: мы пытаемся достигнуть абсолютной правдоподобности, а строки вида 'skjafnskdjn ksajdnf' нам точно не подойдут как комментарии. Поэтому нам на помощь приходит отличное решение - гем raingrams.

Что же такого может этот гем, спросите Вы? На самом деле, ничего особенного, Вы просто скармливаете ему текст, а он, в свою очередь, разбивает его на куски и рандомно выдает обратно. В чем плюсы? Да, они не отличаются от банальной генерации строки, единственное и очевидное отличие - генерируемый текст будет логичен в пределах строки.

В документации достаточно подробно описано, как гем ставится и настраивается, но я бы хотел уделить внимание 2ум подводным камням, с которыми мы столкнулись:

Во первых, гем не поддерживает русский язык. Скажем так, он его не видит. Поэтому, если для Вас важен русский язык, используйте наш форк, в котором исправлен этот косяк.
Ну а второй момент, в старых версиях существовал метод train_with_url, в который передавалась ссылка, а он уже все парсил и выдавал конечный результат. К сожалению, в свежих версиях этот метод был убран, причем убран очень хитро. Если быть точным, то автор просто вырезал часть этого метода, а вторую забыл(а может, решил стебануться над простыми парнями как мы, этого я, к сожалению, не знаю :) ).

А теперь, используя полученные знания, перепишем наш метод. В качестве текста для raingrams мы будем использовать комментарии из пикабу, которые предварительно распарсим:

model = QuadgramModel.build do |model|
  doc = Nokogiri::HTML(open('http://pikabu.ru/story/v_den_programmista_pro_logiku_pikabu_685289'))
  doc.search('div.comment_desc').each do |div|
    model.train_with_text(div.inner_text)
    model.refresh
  end
end

# ....

posts.each do |post|
  rand_user = rnd_user user_count, rnd

  post[:user_id] = rand_user.id
  created_post = rand_user.create_post(post)

  rnd.rand(10..21).times do
    rand_user = rnd_user user_count, rnd
    comment = created_post.build_comment(rand_user.id, model.random_sentence)
    comment.save!

    rnd.rand(9).times do
      rand_user = rnd_user user_count, rnd
      child_comment = created_post.build_comment(rand_user.id, model.random_sentence)
      child_comment.save!
      child_comment.move_to_child_of(comment)
    end
  end
end

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

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

Как думаете, где еще нам придется создавать пользователей (и не только их), которых мы создали в самом начале? Правильно, в тестах, надо же на чем-то тестировать приложение. Так почему бы нам не убить 2ух зайцев и не заменить ручную генерацию, как это было в начале статьи, на старую добрую фабричную? Так как в нашем проекте мы используем гем fabrication, то и пример будет с ним. Вы также можете использовать любую другуюю фабрику, которая вам по вкусу.

Для начала определим нашего пользователя и администратора:

Fabricator(:user) do
  email Faker::Internet.email
  name Faker::Name.name
  password '12345678'
  password_confirmation '12345678'
end

Fabricator(:admin) do
  email 'admin@my_app.org'
  name 'admin'
  password '12345678'
  password_confirmation '12345678'
end

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

user_count = rnd.rand(18..23)
Fabricate(:admin)

user_count.times { Fabricate(:user) }

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

На этом, пожалуй, я закончу наши эксперименты. Как видите, простора для фантазии осталось еще много и также осталось много идей для рефакторинга. В любом случае, данный пример явно показывает, что к любой, сколь скучной она не была бы, задаче всегда можно применить творческий подход и неплохо развлечься :)

IRB и все все все

2014-02-09T00:00:00+00:00

Думаю, каждый, кто так или иначе связан с Ruby и тем более с Rails, хоть раз в жизни использовал irb. Возможности интерактивного ruby шела безграничны, поэтому сегодня я бы хотел поговорить об улучшении или кастомизации, если вам так угодно, вашего irb.

Но для начала давайте посмотрим документацию, а именно откроем модуль IRB в стандартной библиотеке ruby. “Что интересного тут есть?”, спросите вы? Думаю стоит начать с самого начала, с запуска. Если вы просто наберете в консоли irb, то запустите шел с вашей текущей версией руби. Но если у вас RVM(хотя, сказать по правде я не уверен, что это работает только с RVM), то вы можете выбрать среду для запуска из всех тех, что у вас установлены. Например вот так, я, при активном MRI 2.0, могу запустить у себя jruby:

Дальше, думаю, следует обсудить ключи. Их много, они разные. В документации они все есть. Самые интересные, на мой взляд, - -d включающий дебаг мод(аналогично ruby -d) и ключ -I path, загружающий указанную директорию.

Ну а теперь самое интересное: поговорим о конфигурации вашего irb. Для этого необходимо создать *rc аналогичный .bashrc или .vimrc. Существует несколько разновидностей именования этого файла, например: .irbrc, irb.rc, _irbrc или же $irbrc.

Думаю, для начала, следует указать конфигурационные значения, например, увеличить количество сохраняемых команд и записывать их в отдельный файл:

IRB.conf[:SAVE_HISTORY] = 1000
IRB.conf[:HISTORY_FILE] = "#{ENV['HOME']}/.irb_history"

Так же можно указать кучу других настроек, но я бы не стал писать эту статью, если бы хотел рассказать только это. Все веселье начинается тогда, когда приходит понимание того, что данный файл является обычным *.rb файлом, который загружается при старте вашего irb.

Думаю, все догадались, что дальше будет? :)

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

# .irbrc
class Object
  def local_methods
    (methods - Object.instance_methods).sort
  end
end

Как он будет работать, спросите вы? Да все просто, берете объект и вызываете на нем данный метод:

Думаю, вы заметили цвета, которых не хватает в дефолтном irb?

Да, все верно, так же можно подключать гемы, и да, есть гемы, которые добавляют ярких цветов в ваш irb, например, wirble. Достаточно написать такой код:

require 'rubygems'
require 'wirble'

Wirble.init
Wirble.colorize

И ваш интерактивный шел заиграет новыми красками :)

А если вам нравится pry, то вам никто не запрещает его добавить, в последующем вызывая его, просто набрав pry во время irb сессии:

#.irbrc
require 'pry'

# irb
2.0.0p247 :015 > pry
[1] pry(main)>

Ну а выглядеть это будет как-то так:

Но самое полезное, что можно сделать, это забыть построчный ввод кода. “Как?”, спросите вы? Начну издалека: мне очень нравится vim :) Поэтому, смотря vimcasts-ы, я узнал то, что перевернуло мой мир, а именно: любой текстовый редактор можно вызывать прямо из irb.

Делается это очень просто: нужно добавить гем interactive_editor. Данный гем позволяет вызывать любой текстовый редактор из вашего irb, например, набрав vim - откроется vim, где вы сможете набрать любой код, который выполнится после сохранения файла и закрытия редактора.

Собственно то же самое будет работать с sublime, textmate, emacs и дургими текстовыми редакторами.

Ну и на последок стоит рассказать про сессии в irb. Если вы используете vim или когда то использовали его, то вам знакомо такое понятие как буфер, которое чем-то похоже на сессии в irb. Ну а если нет, то краткая справка: сессия - некий сеанс интерактивного шела. Для того, что бы посмотреть список всех сессий в irb, достаточно набрать jobs:

2.0.0p247 :012 > jobs
 => #0->irb on main (#<Thread:0x007fcb810bcda0>: running)

Ну а если вам надо создать новую сессию, то просто наберите irb:

2.0.0p247 :013 > irb
2.0.0p247 :001 > jobs
 => #0->irb on main (#<Thread:0x007fcb810bcda0>: stop)
#1->irb#1 on main (#<Thread:0x007fcb819b7bf8>: running)

Как видите, irb создал новую сессию и переключился в нее. Но что делать, когда вы хотите удалить или изменить сессию? Для этого есть методы kill <number_session> и fg <number_session> соответственно:

2.0.0p247 :002 > jobs
 => #0->irb on main (#<Thread:0x007fcb810bcda0>: stop)
#1->irb#1 on main (#<Thread:0x007fcb819b7bf8>: stop)
#2->irb#2 on main (#<Thread:0x007fcb81319238>: running) 
2.0.0p247 :003 > fg 1
 => #<IRB::Irb: @context=#<IRB::Context:0x007fcb819b7a40>, @signal_status=:IN_EVAL, @scanner=#<RubyLex:0x007fcb819b74c8>> 
2.0.0p247 :009 > jobs
 => #0->irb on main (#<Thread:0x007fcb810bcda0>: stop)
#1->irb#1 on main (#<Thread:0x007fcb819b7bf8>: running)
#2->irb#2 on main (#<Thread:0x007fcb81319238>: stop) 
2.0.0p247 :010 > kill 2
 => [2] 
2.0.0p247 :011 > jobs
 => #0->irb on main (#<Thread:0x007fcb810bcda0>: stop)
#1->irb#1 on main (#<Thread:0x007fcb819b7bf8>: running) 
2.0.0p247 :012 > kill 1
 => #<IRB::Irb: @context=#<IRB::Context:0x007fcb8185b2c8>, @signal_status=:IN_EVAL, @scanner=#<RubyLex:0x007fcb8110d5e8>> 
2.0.0p247 :014 > jobs
 => #0->irb on main (#<Thread:0x007fcb810bcda0>: running)

Ruby и special/predefined variables

2014-01-15T00:00:00+00:00

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

Выглядел примерно так:

"test string in irb".match /irb/
puts $&
#=> "irb"

Так как до этого я не часто встречался с подобными “глобальными” переменными, пример заинтересовал меня и захотелось выяснить, что же это за переменные. Первым делом, я решил узнать, как они называются и где их можно найти. Спустя несколько минут, стало ясно, что это так называемые “special variables”. Не долго думая и открыв google, просмотрев пару тройку результатов, стало ясно, что кроме списка этих переменных ничего особо нет. Это не сильно меня обрадовало и стало понятно, что пришло время открыть репозитарий ruby и начать искать в нем. Так же мне очень помогла одна небезизвестная книга. Как оказалось, ruby создает несколько специальных переменных, в зависимости от откружения, в котором запускаются программы, или в зависимости от действий, которые были выполены ранее. Кстати, это не совсем глобальные перменные, в чем легко можно убедиться, рассмотрев простой пример:

def test
  "test string in irb".match /test/
  puts "$& in test method #{$&}"
end

"test string in irb".match /irb/
puts "$& in main #{$&}"
#=> "irb"

test
#=> "test"

Как видно из примера, в каждом scope (main и метода), “глобальная” переменная отличается. Любой адекватный человек спросит: как такое, тысяча чертей, возможно? На самом деле все довольно просто, но, для полного понимания, начать придется с основ. Как многие знают, начиная с верисии 1.9 в ruby была добавлена виртуальная машина или YARV или же yet another ruby virtual machine, называйте как хотите, суть одна и та же. Смысл в том, что каждый раз, при запуске, YARV так же создает особый стек, для локальных переменных. В этом стеке указываются абсолютно все локальные переменные, свои для каждого scope. Разделение scope-ов происходит с помощью специальной точки или указателя - environment point (далее EP). Так же, в стеке, перед каждой EP, создается специальная переменная svar, которая как раз и указывает на таблицу специальных символов. Именно из-за этого для каждого scope могут быть свои значения специальных символов, что мы видели в примере выше. Но самое интересное, что у обычного блока и у места, где он будет вызван, scope одинаковый, в чем можно легко убедиться благодаря такому примеру:

"test string in irb".match /irb/

1.times do
  "test string in irb".match /test/
  puts "$& in block #{$&}"
end

puts "$& in main #{$&}"

> ruby test.rb
>> "$& in block test"
>> "$& in block test"
>> "$& in main test"

На самом деле это логичное поведение, ибо замыкания никто не отменял. Как я уже говорил, таких переменных много, но расскажу я о самых интересных(естественно для себя):

$&

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

$1 $2 $3 …

Думаю, многим знакомая похожая переменная из регулярных выражений. Хотя, кого я обманываю? Это та же самая перменная, которая хранит совпадения из скобок:

"test string in irb".match /(irb)/
puts $1
#=> "irb"

$~

Содержит объект класса MatchData, соответствующий последнему совпадению.

"test string in irb".match /(irb)/
puts $~
#=> #<MatchData "irb" 1:"irb">
puts $~.to_s
#=> "irb"
puts $~.to_a
#=> ["irb", 'irb']

$+

Содержит значение последней круглой скобки из последнего совпадения:

"test string in irb".match /irb/
puts $~
#=> #<MatchData "irb" 1:"irb">
puts $+
#=> nil
"test in irb".match /(test) (in) (irb)/
puts $~
#=> #<MatchData "test in irb" 1:"test" 2:"in" 3:"irb">
puts $+
#=> "irb"

$`

Содержит все то, что не совпало в последнем регулярном выражении:

"test string in irb".match /irb/
puts $`
#=> "test string in"

$!

Содержит последнее вызванное исключение:

1 / 0 rescue $!
#=> #<ZeroDivisionError: divided by 0>

$@

Ну а эта переменная содержит массив со всеми trace stack-ами из последнего исключения:

1 / 0 rescue $@
#=> ["<main>:4:in `/'", "<main>:4:in `/'", "(irb):98:in `irb_binding'", ... ]

$*

Эта переменная равносильна переменной ARGV, думаю этим все сказанно.

$$

Переменная возвращает номер процесса, под которым выполняется скрипт.

$$
#=> 33630
puts `ps aux | grep irb`
#=> anton           33630   0.0  0.3  2470520  24084 s008  S+    2Jan14   0:01.24 irb

Так где же определены эти переменные в исходном коде ruby? Как оказалось, все не так сложно, как кажется. Определенны эти переменные в файле parse.y примерно на 7950-той строке (да да, файл не очень большой, всего 11.5к строк кода). Для тех, кто не в курсе, parse.y - грамматический файл интерпритатора, благодаря которому происходит разбиение написанного вами кода на токены (лексемы/указатели), которые в последующем преобразуются в AST структуру, а затем в YARV структуру, ну а дальше в машинный код, который в последующем и будет выполняется. Как не трудно заметить, case функция ищет совпадение символа “$” и специальных символов (блок case), после чего передает их функции set_yylval_name:

7965: case '~':                /* $~: match-data */
7966: case '*':                /* $*: argv */
7967: case '$':                /* $$: pid */
7968: case '?':                /* $?: last status */
7969: case '!':                /* $!: error string */
7970: case '@':                /* $@: error position */
7971: case '/':                /* $/: input record separator */
7972: case '\\':               /* $\: output record separator */
7973: case ';':                /* $;: field separator */
7974: case ',':                /* $,: output field separator */
7975: case '.':                /* $.: last read line number */
7976: case '=':                /* $=: ignorecase */
7977: case ':':                /* $:: load path */
7978: case '<':                /* $<: reading filename */
7979: case '>':                /* $>: default output handle */
7980: case '\"':                /* $": already loaded files */
7981:   tokadd('$');
7982:   tokadd(c);
7983:   goto gvar;

-------

7997: gvar:
7998: set_yylval_name(rb_intern3(tok(), tokidx, current_enc));
7999: return tGVAR

И в завершение, следует упомянуть особый файл - English.rb, в котором прописаны алиасы для специальных переменных, благодаря чему можно использовать данные переменные намного понятнее, нежели чем использование $$, $& и так далее:

"waterbuffalo" =~ /buff/
print $", $', $$, "\n"

# With English:

require "English"

"waterbuffalo" =~ /buff/
print $LOADED_FEATURES, $POSTMATCH, $PID, "\n"

Anton Davydov

Five common issues with services and dry-monads

TLDR

Original code

Problems

Naming based on the implementation

Redundancy of service objects

Using of generic names

State inside a class and mix of parameters and dependencie

ActiveModel’s chain of calls in business logic

Finnal result

Conclusions

Useful links

UPD

Profiling your SQL queries in hanami (or ROM)

Ruby tips #2

Special values

Safe Levels

Email Regexp

DATA object

Symbol

#all_symbols

id2name

slice

Array

#bsearch

Range to array

Hash

** method

#gsub with hash args

Non string and symbol keys

Hash#assoc

Range

#cover? and time

Ranges in case statements

Conclusions

Ruby tips #1

Kernel

Char

callcc

caller

itself

j and jj

Class

allocate

Refinements

Object

tap

Proc (lambda)

curry

#to_proc and #method

All ways to call proc (lambda)

Method

method

Block

Empty block

Conclusions

Adding domain for your github project

Preview hanami emails in browser

Building your rails API with roda

Introduction

Integration

Problems / future

Conclusion

Further reading

Adding anchors to your middleman project

Simplest way to authenticate user in hanami app

Profiling minitest examples with Stackprof

Rendering ruby block result in layout file

Ignore file lines in git

Write simple scheme interpreter on ruby

Why scheme and lisp?

Main idea

First step. Parser.

Eval method

REPL

Conclusions

Further reading

Get request with custom locale in your tests

Memory profiler tools for ruby

`**` method

`j` and `jj`