restfulie 0.2 → 0.3

data/README.textile

@@ -2,6 +2,8 @@ h1. Quit pretending
 
 CRUD through HTTP is a good step forward to using resources and becoming RESTful, another step further into it is to make use of hypermedia based services and this gem allows you to do it really fast.
 
+You can read the "article on using the web for real":http://guilhermesilveira.wordpress.com/2009/11/03/quit-pretending-use-the-web-for-real-restfulie/ which gives an introduction to hypermedia/resources/services.
+
 h2. Why would I use restfulie?
 
 1. Easy --> writing hypermedia aware resource based clients
@@ -10,7 +12,16 @@ h2. Why would I use restfulie?
 4. HATEOAS --> clients you are unaware of will not bother if you change your URIs
 5. HATEOAS --> services that you consume will not affect your software whenever they change part of their flow or URIs
 
-h1. Restfulie: client-side
+h2. Could you compare it with Spring or JAX-RS based APIs?
+
+Restfulie is the first API which tries to somehow implement "Jim Webber":http://jim.webber.name/ and "Ian Robinson":http://iansrobinson.com/ opinion on how RESTFul systems use hypermedia
+as the way to lead your client's path through a business process.
+
+Therefore Restfulie is unique both in its feature set when compared to both Spring and JAX-RS based implementations, and its implementation: looking for simple code and favoring conventions over manual configurations.
+
+h1. Short examples
+
+h2. Restfulie: client-side
 
 Example on accessing a resource and its services through the restfulie API:
 
@@ -24,24 +35,26 @@ order.pay payment                        # sends a post request to pay this orde
 order.cancel                             # sends a delete request
 </pre>
 
-h1. Restfulie: server-side
+h2. Restfulie: server-side
 
 This is a simple example how to make your state changes available to your resource consumers:
 
 <pre>
 class Order < ActiveRecord::Base
+
+  acts_as_restfulie
+
   def following_transitions
     transitions = []
     transitions << [:show, {}]
     transitions << [:destroy, {}] if can_cancel?
     transitions << [:pay, {:id => id}] if can_pay?
-    transitions << [:show, {:controller => :payments, :payment_id => payment.id }] if paid?
     transitions
   end
 end
 </pre>
 
-*Do not forget to create a migration with a string field named status for your resource:*
+*You might want to create a migration with a string field named status for your resource:*
 
 <pre>
 scripts/generate migration add_status_to_order	
@@ -67,14 +80,14 @@ end
 
 Or simply define a status reader and writer on your own.
 
-
-
 h2. Restfulie server-side: state machine
 
 For those willing to implement a more complex or advanced state machine, you can use the dsl-like api:
 
 <pre>
 class Order < ActiveRecord::Base
+  acts_as_restfulie
+
   state :unpaid, :allow => [:latest, :pay, :cancel]
   state :cancelled, :allow => :latest
 
@@ -84,7 +97,7 @@ class Order < ActiveRecord::Base
 end
 </pre>
 
-h2. Installing
+h1. Installing
 
 Just add in your environment.rb the following line:
 
@@ -116,6 +129,13 @@ Trying to follow the definition of a RESTful application supporting resources wi
 
 h2. Client Usage
 
+Create your class and invoke the *uses_restfulie* method:
+
+<pre>class Order < ActiveRecord::Base
+	uses_restfulie
+end
+</pre>
+
 One should first acquire the representation from the server through your common GET request and process it through the usual from_* methods:
 <pre>xml = Net::HTTP.get(URI.parse('http://www.caelum.com.br/orders/1'))
 order = Order.from_xml(xml)</pre>
@@ -189,14 +209,25 @@ h2. Server-side configuration
 
 There are two different approaches that can be combined to create a full hypermedia aware resource based service, including awareness of its states and transitions.
 
-h3. The following available transitions method
+h3. Simple usage: following transitions
 
 The most easy way to use restfulie is to write the *following_transitions* method.
-It should return a list of possible transitions, where each transition is identified by an array of its name and definition.
+There are three easy steps to make it work:
 
-The next example shows how to define a transition which will map to the current controller, action show:
+1. Create your model (i.e. Order) with an *status* field
+<pre>
+script/generate scaffold Order status:string location:string
+rake db:create
+rake db:migrate
+</pre>
+
+Note that with this usage the status field is optional (from 0.3.0 onwards).
+
+2. Add the *acts_as_restfulie* invocation and *following_transitions* method returning an array of possible transitions:
 
 <pre>
+acts_as_restfulie
+
 def following_transitions
   transitions = []
   transitions << [:show, {}]
@@ -204,9 +235,48 @@ def following_transitions
 end
 </pre>
 
-Which will generate an hyperlink as
+3. Update your *show* method within the *OrdersController* to show the hypermedia content:
+
+<pre>
+ def show
+   @order = Order.find(params[:id])
+
+   respond_to do |format|
+     format.html # show.html.erb
+     format.xml  { render :xml => @order.to_xml(:controller=>self) }
+   end
+ end
+</pre>
+
+You are ready to go, create a new order and save it into the database:
 
-<pre><atom:link rel="show" rel="http://yourserver/orders/15" /></pre>
+<pre>
+	order = Order.new
+	order.location = "take away"
+	order.status = "unpaid"
+	order.save
+	puts "Order #{order.id} saved"
+</pre>
+
+Start up the server:
+
+<pre>
+	script/server
+</pre>
+
+And now access your server at http://localhost:3000/orders/1.xml
+
+<pre>
+<?xml version="1.0" encoding="UTF-8"?>
+<order>
+  <created-at>2009-11-23T00:15:15Z</created-at>
+  <id>1</id>
+  <location>take away</location>
+  <status>unpaid</status>
+  <updated-at>2009-11-23T00:15:15Z</updated-at>
+  <atom:link rel="show" xmlns:atom="http://www.w3.org/2005/Atom" href="http://localhost:3000/orders/3"/>
+</order>
+</pre>
 
 h3. Customizing the rel name
 
@@ -239,7 +309,7 @@ def following_transitions
 end
 </pre>
 
-h2. Defining the state machine and its transitions
+h2. Advanced usage: Defining the state machine and its transitions
 
 The second way of defining your available transitions is to explicitely define the states and transitions.
 
@@ -255,6 +325,9 @@ The following example shows all possible states for an order:
 
 <pre>
 class Order < ActiveRecord::Base
+
+	acts_as_restfulie
+	
 	state :unpaid, :allow => [:latest, :pay, :cancel]
 	state :cancelled, :allow => :latest
 	state :received, :allow => [:latest, :check_payment_info]
@@ -277,6 +350,9 @@ list of available transition whenever the *can_pay?* method returns true:
 
 <pre>
 class Order < ActiveRecord::Base
+
+	acts_as_restfulie
+	
 	transition :pay, {:action => pay_this_order, :controller => :payments}, :preparing
 
 	def following_transitions
@@ -303,6 +379,36 @@ class Order < ActiveRecord::Base
 	end
 end
 </pre>
+
+h3. Accessing all possible transitions
+
+One can access all possible transitions for an object by invoking its available_transitions method:
+
+<pre>
+	transitions = order.available_transitions
+</pre>
+
+h3. Checking the possibility of following transitions
+
+By following the advanced usage, one receives also all *can_* method. i.e.:
+
+<pre>
+	order.status = :unpaid
+	puts(order.can_pay?)              # will print true
+	order.status = :paid
+	puts(order.can_pay?)              # will print false
+</pre>
+
+You can use the *can_xxx* methods in your controllers to check if your current resource's state can be changed:
+
+<pre>
+def pay
+  @order = Order.find(params[:id])
+  raise "impossible to pay due to this order status #{order.status}" if !@order.can_pay?
+
+  # payment code
+end
+</pre>
   
 h3. Using xml+rel links instead of atom links
 
@@ -331,10 +437,10 @@ h2. Team
 Restfulie was created and is maintained within Caelum by
 
 Projetct Founder
-* "Guilherme Silveira":mailto:guilherme.silveira@caelum.com.br
+* "Guilherme Silveira":mailto:guilherme.silveira@caelum.com.br - twitter:http://www.twitter.com/guilhermecaelum "http://guilhermesilveira.wordpress.com":http://guilhermesilveira.wordpress.com
 
 Active Commiters
