Diary of a Mad Rails Engineer

Slides for LoneStarRuby Conference 2013 talk: "Diary of a Mad Rails Engineer" http://www.lonestarruby.org/2013/lsrc

Transcript

1. Diary of a Mad Rails Engineer Akira Matsuda 2013
2. self.name Akira Matsuda (দా ໌)
3. Matz? ɹ matz: Yukihiro Matsumoto (দຊ ߦ߂)
4. Matz! me: Akira Matsuda (দా ໌) দ (= matz) matz: Yukihiro Matsumoto (দຊ ߦ߂)
5. self.inspect GitHub: amatsuda Twitter: @a_matsuda a committer of: Ruby, Rails, Haml the author of: kaminari, active_decorator, action_args, gem-src, html5_validators, kawaii_validation, i18n_generators, ... the founder of: Asakusa.rb an organizer of: RubyKaigi
6. Rails Engineer?
7. https://twitter.com/kosaki55tea/ status/147525384546689024 Boeing 787 engine engineer strongly objects to software engineers calling them selves engineers.
8. Ruby on Rails has Engines!
9. What are Rails Engines? Engine is_a Rails plugin ( + Rails app itself) "Engines can be considered miniature applications that provide functionality to their host applications" (Rails Guides)
10. Engine.is_a Rails plugin plugin.is_a Gem
11. Minimum Rails plugin % cd RAILS_ROOT % mkdir lsrc lsrc/lsrc.gemspec
12. The gemspec # lsrc/lsrc.gemspec Gem::Specification.new do |g| g.name = 'lsrc' g.version = '0' end
13. Gem le # RAILS_ROOT/Gemfile gem 'lsrc', path: 'lsrc'
14. Bundler (RubyGems) adds PLUGIN_ROOT/lib into $LOAD_PATH % rails r 'puts $:'
15. Say hello from our plugin # lsrc/lib/lsrc.rb puts 'Hello, LSRC!'
16. What happens when bundling lsrc gem? RubyGems adds the lib directory into $LOAD_PATH Then someone calls lsrc/lib/ lsrc.rb le somehow
17. Let's see who called lsrc.rb # lsrc/lib/lsrc.rb puts caller puts 'Hello, LSRC!'
18. the callers were require require require require... # gems/bundler-1.3.5/lib/bundler/runtime.rb module Bundler class Runtime < Environment def require(*groups) ... Array(dep.autorequire || dep.name).each do |file| required_file = file Kernel.require file end ... ennnnnd
19. Kernel.require(autorequire || name) I didn't set anything to "autorequire" attribute, so it just requires the "name" equivalent to `require 'lsrc'` lsrc/lib/ is included in $LOAD_PATH, so nally ruby nds lsrc/lib/lsrc.rb and loads it
20. Adding Railtie class and an initializer # lsrc/lib/lsrc.rb module Lsrc class Railtle < ::Rails::Railtie initializer 'lsrc.init' do puts 'initializing lsrc...' end end end
21. How this adds hooks? # railties/lib/rails/railtie.rb module Rails class Railtie class << self def inherited(base) unless base.abstract_railtie? subclasses << base end end ... ennnd
22. YOUR_APP::Application. initialize! YOUR_APP/con g/environment.rb => railties/lib/rails/application.rb: initialize! => railties/lib/rails/initalizable.rb: run_initializers => raities/lib/rails/application.rb: initializer ... => Railties.new
23. Railtie.subclasses # railties/lib/rails/engine/railties.rb module Rails class Engine < Railtie class Railties include Enumerable attr_reader :_all def initialize @_all || = ::Rails::Railtie.subclasses.map(&:instance) + ::Rails::Engine.subclasses.map(&:instance) end ... ennnd
24. Rails Engine
25. Anatomy of Rails Engine my_engine !"" app # !"" assets # # !"" images # # !"" javascripts # # $"" stylesheets # !"" controllers # !"" helpers # !"" mailers # !"" models # $"" views !"" bin !"" config !"" lib # !"" my_engine # # !"" engine.rb # # $"" version.rb # !"" my_engine.rb # $"" tasks $"" test
26. Difference between Engines and non-Engine plugins An Engine can contain models, controllers, views, routes, etc An Engine should contain a subclass of ::Rails::Engine
27. Enginize lsrc gem by subclassing Rails::Engine # lsrc/lib/lsrc.rb module Lsrc class Engine < ::Rails::Engine end end
28. What happens when subclassed? # railties/lib/rails/engine.rb class Engine < Railtie class << self attr_accessor :called_from, :isolated ... def inherited(base) ... base.called_from = begin call_stack = caller.map { |p| p.sub(/:\d+.*/, '') } File.dirname(call_stack.detect { |p| p !~ %r[railties[\w.-]*/lib/rails|rack[\w.-]*/lib/rack] }) end ...
29. Doesn't have to be a named class # lsrc/lib/lsrc.rb module Lsrc Class.new ::Rails::Engine end
30. Doesn't have to be wrapped inside the Lsrc module # lsrc/lib/lsrc.rb Class.new ::Rails::Engine
31. Engine can contain models # lsrc/app/models/foo.rb class Foo def foo p 'foooo' end end
32. How could Rails nd Foo? lsrc/app/models was added in $LOAD_PATH lsrc/app/models was added in the Engine's eager_load_paths
33. $LOAD_PATH % rails r 'puts $:'
34. eager_load_paths? # lsrc/lib/lsrc.rb p Class.new(::Rails::Engine).config.eager_load_paths
35. Make it a webapp #lsrc/config/routes.rb Rails.application.routes.draw do resources :foos end # lsrc/app/controllers/foos_controller.rb class FoosController < ApplicationController def index render text: Foo.new.foo end end
36. Rails Engine is_a plugin is_a Gem is_a tiny application that can contain models, controllers, routes, etc.
37. What can Engines do?
38. My First Rails Engine
39. amatsuda/kaminari A pagination plugin Created for Rails 3.0.0 AFAIK the 2nd Rails Engine in the world
40. Why Engine? Rails Engine can contain app/ {controllers,models,views,helpers,etc} A pagination library consists of model extension, helpers, and views It was quite natural to implement as an Engine (Just wanted to try the new feature of Rails 3.0)
41. Anatomy of Kaminari kaminari !"" app # !"" helpers # $"" views # $"" kaminari !"" config # $"" locales !"" lib # !"" generators # # $"" kaminari # # $"" templates # $"" kaminari # !"" helpers # $"" models $"" spec
42. Initial version https://github.com/amatsuda/ kaminari/tree/v0.1.0 There exist some bugs, but the code is pretty straightforward Only 4 les in kaminari/lib/ directory!
43. v0.1.0 railtie.rb for the Raitie class engine.rb for the Engine class active_record.rb for AR extension helper.rb for the helpers (don't read) views are in app/views
44. active_record.rb (edited) # kaminari/lib/kaminari/active_record.rb (edited) module Kaminari::ActiveRecord extend ActiveSupport::Concern included do def self.inherited(kls) kls.class_eval do scope :page, lambda {|num| offset(PER_PAGE * ([num.to_i, 1].max - 1)).limit(10) } do def per(num) offset(offset_value / limit_value * num).limit(num) end ... ennnnnd
45. How this code works? How does Kaminari paginate? (Pat Shaughnessy) http://patshaughnessy.net/2011/9/10/ how-does-kaminari-paginate Active Record scopes vs class methods (Carlos Antônio) http://blog.plataformatec.com.br/ 2013/02/active-record-scopes-vs- class-methods/
46. "Kaminari" Naming a gem is so hard There was no available /.*page.*/ name @hsbt named it "kaminari" probably inspired by "nokogiri"
47. "Kaminari" ཕ == thunder I know it's hard to memorize, hard to spell, and hard to pronounce for you, non-Japanese In fact, everybody pronounces it incorrectly (I don't mind though)
48. New version? The next version will be 0.15.0 Coming soon...
49. Mountable Engines
50. The Problem constants, routes, helpers often con ict between main_app and Engines
51. The Solution Since Rails 3.1 "Isolated Engine" or "Mountable Engine"
52. Mountable Engine % rails plugin new my_engine -- mountable
53. Mountable Engine's Engine # my_engine/lib/my_engine/ engine.rb module MyEngine class Engine < ::Rails::Engine isolate_namespace MyEngine end end
54. What can a Mountable Engine do? It can provide safely namespaced models, controllers, views, etc. It can be "mounted" onto the parent Rails application's certain URL It can refer to the parent application from controllers / views via `main_app` method
55. Real world examples Documentations in Rails ER diagram Page transition diagram
56. ER Diagram
57. amatsuda/erd
58. ERD Developed during RailsConf 2012 Made in Austin A mounted Engine that loads the main_app's models and draws the ER diagram on the browser
59. (DEMO)
60. A tiny tip erd mounts itself onto the main_app's routes on the :after_initialize hook, so users don't have to con gure anything
61. Self-mounting Engine # erd/lib/erd/railtie.rb module Erd class Railtie < ::Rails::Railtie #:nodoc: initializer 'erd' do |app| ActiveSupport.on_load(:after_initialize) do if Rails.env.development? Rails.application.routes.append do mount Erd::Engine, :at => '/erd' ennnnnnd
62. amatsuda/roundabout
63. I'll be the Roundabout Visualizes page (action) transitions No need for any extra programming or document writing. Just run `rake spec`. Records all page transitions in `rake spec`
64. (DEMO) % rails g scaffold user name age:integer % rake db:migrate add spec/feature/???_spec.rb
65. What roundabout does Generates documents Tells us missing `visit`s Shows us "page visit coverage" Motivates users to complete feature specs
66. amatsuda/hocus_pocus
67. hocus_pocus Released before 3.1.0 stable AFAIK this was the rst released mountable Engine in the world
68. HocusPocus Records your browser action You can copy & paste the generated text into your spec/ features. No need to handwrite anymore!
69. (DEMO)
70. HocusPocus (reprise) A Wiki-wiki way Rails app development platform Users can edit current page like a Wiki page Catches URL missing in the browser for example, just visit http://localhost:3000/books Catches link_to missing in the browser for example, add `link_to 'authors', authors_path`
71. (DEMO)
72. Anatomy of HocusPocus hocus_pocus !"" engines # !"" command_line # # !"" app # # # !"" controllers # # # $"" views # # !"" config # # $"" lib # !"" editor # # !"" app # # # !"" assets # # # !"" controllers # # # $"" views # # !"" config # # $"" lib # !"" generator # # !"" app # # # !"" assets # # # !"" controllers # # # !"" helpers # # # $"" views # # !"" config # # $"" lib # $"" recorder # !"" app # # !"" assets # # !"" controllers # # $"" views # !"" config # $"" lib !"" lib # !"" generators # # $"" hocus_pocus # $"" hocus_pocus $"" spec
73. Engines in an Engine! AFAIK the only Rails Engine that contains other Rails Engines inside Adds each Engine's lib, app/* into $LOAD_PATH require_paths does the trick
74. Gem::Speci cation #require_path # hocus_pocus/hocus_pocus.gemspec Gem::Specification.new do |s| s.name = 'hocus_pocus' s.version = HocusPocus::VERSION s.authors = ['Akira Matsuda'] s.homepage = 'https://github.com/amatsuda/hocus_pocus' ... s.require_paths = ['lib', 'engines/generator/lib', 'engines/ editor/lib', 'engines/recorder/lib', 'engines/command_line/lib'] ... end
75. Have fun with Rails Engines, and be a great Rails Engineer!