rails-and-solid 0.9.0 → 0.9.1

data/README

@@ -1,3 +1,8 @@
+# What is this?
+
+This is a gem that changes Rails behavior to allow you to code more freely, without coupling
+yourself to inheritance issues. Take a look at the examples to see what it changes.
+
 # Installing
 
 Configure the gem in your Gemfile:
@@ -11,22 +16,194 @@ and make it believe you have the controller he wants, just trick him:
 
   class ApplicationController < ActionController::Base
     
-    protect_from_forgery
-    include RailsAndSolid::TrickHim
+    solidify
+  
+  end
+
+# Inheritance coupling in controllers
+
+Ok. Time for some goodies. First example, let's unpimp :
+
+[code]
+RailsAndSolid.pimp :clients
+
+class ClientsControl
+  
+  def show(id)
+    @client = Client.find(id)
+  end
+  
+end
+[/code]
+
+Notice that *id* is the parameter *id* from your http request. No inheritance required.
+Same old behavior. No http params appeared. You can unit test for real, without all
+its inherited behavior.
+
+Why? Am I really coupled to something when inheriting?
+
+[code]
+rails console
+> ActionController::Base.instance_methods.size
+374
+> (ActionController::Base.instance_methods + ActionController::Base.instance_methods - Object.instance_methods - Object.private_instance_methods).size
+560
+> ActionController::Base.methods.size
+353
+> ActionController::Base.ancestors.size
+36
+[/code]
+
+By default, when creating a new controller in Rails, you are coupled
+with 374 public methods (*542 in total*), inheriting behavior from *36 different* sources.
+
+# Session parameters
+
+[code]
+class ClientsControl
+  
+  def show(current_user, id)
+	# if session[:current_user] exists, guess who is here?
+  end
+  
+end
+[/code]
+
+Again, unit testable. Non-http intrusive.
+
+# Session parameters
+
+[code]
+class ClientsControl
+  
+  def show(current_user, id)
+	# if session[:current_user] exists, guess who is here?
+  end
+  
+end
+[/code]
+
+# What about creating a client?
+
+Well, just create it:
+
+[code]
+class ClientsControl
   
+  def create(client)
+	client.save
   end
+  
+end
+[/code]
+
+# But you can't load, right?
+
+I don't think so:
+
+[code]
+class ClientsControl
+  
+	def show(loaded_client)
+		@client = loaded_client
+	end
+  
+end
+[/code]
 
-# Using
+# But what about responses? Sessions? Http stuff?
 
-NO INHERITANCE
+Just bind to what you need, nothing more than that:
+
+[code]
+def logout(session, redirect_to, flash)
+  session[:current_user] = nil
+  flash[:message] = "Logged out..."
+  redirect_to.root_path
+end
+[/code]
+
+# Internally: Helpers
+
+Helpers are the classes that help passing parameters to those
+methods by using a key based lookup algorithm. For example
+if a 'json' parameter is received, one will use the Json helper
+to return it:
+
+[code]
+class ApplicationController < ActionController::Base
+  
+  protect_from_forgery
+  solidify
+
+  class JsonHelper
+    def initialize(controller)
+      @controller = controller
+    end
+    def message(x)
+      @controller.render :json => {'message' => x}
+    end
+  end
 
-GIVE A SIMPLE EXAMPLE
+  KEYS["json"] = JsonHelper
+  
+end
+[/code]
 
-GIVE A LOAD EXAMPLE
+Now you can receive json and use the message:
 
-GIVE AN AMAZING EXAMPLE
+[code]
+def some_action(json)
+	json.message("Well done!")
+end
+[/code]
 
-# Helpers
+You can use those auxiliary objects to compose any kind of behavior (not just rendering)
+by just receiving the expected coupled semantic value instead of inheriting everything.
 
 # Handlers
 
+Handlers are not key-fixed parameter providers. For instance, the param lookup:
+
+[code]
+module RailsAndSolid
+  module Handler
+    class Param
+      def extract(controller, name)
+        controller.params[name]
+      end
+      def handles?(controller, name)
+        controller.params[name]
+      end
+    end
+  end
+end[/code]
+
+It will be asked whether it can handle this parameter and the provide it.
+
+# TODO List
+
+Help?
+
+First, simple unit tests.
+
+Units are split and behavior is composed. This was only to
+show that its possible to achieve the same (and better results) with less coupling and a different
+OO design approach. So what about start unit testing, providing new handlers, new helpers or
+just doing a blog post on it? Refactoring trick_him would also be nice. Removing the
+pimp method would be even better but that requires more refactoring on Rails internals,
+not just tricking it.
+
+Results from handlers "handles?" could be cached.
+
+You can also implement DI support by correctly implementing di_instantiate(type) at TrickHim.
+
+Finally, feel you can support named parameters in 1.8.7+ if not yet supported.
+
+Everything is quite simple so far as this is just a concept
+
+# Why not changing Rails internally?
+
+One needs to know how all the mixin of Rails interact with each other (i.e. the 36 ancestors
+of ActionController) in order to make safe changes. That is the coupling this proof of concept
+is trying show how to avoid.

data/lib/rails-and-solid.rb

@@ -4,4 +4,15 @@ module RailsAndSolid
   autoload :TrickHim, 'rails-and-solid/trick_him'
   autoload :Handler, 'rails-and-solid/handler'
 
+  # Shortcut to hack rails.
+  def self.pimp(what)
+    Object.module_eval "class #{what.to_s.camelize}Controller < ApplicationController; end"
+  end
+
+end
+
+class ActionController::Base
+  def self.solidify
+    include RailsAndSolid::TrickHim
+  end
 end

data/lib/rails-and-solid/handler/instantiate.rb

@@ -1,9 +1,9 @@
 module RailsAndSolid
   module Handler
     class Instantiate
-      def extract(controller, var)
-        val = var.camelize.constantize.new(controller.params[p])
-        controller.send :instance_variable_set ,"@#{var}", val
+      def extract(controller, name)
+        val = name.camelize.constantize.new(controller.params[p])
+        controller.send :instance_variable_set ,"@#{name}", val
         return val
       end
       def handles?(controller, name)

data/lib/rails-and-solid/version.rb

@@ -1,3 +1,3 @@
 module RailsAndSolid
-  VERSION = "0.9.0"
+  VERSION = "0.9.1"
 end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 9
-  - 0
-  version: 0.9.0
+  - 1
+  version: 0.9.1
 platform: ruby
 authors: 
 - Guilherme Silveira
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-08 00:00:00 -03:00
+date: 2011-03-18 00:00:00 -03:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency