roar 0.8.0 → 0.8.1

data/lib/roar/model.rb

@@ -1,36 +0,0 @@
-module Roar
-  # Basic methods needed to implement the ActiveModel API. Gives your model +#attributes+ and +model_name+.
-  # Include this for quickly converting an object to a ROAR-compatible monster.
-  #
-  # #DISCUSS: are Models used both on client- and server-side? I'd say hell yeah. 
-  module Model
-    extend ActiveSupport::Concern
-    
-    module ClassMethods
-      def model_name
-        ActiveSupport::Inflector.underscore(self) # We don't use AM::Naming for now.
-      end
-      
-      def accessors(*names)
-        names.each do |name|
-          class_eval %Q{
-            def #{name}=(v)
-              attributes["#{name}"] = v
-            end
-            
-            def #{name}
-              attributes["#{name}"]
-            end
-          }
-        end
-      end
-    end
-    
-    
-    attr_accessor :attributes
-    
-    def initialize(attributes={})
-      @attributes = attributes
-    end
-  end
-end

data/lib/roar/model/representable.rb

@@ -1,31 +0,0 @@
-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/representer.rb

@@ -1,72 +0,0 @@
-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/test/hypermedia_test.rb

@@ -1,35 +0,0 @@
-require 'test_helper'
-require 'roar/representer/feature/hypermedia'
-
-class HypermediaTest
-  describe "Hypermedia" do
-    class Bookmarks
-      include Roar::Representer::Feature::Hypermedia
-    end
-    
-    before do
-      Hyperlink = Roar::Representer::XML::Hyperlink # TODO: move to abstract module.
-      @b = Bookmarks.new
-      @b.links = [Hyperlink.from_attributes({"rel" => "self", "href" => "http://self"}), Hyperlink.from_attributes({"rel" => "next", "href" => "http://next"})]
-    end
-    
-    describe "#links" do
-      it "returns links" do
-        assert_kind_of Roar::Representer::Feature::Hypermedia::LinkCollection, @b.links
-        assert_equal 2, @b.links.size
-      end
-      
-      it "works with empty links set" do
-        assert_equal nil, Bookmarks.new.links # default empty array doesn't make sense.
-      end
-    end
-    
-    
-    it "responds to links #[]" do
-      assert_equal "http://self", @b.links["self"]
-      assert_equal "http://self", @b.links[:self]
-      assert_equal "http://next", @b.links[:next]
-      assert_equal nil, @b.links[:prev]
-    end
-  end
-end

data/test/model_test.rb

@@ -1,50 +0,0 @@
-require 'test_helper'
-
-class ModelTest < MiniTest::Spec
-  describe "HttpVerbs" do
-    before do
-      @klass = Class.new(TestModel) do
-        include Roar::Model::HttpVerbs
-        
-        self.resource_base = "http://localhost:9999/test/"
-      end
-      @o = @klass.new
-    end
-    
-    it "has resource_base* accessors for setting the uri base path" do
-      assert_equal "http://localhost:9999/test/", @klass.resource_base
-    end
-    
-    it ".get returns deserialized object from " do
-      assert_equal({"id" => "4711"},  @klass.get(4711).attributes)
-    end
-  end
-  
-  
-  describe "The Model API" do
-    class Dog
-      include Roar::Model
-      
-      accessors :name
-    end
-      
-    before do
-      @klass = Dog
-    end
-    
-    it "the constructor accepts attributes" do
-      assert_equal({"id" => "4711"},  @klass.new({"id" => "4711"}).attributes)
-    end
-    
-    it "responds to .model_name" do
-      assert_equal "model_test/dog", @klass.model_name
-    end
-    
-    it "lets .accessors create accessors" do
-      @o = @klass.new({"name" => "Joe"})
-      assert_equal "Joe", @o.name
-      @o.name= "Noe"
-      assert_equal "Noe", @o.name
-    end
-  end
-end

data/test/proxy_test.rb

@@ -1,89 +0,0 @@
-require 'test_helper'
-
-class ProxyTest < MiniTest::Spec
-  describe "Transport" do
-    before do
-      @klass = Class.new(Object) do
-        include Roar::Client::Transport
-      end
-      @o = @klass.new
-    end
-    
-    it "#get_uri returns Restfulie response" do
-      assert_equal "<test><id>4711</id></test>",  @o.get_uri("http://localhost:9999/test/4711").body
-    end
-  end
-  
-  
-  describe "The public Proxy API" do
-    before do
-      @klass = Class.new(TestModel) do
-        extend Roar::Client::Proxy
-      end
-    end
-    
-    it "responds to .get_model" do
-      @o = @klass.get_model("http://localhost:9999/test/1", TestModel)
-      assert_kind_of TestModel, @o
-      assert_equal({"id" => "1"}, @o.attributes)
-    end
-  end
-  
-  describe "EntityProxy" do
-    before do
-      Proxy = Roar::Client::EntityProxy
-      @proxy_class = Proxy.class_for(:class => TestModel)
-    end
-    
-    it ".class_for returns an EntityProxy subclass" do
-      @proxy = @proxy_class.new
-      assert_kind_of Proxy, @proxy
-    end
-    
-    it "responds to .options" do
-      assert_equal({:class => TestModel}, @proxy_class.send(:options))
-    end
-    
-    it "doesn't override superclass options" do
-      assert_equal nil, Proxy.options
-    end
-    
-    it "responds to .from_attributes and responds to #original_attributes" do
-      assert_equal({:urn => "urn:item"}, @proxy_class.from_attributes(:urn => "urn:item").send(:original_attributes))
-    end
-    
-    it "responds to .model_name with the proxied name" do
-      assert_equal "test", @proxy_class.model_name
-    end
-    
-    # finalize!
-    describe "#finalize!" do
-      before do
-        @o = @proxy_class.from_attributes("uri" => "http://localhost:9999/test/1")
-      end
-      
-      it "responds to #proxied_resource" do
-        assert_nil @o.send(:proxied_resource)
-      end
-      
-      it "#finalize! retrieves proxied resource" do
-        @o.finalize!
-        assert_kind_of TestModel, @o.send(:proxied_resource)
-      end
-      
-      # delegation:
-      it "#attributes are delegated" do
-        @o.finalize!
-        assert_equal({"id" => "1"}, @o.attributes)
-      end
-      
-      it "#to_xml renders the unproxied entity" do
-        assert_equal "<test>\n  <uri>http://localhost:9999/test/1</uri>\n</test>\n", @o.to_xml
-      end
-      
-      it "#attributes_for_xml returns the unfinalized EntityProxy#attributes hash" do
-        assert_equal({"uri"=>"http://localhost:9999/test/1"}, @o.attributes_for_xml)
-      end
-    end
-  end
-end

data/test/representable_test.rb

@@ -1,49 +0,0 @@
-require 'test_helper'
-require 'roar/model/representable'
-
-class RepresentableTest < MiniTest::Spec
-  
-  class ThisAsAppXml < Roar::Representer::Base
-    def self.deserialize(represented_class, mime_type, data)
-      "#{represented_class.name}->#{mime_type}: #{data}"
-    end
-    
-    def serialize(represented, mime_type)
-      "#{represented.class.name}->#{mime_type}"
-    end
-  end
-  
-  describe "Representable" do
-    before do
-      @c = Class.new do
-        include Roar::Model::Representable
-        
-        represents "application/xml", :with => ThisAsAppXml
-      end
-    end
-    
-    
-    describe ".representer_class_for" do
-      it "returns the class" do
-        assert_equal ThisAsAppXml, @c.representer_class_for("application/xml")
-      end
-      
-      it "returns nil if unknown" do
-        assert_equal nil, @c.representer_class_for("text/html")
-      end
-    end
-    
-    
-    describe ".from" do
-      it "receives mime_type and content" do
-        assert_equal "->application/xml: <xml/>", @c.from("application/xml", "<xml/>")
-      end
-    end
-    
-    describe "#to" do
-      it "receives mime_type" do
-        assert_equal "->application/xml", @c.new.to("application/xml")
-      end
-    end
-  end
-end

data/test/ruby_representation_test.rb

@@ -1,144 +0,0 @@
-require 'test_helper'
-
-module Roar
-  module Representer
-    class Ruby < Base
-      def serialize(attributes)
-        serializable_attributes = attributes.dup
-        
-        serialize_typed_attributes(serializable_attributes)
-        Marshal.dump serializable_attributes
-      end
-      
-      def deserialize(body)
-        deserialized_hash = Marshal.load body
-        deserialize_typed_attributes(deserialized_hash)
-      end
-      
-      
-      
-      module ConfigurationDsl # FIXME: move to Representer::BaseDsl or so.
-        def has_many(name, options={})
-          collections[name] = options
-        end
-        alias_method :collection, :has_many
-        
-        def has_one(name, options={})
-          typed_entities[name] = options
-        end
-        
-        def has_proxied(name, options={})
-          has_one(name, {:class => EntityProxy.class_for(options)}) 
-        end
-        
-        def has_many_proxied(name, options={})
-          has_many(name, {:class => EntityProxy.class_for(options)}) 
-        end
-      end
-      
-      self.extend ConfigurationDsl
-      # FIXME: use one variable?
-      extend Hooks::InheritableAttribute
-      inheritable_attr :collections
-      self.collections = {}
-      inheritable_attr :typed_entities
-      self.typed_entities = {}
-      
-      
-      
-      def serialize_typed_attributes(attributes)
-          filter_attributes_for(attributes, self.class.typed_entities) do |name, options|
-            next unless entity = attributes[name]
-            attributes[name] = entity.to(mime_type)
-          end
-        end
-      
-      # Attributes can be typecasted with +has_one+.
-        def deserialize_typed_attributes(attributes)
-          filter_attributes_for(attributes, self.class.typed_entities) do |name, options|
-            item  = attributes.delete(name)                        # attributes[:sum]
-            item  = options[:class].from(mime_type, item) # Sum.from_xml_attributes
-            attributes[name] = item
-          end
-        end
-        
-        def filter_attributes_for(attributes, config)
-          config.each do |name, options|
-            name = name.to_s
-            yield name, options
-          end
-          attributes
-        end
-      
-    end
-    
-    
-  end
-  
-end
-
-
-class RubyRepresenterFunctionalTest < MiniTest::Spec
-  class Item
-    attr_reader :value
-    
-    def initialize(value)
-      @value = value
-    end
-    
-    def to(mime_type)
-      raise unless mime_type == "ruby/serialized"
-      Marshal.dump(@value)
-    end
-    
-    def self.from(mime_type, string)
-      raise unless mime_type == "ruby/serialized"
-      new Marshal.load(string)
-    end
-    
-    def ==(b)
-      value == b.value
-    end
-  end
-  
-  describe "RubyRepresenter" do
-    before do
-      @r = Class.new(Roar::Representer::Ruby).new("ruby/serialized")
-      @m = {:id => 1}
-    end
-    
-    describe "without options" do
-      it "#serialize returns the serialized model" do
-        assert_equal "\x04\b{\x06:\aidi\x06", @r.serialize(@m)
-      end
-      
-      it "#deserialize returns the attributes" do
-        assert_equal @m, @r.deserialize("\x04\b{\x06:\aidi\x06")
-      end
-    end
-    
-    
-    describe "has_one" do
-      before do
-        @r.class.instance_eval do
-          has_one :item, :class => Item
-        end
-      end
-      
-      it "#serialize skips empty :item" do
-        assert_equal "\x04\b{\x06:\aidi\x06", @r.serialize(@m)
-      end
-      
-      it "#serialize delegates to item#to" do
-        @m = {:id => 1, "item" => Item.new("beer")}
-        assert_equal "\x04\b{\a:\aidi\x06I\"\titem\x06:\x06EF\"\x13\x04\bI\"\tbeer\x06:\x06EF", @r.serialize(@m)
-      end
-      
-      it "#deserialize typecasts :item" do
-        m = @r.deserialize("\x04\b{\a:\aidi\x06I\"\titem\x06:\x06EF\"\x13\x04\bI\"\tbeer\x06:\x06EF")
-        assert_equal({:id => 1, "item" => Item.new("beer")}, m)
-      end
-      
-    end
-  end
-end