Postobjektové programovanie v Ruby

Postobjektové
programovanie v Ruby
@tkramar, @jsuchal

Paradigma
model, súbor princípov, spôsob uchopenia
problému

Aké paradigmy poznáte?
procedurálna (C, Basic, COBOL, ..)
zdieľané dáta, procedúry operujúce nad dátami
objektová (Ruby, Java, Python, ..)
zapuzdrené dáta, metódy operujúce nad stavom objektu
funkcionálna (Lisp, Haskell, Scheme, ..)
dáta = program, čisté výrazy, bez vedľajších efektov
logická (PROLOG)
deklaratívne programovanie - fakty a predikáty, odvodzovanie

Objekt
identita

stav

správanie

class Person
@name = ''

def initialize(name)
@name = name
end

def say
"Ahoj, ja som #{@name}"
end
end

Person
Stav
@name

Správanie
def say
"Ahoj, ja som #{@name}"
end

Identita
p = Person.new('Janko')
o.object_id

Identita
sú dva objekty rovnaké?
==

sú dva objekty rovnaké a rovnakého typu?
eql?

sú dva objekty totožné?
equals?

Identita
p1 = Person.new('Janko')
#=> #<Person:0x00000001b5c100 @name="Janko">
#=> #<Person:0x00000001b556e8 @name="Janko">

family = []
family << p1
family << p2

family.uniq
#=> [#<Person:0x00000001b5c100 @name="Janko">,
#<Person:0x00000001b556e8 @name="Janko">]

class Person
def ==(other)
other.name == @name
end

def eql?(other)
self == other
end
end

class Person
def hash
@name.hash
end
end

Identita
#=> #<Person:0x00000001b5c100 @name="Janko">
#=> #<Person:0x00000001b556e8 @name="Janko">

family = []
family << p1
family << p2

family.uniq
#=> [#<Person:0x00000001b5c100 @name="Janko">]

Základné koncepty
inheritance (dedenie)

method overloading (preťažovanie metód)

method overriding (prekonávanie metód)

Dedenie
class Instrument
def tune
...
end
end

class Violin < Instrument
def play
tune
"Taa daa"
end
end

Overloading v ruby nefunguje
class Instrument
def play
"Ta da"
end

def play(octave)
"Ta da #{octave}"
end
end

i = Instrument.new
i.play #=> ArgumentError: wrong number of arguments (0 for 1)
i.play('c dur') #=> "Ta da c dur"

Overriding
class Instrument
def play
"Ta da"
end
end

def play
"Tiii diii tiii"
end
end

v = Violin.new
v.play #=> "Tiii diii tiii"

Polymorfia
class Instrument
def play
end
end
def play
"Taa daa"
end
end

class Drum < Instrument
def play
"Dum dum"
end
end

orchestra = [Violin.new, Violin.new, Drum.new]
orchestra.each { |i| i.play }
#=> "Taa daa", "Taa daa", "Dum dum"

Aj nil
Object.class #=> Class
nil.class #=> NilClass

ActiveSupport try
p = Person.find(params[:id])

p.address.downcase
#=> NoMethodError: undefined method `downcase'
# for nil:NilClass

p.address.try :downcase #=> nil

Aj metóda
class Person
def greet(other_person)
"Ahoj #{other_person}"
end
end

m = Person.instance_method(:greet)
m.class #=> UnboundMethod
m.arity #=> 1
m.name #=> :greet
m.parameters #=> [[:req, :other_person]]

Aj trieda
Class.class #=> Class

.. o metaprogramovaní inokedy

Modul ako namespace
module Rubyslava
class OOP
end
end

module Pyvo
class OOP
end
end

Rubyslava::OOP == Pyvo::OOP #=> false

Modul ako nositeľ kódu
module Rubyslava
def hello
"Rubyslava"
end
end

Mixiny
class RubyslavaAPyvo
include Rubyslava
end

rp = RubyslavaAPyvo.new
rp.hello #=> "Rubyslava"

class RubyslavaAPyvo
extend Rubyslava
end

RubyslavaAPyvo.hello #=> "Rubyslava"

Viacnásobné dedenie
class RubyslavaAPyvo < Array
include Rubyslava, Pyvo
end

RubyslavaAPyvo.ancestors
#=> [RubyslavaAPyvo, Rubyslava, Pyvo
# Array, Object, Kernel, BasicObject]

Viditeľnosť v moduloch
moduly zdieľajú všetko

inštančné premenné (@)

metódy

module AdditionalBehaviour
def show
greet
end
end

class Test
include AdditionalBehaviour

def greet
"hello"
end
end

Test.new.show #=> "hello"

module GreetingBehavior
def greet
"hello"
end
end

module RelyOnGreetingBehavior
def show
greet
end
end

class Test
include GreetingBehavior, RelyOnGreetingBehavior
end
Test.new.show #=> "hello"

Zo života
Enumerable

acts_as_..

ActiveSupport::Concern

class Tree
include Enumerable

def each(&block)
leafs.each do { |n| yield n }
end
end