-* "Caue Guerra":mailto:caue.guerra@gmail.com
+* "Caue Guerra":mailto:caue.guerra@gmail.com - "http://caueguerra.com/":http://caueguerra.com/
 * "Guilherme Silveira":mailto:guilherme.silveira@caelum.com.br
 
 Contributors
@@ -381,9 +487,61 @@ In order to pay do not forget to send the parameter *payment* with a value as
 
 h3. Sources
 
+You can see an application's source code here, both client and server side were implemented using *restfulie*:
+
 "Client":http://github.com/caelum/restfulie-client
 "Server":http://github.com/caelum/restfulie-test
 
+h3. More tutorials
+
+There is a "portuguese tutorial on the server-side support":http://wakethedead.com.br/blog/70-restfulie, "more on restfulie - portuguese":http://andersonleiteblog.wordpress.com/2009/11/23/mais-sobre-restfulie/ and a "blog post on the entire ecosystem in english":http://guilhermesilveira.wordpress.com/2009/11/03/quit-pretending-use-the-web-for-real-restfulie/
+
+
+h2. What's new
+
+h3. next release
+* API change: you need to invoke "acts_as_restfulie" to your models
+* implemented support to can_*** methods
+* post data through http POST body
+* no need for the *status* field if you use the following_transition approach on the server side
+* bug fixed when *status* was nil
+* lots of internal refactoring
+* lots of new documentation
+
+h3. 0.2
+* support to state machine configuration
+* resources must contain a status field
+
+h3. 0.1
+* first release
+
+h2. Coming soon
+
+* Generate and link to rubydoc
+* release 0.3
+* change parameter order for transition: last one is HASH, first is name, second (if existing) is target state
+* allows pure String/byte array client side post and server side retrieval
+* integration tests on orderserver/client api
+* controller method should check if its an restfulie resource
+* full support to extended json
+* rel prepend suffix as http://iansrobinson.com/resources/link-relations/preceding
+* automatically generate uri for this rel with its transition description
+* pure href definition of link
+* post entry point support
+* remove client dependency from ActiveRecord
+* remove server side dependency from ActiveRecord (its ok to use anything else)
+* Set the correct media type instead of application/xml
+* transitions << [:show]  should work
+* rails 3 easier support (no controller argument!)
+* allow servers to define transitions by accessing other systems
+* allow servers to define a state method instead of internal variable
+* controller filtering and methods
+* english tutorial
+* when receiving a 201 + content, it should believe the content
+* when receiving a 201 without any content, it should allow to redirect or not
+* client side should allow withTimeStamp, withETag, withAuth
+* is there is an etag, use it by default (maybe NOT use it by default)... modified since and so on (header tags)
+* server side maybe allow hypermedia controls or not
 
 h2. License
 
@@ -403,3 +561,4 @@ h2. License
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+

data/Rakefile

@@ -5,8 +5,8 @@ require 'rake/gempackagetask'
 require 'spec/rake/spectask'
 
 GEM = "restfulie"
-GEM_VERSION = "0.2"
-SUMMARY = "This is a small cute plugin to show how to implement hypermedia based services in a easy way using rails."
+GEM_VERSION = "0.3"
+SUMMARY = "Hypermedia aware resource based library in ruby (client side) and ruby on rails (server side)."
 AUTHOR = "Guilherme Silveira, Caue Guerra"
 EMAIL = "guilherme.silveira@caelum.com.br"
 HOMEPAGE = "http://github.com/caelum/restfulie"
@@ -49,3 +49,6 @@ end
 
 desc "Builds the project"
 task :build => :spec
+
+desc "Default build will run specs"
+task :default => :spec

data/lib/restfulie/client/base.rb

