Ruby on Rails: Tasty Burgers

http://tenderlovemaking.com/
railsconf2010.pdf

AT&T, AT&T logo and all AT&T related marks are trademarks of AT&T Intellectual Property and/or AT&T affiliated companies.

Rails 4*

• Ponies
• Unicorns
• Venture Capital

*Disclaimer

Some of the things I say may not be true.

Why I’m Here*
*The following events may not have actually
happened

Hello! This is
@tenderlove,
who is this?

AH! Chad
Flower, the
famous
ﬂorist?

Chad Fouler
the Baseball
player?

Chad
Flounder the
Fish Whisperer?

Wait. Yes this is
Chad Flounder,
Fish Whisperer.

But I'm calling on
behalf of Chad Fowler,
Ruby Programmer.

I'll need your bio, afﬁliation, and
so on. I would also love a recent
head shot of you. 300 dpi, 3 "
minimum is preferable.

Erm. Nice mullet. Is
that really you?

You know that means I'm
going to require you to
have that mullet at
RailsConf.

Rails
This is RailsConf right?

ERb
SQLITE RACK
RAILS
YAML

Better ingredients,
better burgers.
Guaranteed

TOPICS OF DOOM

• SQLite
• ERb
• Rack
• YAML

SQLite3-Ruby

• Adapter for SQLite3 database
• Originally by Jamis Buck
• SWIG

class Foo < AR::Base; end

Foo.ﬁnd(:all, :conditions => {...})

Foo.ﬁnd(:all, :conditions => [
‘x = ?’, 20
])

ActionView

ActionController

ActiveRecord

SQLite3-Ruby

AR::Base SQLite3 Adapter

Connection Pool

SQLite3Adapter

SQLite3-Ruby

Establishing a
Connection

require 'sqlite3'

connection =
SQLite3::Database.new('ﬁle.sqlite3')

In Memory
Database
Pro Tip

require 'sqlite3'

connection =
SQLite3::Database.new(':memory:')

database.yml

development:
adapter: sqlite3
database: ':memory:'

Making a Query

connection.execute('CREATE TABLE foo(id INTEGER)')

connection.execute('INSERT INTO foo (id) VALUES (?)',
[10])

Preparing a Statement