t = Tree.new
t.map
t.inject
t.sum
...

class Post
acts_as_taggable
end

p = Post.find(1)
p.tag_list #=> ["Ruby", "OOP"]

ActiveSupport::Concern
module Annotatable
extend ActiveSupport::Concern
included do
has_many :notes, :as => :annotatable,
:order => "created_at DESC"
end

def most_annotated
joins(:notes).group(:id).order("COUNT(*) DESC").first
end
end
class Project < ActiveRecord::Base
include Annotatable, Importable, Versionable
end

Idiómy
jazykovo špecifické vzory

Ruby idiómy
bloky

a, b = b,a

a, b, c = array

(cachovanie) @var ||= ..

Bloky
transaction do |transaction|
transaction.rollback if error?
end

Dir.chdir('/') do
end

with_disabled_keys do
end

with_nested_loop_plan do
end

Vzory
Všeobecné riešenie často sa opakujúceho
problému. Nie je to knižnica, ani kód, skôr
šablóna.

"When I see patterns in
my programs, I consider it
a sign of trouble."
(Paul Graham)

Vzory, ktoré v Ruby
netreba programovať

Singleton
Problém: Zabezpečiť jednotný prístup k zdrojom
(napr. databáza)
Zlo, česť výnimkám (ActiveSupport::Inflections)

Singleton
class Logger
def initialize
@log = File.open("log.txt", "a")
end

@@instance = Logger.new

def self.instance
@@instance
end

def log(msg)
@log.puts(msg)
end

private_class_method :new
end
Logger.instance.log('message 1')

Singleton (lepšie)
require 'singleton'

class Logger
include Singleton

def initialize
@log = File.open("log.txt", "a")
end

def log(msg)
@log.puts(msg)
end
end

Logger.instance.log('message 2')

Iterator
Problém: Umožniť manipuláciu s kompozitným
objektom bez odhalenia jeho internej štruktúry

Iterator
class Tree
include Enumerable

def each(&block)
leafs.each { |e| yield e }
end
end

Decorator
Problém: pridávanie funkcionality do triedy
počas behu programu

Dekorátor obalí pôvodnú triedu a kde treba
rozšíri správanie

class StringDecorator < String
def starts_with? substr
# ...
end
end

title = StringDecorator.new("Rubyslava")

Decorator = open classes
class String
def starts_with? substr
# ...
end
end

"aye aye captain".starts_with? "pirate"
#=> false

Delegator
Problém: Skrytie vnútorných závislostí

Delegator
include 'forwardable'
class Car
extend Forwardable

def_delegators :@car_computer, :velocity,
:distance

def initialize
@car_computer = CarComputer.new
end
end

c = Car.new
c.velocity
c.distance

Proxy
Problém: Skrytie implementačných detailov
načítavania zdroja

Proxy
require 'delegate'

class Future < SimpleDelegator
def initialize(&block)
@_thread = Thread.start(&block)
end

def __getobj__
__setobj__(@_thread.value) if @_thread.alive?
super
end
end

google = Future.new do
Net::HTTP.get_response(URI('http://www.google.com')).body
end
yahoo = Future.new do
Net::HTTP.get_response(URI('http://www.yahoo.com')).body
end

puts google
puts yahoo

Template method
Problém: Často sa opakujúci boilerplate kód.
Kostra programu, algoritmu.

class Game
def play
prepare_board
initialize_score
while not end_of_game?
make_move
end
end
end

class Carcassonne < Game
def make_move
tile = tiles.pick_random
...
end
end

class Agricola < Game
def make_move
peasant = select_peasant
...
end
end

Composite
Problém: V stromových štruktúrach
zamaskovať implementačný detail:
uzly a listy.

class Person
def say
"#{@name}"
end
end
class Family
attr_accessor :members

def initialize(members)
@members = members
end
def say
@members.each { |m| m.say }
end
end

f = Family.new(Person.new('Janko'), Person.new('Tomas'))
t = Family.new(Person.new('Ferko'), f)

t.say #=> "Ferko", "Janko", "Tomas"

Strategy
Problém: Výber vhodného algoritmu
za behu programu

class FileLogger < Logger
def log(message)
File.open('a') { |f| f << message }
end
end

class DatabaseLogger < Logger
def log(message)
Log.create(:message => message)
end
end

State
Problém: Zmena správania objektu
v rôznych stavoch

class TrafficLight
include AlterEgo
state :proceed, :default => true do
handle :color do
"green"
end
transition :to => :caution, :on => :cycle!
end

state :caution do
handle :color do
"yellow"
end
transition :to => :stop, :on => :cycle!
end
state :stop do
handle :color do
"red"
end
transition :to => :proceed, :on => :cycle!
end
end

light = TrafficLight.new
light.color # => "green"
light.cycle!
light.color # => "yellow"
light.cycle!
light.color # => "red"
light.cycle!
light.color # => "green"

Observer
Problém: Oddelenie core funkcionality
a špecifického správania v určitých
stavoch objektu.

class Comment < ActiveRecord::Base
end

