Maurício Linhares. Desenvolvedor. JUGLeader do PBJUG. Java Ruby C#

Transcrição

1 Maurício Linhares

2 Maurício Linhares Desenvolvedor Java Ruby C# JUGLeader do PBJUG

3 Completamente, absurdamente, absolutamente, plagiadamente, baseado em... Programming Ruby The Pragmatic Programmers Guide 2nd. Por Dave Thomas, Andy Hunt e Chad Fowler; Agile Web Development with Rails 2nd. Dave Thomas, David Heinemeier Hanson;

4 Do Japão Yukihiko Matz Matsumoto Trazida ao mundo ocidental pelos Pragmatic Programmers Andy Hunt e Dave Thomas (livro da machadinha) Completamente orientada a objetos Não existem tipos primitivos

5 Linguagem de script interpretada; Muito influenciada por Smalltalk e Perl; Contém conceitos de linguagens funcionais (closures blocos de código); ( g ); Completamente dinâmica (tudo pode mudar Completamente dinâmica (tudo pode mudar em tempo de execução);

6 IRB é o Interactive Ruby, o console da linguagem; Pode-se enviar comandos ou se definir classes, módulos, funções e qualquer outra coisa pra se utilizar durante uma sessão;

7 numero = 30 outro_numero = -20 numero + outro_numero numero + outro_numero.abs

8 Não se usam ; ou qualquer outra coisa pra indicar o fim de uma linha, o fim da linha é o fim da linha, oras; Variáveis não tem tipo, elas simplesmente guardam um objeto qualquer, de qualquer tipo; Quando nós vamos dar nomes a variáveis, normalmente separamos nomes compostos com _ ;

9 Eu faço quack(), nadar() e voar(), igual a qualquer outro pato, eu sou ou não um pato?

10 Pois é, você perdeu a aula de Smalltalk né? Não importa qual o tipo do objeto, o que importa são as mensagens (métodos?) que ele é capaz de responder; Se faz quack, nada e voa feito um pato, então pra mim é um pato;

11 def soma( primeiro, segundo) primeiro + segundo soma( 10, 20) soma 50, 90

12 A definição de um método começa com def depois vem o nome do método e depois seus parâmetros entre parenteses; Blocos de código, como métodos, classes, ifs são sempre fechados com, aqui não tem {} não;

13 Em Ruby não se usa return, se a úli última expressão no corpo de um método for avaliada para um valor, esse valor é retornado (Lembra do Effective Java? Não? Pois deveria!); O uso de parênteses não é obrigatório na chamada de métodos, mas tenha cuidado com a legibilidade; Bem, você ainda pode usar return se quiser, mas é feio, oras;

14 class Song def initialize(name, artist, = = = duration musica = Song.new Denied, Sonic Syndicate, 3 musica.inspect i

15 A definição de uma classe começa com a palavra class ; As classes são sempre abertas, você pode redefinir os métodos de uma classe em qualquer lugar, é só declarar ela outra vez; Nomes de classe normalmente são definidos usando CamelCase (como em NomeDeClasse);

16 Os contrutores são os métodos initialize(), que são invocados indiretamente, através do método de classe new ; Não é possível fazer sobrecarga de construtores em Ruby =( ; Variáveis de instância tem o nome começado ;

17 class Song attr_writer :duration attr_reader :duration attr_acessor :title song = Song.new( new("bicylops", "Fleck", 260) song.duration = 257 song.title = Triciclops

18 attr_reader define métodos de acesso a um atributo de instância de um objeto; attr_writer define métodos de alteraçao a um atributo de instância de um objeto, assim como o reader, ele cria a variável dentro do objeto; attr_acessor faz o mesmo que os dois anteriores juntos;

19 class Song def def = (new_duration * 60).to_i

20 Criamos métodos de acesso a um atributo, mas o cliente não sabe se são métodos ou se ele está acessando os atributos t diretamente; t Sobrescrevemos o operador = (atribuição) para a nossa propriedade, Ruby tem sobrecarga de operadores (alguns, apenas)!

21 class SongList MAX_TIME = 5*60 # 5 minutos MIN_TIME = 1*60 # 1 minuto def SongList.is_too_long(song) song.duration > MAX_TIME def self.is_too_short(song) song.duration < MIN_TIME

22 Variáveis de classe são definidas com como em ; Constantes são definidas com o seu nome completo em caixa alta (na verdade é só a primeira letra, mas use o NOME COMPLETO); Métodos de classe são definidos colocando o nome da classe antes do nome do método ou usando self (é o this em Ruby);

23 class MCl MyClass def method1 # o padrão é public protected def method2 private def method3 public def method4

24 Os níveis de acesso são definidos em blocos, quando não há definição, é public, quando se quer definir i um nível de acesso, deve-se utilizar um bloco de acesso; Um bloco termina assim que outro se iniciar;

25 a = [ , "pie", 99 ] a[0] # a[3] # nil a << 123 # adicionando um item a[4] = 456 #adicionando outro item a[-1] # 456 acessando de trás pra frente a[2..4] # [99, 123, 456]

26 Arrays são definidos pela simples declaração de [], como em a = [], também pode-se fazer a = Array.new ; Arrays são acessados pelo índice, tanto positivo (ordem crescente) como negativo (ordem decrescente); Quando se acessa um índice que não existe em um array, ele retorna nil ;

27 Novos items podem ser colocados no array simplesmente utilizando o próprio operador [], como em a[10] = 10 ; Para se adicionar um item no fim do array usa-se o operador <<, como em a << 10 ; Arrays podem ser pegos em pedaços como em a[1..3], que cria um novo array com os itens do índice 1 ao 3;

28 h = { 'dog' => 'canine', 'cat' => 'feline', 'donkey' => 'asinine' } h.length # 3 h['dog'] # "canine" h['cow'] = 'bovine' h[12] = 'dodecine' h['cat'] = 99

29 São conjuntos de chave-valor (Lembra do Map em Java?); São declarados com o uso de {} como em h = {}, ou usando Hash.new; Para se adicionar itens basta usar o operador [], como em h[ chave ] = valor ;

30 class SongList def with_title(title) for i in [email protected] g[] if title return nil

31 class SongList def { song title == song.name }

32 Blocos são pedaços de código que podem ser passados como parâmetros para funções, para fazer algum trabalho especial, como filtragem, ordenação e outros; Você pode definir os seus próprios métodos it bl que aceitam blocos;

33 def fib_up_to(max) i1, i2 = 1, 1 # atribuição paralela (i1 = 1 and i2 = 1) while i1 <= max yield i1 i1, i2 = i2, i1+i2 fib_up_to(1000) { f print f, " " }

34 O método não tem nada de especial, a sua definição fica igual a qualquer outro método e ele pode ou não receber parâmetros; Na implementação do método, você invoca o método especial yield para executar o bloco, se o bloco recebe parâmetros, você os passa para o método yield ;

35 'escape using "\\"' # escape using "\" 'That\'s right'! #That's right "Seconds/day: #{24*60*60}" # Seconds/day: def to_s Song: #@song Artist: #{@artist}

36 #Q!String de muitas linhas com aspas duplas e acessando variáveis #{variavel}! #q( String de muitas linhas com aspas simples, aqui não pode ter variável ) a << b << c # abc

37 Strings são sequências de caracteres de 8 bits, não necessariamente Unicode; Elas podem ser definidas usando (aspas simples) ou (aspas duplas); Usando aspas duplas você pode colocar expressões ou variáveis com o uso do caracter # seguido de {} para variáveis de método ou funções ou para variáveis de instância;

38 # [ ] [1,2,3,4,5,6,7,8,9,10] 'a'..'z ' ' # lembra do alfabeto? my_array = [ 1, 2, 3 ] 0...my_array.length # [0,1,2,3,4] (1..10).to_a # [1, 2, 3, 4, 5, 6, 7, 8, 9,10] ('bar'..'bat').to_a # ["bar", "bas", "bat"]

39 São um conjunto de objetos em sequência, normalmente caracteres ou números; São definidos através da declaração de [ valor inicial.. valor final ], como em [1..100]; Você pode definir os seus próprios ranges com o operador <=> (disco voador?);

40 class VU include Comparable attr :volume def = volume def to_s '#' def <=>(other) self.volume <=> other.volume def succ raise(indexerror, "Volume too big") >= 9 VU.new(@volume.succ)

41 num = 81 6.times do puts "#{num.class}: #{num}" num *= num

42 def cool_dude(arg1="miles", d " arg2="coltrane", " arg3="roach") "#{arg1}, #{arg2}, #{arg3}." cool_dude # "Miles, Coltrane, Roach." cool_dude( dude("bart") Bart) # "Bart Bart, Coltrane, Roach. " cool_dude("bart", "Elwood") # "Bart, Elwood, Roach. " cool_dude("bart", "Elwood", "Linus") # "Bart, Elwood, Linus."

43 def meth_three 100.times do num square = num*num return num, square if square > 1000 meth_three three # [32, 1024]

44 def five(a, b, c, d, e) "I was passed #{a} #{b} #{c} #{d} #{e}" five(1, 2, 3, 4, 5 ) # "I was passed " five(1, 2, 3, *['a' [a, 'b']) # "I was passed a b" five(*(10..14).to_a) # "I was passed "

45 class SongList def create_search(name, params) #... list.create_search('short jazz songs', :genre => :jazz, :duration_less_than => 270)

46 puts "a = #{a}" if debug print total unless total.zero? f 2 if x == 2 puts x elsif x < 0 puts #{x} é menor que zero else puts Caiu no else

47 leap = case when year % 400 == 0: true when year % 100 == 0: false else year % 4 == 0

48 case input_line when "debug" dump_debug_infod dump_symbols when /p\s+(\w+)/ dump_variable($1) when "quit", "exit" exit else print "Illegal command: #{input_line}"

49 print "Hello\n" while false begin print "Goodbye\n" while false while x < 10 puts X é #{x} x = x + 1

50 3.times do print "Ho! 0.upto(9) do x print x, " " [ 1..5 ].each { val puts #{val} }

51 for i in ['fee', 'fi', 'fo', 'fum'] print i, " " for i in 1..3 print i, " "

52 while line = gets next if line =~ /^\s*#/ # pular comentários break if line =~ /^END/ # parar no fim # executar coisas redo if line.gsub!(/`(.*?)`/) { eval($1) } # process line...

53 for i in print "Now at #{i}. Restart? " retry if gets =~ /^y/i

54 Agora você programa em Ruby!

55 Admita, você já estava cansado de tanto mexer e não ver nada né?

56 Um framework web completo, baseado no MVC web (lembra disso?); Ele define aonde cada pedaço de código deve ficar e como ele deve ser acessado; Convenções são melhor do que a liberdade de configuração;

57 Né pra repetir código não, rapá!

58 Projeto Depot do livro Agile Web Development With Ruby ; Aplicação de vas de produtos a clientes; Uma interfaces para clientes, outra para a p, p administração;

59

60

61

62 rails depot #sério, é só isso =P

63 README Rakefile Documentação Arquivo de build components/ Esqueça =P doc/ lib/ script/ Mais documentação Código genérico da aplicação Scripts de build vor/ Plugins para a sua aplicação app/ db/ log/ test/ config/ tmp/ public/ Código da sua aplicação! Migrations e geração de banco Arquivos de log Testes da sua aplicação Configuração geral Arquivos temporários do Rails Arquivos estáticos (html, js, css)

64 development: adapter: mysql database: depot_development username: root password: host: localhost

65 rake db:migrate

66 ruby script/generate model product

67 class CreateProducts < ActiveRecord::Migration def self.up create_table :products do t t.column :title, :string t.column :description, :text t.column :image_url, :string ti t.column :price, :decimal, :precision => 8, :scale => 2, :default => 0 def self.down drop_table :products

68 O seu banco de dados d com controle de versão! Define tabelas, adiciona linhas, cria índices e ainda faz a janta! Contém métodos utilitários para criar, alterar e remover tabelas, colunas e linhas; Você faz no up e desfaz no down, não se esqueça da ordem!

69

70

71 :null indica se pode ser null ou não (truefalse) :limit indica o tamanho máximo do campo :default indica o valor padrão do campo :precision indica a precisão do número :scale indica a escala do número (quantas casas depois da vírgula)

72 create_table :authors_books, :id => false do t t.column :author_id, :integer, :null => false t.column :book_id, :integer, :null => false

73 class CreateLineItems < ActiveRecord::Migration def self.up execute "alter table line_items add constraint fk_line_item_products foreign key (product_id) references products(id) def self.down drop_table :line_items

74

75 ruby script/generate scaffold product admin #não, você não vai usar isso até o fim

76 def index list rer :action => 'list' = paginate :products, :per_page => 10 def = Product.find(params[:id]) def = Product.new

77 def = Product.new(params[:product]) flash[:notice] = 'Product was successfully created.' redirect_to to :action => 'list' else rer :action => 'new' def = Product.find(params[:id])

78 def = Product.find(params[:id]) update attributes( params[:product]) flash[:notice] = 'Product was successfully updated.' redirect_to :action => 'show', :id else rer :action => 'edit'

79 rake db:migrate #rodando o migration ruby script/server webrick #iniciando o servidor #voilá!

80 Todo mundo vem de ApplicationController; As URLs nomalmente são.../ nomedocontroller / metododocontroller / aqui pode vir um id ou não, como em /admin/edit/10 ; Todos os métodos públicos de um controller podem se chamados, métodos não públicos não ficam disponíveis (segurança rapá!);

81 action_name nome da action que está executando; headers hash com os cabeçalhos HTTP (você pode colocar novos se quiser); params parametros que vieram da requisição, podem ser acessados usando símbolos ou strings; flash objeto que pode guardar uma mensagem entre uma requisição e outra (como enviar uma mensagem pra um redirect);

82 domain retorna o domínio que veio na requisição remote_ip retorna o ip que gerou a requisição; env hash de parametros enviados pelo browser (como língua); method retorna o método http invocado como um símbolo, :get, :post e ect; get?, post?, put?, delete?, xml_http_request?, xhr?

83 É um hash de strings, onde você pode passar qualquer valor; Você só pode passar Strings; Sempre use o atributo cookies para enviar cookies para o navegador, nunca envie usando o atributo headers ;

84 Representa uma sessão HTTP de um usuário com a aplicação; Você pode colocar valores dentro dela, como se ela fosse um hash; Os valores podem ser qualquer coisa, contanto que seja um objeto que possa ser serializado; EVITE colocar muita coisa na sessão;

85 rake db:sessions:create rake db:migrate config.action_controller.session_store = :active_record_store _

86 <% form_tag :action => 'update', :id do %> <%= rer :partial => 'form' %> <%= submit_tag 'Editar' %> <% %> <%= link_to 'Mostrar', :action => 'show', :id %> <%= link_to 'Voltar', :action => 'list' %>

87 form_tag é uma função de ajuda que gera um formulário através de um bloco de código; rer :partial => form, vai incluir o arquivo _form dentro da página submit_tag Editar gera um botão clicável link_to Editar :action => show gera um link para o método show do controller atual;

88 <%= error_messages_for 'product' %> <!--[form:product]--> <p><label for="product_name">nome</label><br/> <%= text_field t :product, :name %></p> <p><label for="product_category">categoria</label><br/> <%= select :product, :prompt => "Escolha uma categoria"%> </p> <p><label for= "product_label label" >Marca</label><br/> br/ <%= select :product, :prompt => "Escolha uma marca" %> </p> <p><label for="product_price">preço real</label><br/> <%= text_field :product, :real_price %></p> <!--[eoform:product]-->

89 text_field e select são utilitários para gerar um campo de entrada e um select HTML, existem outros utilitários i para todos os outros componentes HTML; O uso de símbolos, como em text_field :product, :name é para dizer de onde vem o campo e que campo é que nós queremos mostrar (veja o código fonte gerado!);

90 @categories = Category.find( :all, :order => :name).map { c [c.name, c.id] } Ao mostrar alguma coisa em um select, ele deve vir em um array de arrays, onde o primeiro item é o label do select e o segundo item é o value do select;

91 <% form_for f :product, :url => { :action => :create } do form %> <p>title: <%= form.text_field :title, :size => 30 %></p> <p>description: <%= form.text_area :description, :rows => 3 %></p> <p>price: <%= form.text_field :price, :size => 10 %></p> <p><%= submit_tag %></p> <% %>

92 É feito especificamente para gerar formulários para objetos do modelo; Os métodos utilitários de criação de componentes são chamados direto no form e não é necessário repetir diversas vezes qual o objeto real; De resto é igual a form_tag;

93 class Product < ActiveRecord::Base validates_presence_of :title, :description, :image_url validates_numericality_of :price validates_uniqueness_of :title validates_format_of of :image_url, :with => %r{\.(gif jpg png)$}i, :message => deve ser um gif, jpg ou png" protected def validate errors.add(:price, deve ser ao menos 0.01" ) if price.nil? price < 0.01

94 Td Toda a validação é definida id dentro do próprio objeto do modelo; Existem diversos métodos utilitários para diversos tipos de validação; Se nenhum dos métodos resolve o seu problema, implemente o método validate ; As mensagens aparecem em -> <%= error_messages_for _ 'product' %>

95 ruby script/generate migration add_test_data data class AddTestData < ActiveRecord::Migration def self.up Product.create( :title => 'Pragmatic Version Control', :description => %{<p>with Subversion</p>}, :image _ url => '/images/svn.jpg', :price => 28.50) def self.down Product.delete_all

96 <%= link_to Remover', { :action => 'destroy', y, :id => product }, :confirm => Tem certeza?", :method => :post %>

97 module ApplicationHelper def format_price( price ) number_to_currency( price, :precision => 2, :unit => 'R$ ', :separator => ',', :delimiter => '.' )

98 Cada controller tem o seu próprio helper e existe um helper padrão que sempre está disponível para todos os controllers; Todo o trabalho que possa ser de lógica das views (como formatação, geração de templates t e etc) deve ser feito por eles; Ó NAS VIEWS NÃO PODE HAVER LÓGICA, enteu? Ou quer que desenhe?

99 <% form_for(:picture, f it :url => {:action => 'save'}, :html => { :multipart => true }) do form %> Comment: <%= form.text_field("comment" ) %><br/> Upload your picture: <%= form.file_field("uploaded_picture" p ) %><br/> <%= submit_tag("upload file" ) %> <% %>

100 class Picture < ActiveRecord::Base validates_format_of :content_type, :with => /^image/, :message => "-- you can only upload pictures it def uploaded_picture=(picture_field) self.name = base_part_of(picture_field.original_filename) f l f l self.content_type = picture_field.content_type.chomp self.data = picture_field.read def base_part_of(file_name) File.basename(file_name).gsub(/[^\w._-]/, '' )

101 def = Picture.find(params[:id]) s_data(@picture.data, :filename :type :disposition => "inline" )

102 Ei, você já está mexo com ele desde o primeiro migration!

103 É a abstração de banco de dados de Rails; Baseado no padrão de projeto active record ; Cada coluna que você definiu lá no q migration, vira uma propriedade do objeto;

104 save e save!, salva ou atualiza um objeto, save retorna true se conseguir salvar, false senão ou o objeto for inválido, save! lança uma exeção se não conseguir salvar ou se o objeto for inválido; destroy remove um objeto do banco de dados e não deixa que nenhum dos seus atributos seja alterado;

105 update_attributes e update_attributes!, recebem um hash com os parâmetros e valores das propriedades d do objeto e tentam t enviar uma atualização para o banco de dados; create cria um novo objeto com o hashh de parametros passado e salva ele no banco de dados automaticamente;

106

107 Define um relacionamento de 1 pra N (como em um item pertence a um produto, mas um produto pode ter N itens); Métodos adicionados: product(reload = false) product= build_product( hash ) create_product( hash )

108

109 Define o lado 1 do relacionamento um para muitos; Adiciona os métodos (e ainda outros...): orders(force_reload=false) reload=false) orders <<order orders.push(order1,...) orders.replace(order1,...) orders.delete(order1,...) orders.destroy_all orders.size orders.empty?

110 class Article < ActiveRecord::Base has_and_belongs_to_many :users class User < ActiveRecord::Base has_ and_ belongs _ to_ many :articles

111 Account.transaction do account1.deposit(100) account2.withdraw(100)

112 name = params[:name] pos = Order.find(:all, :conditions => "name = '#{name}' and pay_type yp = 'po'" )

113 name = params[:name] pos = Order.find(:all, :conditions => ["name =? and pay_type = 'po'", name])

114 name = params[:name] pay_type = params[:pay_type] pos = Order.find(:all, :conditions => ["name = :name and pay_type = :pay_type type", {:pay_type => pay_type, :name => name}])

115 :order para ordenar a consulta, use símbolos; :limit quantidade máxima de itens que deve ser trazida; :offset primeiro item a ser trazido; :first no lugar de :all, para trazer apenas um item;

116 items = LineItem.find_by_sql("select *, " + " quantity*unit_price as total_price, " + " products.title as title " + " from line_items, products " + " where line_items.product_id = products.id " ) li = items[0] puts "#{li.title}: #{li.quantity}x#{li.unit_price} => #{li.total_price} price}"

117 average = Order.average(:amount) max = Order.maximum(:amount) min = Order.minimum(:amount) total = Order.sum(:amount) number = Order.count #tudo isso pode receber :conditions, como o find

118 order = Order.find_by_name("Dave Thomas" ) orders = Order.find_all_by_name("Dave Thomas" ) order = Order.find_all_by_ (params[' ' y_ (p [ ])

119 Obrigado pessoal! \o/