reactive_resource 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+pkg/*
+*.gem
+.bundle
+doc/*

data/Gemfile

@@ -0,0 +1,5 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in reactive_resource.gemspec
+gemspec
+gem 'rake'

data/Gemfile.lock

@@ -0,0 +1,29 @@
+PATH
+  remote: .
+  specs:
+    reactive_resource (0.0.1)
+      activeresource (~> 2.3.10)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activeresource (2.3.10)
+      activesupport (= 2.3.10)
+    activesupport (2.3.10)
+    addressable (2.2.2)
+    crack (0.1.8)
+    rake (0.8.7)
+    shoulda (2.11.3)
+    webmock (1.6.2)
+      addressable (>= 2.2.2)
+      crack (>= 0.1.7)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activeresource (~> 2.3.10)
+  rake
+  reactive_resource!
+  shoulda (~> 2.11.3)
+  webmock (~> 1.6.1)

data/README.rdoc

@@ -0,0 +1,72 @@
+= Reactive Resource
+
+Reactive Resource is a collection of extensions extracted from
+ActiveResource wrappers around various APIs. 
+
+== Usage
+
+After installing the gem, your ActiveResource models should inherit
+from <tt>ReactiveResource::Base</tt> instead of
+<tt>ActiveResource::Base</tt>.
+
+== Associations
+
+The most useful thing Reactive Resource adds to ActiveResource is read
+support for associations. This allows you to specify relationships between objects:
+
+  class ReactiveResource::Lawyer < ReactiveResource::Base
+    has_many :addresses
+  end
+  
+  class ReactiveResource::Address < ReactiveResource::Base
+    belongs_to :lawyer
+    has_many :phones
+  end
+  
+  class ReactiveResource::Phone < ReactiveResource::Base
+    belongs_to :address
+  end
+
+and allows you to make calls like:
+
+  ReactiveResource::Lawyer.find(1).addresses.first.phones
+
+This also takes care of URL generation for the associated objects, so
+the above command will hit <tt>/lawyers/1.json</tt>, then
+<tt>/lawyers/1/addresses.json</tt>, then
+<tt>/lawyers/1/addresses/:id/phones.json</tt>.
+
+Currently, Reactive Resource only supports 'read-style'
+associations. It does not yet support things like +build_association+
+and <tt>association=</tt>.
+
+== Other additions
+
+=== Nested routes
+
+One thing ActiveResource was lacking was good support for generating
+nested paths for child resources. Reactive Resource uses the
++belongs_to+ declarations to generate paths like
+<tt>/lawyers/1/addresses.json</tt>, without having to specify all the paths
+in each class. 
+
+=== Support for singleton resources
+
+For singleton resources, ActiveResource would still use the plural and
+generate paths like "/lawyers/1/headshots.json". I didn't like this, so you
+can now mark a resource as a singleton resource:
+
+  class ReactiveResource::Headshot < ReactiveResource::Base
+    singleton
+  end
+
+and the paths will be generated correctly. This is based on the patch
+at https://rails.lighthouseapp.com/projects/8994/tickets/4348-supporting-singleton-resources-in-activeresource
+
+=== Support for setting URL options after creation
+
+In ActiveResource, if you had nested URLs specified in the resource
+path in your class definition, you had to set those params at the
+object's creation time. Reactive Resource allows you to set those
+parameters at any time after object creation.
+

data/Rakefile

@@ -0,0 +1,19 @@
+require 'bundler'
+require 'rake/testtask'
+require 'rake/rdoctask'
+Bundler::GemHelper.install_tasks
+
+task :default => :test
+task :build => :test
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/**/*_test.rb']
+  t.verbose = true
+end
+
+Rake::RDocTask.new do |rd|
+  rd.main = "README.rdoc"
+  rd.rdoc_files.include("README.rdoc", "lib/**/*.rb")
+  rd.rdoc_dir = 'doc'
+end

data/lib/reactive_resource/association/belongs_to_association.rb

