Having Fun Programming!

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

Q: How can I
enjoy
programming?

http://www.ﬂickr.com/photos/recompile_net/3733132232/

A: Use Vim!

http://www.ﬂickr.com/photos/recompile_net/3732334373/

class
end
6.times {
.new
}

Thread.new do
. ()
end
Thread.new do
. ()
end
(Thread.list -[Thread.main]).each
{ |x|
x.join
}

• Ruby
•C
• Java
• Lisp
• PHP?

;_;
";_;".encode( ) # => ":'("

• Rails 3
•
• XML
• YAML

Syck

• Ruby 1.8 1.9

• YAML 1.0 ( ) parser emitter

•

Psych

• Ruby >= 1.9.2
• libyaml
• YAML 1.1 parser emitter

•

Ruby 1.8 / 1.9

require 'yaml'

YAML.load_file('some_file.yml')
YAML.load('--- hello world!')

Ruby 1.9.2 / Psych

require 'psych'

Psych.load_file('some_file.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">

Independent
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.first]
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

SQLite3-Ruby

• SQLite3
• Jamis Buck
• SWIG

require 'sqlite3'

connection =
SQLite3::Database.new('file.sqlite3')

Pro Tip

require 'sqlite3'

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

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

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

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

stmt.bind_param(1, 10)

stmt.each do |row|
p row
end

• 1: API

• 2:

• 3:

: 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, flags)
OurFile.new(name, flags)
end
end

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

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
File.size(@store.path) - @offset
end
end

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__

http://gist.github.com/319224/

• Ruby 1.9
• 1000 ( )

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>

(SELECT )
1.2.5 1.3.0

1000

100

10

1

0.1

0.01
500 1000 1500 2000 2500 3000 3500

Ruby.PHP()

Phuby::Runtime.php do |rt|
rt.eval('$v = strlen("PHP IS AWESOME");')
puts rt['v'] # => 14
end

Ruby.PHP()

rt.eval('$foo = array();')
rt.eval('$foo["hello"] = "world";')

foo = rt['foo'] # => #<Phuby::Array:
0x101f8f848>
p foo['hello'] # => ‘world’
end

$PHP->Ruby();
class FUN
def times
puts "hello"
end
end

rt['fun'] = FUN.new
rt.eval('$fun->times();') # => hello
end

Ruby C PHP

Weak
Proxy
Reference PHP
(runtime)
Table

Ruby

Ruby C PHP

Proxy
Ruby PHP
(runtime)

Ruby C PHP

Proxy
Ruby PHP
(runtime)

Proxy
(object)

PHP + WEBrick
=
Blog

#!/usr/bin/env ruby

require 'rubygems'
require 'phuby'
require 'rack'

##
# Rack::Phrack is a Rack handler that will evaulate and serve PHP files.

class Rack::Phrack < Rack::File
class Events < Struct.new(:code, :headers, :body)
def write string; body << string; end
def send_headers response_code; end

def header value, op
k, v = value.split(': ', 2)
self.code = 302 if k == 'Location'
headers[k] = [headers[k], Rack::Utils.unescape(v)].compact.join "n"
end
end

def call env
events = Events.new 200, {}, ''
file = File.join @root, env['PATH_INFO']
file = File.join file, "index.php" if File.directory?(file)

return super unless file =~ /php$/

Dir.chdir(File.dirname(file)) do
rt.eval "date_default_timezone_set('America/Los_Angeles');" # *shrug*

{ Rack::Utils.parse_query(env['QUERY_STRING']) => "_GET",
Rack::Utils.parse_query(env['rack.input'].read) => "_POST",
Rack::Utils.parse_query(env['HTTP_COOKIE'], ';') => "_COOKIE",
}.each do |from, to|
from.each { |k,v| rt[to][k] = v }
end

env.each { |k,v| rt['_SERVER'][k] = v || '' unless k =~ /^rack/ }
rt["_SERVER"]['REQUEST_URI'] = env['PATH_INFO']

rt.with_events(events) { open(file) { |f| rt.eval f } } # RUN!
end
end
events.to_a
end
end

Rack::Handler::WEBrick.run(Rack::Phrack.new(ARGV[0] || Dir.pwd), :Port => 10101)

Client

Phrack

PHPRuntime

One Click Installer

Luis Lavena

Having Fun Programming!

More Related Content

What's hot

Similar to Having Fun Programming!

More from Aaron Patterson

Recently uploaded

Having Fun Programming!