@@ -0,0 +1,76 @@
+module Restfulie
+  module Client
+    module Base 
+    
+      # translates a response to an object
+      def from_response(res)
+      
+        raise "unimplemented content type" if res.content_type!="application/xml"
+
+        hash = Hash.from_xml res.body
+        return hash if hash.keys.length == 0
+        raise "unable to parse an xml with more than one root element" if hash.keys.length>1
+      
+        type = hash.keys[0].camelize.constantize
+        type.from_xml(res.body)
+      
+      end
+    
+      def requisition_method_for(overriden_option,name)
+        basic_mapping = { :delete => Net::HTTP::Delete, :put => Net::HTTP::Put, :get => Net::HTTP::Get, :post => Net::HTTP::Post}
+        defaults = {:destroy => Net::HTTP::Delete, :delete => Net::HTTP::Delete, :cancel => Net::HTTP::Delete,
+                    :refresh => Net::HTTP::Get, :reload => Net::HTTP::Get, :show => Net::HTTP::Get, :latest => Net::HTTP::Get}
+
+        return basic_mapping[overriden_option.to_sym] if overriden_option
+        defaults[name.to_sym] || Net::HTTP::Post
+      end
+    
+      def add_state(transition)
+        name = transition["rel"]
+      
+        self.module_eval do
+        
+          def temp_method(options = {}, &block)
+            self.invoke_remote_transition(Restfulie::Client::Helper.current_method, options, block)
+          end
+        
+          alias_method name, :temp_method
+          undef :temp_method
+        end
+      end  
+    
+      # receives an object and inserts all necessary methods
+      # so it can answer to can_??? invocations
+      def add_transitions(result, states)
+        result._possible_states = {}
+
+        states.each do |state|
+          result._possible_states[state["rel"]] = state
+          add_state(state)
+        end
+        result.extend Restfulie::Server::State
+      
+        result
+      end
+
+      # retrieves a resource form a specific uri
+      def from_web(uri)
+        res = Net::HTTP.get_response(URI.parse(uri))
+        # TODO redirect... follow or not? (optional...)
+        raise "invalid request" if res.code != "200"
+      
+        # TODO really support different content types
+        case res.content_type
+        when "application/xml"
+          self.from_xml res.body
+        when "application/json"
+          self.from_json res.body
+        else
+          raise "unknown content type"
+        end
+      
+      end
+
+    end
+  end
+end

data/lib/restfulie/client/helper.rb