@@ -0,0 +1,96 @@
+module ReactiveResource
+  module Association
+    # Represents and resolves a belongs_to association.
+    class BelongsToAssociation
+
+      # The class this association is attached to
+      attr_reader :klass
+
+      # The attribute name this association represents
+      attr_reader :attribute
+
+      # additional options passed in when the association was created
+      attr_reader :options
+
+      # Returns the class name of the target of the association. Based
+      # off of +attribute+ unless +class_name+ was passed in the
+      # +options+ hash.
+      def associated_class
+        if options[:class_name]
+          options[:class_name].constantize
+        else
+          klass.relative_const_get(attribute.to_s.camelize)
+        end
+      end
+
+      # A flattened list of attributes from the entire association
+      # +belongs_to+ hierarchy, including this association's attribute.
+      def associated_attributes
+        attributes = [attribute]
+        if associated_class
+          attributes += associated_class.belongs_to_associations.map(&:attribute)
+        end
+        attributes.uniq
+      end
+
+      # Called when this assocation is referenced. Finds and returns
+      # the target of this association.
+      def resolve_relationship(object)
+        parent_params = object.prefix_options.dup
+        parent_params.delete("#{attribute}_id".intern)
+        associated_class.find(object.send("#{attribute}_id"), :params => parent_params)
+      end
+      
+      # Adds methods for belongs_to associations, to make dealing with
+      # these objects a bit more straightforward. If the attribute name
+      # is +lawyer+, it will add:
+      #
+      # [lawyer] returns the actual lawyer object (after doing a web request)
+      # [lawyer_id] returns the lawyer id
+      # [lawyer_id=] sets the lawyer id
+      def add_helper_methods(klass, attribute)
+        association = self
+        
+        klass.class_eval do 
+          # address.lawyer_id
+          define_method("#{attribute}_id") do
+            prefix_options["#{attribute}_id".intern]
+          end
+          
+          # address.lawyer_id = 3
+          define_method("#{attribute}_id=") do |value|
+            prefix_options["#{attribute}_id".intern] = value
+          end
+
+          # address.lawyer
+          define_method(attribute) do
+            # if the parent has its own belongs_to associations, we need
+            # to add those to the 'find' call. So, let's grab all of
+            # these associations, turn them into a hash of :attr_name =>
+            # attr_id, and fire off the find.
+            
+            unless instance_variable_get("@#{attribute}")
+              object = association.resolve_relationship(self)
+              instance_variable_set("@#{attribute}", object)
+            end
+            instance_variable_get("@#{attribute}")
+          end
+        end
+        
+        # Recurse through the parent object.
+        associated_class.belongs_to_associations.each do |parent_attribute|
+          parent_attribute.add_helper_methods(klass, parent_attribute.attribute)
+        end
+      end
+
+      # Create a new belongs_to association.
+      def initialize(klass, attribute, options)
+        @klass = klass
+        @attribute = attribute
+        @options = options
+
+        add_helper_methods(klass, attribute)
+      end
+    end
+  end
+end

data/lib/reactive_resource/association/has_many_association.rb

@@ -0,0 +1,62 @@
+module ReactiveResource
+  module Association
+    # Represents and resolves a has_many association.
+    class HasManyAssociation
+
+      # The class this association is attached to
+      attr_reader :klass
+
+      # The attribute name this association represents
+      attr_reader :attribute
+
+      # additional options passed in when the association was created
+      attr_reader :options
+
+      # Returns the class name of the target of the association. Based
+      # off of +attribute+ unless +class_name+ was passed in the
+      # +options+ hash.
+      def associated_class
+        if options[:class_name]
+          options[:class_name].constantize
+        else
+          klass.relative_const_get(attribute.to_s.singularize.camelize)
+        end
+      end
+
+      # Called when this assocation is referenced. Finds and returns
+      # the targets of this association.
+      def resolve_relationship(object)
+        id_attribute = "#{klass.name.split("::").last.underscore}_id"
+        associated_class.find(:all, :params => object.prefix_options.merge(id_attribute => object.id))
+      end
+      
+      # Adds methods for has_many associations, to make dealing with
+      # these objects a bit more straightforward. If the attribute name
+      # is +lawyers+, it will add:
+      #
+      # [lawyers] returns the associated lawyers
+      def add_helper_methods(klass, attribute)
+        association = self
+        klass.class_eval do 
+          # lawyer.addresses
+          define_method(attribute) do
+            unless instance_variable_get("@#{attribute}")
+              object = association.resolve_relationship(self)
+              instance_variable_set("@#{attribute}", object)
+            end
+            instance_variable_get("@#{attribute}")
+          end
+        end
+      end
+      
+      # Create a new has_many association.
+      def initialize(klass, attribute, options)
+        @klass = klass
+        @attribute = attribute
+        @options = options
+
+        add_helper_methods(klass, attribute)
+      end
+    end
+  end
+end

