roar 0.0.1.alpha1 → 0.8.0

data/lib/roar/model/representable.rb

@@ -0,0 +1,31 @@
+module Roar
+  module Model
+    module Representable
+      extend ActiveSupport::Concern
+      
+      included do |base|
+        base.extend Hooks::InheritableAttribute
+        base.inheritable_attr :representable
+        base.representable = {} # FIXME: doesn't that break inheritance?
+      end
+      
+      module ClassMethods
+        def represents(mime_type, options)
+          self.representable[mime_type] = options[:with]
+        end
+        
+        def representer_class_for(mime_type)
+          representable[mime_type]
+        end
+        
+        def from(mime_type, representation)
+          representer_class_for(mime_type).deserialize(self, mime_type, representation)
+        end
+      end
+      
+      def to(mime_type)
+        self.class.representer_class_for(mime_type).new.serialize(self, mime_type)
+      end
+    end
+  end
+end

data/lib/roar/rails.rb

@@ -0,0 +1,21 @@
+require 'roar/rails/controller_methods'
+require 'roar/representer'
+require 'roar/representer/xml'  # TODO: make dynamically.
+require 'roar/representer/json' # TODO: make dynamically.
+require 'roar/rails/representer_methods'
+require 'roar/representer/feature/model_representing'
+
+module Roar
+  module Rails
+    
+  end
+end
+
+# FIXME: don't like monkey-patching:
+# TODO: assure we don't overwrite anything here, as people might want to do things without AR/DM.
+
+Roar::Representer::XML.class_eval do # FIXME: why in XML, only? #definition_class is defined in Representable.
+  include Roar::Representer::Feature::ModelRepresenting
+  include Roar::Representer::Feature::ActiveRecordMethods  # to_nested_attributes
+  include Roar::Rails::RepresenterMethods
+end

data/lib/roar/rails/controller_methods.rb

@@ -0,0 +1,71 @@
+require 'active_support/core_ext/class/attribute'
+
+module Roar
+  module Rails
+    module ControllerMethods
+      extend ActiveSupport::Concern
+      
+      included do |base|
+        base.responder = Responder
+        base.class_attribute :represented_class
+      end
+      
+      module ClassMethods
+        # Sets the represented class for the controller.
+        def represents(model_class)
+          self.represented_class = model_class
+        end
+      end
+      
+    #private
+      def representer_class_for(model_class, format)
+        # DISCUSS: upcase and static namespace is not cool, but works for now.
+        "Representer::#{format.to_s.upcase}::#{model_class}".constantize
+      end
+      
+      # Returns a representer instance that has parsed the request body.
+      def incoming
+        representer = representer_class_for(self.class.represented_class, formats.first).deserialize(request.raw_post)
+      end
+      
+      
+      # Returns the deserialized representation as a hash suitable for #create and #update_attributes.
+      def representation
+        incoming.to_nested_attributes
+      end
+      
+      
+      class Responder < ActionController::Responder
+        def display(resource, given_options={})
+          # TODO: find the correct representer for #format.
+          # TODO: should we infer the represented class per default?
+          # TODO: unit-test this method.
+          #representer = controller.representer_class_for(resource.class, format)
+          representer = controller.representer_class_for(controller.represented_class, format)
+          
+          # DISCUSS: do that here?
+          #representer.extend(RepresenterMethods::ClassMethods)
+          
+          controller.render given_options.merge!(options).merge!(
+            format => representer.serialize_model_with_controller(resource, controller)
+          )
+        end
+        
+        # This is the common behavior for formats associated with APIs, such as :xml and :json.
+        def api_behavior(error)
+          if has_errors?
+            controller.render :text => resource.errors, :status => :unprocessable_entity # TODO: which media format? use an ErrorRepresenter shipped with Roar.
+          elsif get?
+            display resource
+          elsif post?
+            display resource, :status => :created, :location => api_location
+          elsif put?
+            display resource
+          else
+            head :ok
+          end
+        end
+      end
+    end
+  end
+end

data/lib/roar/rails/representer_methods.rb

@@ -0,0 +1,52 @@
+module Roar
+  module Rails
+    # Makes Rails URL helpers work in representers. Dependent on Rails.application.
+    module RepresenterMethods
+      extend ActiveSupport::Concern
+      
+      included do |base|
+        base.class_eval do
+          attr_accessor :_controller
+          delegate :request, :env, :to => :_controller
+          
+          include ActionController::UrlFor
+          include ::Rails.application.routes.url_helpers
+          
+          extend Conventions
+        end
+      end
+      
+      module ClassMethods
+        # TODO: test?
+        def for_model_with_controller(represented, controller)
+          # DISCUSS: use #for_model_attributes for overriding?
+          from_attributes(compute_attributes_for(represented)) do |rep| 
+            rep.represented = represented
+            rep._controller = controller 
+          end
+        end
+        
+        # TODO: test?
+        def serialize_model_with_controller(represented, controller)
+          for_model_with_controller(represented, controller).serialize
+        end
+      end
+      
+      # Introduces strongly opinionated convenience methods in Representer.
+      module Conventions
+        def representation_name
+          super.to_s.singularize
+        end
+        
+        def collection(name, options={})
+          namespace     = self.name.split("::")[-2] # FIXME: this assumption is pretty opinionated.
+          singular_name = name.to_s.singularize
+          
+          super name, options.reverse_merge(
+            :as => "representer/#{namespace}/#{singular_name}".classify.constantize,
+            :tag => singular_name)
+        end
+      end
+    end
+  end
+end

data/lib/roar/rails/test_case.rb

@@ -0,0 +1,43 @@
+require 'test_xml/test_unit'
+
+ActionController::TestCase.class_eval do
+  # FIXME: ugly monkey-patching.
+  # TODO: test:
+  #   put :create
+  #   put :create, :format => :xml
+  #   put :create, "<order/>", :format => :xml
+  #   put :create, "<order/>"
+  def process(action, *args)
+    if args.first.is_a?(String)
+       request.env['RAW_POST_DATA'] = args.shift
+       method = args.pop
+       args << nil
+       args << method
+    end
+    
+    super
+  end
+  
+  def assert_response(status, headers={})  # FIXME: allow message.
+    super
+    
+    if headers.is_a?(Hash)
+      assert_headers(headers)
+    else
+      assert_body(headers)
+    end
+  end
+  
+  def assert_headers(headers)
+    headers.each_pair do |k,v|
+      assert_equal v, @response.headers[k]
+    end
+  end
+  
+  def assert_body(body, options={})
+    return assert_xml_equal body, @response.body if options[:format] == :xml  # FIXME: how do we know whether assert_xml is appropriate?
+    assert_equal body, @response.body
+  end
+  
+  
+end

data/lib/roar/representer.rb

@@ -0,0 +1,72 @@
+require 'representable'
+
+module Roar
+  module Representer
+    class Base
+      include Representable
+      
+      class << self
+        alias_method :property, :representable_property
+        alias_method :collection, :representable_collection
+        
+        # Creates a representer instance and fills it with +attributes+.
+        def from_attributes(attributes)
+          new.tap do |representer|
+            yield representer if block_given?
+            
+            representable_attrs.each do |definition|
+              definition.populate(representer, attributes)
+            end
+          end
+        end
+      end
+      
+      
+      def initialize(properties={})
+        properties.each { |p,v| send("#{p}=", v) }  # DISCUSS: check if valid property?
+      end
+      
+      # Convert representer's attributes to a nested attributes hash.
+      def to_attributes
+        {}.tap do |attributes|
+          self.class.representable_attrs.each do |definition|
+            value = public_send(definition.accessor)
+            
+            if definition.typed?
+              value = definition.apply(value) do |v|
+                v.to_attributes  # applied to each typed attribute (even in collections).
+              end
+            end
+            
+            attributes[definition.accessor] = value
+          end
+        end
+      end
+    end
+    
+    class LinksDefinition < Representable::Definition
+      def rel2block
+        @rel2block ||= []
+      end
+      
+      def populate(representer, *args)
+        representer.links ||= []
+        
+        rel2block.each do |link|
+          representer.links << sought_type.from_attributes({  # create Hyperlink representer.
+            "rel"   => link[:rel],
+            "href"  => representer.instance_exec(&link[:block])})  # DISCUSS: run block in representer context?
+        end
+      end
+    end
+    
+  end
+end
+
+# FIXME: move to some init asset.
+Representable::Definition.class_eval do
+  # Populate the representer's attribute with the right value.
+  def populate(representer, attributes)
+    representer.public_send("#{accessor}=", attributes[accessor])
+  end
+end

data/lib/roar/representer/feature/http_verbs.rb