@@ -0,0 +1,11 @@
+module Restfulie
+  module Client
+    module Helper
+      # retrieves the invoking method's name
+      def self.current_method
+        caller[0]=~/`(.*?)'/
+        $1
+      end
+    end
+  end
+end

data/lib/restfulie/client/instance.rb

@@ -0,0 +1,32 @@
+module Restfulie
+  module Client
+    module Instance
+      
+      # list of possible states to access
+      attr_accessor :_possible_states
+
+      # which content-type generated this data
+      attr_accessor :_came_from
+      
+      
+      def invoke_remote_transition(name, options, block)
+
+        method = self.class.requisition_method_for options[:method], name
+
+        url = URI.parse(_possible_states[name]["href"])
+        req = method.new(url.path)
+        req.body = options[:data] if options[:data]
+        req.add_field("Accept", "application/xml") if self._came_from == :xml
+
+        response = Net::HTTP.new(url.host, url.port).request(req)
+
+        return block.call(response) if block
+        return response if method != Net::HTTP::Get
+        self.class.from_response response
+      end
+
+
+
+    end
+  end
+end

data/lib/restfulie/server/base.rb

@@ -0,0 +1,54 @@
+module Restfulie
+  module Server
+    module Base
+    
+      # returns the definition for the transaction
+      def existing_transitions(name)
+        transitions[name]
+      end
+    
+      # returns a hash of all possible transitions: Restfulie::Server::Transition
+      def transitions
+        @transitions ||= {}
+      end
+
+      # returns a hash of all possible states
+      def states
+        @states ||= {}
+      end
+
+      # adds a new state to the list of possible states
+      def state(name, options = {})
+        options[:allow] = [options[:allow]] unless options[:allow].kind_of? Array
+        states[name] = options
+      end
+
+      # defines a new transition. the transition options works in the same way
+      # that following_transition definition does.
+      def transition(name, options = {}, result = nil, &body)
+      
+        transition = Restfulie::Server::Transition.new(name, options, result, body)
+        transitions[name] = transition
+
+        define_methods_for(self, name, result)
+        controller_name = (self.name + "Controller")
+      end
+ 
+      def define_methods_for(type, name, result) 
+
+        return nil if type.respond_to?(name)
+
+        type.send(:define_method, name) do |*args|
+          self.status = result.to_s unless result == nil
+        end
+
+        type.send(:define_method, "can_#{name}?") do
+          transitions = self.available_transitions[:allow]
+          transitions.include? name
+        end
+
+      end
+ 
+    end
+  end
+end

data/lib/restfulie/server/controller.rb

@@ -0,0 +1,17 @@
+require 'restfulie'
+
+module ActionController
+  # class Base
+  #   alias_method :simple_render, :render
+  #   def render(options={})
+  #     debugger
+  #     if options[:xml]
+  #       resource = options[:xml]
+  #       debugger
+  #       return simple_render(options) if resource.kind_of?(String) || !resource.class.respond_to?(:is_acting_as_restfulie)
+  #       options[:xml] = resource.to_xml(:controller => self)
+  #     end
+  #     simple_render(options)
+  #   end
+  # end
+end

data/lib/restfulie/server/instance.rb

@@ -0,0 +1,50 @@
+module Restfulie
+  module Server
+    module Instance
+
+      # Returns an array with extra possible transitions.
+      # Those transitions will be concatenated with any extra transitions provided by your resource through
+      # the use of state and transition definitions.
+      # For every transition its name is the only mandatory field:
+      # options = {}
+      # [:show, options] # will generate a link to your controller's show action
+      #
+      # The options can be used to override restfulie's conventions:
+      # options[:rel] = "refresh" # will create a rel named refresh
+      # options[:action] = "destroy" # will link to the destroy method
+      # options[:controller] = another controller # will use another controller's action
+      #
+      # Any extra options will be passed to the target controller url_for method in order to retrieve
+      # the transition's uri.
+      def following_transitions
+        []
+      end
+
+
+      # returns a list of available transitions for this objects state
+      # TODO rename because it should never be used by the client...
+      def available_transitions
+        status_available = respond_to?(:status) && status!=nil
+        return {:allow => []} unless status_available
+        self.class.states[self.status.to_sym] || {:allow => []}
+      end
+      
+      # returns a list containing all available transitions for this object's state
+      def all_following_transitions
+        all = [] + available_transitions[:allow]
+        following_transitions.each do |t|
+          t = Restfulie::Server::Transition.new(t[0], t[1], t[2], nil) if t.kind_of? Array
+          all << t
+        end
+        all
+      end
+
+      # checks if its possible to execute such transition and, if it is, executes it
+      def move_to(name)
+        raise "Current state #{status} is invalid in order to execute #{name}. It must be one of #{transitions}" unless available_transitions[:allow].include? name
+        self.class.transitions[name].execute_at self
+      end
+
+    end
+  end
+end

data/lib/restfulie/server/marshalling.rb

@@ -0,0 +1,41 @@
+
+module Restfulie
+  
+  module Server
+  
+    module Marshalling
+  
+      def to_json
+        super :methods => :following_states
+      end
+  
+      # adds a link for each transition to the current xml writer
+      def add_links(xml, all, options)
+        all.each do |transition|
+          add_link(transition, xml, options)
+        end
+      end
+
+      # adds a link for this transition to the current xml writer
+      def add_link(transition, xml, options) 
+
+        transition = self.class.existing_transitions(transition.to_sym) unless transition.kind_of? Restfulie::Server::Transition
+        transition.add_link_to(xml, self, options)
+
+      end
+
+      def to_xml(options = {})
+    
+        transitions = all_following_transitions
+        return super(options) if transitions.empty? || options[:controller].nil?
+    
+        options[:skip_types] = true
+        super options do |xml|
+          add_links xml, transitions, options
+        end
+      end
+  
+    end
+
+  end  
+end

data/lib/restfulie/server/state.rb

@@ -0,0 +1,19 @@
+module Restfulie
+  
+  module Server
+  
+    # adds respond_to and has_state methods to resources
+    module State
+    
+      # overrides the respond_to? method to check if this method is contained or was defined by a state
+      def respond_to?(sym)
+        has_state(sym.to_s) || super(sym)
+      end
+
+      # returns true if this resource has a state named name
+      def has_state(name)
+        !@_possible_states[name].nil?
+      end
+    end
+  end
+end

data/lib/restfulie/server/transition.rb

@@ -0,0 +1,44 @@
+module Restfulie
+  
+  module Server
+
+    # represents a transition on the server side
+    class Transition
+      attr_reader :body, :name, :result
+      def initialize(name, options, result, body)
+        @name = name
+        @options = options
+        @result = result
+        @body = body
+      end
+      def action
+        @options || {}
+      end
+      
+      # executes this transition in a resource
+      def execute_at(target_object)
+        target_object.status = result.to_s unless result.nil?
+      end
+    
+      # adds a link to this transition's uri on a xml writer
+      def add_link_to(xml, model, options)
+        specific_action = action.dup
+        specific_action = @body.call(model) if @body
+
+        rel = specific_action[:rel] || @name
+        specific_action[:rel] = nil
+
+        specific_action[:action] ||= @name
+        uri = options[:controller].url_for(specific_action)
+      
+        if options[:use_name_based_link]
+          xml.tag!(rel, uri)
+        else
+          xml.tag!('atom:link', 'xmlns:atom' => 'http://www.w3.org/2005/Atom', :rel => rel, :href => uri)
+        end
+      end
+    
+    end
+  end
+
+end

data/lib/restfulie/unmarshalling.rb

@@ -0,0 +1,60 @@
+module ActiveRecord
+  class Base
+
+    # basic code from Matt Pulver
+    # found at http://www.xcombinator.com/2008/08/11/activerecord-from_xml-and-from_json-part-2/
+    # addapted to support links
+    def self.from_hash( hash )
+      h = {}
+      h = hash.dup if hash
+      links = nil
+      h.each do |key,value|
+        case value.class.to_s
+        when 'Array'
+          if key=="link"
+            links = h[key]
+            h.delete("link")
+          else
+            h[key].map! { |e| reflect_on_association(key.to_sym ).klass.from_hash e }
+          end
+        when /\AHash(WithIndifferentAccess)?\Z/
+          if key=="link"
+            links = [h[key]]
+            h.delete("link")
+          else
+            h[key] = reflect_on_association(key.to_sym ).klass.from_hash value
+          end
+        end
+        h.delete("xmlns") if key=="xmlns"
+      end
+      result = self.new h
+      if !(links.nil?) && self.include?(Restfulie::Client::Instance)
+        add_transitions(result, links)
+      end
+      result
+    end
+
+    def self.from_json( json )
+      from_hash safe_json_decode( json )
+    end
+
+    # The xml has a surrounding class tag (e.g. ship-to),
+    # but the hash has no counterpart (e.g. 'ship_to' => {} )
+    def self.from_xml( xml )
+      hash = Hash.from_xml xml
+      head = hash[self.to_s.underscore]
+      result = self.from_hash head
+      return nil if result.nil?
+      result._came_from = :xml if self.include?(Restfulie::Client::Instance)
+      result
+    end
+  end
+end
+
+def safe_json_decode( json )
+  return {} if !json
+  begin
+    ActiveSupport::JSON.decode json
+  rescue ; {} end
+end
+# end of code based on Matt Pulver's

data/lib/restfulie.rb

@@ -1,264 +1,30 @@
 require 'net/http'
 require 'uri'
-
-module Restfulie
-  def to_json
-    super :methods => :following_states
-  end
-  
-  def to_xml(options = {})
-    return super unless respond_to?(:status)
-
-    controller = options[:controller]
-    return super if controller.nil?
-        
-    options[:skip_types] = true
-    super options do |xml|
-      possible_following = []
-      default_transitions_map = self.class._transitions_for(status.to_sym)
-      default_transitions = default_transitions_map[:allow] unless default_transitions_map.nil?
-    
-      possible_following += default_transitions unless default_transitions.nil?
-      possible_following += self.following_transitions if self.respond_to?(:following_transitions)
-      
-      return super if possible_following.empty?
-      
-      possible_following.each do |possible|
-        if possible.class.name=="Array"
-          name = possible[0]
-          result = [possible[1], nil]
-        else
-          name = possible
-          result = self.class._transitions(name.to_sym)
-        end
-    
-        if result[0]
-          action = result[0]
-          body = result[1]
-          action = body.call(self) if body
-
-          rel = action[:rel] || name || action[:action]
-          action[:rel] = nil
-        else
-          action = {}
-          rel = name
-        end
-    
-        action[:action] ||= name
-        translate_href = controller.url_for(action)
-        if options[:use_name_based_link]
-          xml.tag!(rel, translate_href)
-        else
-          xml.tag!('atom:link', 'xmlns:atom' => 'http://www.w3.org/2005/Atom', :rel => rel, :href => translate_href)
-        end
-      end
-    end
-  end
-
-  def create_method(name, &block)
-    self.class.send(:define_method, name, &block)
-  end
-  
-  def move_to(name)
-    transitions = self.class._transitions_for(self.status.to_sym)[:allow]
-    raise "Current state #{status} is invalid in order to execute #{name}. It must be one of #{transitions}" unless transitions.include? name
-    result = self.class._transitions(name)[2]
-    self.status = result.to_s unless result.nil?
+require 'restfulie/unmarshalling'
+
+require 'restfulie/client/base'
+require 'restfulie/client/helper'
+require 'restfulie/client/instance'
+
+require 'restfulie/server/base'
+require 'restfulie/server/controller'
+require 'restfulie/server/instance'
+require 'restfulie/server/marshalling'
+require 'restfulie/server/state'
+require 'restfulie/server/transition'
+
+class Class
+  def acts_as_restfulie
+    class << self
+      include Restfulie::Server::Base
+    end
+    include Restfulie::Server::Instance
+    include Restfulie::Server::Marshalling
   end
-  
-end
-
-module ActiveRecord
-  class Base
-
-    include Restfulie
-    attr_accessor :_possible_states
-    attr_accessor :_came_from
-    
-    def self._transitions_for(state)
-      @@states[state]
-    end
-    
-    def self._transitions(name)
-      [@@transitions[name], @@bodies[name], @@results[name]]
-    end
-    
-    @@states = {}
-    @@transitions = {}
-    @@bodies = {}
-    @@results = {}
-    
-    def self.state(name, options)
-      if name.class==Array
-        name.each do |simple|
-          self.state(simple, options)
-        end
-      else
-        options[:allow] = [options[:allow]] unless options[:allow].class == Array
-        @@states[name] = options
-      end
-    end
-
-    def self.transition(name, options = {}, result = nil, &body)
-      @@transitions[name] = options
-      @@bodies[name] = body
-      @@results[name] = result unless result == nil
-      defined = self.respond_to?(name)
-      if !defined
-        self.send(:define_method, name) do |*args|
-          self.status = result.to_s unless result == nil
-        end
-        self.send(:define_method, "can_#{name}2?") do
-          puts "executing can_#{name}2?"
-        end
-      end
-    end
-
-    def self.add_states(result, states)
-      result._possible_states = {}
-      states.each do |state|
-        result._possible_states[state["rel"]] = state
-      end
-      def result.respond_to?(sym)
-        has_state(sym.to_s) || super(sym)
-      end
-
-      def result.has_state(name)
-        !@_possible_states[name].nil?
-      end
-      
-      states.each do |state|
-        name = state["rel"]
-        self.module_eval do
-          def current_method
-            caller[0]=~/`(.*?)'/
-            $1
-          end
-          def temp_method(options = {}, &block)
-            name = current_method
-            state = _possible_states[name]
-            data = options[:data] || {}
-            url = URI.parse(state["href"])
-            get = false
-
-            # gs: i dont know how to meta play here! i suck
-            if options[:method]=="delete"
-              req = Net::HTTP::Delete.new(url.path)
-            elsif options[:method]=="put"
-              req = Net::HTTP::Put.new(url.path)
-            elsif options[:method]=="get"
-              req = Net::HTTP::Get.new(url.path)
-              get = true
-            elsif options[:method]=="post"
-              req = Net::HTTP::Post.new(url.path)
-            elsif ['destroy','delete','cancel'].include? name
-              req = Net::HTTP::Delete.new(url.path)
-            elsif ['refresh', 'reload', 'show', 'latest'].include? name
-              req = Net::HTTP::Get.new(url.path)
-              get = true
-            else
-              req = Net::HTTP::Post.new(url.path)
-            end
-
-            req.set_form_data(data)
-            req.add_field("Accept", "text/xml") if _came_from == :xml
-
-            http = Net::HTTP.new(url.host, url.port)
-            response = http.request(req)
-            return yield(response) if !block.nil?
-            if get
-              case response.content_type
-              when "application/xml"
-                content = response.body
-                hash = Hash.from_xml content
-                return hash if hash.keys.length == 0
-                raise "unable to parse an xml with more than one root element" if hash.keys.length>1
-                key = hash.keys[0]
-                type = key.camelize.constantize
-                return type.from_xml content
-              else
-                raise :unknown_content_type
-              end
-            end
-            response
-
-          end
-          alias_method name, :temp_method
-          undef :temp_method
-        end
-      end
-      
-      result
-    end
-
-    def self.from_web(uri)
-      url = URI.parse(uri)
-      req = Net::HTTP::Get.new(url.path)
-      http = Net::HTTP.new(url.host, url.port)
-      res = http.request(req)
-      raise :invalid_request, res if res.code != "200"
-      case res.content_type
-      when "application/xml"
-        self.from_xml res.body
-      when "application/json"
-        self.from_json res.body
-      else
-        raise :unknown_content_type
-      end
-    end
-
-    # basic code from Matt Pulver
-    # found at http://www.xcombinator.com/2008/08/11/activerecord-from_xml-and-from_json-part-2/
-    # addapted to support links
-    def self.from_hash( hash )
-      h = {}
-      h = hash.dup if hash
-      links = nil
-      h.each do |key,value|
-        case value.class.to_s
-        when 'Array'
-          if key=="link"
-            links = h[key]
-            h.delete("link")
-          else
-            h[key].map! { |e| reflect_on_association(key.to_sym ).klass.from_hash e }
-          end
-        when /\AHash(WithIndifferentAccess)?\Z/
-          if key=="link"
-            links = [h[key]]
-            h.delete("link")
-          else
-            h[key] = reflect_on_association(key.to_sym ).klass.from_hash value
-          end
-        end
-        h.delete("xmlns") if key=="xmlns"
-      end
-      result = self.new h
-      add_states(result, links) unless links.nil?
-      result
-    end
-
-    def self.from_json( json )
-      from_hash safe_json_decode( json )
-    end
-
-    # The xml has a surrounding class tag (e.g. ship-to),
-    # but the hash has no counterpart (e.g. 'ship_to' => {} )
-    def self.from_xml( xml )
-      hash = Hash.from_xml xml
-      head = hash[self.to_s.underscore]
-      result = self.from_hash head
-      return nil if result.nil?
-      result._came_from = :xml
-      result
+  def uses_restfulie
+    class << self
+      include Restfulie::Client::Base
     end