data/lib/reactive_resource/association/has_one_association.rb

@@ -0,0 +1,62 @@
+module ReactiveResource
+  module Association
+    # Represents and resolves a has_one association
+    class HasOneAssociation
+
+      # The class this association is attached to
+      attr_reader :klass
+
+      # The attribute name this association represents
+      attr_reader :attribute
+
+      # additional options passed in when the association was created
+      attr_reader :options
+
+      # Returns the class name of the target of the association. Based
+      # off of +attribute+ unless +class_name+ was passed in the
+      # +options+ hash.
+      def associated_class
+        if options[:class_name]
+          options[:class_name].constantize
+        else
+          klass.relative_const_get(attribute.to_s.camelize)
+        end
+      end
+
+      # Called when this assocation is referenced. Finds and returns
+      # the target of this association.
+      def resolve_relationship(object)
+        id_attribute = "#{klass.name.split("::").last.underscore}_id"
+        associated_class.find(:one, :params => object.prefix_options.merge(id_attribute => object.id))
+      end
+      
+      # Adds methods for has_one associations, to make dealing with
+      # these objects a bit more straightforward. If the attribute name
+      # is +headshot+, it will add:
+      #
+      # [headshot] returns the associated headshot
+      def add_helper_methods(klass, attribute)
+        association = self
+        klass.class_eval do 
+          # lawyer.headshot
+          define_method(attribute) do
+            unless instance_variable_get("@#{attribute}")
+              object = association.resolve_relationship(self)
+              instance_variable_set("@#{attribute}", object)
+            end
+            instance_variable_get("@#{attribute}")
+          end
+        end
+      end
+      
+      # Create a new has_one association.
+      def initialize(klass, attribute, options)
+        @klass = klass
+        @attribute = attribute
+        @options = options
+
+        add_helper_methods(klass, attribute)
+      end
+    end
+  end
+end

data/lib/reactive_resource/association.rb

@@ -0,0 +1,7 @@
+module ReactiveResource 
+  module Association # :nodoc:
+    autoload :BelongsToAssociation, 'reactive_resource/association/belongs_to_association'
+    autoload :HasManyAssociation, 'reactive_resource/association/has_many_association'
+    autoload :HasOneAssociation, 'reactive_resource/association/has_one_association'
+  end
+end

data/lib/reactive_resource/base.rb