@@ -0,0 +1,63 @@
+require 'roar/client/transport'
+
+module Roar
+  # Used in Models as convenience, ActiveResource-like methods. # FIXME: currently this is meant for clients like Representers.
+  module Representer
+    module Feature
+      module HttpVerbs
+        extend ActiveSupport::Concern
+        
+        included do |base|
+          base.class_attribute :resource_base
+        end
+        
+        module ClassMethods
+          include Client::Transport
+          
+          def get(url, format)  # TODO: test me!
+            #url = resource_base + variable_path.to_s
+            representation = get_uri(url, format).body
+            deserialize(representation)
+          end
+          
+          def post(url, body, format)
+            representation = post_uri(url, body, format).body
+            deserialize(representation)
+          end
+          
+          
+          def put(url, body, format)
+            representation = put_uri(url, body, format).body
+            deserialize(representation)
+          end
+        end
+        
+        def post(url, format)
+          self.class.post(url, serialize, format)
+        end
+        def post!(*args)
+          rep = post(*args) # TODO: make this better.
+          
+          self.class.representable_attrs.each do |definition|
+
+            send(definition.setter, rep.public_send(definition.accessor))
+          end # TODO: this sucks. do this with #properties and #replace_properties.
+        end
+        
+        def get!(url, format) # FIXME: abstract to #replace_properties
+          rep = self.class.get(url, format) # TODO: where's the format? why do we need class here?
+          
+          self.class.representable_attrs.each do |definition|
+            send(definition.setter, rep.public_send(definition.accessor))
+          end # TODO: this sucks. do this with #properties and #replace_properties.
+        end
+        
+        def put(url, format)
+          self.class.put(url, serialize, format)
+        end
+        
+        # TODO: implement delete, patch.
+      end
+    end
+  end
+end

data/lib/roar/representer/feature/hypermedia.rb

@@ -0,0 +1,43 @@
+require "roar/model"
+
+module Roar
+  module Representer
+    module Feature
+      # Adds links methods to the model which can then be used for hypermedia links when
+      # representing the model.
+      module Hypermedia # TODO: test me.
+        extend ActiveSupport::Concern
+        
+        def links=(links)
+          @links = LinkCollection.new(links)
+        end
+        
+        def links
+          @links
+        end
+        
+        class LinkCollection < Array
+          def [](rel)
+            link = find { |l| l.rel.to_s == rel.to_s } and return link.href
+          end
+        end
+        
+        
+        module ClassMethods
+          # Defines an embedded hypermedia link.
+          def link(rel, &block)
+            unless links = representable_attrs.find { |d| d.is_a?(LinksDefinition)}
+              links = LinksDefinition.new(:links, links_definition_options)
+              representable_attrs << links
+              #add_reader(links) # TODO: refactor in Roxml.
+#              attr_writer(links.accessor)
+            end
+            
+            links.rel2block << {:rel => rel, :block => block}
+          end
+        end
+        
+      end
+    end
+  end
+end 

data/lib/roar/representer/feature/model_representing.rb

@@ -0,0 +1,88 @@
+module Roar
+  module Representer
+    module Feature
+      module ModelRepresenting
+        attr_accessor :represented
+        
+        def self.included(base)
+          base.extend ClassMethods
+        end
+        
+        module ClassMethods
+          def for_model(represented)
+            # DISCUSS: split that into #for_model_attributes so it's easier overridable?
+            from_attributes(compute_attributes_for(represented)) { |rep| rep.represented = represented }
+          end
+          
+          def serialize_model(represented)
+            for_model(represented).serialize
+          end
+          
+        private
+          def definition_class
+            ModelDefinition
+          end
+          
+          # Called in for_model.
+          def compute_attributes_for(represented)
+            {}.tap do |attributes|
+              self.representable_attrs.each do |definition|
+                next unless definition.kind_of?(ModelDefinition)  # for now, really only use "our" model attributes.
+                definition.compute_attribute_for(represented, attributes)
+              end
+            end
+          end
+          
+          
+        end # ClassMethods
+        
+        # Properties that are mapped to a model attribute.
+        class ModelDefinition < ::Representable::Definition
+          def compute_attribute_for(represented, attributes)
+            value = represented.send(accessor)
+                
+            if typed?
+              value = apply(value) do |v|
+                sought_type.for_model(v)  # applied to each typed attribute (even in collections).
+              end
+            end
+            
+            attributes[accessor] = value
+          end
+        end
+      end
+      
+      
+      module ActiveRecordMethods
+        def to_nested_attributes # FIXME: works on first level only, doesn't check if we really need to suffix _attributes and is horriby implemented. just for protoyping.  
+          attrs = {}
+          
+          to_attributes.each do |k,v|
+          
+          
+          
+          #next if k.to_s == "links"  # FIXME: how to skip virtual attributes that are not mapped in a model?
+          clear_attributes(attrs)  
+            
+            attrs[k] = v
+            if v.is_a?(Hash) or v.is_a?(Array)
+              attrs["#{k}_attributes"] = attrs.delete(k)
+            end
+          end
+          
+          attrs
+        end
+        
+      private
+        def clear_attributes(attrs)
+          puts "clearing #{attrs.inspect}"
+          attrs.each do |k,v|
+            attrs.delete(k) if k == "links"
+            
+            clear_attributes(v) if v.is_a?(Hash) 
+          end
+        end
+      end
+    end
+  end
+end