stmt = connection.prepare('SELECT * FROM foo WHERE id
= ?')

stmt.bind_param(1, 10)

stmt.each do |row|
p row
end

Can improve
database
performance

SELECT * FROM users WHERE id = ?

stmt = get_cached_stmt ||
connection.prepare(
'SELECT * FROM users WHERE id = ?'
)
stmt.execute(10)

WRONG
stmt = get_cached_stmt ||
connection.prepare(
'SELECT * FROM users WHERE id = ?'
)
stmt.execute(10)

connection.execute(
'SELECT * FROM users WHERE id = 10'
)

No Prepared
Statement Support
:-(

• Step 1: Read the API
• Step 2: Write your code
• Step 3: Annoy your friends (or proﬁt)

Step 1: Read the API
struct sqlite3_vfs {
int iVersion; /* Structure version number */
int szOsFile; /* Size of subclassed sqlite3_file */
int mxPathname; /* Maximum file pathname length */
sqlite3_vfs *pNext; /* Next registered VFS */
const char *zName; /* Name of this virtual file system */
void *pAppData; /* Pointer to application-specific data */
int (*xOpen)(sqlite3_vfs*, const char *zName, sqlite3_file*,
int flags, int *pOutFlags);
int (*xDelete)(sqlite3_vfs*, const char *zName, int syncDir);
int (*xAccess)(sqlite3_vfs*, const char *zName, int flags, int *pResOut);
int (*xFullPathname)(sqlite3_vfs*, const char *zName, int nOut, char *zOut);
void *(*xDlOpen)(sqlite3_vfs*, const char *zFilename);
void (*xDlError)(sqlite3_vfs*, int nByte, char *zErrMsg);
void (*(*xDlSym)(sqlite3_vfs*,void*, const char *zSymbol))(void);
void (*xDlClose)(sqlite3_vfs*, void*);
int (*xRandomness)(sqlite3_vfs*, int nByte, char *zOut);
int (*xSleep)(sqlite3_vfs*, int microseconds);
int (*xCurrentTime)(sqlite3_vfs*, double*);
int (*xGetLastError)(sqlite3_vfs*, int, char *);
/* New fields may be appended in figure versions. The iVersion
** value will increment whenever this happens. */
};

static int rbFile_close(sqlite3_file * ctx)
{
rubyFilePtr rfile = (rubyFilePtr)ctx;
VALUE file = rfile->file;
rb_funcall(file, rb_intern("close"), 0);
return SQLITE_OK;
}

class VFS < SQLite3::VFS
def open(name, ﬂags)
OurFile.new(name, ﬂags)
end
end

class OurFile
def read(...); ... end
def write(...); ... end
end

Anything can store
a SQLite Database

class EvilVFS < SQLite3::VFS
def open name, flags
DATABase.new name, flags
end
end

class DATABase < SQLite3::VFS::File
def initialize name, flags
super
@store = File.open(name, File::RDWR | File::CREAT)
@offset = 0

if File.expand_path(__FILE__) == name
@store.seek DATA.pos
@offset = DATA.pos
end
end

def close
@store.close
end

def read amt, offset
@store.seek(offset + @offset)
@store.read amt
end

def write data, offset
@store.seek(offset + @offset)
@store.write data
end

def sync opts
@store.fsync
end

def file_size

SQLite3.vfs_register(EvilVFS.new)
db = SQLite3::Database.new(__FILE__, nil, 'EvilVFS')

db.execute(<<-eosql)
create table if not exists
users(id integer primary key, name string)
eosql

100.times {
db.execute(<<-eosql, 'tenderlove')
insert into users(name) values (?)
eosql
}

p db.execute('select count(*) from users')

__END__

Get the Code!
http://gist.github.com/319224/

Fun Stuff!!

• Ruby 1.9 Encoding support
• 1000x faster (or something)

Encodings
require 'sqlite3'

db = SQLite3::Database.new(':memory:')

db.execute('CREATE TABLE foo(id INTEGER, name VARCHAR)')
db.execute('INSERT INTO foo (id, name) VALUES (?,?)',[10,'hello
world'])

rows = db.execute('SELECT name FROM foo')
p rows.first.first.encoding # => #<Encoding:UTF-8>

Encoding.default_internal = 'EUC-JP'

rows = db.execute('SELECT name FROM foo')
p rows.first.first.encoding # => #<Encoding:EUC-JP>

Speed! (on selects)
1.2.5 1.3.0

1000

100

10

1

0.1

0.01
500 1000 1500 2000 2500 3000 3500

ERb

• Masatoshi SEKI
• Template System
• Ruby 1.8 and 1.9

Template Registration
class Something::ERB < AV::Template::Handler
def render(template, *args)
...
body
end
end

ActionView::Template.register_template_handler(
:erb, Something::ERB
)

AV Resolver
render()

Something::ERB

require 'erb'

erb = ERB.new(File.read(__FILE__))
puts erb.result(binding)

__END__
Hello world! <%= 10 + 100 %>

Output

require 'erb'

puts erb.result(binding)

__END__
Hello world! 110

Template Source

require 'erb'

puts erb.src

__END__
Hello world! <%= 10 + 100 %>

Output
_erbout = ''; _erbout.concat "require 'erb'nnerb
= ERB.new(File.read(__FILE__))nputs erb.srcn
n__END__nHello world! "

; _erbout.concat(( 10 + 100 ).to_s);
_erbout.concat "n"
; _erbout

Output Buffer

require 'erb'

erb = ERB.new(File.read(__FILE__), nil, nil, '@foo')
puts erb.src

__END__
Hello world! <%= 10 + 100 %>

Output
@foo = ''; @foo.concat "require 'erb'nnerb =
ERB.new(File.read(__FILE__), nil, nil, '@foo')nputs
erb.srcnn__END__nHello world! "

; @foo.concat(( 10 + 100 ).to_s); @foo.concat
"n"
; @foo

mmap
allocate memory, or map ﬁles or devices into
memory

IO input
require 'erb'
require 'rubygems'
require 'mmap'

erb = ERB.new(Mmap.new(__FILE__), nil, nil, '@foo')
erb.result(binding)

puts @foo

__END__
Hello world! <%= 10 + 100 %>

Our Problem

def set_eoutvar(compiler, eoutvar)
...
cmd = []
cmd.push "#{eoutvar} = ''"

compiler.pre_cmd = cmd
...
end

A Solution

class ERB::Compiler
def pre_cmd= x; end
end

Source Output (before)
@foo = ''; @foo.concat "require 'erb'nrequire
'rubygems'nrequire 'mmap'nnclass
ERB::Compilern def pre_cmd= x; endnend
nnerb = ERB.new(Mmap.new(__FILE__), nil,
nil, '@foo')nputs erb.srcnn__END__nHello
world! "

"n"
; @foo

Source Output (after)
@foo.concat "require 'erb'nrequire
world! "

"n"
; @foo

Source Output
@foo.concat "require 'erb'nrequire
world! "

"n"
; @foo

Adapting to "concat"

class IOAdapter < Struct.new(:io)
def concat(string)
io.write string
end
end

require 'erb'
require 'mmap'

class ERB::Compiler
def pre_cmd= x; end
end

class IOAdapter < Struct.new(:io)
def concat(string)
io.write string
end
end

@foo = IOAdapter.new($stdout)

erb = ERB.new(Mmap.new(__FILE__), nil, nil, '@foo')
erb.result(binding)

__END__
Hello world! <%= 10 + 100 %>

Performance Results*

• Slower compiler
• Similar output
• Lower memory overhead

rack
Ruby webserver interface ACK!

not racc
Ryet Another Compiler Compiler

Rack

• Interface between app code and
servers

• By Christian Neukirchen

Unicorn (etc)

Rack

Rails

Unicorn (etc)

Rack

Rack Adapter
RAILS

class MyRack
def call env
[
200,
{'X-RailsConf' => 'yay'},
"hello world!"
]
end
end

HTTP/1.1 200 OK
Connection: close
Date: Thu, 03 Jun 2010 03:57:05 GMT
Server: WEBrick/1.3.1 (Ruby/
1.8.7/2009-06-08)
Content-Length: 11
X-Railsconf: yay

hello world

block must yield a
String

class MyRack
def call env
[
200,
['hello ', 'America!']
]
end
end

GET / HTTP/1.0

HTTP/1.1 200 OK
Connection: close
Date: Thu, 03 Jun 2010 04:06:08 GMT
Server: WEBrick/1.3.1 (Ruby/
1.8.7/2009-06-08)
Content-Length: 14
X-Railsconf: yay

hello America!

class MyRack
def call env
[
200,
File.open(__FILE__, 'rb')
]
end
end

HTTP/1.1 200 OK
Connection: close
Date: Thu, 03 Jun 2010 04:08:21 GMT
Server: WEBrick/1.3.1 (Ruby/1.8.7/2009-06-08)
Content-Length: 215
X-Railsconf: yay

class MyRack
def call env
[
200,
File.open(__FILE__, 'rb')
]
end
end

class ERBHandler
def initialize
@root =
File.join(File.dirname(__FILE__), 'htdocs')
end

def call env
erb =
ERB.new(File.read("#{@root}#{env['REQUEST_PATH']}"))
[
200,
erb.result(binding)
]
end
end

<%= env['SERVER_SOFTWARE'] %>

<%
def fib n
n < 2 ? n : fib(n - 1) + fib(n - 2)
end
%>
<% 1.upto(30) do |i| %>
<%= fib(i) %>
<% end %>

Connection Times (ms)
min mean[+/-sd] median max
Connect: 0 0 0.0 0 0
Processing: 3239 3312 91.8 3274 3483
Waiting: 3238 3311 91.2 3274 3482
Total: 3239 3312 91.8 3274 3483

Requests per second: 0.30 [#/sec] (mean)
Time per request: 3312.112 [ms] (mean)

class ERBHandler
def initialize
@root = File.join(File.dirname(__FILE__), 'htdocs')
@cache = Hash.new do |h,file|
h[file] = ERB.new(File.read("#{@root}#{file}"))
end
end

def call env
[
200,
@cache[env['REQUEST_PATH']].result(binding)
]
end
end

Connect: 0 0 0.0 0 0
Processing: 3230 3267 30.6 3269 3315
Waiting: 3229 3267 30.5 3269 3315
Total: 3230 3267 30.7 3269 3315

Requests per second: 0.31 [#/sec] (mean)
Time per request: 3266.990 [ms] (mean)

ERB Hacks

class ERB::Compiler
def pre_cmd= x; end
end

class IO
alias :concat :write
end

class ERBHandler
def initialize
@root = File.join(File.dirname(__FILE__), 'htdocs')
@cache = Hash.new do |h,file|
h[file] = ERB.new(
File.read("#{@root}#{file}"), nil, nil, 'wr')
end
end

def call env
rd, wr = IO.pipe

Thread.new do
@cache[env['REQUEST_PATH']].result(binding)
wr.close
end

[ 200, {'X-RailsConf' => 'yay'}, rd ]
end
end

Connect: 0 0 0.0 0 0
Processing: 3273 3312 22.0 3322 3338
Waiting: 0 1 0.5 0 2
Total: 3273 3313 22.0 3322 3338

Syck

• Ruby 1.8 and 1.9
• YAML 1.0 (mostly) parser / emitter
• Written by Why

Psych

• Ruby >= 1.9.2 only
• Wraps libyaml
• YAML 1.1 parser / emitter
• Written by me

database.yml

development: &defaults
adapter: sqlite3
database: db/development.sqlite3

test:
<<: *defaults
database: db/test.sqlite3

i18n
ja:
calendars:
gregorian:
days:
format:
abbreviated:
fri:
mon:
sat:
sun:
thu:
tue:
wed:

ﬁxtures

default:
user: default
text: hello world
created_at: <%= Time.now.to_formatted_s(:db)
%>

Serialized Attributes

# Serialize a preferences attribute
class User < AR::Base
serialize :preferences # ZOMG YAML!
end

Ruby 1.8 / 1.9

require 'yaml'

YAML.load_ﬁle('some_ﬁle.yml')
YAML.load('--- hello world!')

Ruby 1.9.2 / Psych

require 'psych'

Psych.load_ﬁle('some_ﬁle.yml')
Psych.load('--- hello world!')

1.9.2 Opt-in

require 'yaml'

YAML::ENGINE.yamler = 'psych'

YAML.load('--- this is psych')

require 'psych'

Psych.dump { :foo => 'bar' }
{ :hello => 'world' }.to_yaml

YAML Map

---
{ 'foo': 'bar' }

require 'psych'

Psych.to_json { :foo => 'bar' }

class Foo
def initialize
@greeting = 'world'
end

def encode_with(coder)
coder['hello'] = @greeting
end

def init_with(coder)
@greeting = coder['hello']
end
end

Psych.dump

--- !ruby/object:Foo
hello: world

Psych.load

#<Foo:0x000001009f6770
@greeting="world">

Format Agnostic
class Foo
def initialize
@greeting = 'world'
end

def encode_with(coder)
coder['hello'] = @greeting
end

def init_with(coder)
@greeting = coder['hello']
end
end

YAML & JSON

Psych.dump Foo.new
Psych.to_json Foo.new

class XMLDumper < Psych::Handler
def self.dump(object)
dumper = new
viz = Psych::Visitors::YAMLTree.new({}, dumper)
viz << object
dumper.doc.to_xml
end

attr_reader :doc

def initialize
@doc = Nokogiri::XML::Document.new
@doc.root = @doc.create_element 'root'
@tags = []
@stack = [@doc.root]
end

def start_mapping(anchor, tag, implicit, style)
tag = @doc.create_element('table')
@stack.last << tag
@stack << tag
end

def end_mapping
@stack.pop
end

def scalar(value, anchor, tag, *args)
@stack.last << @doc.create_element('tr').tap do |tag|
tag << @doc.create_element('td', value)
end
end
end

YAML & JSON &
XML

Psych.dump Foo.new
XMLDumper.dump Foo.new

class HTMLDumper < XMLDumper
def initialize
@doc =
Nokogiri::HTML::Document.new
@doc.root = @doc.create_element('html')
@doc.root <<
@doc.create_element('body')
@tags = []
@stack = [@doc.root.children.ﬁrst]
end
end

YAML & JSON &
XML & HTML

Psych.dump Foo.new
HTMLDumper.dump Foo.new

module Marshalable
module ClassMethods
def _load data
x = allocate
x.init_with Marshal.load data
x
end
end

def self.included klass
klass.extend ClassMethods
end

def _dump o
coder = {}
encode_with coder
Marshal.dump coder
end
end

class Foo; include Marshalable; end

YAML & JSON &
XML & HTML &
Marshal
Psych.dump Foo.new
HTMLDumper.dump Foo.new
Marshal.dump Foo.new

Rails is made up of
interesting things

It's JSON!

512
{"in_reply_to_screen_name":null,...}

419
{"in_reply_to_screen_name":"tenderlove"...}

Still JSON!

---
{"in_reply_to_screen_name":null,...}
...
---
{"in_reply_to_screen_name":"tenderlove"...}
...

Event Output

stream = Psych::JSON::Stream.new $stdout
loop do
stream << { :hello => "world" }
end

--- {'hello': 'world'}
...
...
...
...

class StreamAPI
def call(env)
reader, writer = IO.pipe

Thread.new(writer) do |wr|
stream = Psych::JSON::Stream.new writer
loop { stream << { :hello => "world" } }
end

[200, {}, reader]
end
end

Ruby on Rails: Tasty Burgers

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to Ruby on Rails: Tasty Burgers

Similar to Ruby on Rails: Tasty Burgers (20)

More from Aaron Patterson

More from Aaron Patterson (7)

Recently uploaded

Recently uploaded (20)

Ruby on Rails: Tasty Burgers

Editor's Notes