Contribute to Rails

in a right way

• Motivate to start looking at the source code more often
• Give a vision on rails internal problems
  • Solved
  • Unsolved

The first thing to spot is that

documentation isn't

good enough

If you start looking at the source code

more than at the documentation than you are on a right track.

Looking at source code

reveal hidden features

def add_default_name_and_id(options)
  ...
  options["name"] += "[]" 
    if options["multiple"]
  ...
end

Use case:

roles.each do |role|
  f.check_box :role_ids, 
    :value => role.id, :multiple => true
end

Looking at source code

reveal a hidden bugs

<input type="checkbox" 
    name="user[role_ids][]" 
    value="1" multiple="multiple">

Looking at source code

reveals all internal problems

Source link

bundle open activerecord

Now lets talk about

how to contribute

Start with

fixing bugs in documentation

is wrong way

• You don't improve yourself
• You can do same tasks at work and get paid

Contribute to opensource is

do something that

• Makes your life easier
• Lets you improve yourself

A few examples of

what can make life easier

Pluck method

User.where(:active => true).pluck(:id)
# SELECT id FROM users WHERE active = 1

User.uniq.pluck(:role)
# SELECT DISTINCT role FROM users

Mass assignment security that is easy to spot

> Education.new(:user_id => 1)

ActiveModel::MassAssignmentSecurity::Error: 
  Can't mass-assign protected 
    attributes: user_id