@@ -0,0 +1,219 @@
+require 'active_resource'
+
+module ReactiveResource
+  
+  # The class that all ReactiveResourse resources should inherit
+  # from. This class fixes and patches over a lot of the broken stuff
+  # in Active Resource, and smoothes out the differences between the
+  # client-side Rails REST stuff and the server-side Rails REST stuff.
+  # It also adds support for ActiveRecord-like associations.
+  class Base < ActiveResource::Base
+    extend Extensions::RelativeConstGet
+    # Call this method to transform a resource into a 'singleton'
+    # resource. This will fix the paths Active Resource generates for
+    # singleton resources. See
+    # https://rails.lighthouseapp.com/projects/8994/tickets/4348-supporting-singleton-resources-in-activeresource
+    # for more info.
+    def self.singleton
+      write_inheritable_attribute(:singleton, true)
+    end
+
+    # +true+ if this resource is a singleton resource, +false+
+    # otherwise
+    def self.singleton?
+      read_inheritable_attribute(:singleton)
+    end
+    
+    # Active Resource's find_one does nothing if you don't pass a
+    # +:from+ parameter. This doesn't make sense if you're dealing
+    # with a singleton resource, so if we don't get anything back from
+    # +find_one+, try hitting the element path directly
+    def self.find_one(options)
+      found_object = super(options)
+      if !found_object && singleton?
+        prefix_options, query_options = split_options(options[:params])
+        path = element_path(nil, prefix_options, query_options)
+        found_object = instantiate_record(connection.get(path, headers), prefix_options)
+      end
+      found_object
+    end
+    
+    # Override ActiveResource's +collection_name+ to support singular
+    # names for singleton resources.
+    def self.collection_name
+      if singleton?
+        element_name
+      else
+        super
+      end
+    end
+
+    # Returns the extension based on the format ('.json', for
+    # example), or the empty string if +format+ doesn't specify an
+    # extension
+    def self.extension
+      format.extension.blank? ? "" : ".#{format.extension}"
+    end
+
+    # This method differs from its parent by adding association_prefix
+    # into the generated url. This is needed to support belongs_to
+    # associations.
+    def self.collection_path(prefix_options = {}, query_options = nil)
+      prefix_options, query_options = split_options(prefix_options) if query_options.nil?
+      "#{prefix(prefix_options)}#{association_prefix(prefix_options)}#{collection_name}#{extension}#{query_string(query_options)}"
+    end
+
+    # Same as collection_path, except with an extra +method_name+ on
+    # the end to support custom methods
+    def self.custom_method_collection_url(method_name, options = {})
+      prefix_options, query_options = split_options(options)
+      "#{prefix(prefix_options)}#{association_prefix(prefix_options)}#{collection_name}/#{method_name}#{extension}#{query_string(query_options)}"
+    end
+
+    # Same as collection_path, except it adds the ID to the end of the
+    # path (unless it's a singleton resource)
+    def self.element_path(id, prefix_options = {}, query_options = nil)
+      prefix_options, query_options = split_options(prefix_options) if query_options.nil?
+      element_path = "#{prefix(prefix_options)}#{association_prefix(prefix_options)}#{collection_name}"
+      
+      # singleton resources don't have an ID
+      if id || !singleton?
+        element_path += "/#{id}"
+      end
+      element_path += "#{extension}#{query_string(query_options)}"
+      element_path
+    end
+
+    # It's kind of redundant to have the server return the foreign
+    # keys corresponding to the belongs_to associations (since they'll
+    # be in the URL anyway), so we'll try to inject them based on the
+    # attributes of the object we just used.
+    def load(attributes)
+      self.class.belongs_to_with_parents.each do |belongs_to_param|
+        attributes["#{belongs_to_param}_id".intern] ||= prefix_options["#{belongs_to_param}_id".intern]
+      end
+      super(attributes)
+    end
+
+    # Add all of the belongs_to attributes as prefix parameters. This is
+    # necessary to support nested url generation on our polymorphic
+    # associations, because we need some way of getting the attributes
+    # at the point where we need to generate the url, and only the
+    # prefix options are available for both finds and creates.
+    def self.prefix_parameters
+      if !@prefix_parameters
+        @prefix_parameters = super
+
+        @prefix_parameters.merge(belongs_to_with_parents.map {|p| "#{p}_id".to_sym})
+      end
+      @prefix_parameters
+    end
+
+    # Generates the URL prefix that the belongs_to parameters and
+    # associations refer to. For example, a license with params
+    # :lawyer_id => 2 will return 'lawyers/2/' and a phone with params
+    # :address_id => 2, :lawyer_id => 3 will return
+    # 'lawyers/3/addresses/2/'.
+    def self.association_prefix(options)
+      options = options.dup
+      association_prefix = ''
+      parent_prefix = ''
+      
+      if belongs_to_associations
+        # Recurse to add the parent resource hierarchy. For Phone, for
+        # instance, this will add the '/lawyers/:id' part of the URL,
+        # which it knows about from the Address class.
+        parents.each do |parent|
+          parent_prefix = parent.association_prefix(options) if parent_prefix.blank?
+        end
+
+        belongs_to_associations.each do |association|
+          if association_prefix.blank? && param_value = options.delete("#{association.attribute}_id".intern) # only take the first one
+            association_prefix = "#{association.associated_class.collection_name}/#{param_value}/"
+          end
+        end
+      end
+      parent_prefix + association_prefix
+    end
+
+    class << self
+      # Holds all the associations that have been declared for this class
+      attr_accessor :associations
+    end
+    self.associations = []
+    
+    # Add a has_one relationship to another class. +options+ is a hash
+    # of extra parameters:
+    #
+    # [:class_name] Override the class name of the target of the
+    #               association. By default, this is based on the
+    #               attribute name.
+    def self.has_one(attribute, options = {})
+      self.associations << Association::HasOneAssociation.new(self, attribute, options)
+    end
+    
+    # Add a has_many relationship to another class. +options+ is a hash
+    # of extra parameters:
+    #
+    # [:class_name] Override the class name of the target of the
+    #               association. By default, this is based on the
+    #               attribute name.
+    def self.has_many(attribute, options = {})
+      self.associations << Association::HasManyAssociation.new(self, attribute, options)
+    end
+
+    # Add a parent-child relationship between +attribute+ and this
+    # class. This allows parameters like +attribute_id+ to contribute
+    # to generating nested urls. +options+ is a hash of extra
+    # parameters:
+    #
+    # [:class_name] Override the class name of the target of the
+    #               association. By default, this is based on the
+    #               attribute name.
+    def self.belongs_to(attribute, options = {})
+      self.associations << Association::BelongsToAssociation.new(self, attribute, options)
+    end
+
+    # Returns all of the belongs_to associations this class has.
+    def self.belongs_to_associations
+      self.associations.select {|assoc| assoc.kind_of?(Association::BelongsToAssociation) }
+    end
+
+    # Fix up the +klass+ attribute of all of our associations to point
+    # to the new child class instead of the parent class, so class
+    # lookup works as expected
+    def self.inherited(child)
+      super(child)
+      child.associations = []
+      associations.each do |association|
+        begin
+          child.associations << association.class.new(child, association.attribute, association.options)
+        rescue NameError
+          # assume that they'll fix the association later by manually specifying :class_name in the belongs_to
+        end
+      end
+    end
+
+    # belongs_to in ReactiveResource works a little differently than
+    # ActiveRecord. Because we have to deal with full class hierachies
+    # in order to generate the full URL (as mentioned in
+    # association_prefix), we have to treat the belongs_to
+    # associations on objects that this object belongs_to as if they
+    # exist on this object itself. This method merges in all of this
+    # class' associated classes' belongs_to associations, so we can
+    # handle deeply nested routes. So, for instance, if we have phone
+    # \=> address => lawyer, phone will look for address' belongs_to
+    # associations and merge them in. This allows us to have both
+    # lawyer_id and address_id at url generation time.
+    def self.belongs_to_with_parents
+      belongs_to_associations.map(&:associated_attributes).flatten.uniq
+    end
+
+    # All the classes that this class references in its +belongs_to+,
+    # along with their parents, and so on.
+    def self.parents
+      @parents ||= belongs_to_associations.map(&:associated_class)
+    end
+
+  end
+end