+    include Restfulie::Client::Instance
   end
-end
-
-def safe_json_decode( json )
-  return {} if !json
-  begin
-    ActiveSupport::JSON.decode json
-  rescue ; {} end
-end
-# end of code based on Matt Pulver's
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: restfulie
 version: !ruby/object:Gem::Version 
-  version: "0.2"
+  version: "0.3"
 platform: ruby
 authors: 
 - Guilherme Silveira, Caue Guerra
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-11-11 00:00:00 -02:00
+date: 2009-11-25 00:00:00 -02:00
 default_executable: 
 dependencies: []
 
@@ -22,6 +22,16 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
+- lib/restfulie/client/base.rb
+- lib/restfulie/client/helper.rb
+- lib/restfulie/client/instance.rb
+- lib/restfulie/server/base.rb
+- lib/restfulie/server/controller.rb
+- lib/restfulie/server/instance.rb
+- lib/restfulie/server/marshalling.rb
+- lib/restfulie/server/state.rb
+- lib/restfulie/server/transition.rb
+- lib/restfulie/unmarshalling.rb
 - lib/restfulie.rb
 - Rakefile
 - README.textile
@@ -52,6 +62,6 @@ rubyforge_project:
 rubygems_version: 1.3.5
 signing_key: 
 specification_version: 3
-summary: This is a small cute plugin to show how to implement hypermedia based services in a easy way using rails.
+summary: Hypermedia aware resource based library in ruby (client side) and ruby on rails (server side).
 test_files: []