from active_model/mass_assignment_security
  /sanitizer.rb:48:in 
    `process_removed_attributes'

Strict validation

Do not let user see validation errors that he can not correct

class Article < AR::Base
  validates! :author, :presence => true
end

u = User.new
u.save
   # raises ActiveModel::StrictValidationFailed

How to improve yourself?

Solve a problem that you

do not solve in daily work

Rails is full of things that are not ok

And this is where we can improve ourselves

A histrory of Rails callback

Rails gay callback party

How callback pattern appeared?

validates_presence_of :author
validates_size_of :title
validates_uniqueness_of :slug

before_filter :load_user
before_filter :require_admin_rights
after_filter :set_page_title

before_save :downcase_email_address
after_save :deliver_registration_email
before_save :generate_api_token

A feeling like

something is add to array

def self.validate(&validator)
   self.validators << validator
end

def valid?
  validators.all? do |validator|
    validator.call(self)
  end
end

How this gonna work with objects hierarchy?

class User < AR::Base
  validates_size_of :name
end

class Customer < User
  validates_presence_of :company
end

class TeamMember < User
  validates_presence_of :role
end

Is it fast?

• Interations over array when #valid? is called
• Memory usage to store these arrays
• Pass though inherited objects on update

A feeling like when callbacks were invented

Rails core team

was not aware of OOP

def valid?
  validates_presence_of(:aution) && 
    validates_size_of(:title) &&
    validates_uniqueness_of(:slug) && 
    super
end

Anyway active_support/callbacks.rb was invented

and it was huge step ahead

comparing to different implementation

accross Rails libraries

Performance problem was solved

class CallbackChain < Array
def compile
  method = []
  method << "value = nil"
  method << "halted = false"
  callbacks = "value = !halted && (!block_given? || yield)"
  reverse_each do |callback|
    callbacks = callback.apply(callbacks)
  end
  method << callbacks
  method << "value"
  method.join("\n")
end
end

But Rails Boot time was a cost

Each time new callback is added

validates_presence_of :user

Rails redefines callback method

def set_callback(*args)
  add_callback_to_chain(*args)
  recompile_callback_method
  and_dont_forget_about_inherited_classes
end

What did I do?

Get rid of other optimization in Callbacks

It was clean that other optimization

made in callbacks doesn't work

1   +
3   ++-
2   +-
4   ++--
19  +++----------------
14  +++++++-------
27  +--------------------------
30  ++++++++++++---------------
47  ++++++++-------------------
7   ++++++-
4   ++--
42  +++++----------------------
19  +++----------------
19  +++----------------
14  ++++++++------
5   ++---
21  +++++++++++----------
120 +++++++++++++-------------
26  ++++++++++++--------------
16  ++++++----------
45  +++++++++++++--------------

Callbacks optimization method

could be generated lazily

def run_callbacks(name)
  runner_method = __callback_runner_name(name)
  unless respond_to?(name)
    define_callback_runner(name)
  end
  send(name)
end

The only one thing left

Construct a runner method is slow

def __callback_runner_name(kind)
  class_id = name.hash.abs
  "_run__#{class_id}__#{kind}__callbacks"
end

Last try resulted in this comment

Link

A histroy of Rails Router

Rails 1.x

/:controller/:action(/:id)

Allows to move through abstraction layer

Rails 1.x

url_for(
  :controller => :users, 
  :action => :show,
  :id => 1
)

Rails 2.x

/:controller/(:id/):action

Rest compatible

Rails 2.x

Named Routes

user_path(1)

• Each route has an internal unique name
• Find a route by name is really faster

Rails 3.x

(/locale/:locale)/page/:name 
              => "pages#show"

• Additional flexibility

• Journey as a router backend

• Makes REST less strict

  • because nobody care at the end but it is ok

Journey solved route recognition problem

Journey parses each route and converts it into

Abstract Syntax Tree

The result of

router evolution

It's new library, so

Journey is not optimized yet

routes.map! { |r|
  match_data  = r.path.match(req.path_info)
  match_names = match_data.names.map do |n| 
    n.to_sym 
  end
  match_values = match_data.captures.map do |v| 
    v && Utils.unescape_uri(v) 
  end
  info = Hash[match_names.zip(match_values).
    find_all { |_,y| y }]

  [match_data, r.defaults.merge(info), r]
}

Bloody mess internals

as the outcome

if options.has_key?(:action) 
    && options[:action].nil?
  options[:action] = 'index'
end
if options[:action] == 'index' 
  recall[:action] = options.delete(:action) 
end

Source code

A need to support unnamed routes with recall

# Pseudocode
def url_for(options)
  options = options.reverse_merge(recall)
  route = routes.find do |route|
    route.match?(options)
  end
  route = format_route(route, options)
end

ActionPack is a worth

rails component now

Why json kills the performance?

        user     system   total     real
user_path(1)                   
        0.1500   0.0000   0.1500 (  0.150241)
users_path(1, format: :json)   
        1.0700   0.0100   1.0800 (  1.079205)

(link generated 1000 times)

Links generation is extremely slow

It takes one millisecond to create a link like this:

      user_path(user, :format => "json")

A page with 100 links will be generated in 100ms

http://github.com

jQuery("a").length // => 177

@module.module_eval -END_EVAL, __FILE__, __LINE__ + 1
  remove_possible_method :#{name}
  def #{name}(*args)
    if #{optimize_helper?(route)}  args.size == #{route.required_parts.size}  !args.last.is_a?(Hash)  optimize_routes_generation?
      # this is fast
      options = #{options.inspect}
      options.merge!(url_options) if respond_to?(:url_options)
      options[:path] = "#{optimized_helper(route)}"
      ActionDispatch::Http::URL.url_for(options)
    else
      # this is slow
      url_for(handle_positional_args(args, #{options.inspect}, #{route.segment_keys.inspect}))
    end
  end
END_EVAL

"I, based on my work with various teams, consider Rails a nice set of conventions, a fantastic routing system and a very useful ORM."

Someone comment in github.com/rails/rails

Why all those things are optimized?

I want things to be always optimized

(c) Aaron Peterson

This problem is not solved

Aaron Peterson is too busy to solve it for you

And I can not solve it on my own

I need your help

One more thing

About Curebit

Company I am working in right now

_

_

_

_

World Class Product

World Class Salary

Send resumes to

jobs@curebit.com

Thanks!

http://gusiev.com

http://github.com/bogdan

jobs@curebit.com