data/lib/reactive_resource/extensions/relative_const_get.rb

@@ -0,0 +1,29 @@
+module Extensions
+  # Supplies RelativeConstGet#relative_const_get, which is like +const_get+, except it
+  # attempts to resolve using the current class's module, rather than
+  # the class's scope itself.
+  module RelativeConstGet
+
+    # Finds the constant with name +name+, relative to the calling
+    # module. For instance, <tt>A::B.const_get_relative("C")</tt> will
+    # search for A::C, then ::C. This is heavily inspired by
+    # +find_resource_in_modules+ in active_resource.
+    def relative_const_get(name)
+      module_names = self.name.split("::")
+      if module_names.length > 1
+        receiver = Object
+        namespaces = module_names[0, module_names.size-1].map do |module_name|
+          receiver = receiver.const_get(module_name)
+        end
+        const_args = RUBY_VERSION < "1.9" ? [name] : [name, false]
+        if namespace = namespaces.reverse.detect { |ns| ns.const_defined?(*const_args) }
+          return namespace.const_get(*const_args)
+        else
+          raise NameError, "Couldn't find a class named #{name}"
+        end
+      else
+        const_get(name)
+      end
+    end
+  end
+end

data/lib/reactive_resource/extensions.rb

@@ -0,0 +1,3 @@
+module Extensions # :nodoc:
+  autoload :RelativeConstGet, 'reactive_resource/extensions/relative_const_get'
+end

data/lib/reactive_resource/version.rb

@@ -0,0 +1,4 @@
+module ReactiveResource
+  # The current version of ReactiveResource
+  VERSION = "0.0.1"
+end

data/lib/reactive_resource.rb