class CommentObserver < ActiveRecord::Observer
def after_save(comment)
Notifications.deliver_comment("admin@do.com",
"New comment was posted", comment)
end
end

Zápachy v kóde
(Bad smells)

Vytváranie vlastného
typového systému
is_a?, kind_of?

lepšie je respond_to?

class Container
def add(node)
if node.kind_of? Array
node.each { |n| @nodes << n }
else
@nodes << node
end
end
end

container.add(Tree.new('a', 'b')) #=> ???

class Container
def add(node)
unless node.respond_to? :each
node = [node]
end
node.each { |n| @nodes << n }
end
end

container.add(Tree.new('a', 'b')) #=> ['a', 'b']

Protipríklad
ActiveRecord::sanitize_sql_for_assignment
def sanitize_sql_for_assignment(assignments)
case assignments
when Array
sanitize_sql_array(assignments)
when Hash
sanitize_sql_hash_for_assignment(assignments)
else assignments
end
end

Visitor + typy
def visit object
method = "visit_#{object.class.name}"
send method, object
end

module Arel
module Visitors
class WhereSql < Arel::Visitors::ToSql
def visit_Arel_Nodes_SelectCore o
"WHERE #{o.wheres.map { |x| visit x }.join ' AND ' }"
end
end
end
end

Shotgun surgery
ak niečo mením tak musím na viacerých
miestach

crosscutting concerns

AOP (AspectJ)

AspectJ
pointcut writableHeaderMethods() :
execution(* (WritableRequestHeader|| WritableResponseHeader) .*(..));

before(HeaderWrapper header) :
writableHeaderMethods() && this(header) {
...
}

ActiveRecord::Observer

ActiveController::Caching::Sweeper

before/after/around filtre

Caching
class DocumentController < ApplicationController
caches_page :show
caches_action :index

def show; end
def index; end
end

Autorizácia
before_filter :find_document
def show
# render @document
end

private
def find_document
@document = Document.find_by_id(params[:id])
end
end

before_filter :find_document
around_filer :authorize
def show
# render @document
end

private
def find_document
@document = Document.find_by_id(params[:id])
end

def authorize
if current_user.can_view?(@document)
yield
else
render :not_authorized
end
end
end

Ťažko testovateľná trieda
skúsiť si najprv napísať test

rcov

Duplicitný kód
reek

metric_fu

rubymine

refaktoring

vzor Template

Často sa meniaci kód
churn

Dlhý zoznam parametrov
*args

nahradenie objektom

fluent interfaces

def params(*args)
puts args.class
puts args.inspect
end

params('a', {:hello => 2}, 42)
#=> Array
#=> ["a", {:hello=>2}, 2]

activerecord 2.x
vs
activerecord 3.x
Visit.first(:select => "happened_at",
:order => "happened_at ASC").happened_at

Visit.select(:happened_at)
.order("happened_at ASC").first.happened_at

Primitívna obsesia
class Debt < ActiveRecord::Base
composed_of :debit,
:class_name => "Money",
:allow_nil => true,
:mapping => [%w(debit_amount amount),
%w(debit_currency currency)]
end

debt.debit # => Money

switch/case
Template polymorfia
<% subject.infos.each do |info| %>
<%= render :partial => "#{info.class.to_s}_detail",
:subject => subject %>
<% end %>

Dátová trieda
Skinny controller, fat model

Dátová trieda
class SubjectController < ApplicationController
def show
if @subject.updated_at < Time.now - 2.weeks.ago
@subject.refresh
end
end
end

class Subject < ActiveRecord::Base
end

Dátová trieda 2
class SubjectController < ApplicationController
def show
@subject.update_if_stale
end
end
def update_if_stale
refresh if updated_at < Time.now - 2.weeks.ago
end
end

class Person < Subject
def update_if_stale
# update vsetky firmy kde je subjekt
end
end

Komentáre
# download new version of article
def perform(x)
# load article from the url 'x'
...
end

def download_article(url)
...
end

Single responsibility
principle
Objekt by mal mať iba jednu zodpovednosť

observers

cache sweepers

moduly (include, extend)

Open/closed principle
Triedy by mali byť otvorené pre rozširovanie,
ale uzavreté pre modifikáciu

v ruby tomu ťažko zabrániť

Liskov substitution principle
Každý nadtyp by mal byť nahraditeľný
podtypom

kruh/kružnica

čo s polomerom?

Interface segregation
principle
Hierarchia v rámci rozhraní - radšej viac
špecifických rozhraní ako jedno obrovské

v ruby nemá zmysel

Dependency inversion
principle
Závislosť musí byť na rozhraní, nie na
konkrétnej implementácii

dependency injection

Domain driven design
ambiguous language

Array#first, Array#second, Array#forty_two

has_many :debts

def is_suspicious?
debts.any? or in_liquidation?
end
end

Záver
With great power comes great responsibility
(Spidermanov otec)

Postobjektové programovanie v Ruby

More Related Content

What's hot

Viewers also liked

More from Jano Suchal

Postobjektové programovanie v Ruby