@@ -0,0 +1,5 @@
+module ReactiveResource # :nodoc:
+  autoload :Base, 'reactive_resource/base'
+  autoload :Association, 'reactive_resource/association'
+  autoload :Extensions, 'reactive_resource/extensions'
+end

data/reactive_resource.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "reactive_resource/version"
+
+Gem::Specification.new do |s|
+  s.name        = "reactive_resource"
+  s.version     = ReactiveResource::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Justin Weiss"]
+  s.email       = ["justin@uberweiss.org"]
+  s.homepage    = ""
+  s.summary     = %q{ActiveRecord-like associations for ActiveResource}
+  s.description = %q{ActiveRecord-like associations for ActiveResource}
+
+  s.rubyforge_project = "reactive_resource"
+
+  s.add_dependency "activeresource", '~> 2.3.10'
+  s.add_development_dependency "shoulda", '~> 2.11.3'
+  s.add_development_dependency "webmock", '~> 1.6.1'
+  
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/test/test_helper.rb

@@ -0,0 +1,15 @@
+require 'rubygems'
+require 'test/unit'
+require 'reactive_resource'
+require 'test_objects'
+
+require 'shoulda'
+
+require 'webmock/test_unit'
+class Test::Unit::TestCase
+  include WebMock::API
+end
+
+WebMock.disable_net_connect!
+
+ReactiveResource::Base.site = 'https://api.avvo.com/1'

data/test/test_objects.rb

@@ -0,0 +1,60 @@
+class ReactiveResource::Base
+  self.site = "https://api.avvo.com/"
+  self.prefix = "/api/1/"
+  self.format = :json
+end
+
+class ReactiveResource::Lawyer < ReactiveResource::Base
+  has_one :headshot
+  has_many :addresses
+end
+
+# half the complications in here come from the fact that we have
+# resources shared with one of two different types of parents
+class ReactiveResource::Doctor < ReactiveResource::Base
+  has_one :headshot
+  has_many :addresses
+end
+
+class ReactiveResource::Headshot < ReactiveResource::Base
+  singleton
+  belongs_to :lawyer
+  belongs_to :doctor
+end
+
+class ReactiveResource::Address < ReactiveResource::Base
+  belongs_to :lawyer
+  belongs_to :doctor
+  has_many :phones
+end
+
+module ChildResource
+  
+  class Address < ReactiveResource::Address
+    belongs_to :lawyer, :class_name => "ReactiveResource::Lawyer"
+    belongs_to :doctor, :class_name => "ReactiveResource::Doctor"
+  end
+
+  class Phone < ReactiveResource::Address
+  end
+end
+
+class ReactiveResource::Phone < ReactiveResource::Base
+  belongs_to :address
+end
+
+module ActiveResource
+  module Formats
+    module NoFormatFormat
+      extend ActiveResource::Formats::JsonFormat
+      extend self
+      def extension
+        ''
+      end
+    end
+  end
+end
+
+class ReactiveResource::NoExtension < ReactiveResource::Base
+  self.format = :no_format
+end

data/test/unit/base_test.rb

@@ -0,0 +1,169 @@
+require 'test_helper'
+
+class ReactiveResource::BaseTest < Test::Unit::TestCase
+
+  context "A resource that inherits from another resource" do
+    setup do
+      @object = ChildResource::Address.new
+    end
+
+    should "inherit its parents' associations" do
+      assert_contains @object.class.associations.map(&:attribute), :phones
+    end
+
+    should "prefer to resolve to another child class" do
+      assert_equal ChildResource::Phone, @object.class.associations.detect {|assoc| assoc.attribute == :phones }.associated_class
+    end
+
+    should "follow relationships where :class_name is specified" do
+      assert_equal ReactiveResource::Lawyer, @object.class.associations.detect {|assoc| assoc.attribute == :lawyer }.associated_class
+    end
+  end
+  
+  context "A resource that inherits from ReactiveResource::Base" do
+    
+    setup do
+      @object = ReactiveResource::Lawyer.new
+    end
+    
+    should "hit the Avvo API with the correct URL when saved" do
+      stub_request(:post, "https://api.avvo.com/api/1/lawyers.json")
+      @object.save
+      assert_requested(:post, "https://api.avvo.com/api/1/lawyers.json")
+    end
+
+    should "hit the Avvo API with the correct URL when retrieved" do 
+      stub_request(:get, "https://api.avvo.com/api/1/lawyers/1.json").to_return(:body => {:id => '1'}.to_json)
+      ReactiveResource::Lawyer.find(1)
+      assert_requested(:get, "https://api.avvo.com/api/1/lawyers/1.json")      
+    end
+
+    context "with a has_many relationship to another object" do
+      should "hit the associated object's URL with the correct parameters when requested" do
+        stub_request(:get, "https://api.avvo.com/api/1/lawyers/1/addresses.json")
+        @object.id = 1
+        @object.addresses
+        assert_requested(:get, "https://api.avvo.com/api/1/lawyers/1/addresses.json")
+      end
+    end
+
+    context "with a has_one relationship to another object" do
+      should "hit the associated object's URL with the correct parameters when requested" do
+        stub_request(:get, "https://api.avvo.com/api/1/lawyers/1/headshot.json").to_return(:body => {:headshot_url => "blah"}.to_json)
+        @object.id = 1
+        @object.headshot
+        assert_requested(:get, "https://api.avvo.com/api/1/lawyers/1/headshot.json")
+      end
+    end
+
+    context "with a belongs_to association and correct parameters" do
+      setup do 
+        @object = ReactiveResource::Address.new(:lawyer_id => 2)
+      end
+      
+      should "hit the Avvo API with the correct URL when saved" do
+        stub_request(:post, "https://api.avvo.com/api/1/lawyers/2/addresses.json")
+        @object.save
+        assert_requested(:post, "https://api.avvo.com/api/1/lawyers/2/addresses.json")
+      end
+      
+      should "hit the Avvo API with the correct URL when retrieved" do 
+        stub_request(:get, "https://api.avvo.com/api/1/lawyers/2/addresses/3.json").to_return(:body => {:id => '3'}.to_json)
+        ReactiveResource::Address.find(3, :params => {:lawyer_id => 2})
+        assert_requested(:get, "https://api.avvo.com/api/1/lawyers/2/addresses/3.json")      
+      end
+
+      should "hit the Avvo API with the correct URL when updated" do 
+        stub_request(:get, "https://api.avvo.com/api/1/lawyers/2/addresses/3.json").to_return(:body => {:id => '3'}.to_json)
+        license = ReactiveResource::Address.find(3, :params => {:lawyer_id => 2})
+        assert_requested(:get, "https://api.avvo.com/api/1/lawyers/2/addresses/3.json")  
+        stub_request(:put, "https://api.avvo.com/api/1/lawyers/2/addresses/3.json")
+        license.save
+        assert_requested(:put, "https://api.avvo.com/api/1/lawyers/2/addresses/3.json")
+      end
+
+      should "set the prefix parameters correctly when saved" do
+        stub_request(:post, "https://api.avvo.com/api/1/lawyers/2/addresses.json").to_return(:body => {:id => '2'}.to_json)
+        @object.save
+        assert_requested(:post, "https://api.avvo.com/api/1/lawyers/2/addresses.json")
+
+        assert_equal "/api/1/lawyers/2/addresses/2.json", @object.send(:element_path)
+      end
+      
+    end
+
+    context "with a belongs_to hierarchy and correct parameters" do 
+
+      setup do 
+        @object = ReactiveResource::Phone.new(:doctor_id => 2, :address_id => 3)
+      end
+
+      should "allow setting the prefix options after creation" do
+        @object = ReactiveResource::Phone.new
+        @object.doctor_id = 2
+        @object.address_id = 3
+        stub_request(:post, "https://api.avvo.com/api/1/doctors/2/addresses/3/phones.json")
+        @object.save
+        assert_requested(:post, "https://api.avvo.com/api/1/doctors/2/addresses/3/phones.json")
+      end
+
+      should "allow following +belongs_to+ associations" do
+        @object = ReactiveResource::Phone.new
+        @object.doctor_id = 2
+        @object.address_id = 3
+        assert_equal 3, @object.address_id
+        stub_request(:get, "https://api.avvo.com/api/1/doctors/2/addresses/3.json").to_return(:body => {:id => '3'}.to_json)
+        @object.address
+        @object.address
+        assert_requested(:get, "https://api.avvo.com/api/1/doctors/2/addresses/3.json", :times => 1)
+      end
+      
+      should "hit the Avvo API with the correct URL when saved" do
+        stub_request(:post, "https://api.avvo.com/api/1/doctors/2/addresses/3/phones.json")
+        @object.save
+        assert_requested(:post, "https://api.avvo.com/api/1/doctors/2/addresses/3/phones.json")
+      end
+
+      should "hit the Avvo API with the correct URL when updated" do 
+        stub_request(:get, "https://api.avvo.com/api/1/doctors/2/addresses/3/phones/4.json").to_return(:body => {:id => '4'}.to_json)
+        phone = ReactiveResource::Phone.find(4, :params => {:doctor_id => 2, :address_id => 3})
+        assert_requested(:get, "https://api.avvo.com/api/1/doctors/2/addresses/3/phones/4.json")
+
+        stub_request(:put, "https://api.avvo.com/api/1/doctors/2/addresses/3/phones/4.json")
+        phone.save
+        assert_requested(:put, "https://api.avvo.com/api/1/doctors/2/addresses/3/phones/4.json")
+      end
+
+      should "set the prefix parameters correctly when saved" do
+        stub_request(:post, "https://api.avvo.com/api/1/doctors/2/addresses/3/phones.json").to_return(:body => {:phone_type_id => 2, :id => 4, :phone_number=>"206-728-0588"}.to_json)
+        @object.save
+        assert_requested(:post, "https://api.avvo.com/api/1/doctors/2/addresses/3/phones.json")
+
+        assert_equal "/api/1/doctors/2/addresses/3/phones/4.json", @object.send(:element_path)
+      end
+      
+      should "hit the Avvo API with the correct URL when retrieved" do 
+        stub_request(:get, "https://api.avvo.com/api/1/doctors/2/addresses/3/phones/4.json").to_return(:body => {:id => '4'}.to_json)
+        ReactiveResource::Phone.find(4, :params => {:doctor_id => 2, :address_id => 3})
+        assert_requested(:get, "https://api.avvo.com/api/1/doctors/2/addresses/3/phones/4.json")      
+      end
+    end
+
+  end
+
+  context "A resource without an extension" do
+    should "hit the correct urls" do
+      stub_request(:get, "https://api.avvo.com/api/1/no_extensions")
+      @object = ReactiveResource::NoExtension.find(:all)
+      assert_requested(:get, "https://api.avvo.com/api/1/no_extensions")
+
+      stub_request(:put, "https://api.avvo.com/api/1/no_extensions/1")
+      @object = ReactiveResource::NoExtension.new(:id => 1).save
+      assert_requested(:put, "https://api.avvo.com/api/1/no_extensions/1")
+
+      stub_request(:get, "https://api.avvo.com/api/1/no_extensions/test")
+      @object = ReactiveResource::NoExtension.get(:test)
+      assert_requested(:get, "https://api.avvo.com/api/1/no_extensions/test")
+    end
+  end
+end

metadata

@@ -0,0 +1,128 @@
+--- !ruby/object:Gem::Specification 
+name: reactive_resource
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Justin Weiss
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-01-14 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activeresource
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 3
+        - 10
+        version: 2.3.10
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: shoulda
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 11
+        - 3
+        version: 2.11.3
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: webmock
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 6
+        - 1
+        version: 1.6.1
+  type: :development
+  version_requirements: *id003
+description: ActiveRecord-like associations for ActiveResource
+email: 
+- justin@uberweiss.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- README.rdoc
+- Rakefile
+- lib/reactive_resource.rb
+- lib/reactive_resource/association.rb
+- lib/reactive_resource/association/belongs_to_association.rb
+- lib/reactive_resource/association/has_many_association.rb
+- lib/reactive_resource/association/has_one_association.rb
+- lib/reactive_resource/base.rb
+- lib/reactive_resource/extensions.rb
+- lib/reactive_resource/extensions/relative_const_get.rb
+- lib/reactive_resource/version.rb
+- reactive_resource.gemspec
+- test/test_helper.rb
+- test/test_objects.rb
+- test/unit/base_test.rb
+has_rdoc: true
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: reactive_resource
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: ActiveRecord-like associations for ActiveResource
+test_files: 
+- test/test_helper.rb
+- test/test_objects.rb
+- test/unit/base_test.rb