hyperresource 0.2.4 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1a85c8ec634a2f03ac5ba0ddcf4fe6e5419bcbb7
-  data.tar.gz: e926a07c7d8c6fcb3bae90989edbab9348e1d48b
+  metadata.gz: 524a169b824f7c61e5aa5c05109415206095ad99
+  data.tar.gz: 70538dc63539ed231dfb71d5cedaccedaf081bda
 SHA512:
-  metadata.gz: a7a6206818559b46e1ef0867672df8d9c520344820b2dd588c2d4de3b983bdaac773de0b67b49e6f1e03b602ee36a19022e3528c63ff154c1ee7fe9f0f539ed5
-  data.tar.gz: 25e4b3d62e9e26ff1087d453e09dad49cd2f04af7df294d488ddf9e7baa3c325ac6b1b0a132ad5916ba376846cfcfd80a321be231c9a42d70b8244285214cb15
+  metadata.gz: 875712e54fc2b58369277dc07d4b2418b8726aeef5dac678584ba0cbc5d617ab6a626d57365381ce3dd3ec3924de0b714060a6f6472e61396258c4cb40439fd8
+  data.tar.gz: 97a73477ec2d1f378b0ae5904f0c09228dd581b7f8d21289e07311c012f3b8ee2ee2f3fef08a04d15e7ba9d2af4b09ab1d19b5f489e1c7e17912dc51d6abb124

data/lib/hyper_resource.rb

@@ -1,15 +1,18 @@
 require 'hyper_resource/attributes'
+require 'hyper_resource/configuration'
 require 'hyper_resource/exceptions'
 require 'hyper_resource/link'
 require 'hyper_resource/links'
 require 'hyper_resource/objects'
-require 'hyper_resource/response'
 require 'hyper_resource/version'
 
 require 'hyper_resource/adapter'
 require 'hyper_resource/adapter/hal_json'
 
+require 'hyper_resource/modules/data_type'
+require 'hyper_resource/modules/deprecations'
 require 'hyper_resource/modules/http'
+require 'hyper_resource/modules/config_attributes'
 require 'hyper_resource/modules/internal_attributes'
 
 require 'rubygems' if RUBY_VERSION[0..2] == '1.8'
@@ -21,7 +24,9 @@ require 'pp'
 
 class HyperResource
 
-  include HyperResource::Modules::HTTP
+  include HyperResource::Modules::ConfigAttributes
+  include HyperResource::Modules::DataType
+  include HyperResource::Modules::Deprecations
   include HyperResource::Modules::InternalAttributes
   include Enumerable
 
@@ -49,16 +54,23 @@ public
   ##                   such as +{request: {timeout: 30}}+.
   ##
   def initialize(opts={})
-    return init_from_resource(opts) if opts.kind_of?(HyperResource)
+    self.root = opts[:root] if opts[:root]
+    self.href = opts[:href] if opts[:href]
 
-    self.root       = opts[:root] || self.class.root
-    self.href       = opts[:href] || ''
-    self.auth       = (self.class.auth || {}).merge(opts[:auth] || {})
-    self.namespace  = opts[:namespace] || self.class.namespace
-    self.headers    = DEFAULT_HEADERS.merge(self.class.headers || {}).
-                                      merge(opts[:headers]     || {})
-    self.faraday_options = opts[:faraday_options] ||
-                               self.class.faraday_options || {}
+    self.hr_config = self.class.hr_config.clone
+
+    self.adapter         = opts[:adapter]         if opts[:adapter]
+    self.faraday_options = opts[:faraday_options] if opts[:faraday_options]
+    self.auth            = opts[:auth]            if opts[:auth]
+
+    self.headers = DEFAULT_HEADERS.
+                     merge(self.class.headers || {}).
+                     merge(opts[:headers]     || {})
+
+    self.namespace = opts[:namespace] if opts[:namespace]
+    if !self.namespace && self.class != HyperResource
+      self.namespace = self.class.namespace || self.class.to_s
+    end
 
     ## There's a little acrobatics in getting Attributes, Links, and Objects
     ## into the correct subclass.
@@ -83,11 +95,41 @@ public
     self.attributes = self.class::Attributes.new(self)
     self.links      = self.class::Links.new(self)
     self.objects    = self.class::Objects.new(self)
-
     self.loaded     = false
+  end
+
 
-    self.adapter    = opts[:adapter] || self.class.adapter ||
-                      HyperResource::Adapter::HAL_JSON
+
+  ## Creates a new resource given args :link, :resource, :href, :response, :url,
+  ## and :body.  Either :link or (:resource and :href and :url) are required.
+  # @private
+  def self.new_from(args)
+    link = args[:link]
+    resource = args[:resource] || link.resource
+    href = args[:href] || link.href
+    url = args[:url] || URI.join(resource.root, href || '')
+    response = args[:response]
+    body = args[:body] || {}
+
+    old_rsrc = resource
+    new_class = old_rsrc.get_data_type_class(:resource => old_rsrc,
+                                             :link => link,
+                                             :url => url,
+                                             :response => response,
+                                             :body => body)
+    new_rsrc = new_class.new(:root => old_rsrc.root,
+                             :href => href)
+    new_rsrc.hr_config = old_rsrc.hr_config.clone
+    new_rsrc.response = response
+    new_rsrc.body = body
+    new_rsrc.adapter.apply(body, new_rsrc)
+    new_rsrc.loaded = true
+    new_rsrc
+  end
+
+  # @private
+  def new_from(args)
+    self.class.new_from(args)
   end
 
 
@@ -143,15 +185,20 @@ public
 
   ## method_missing will load this resource if not yet loaded, then
   ## attempt to delegate to +attributes+, then +objects+, then +links+.
-  ## Override with care.
+  ## Override with extreme care.
   def method_missing(method, *args)
-    self.get unless self.loaded
+    ## If not loaded, load and retry.
+    unless loaded
+      return self.get.send(method, *args)
+    end
+
 
+    ## Otherwise, try to match against attributes, then objects, then links.
     method = method.to_s
     if method[-1,1] == '='
       return attributes[method[0..-2]] = args.first if attributes[method[0..-2]]
     else
-      return attributes[method] if attributes && attributes[method]
+      return attributes[method] if attributes && attributes.has_key?(method.to_s)
       return objects[method] if objects && objects[method]
       if links && links[method]
         if args.count > 0
@@ -165,6 +212,16 @@ public
     raise NoMethodError, "undefined method `#{method}' for #{self.inspect}"
   end
 
+  ## respond_to? is patched to return +true+ if +method_missing+ would
+  ## successfully delegate a method call to +attributes+, +links+, or
+  ## +objects+.
+  def respond_to?(method, *args)
+    return true if self.links && self.links.respond_to?(method)
+    return true if self.attributes && self.attributes.respond_to?(method)
+    return true if self.objects && self.objects.respond_to?(method)
+    super
+  end
+
 
   def inspect # @private
     "#<#{self.class}:0x#{"%x" % self.object_id} @root=#{self.root.inspect} "+
@@ -172,127 +229,13 @@ public
     "@namespace=#{self.namespace.inspect} ...>"
   end
 
-  ## +response_body+, +response_object+, and +deserialized_response+
-  ##  are deprecated in favor of +body+.  (Sorry. Naming things is hard.)
-  def response_body # @private
-    _hr_deprecate('HyperResource#response_body is deprecated. '+
-                  'Please use HyperResource#body instead.')
-    body
-  end
-  def response_object # @private
-    _hr_deprecate('HyperResource#response_object is deprecated. '+
-                  'Please use HyperResource#body instead.')
-    body
-  end
-  def deserialized_response # @private
-    _hr_deprecate('HyperResource#deserialized_response is deprecated. '+
-                  'Please use HyperResource#body instead.')
-    body
-  end
-
-
-
-  ## Return a new HyperResource based on this object and a given href.
-  def _hr_new_from_link(href) # @private
-    self.class.new(:root            => self.root,
-                   :auth            => self.auth,
-                   :headers         => self.headers,
-                   :namespace       => self.namespace,
-                   :faraday_options => self.faraday_options,
-                   :href            => href)
-  end
-
-
-  ## Returns the class into which the given response should be cast.
-  ## If the object is not loaded yet, or if +namespace+ is
-  ## not set, returns +self+.
-  ##
-  ## Otherwise, +response_class+ uses +get_data_type_from_response+ to
-  ## determine subclass name, glues it to the given namespace, and
-  ## creates the class if it's not there yet. E.g., given a namespace of
-  ## +FooAPI+ and a response content-type of
-  ## "application/vnd.foocorp.fooapi.v1+json;type=User", this should
-  ## return +FooAPI::User+ (even if +FooAPI::User+ hadn't existed yet).
-  def self.response_class(response, namespace)
-    if self.to_s == 'HyperResource'
-      return self unless namespace
-    end
-
-    namespace ||= self.to_s
-
-    type_name = self.get_data_type_from_response(response)
-    return self unless type_name
-
-    class_name = "#{namespace}::#{type_name}"
-    class_name.gsub!(/[^_0-9A-Za-z:]/, '')  ## sanitize class_name
-
-    ## Return data type class if it exists
-    klass = eval(class_name) rescue :sorry_dude
-    return klass if klass.is_a?(Class)
-
-    ## Data type class didn't exist -- create namespace (if necessary),
-    ## then the data type class
-    if namespace != ''
-      nsc = eval(namespace) rescue :bzzzzzt
-      unless nsc.is_a?(Class)
-        Object.module_eval "class #{namespace} < #{self}; end"
-      end
-    end
-    Object.module_eval "class #{class_name} < #{namespace}; end"
-    eval(class_name)
-  end
-
-  def _hr_response_class # @private
-    self.namespace ||= self.class.to_s unless self.class.to_s=='HyperResource'
-    self.class.response_class(self.response, self.namespace)
-  end
-
-
-  ## Inspects the given Faraday::Response, and returns a string describing
-  ## this resource's data type.
-  ##
-  ## By default, this method looks for a +type=...+ modifier in the
-  ## response's +Content-type+ and returns that value, capitalized.
-  ##
-  ## Override this method in a subclass to alter HyperResource's behavior.
-  def self.get_data_type_from_response(response)
-    return nil unless response
-    return nil unless content_type = response['content-type']
-    return nil unless m=content_type.match(/;\s* type=([0-9A-Za-z:]+)/x)
-    m[1][0,1].upcase + m[1][1..-1]
-  end
-
-  ## Uses +HyperResource.get_response_data_type+ to determine the proper
-  ## data type for this object.  Override to change behavior (though you
-  ## probably just want to override the class method).
-  def get_data_type_from_response
-    self.class.get_data_type_from_response(self.response)
+  def self.user_agent # @private
+    "HyperResource #{HyperResource::VERSION}"
   end
 
-private
-
-  ## Return this object, "cast" into its proper response class.
-  def to_response_class
-    response_class = self._hr_response_class
-    return self if self.class == response_class
-    response_class.new(self)
+  def user_agent # @private
+    self.class.user_agent
   end
 
-  ## Use the given resource's data to initialize this one.
-  def init_from_resource(resource)
-    (self.class._hr_attributes - [:attributes, :links, :objects]).each do |attr|
-      self.send("#{attr}=".to_sym, resource.send(attr))
-    end
-    self.adapter.apply(self.body, self)
-  end
-
-
-  ## Show a deprecation message.
-  def self._hr_deprecate(message) # @private
-    STDERR.puts "#{message} (called from #{caller[2]})"
-  end
-
-  def _hr_deprecate(*args) # @private
-    self.class._hr_deprecate(*args)
-  end
 end
+

data/lib/hyper_resource/adapter/hal_json.rb

@@ -21,10 +21,10 @@ class HyperResource
 
         def apply(response, resource, opts={})
           if !response.kind_of?(Hash)
-            raise ArgumentError, "'response' argument must be a Hash"
+            raise ArgumentError, "'response' argument must be a Hash (got #{response.inspect})"
           end
           if !resource.kind_of?(HyperResource)
-            raise ArgumentError, "'resource' argument must be a HyperResource"
+            raise ArgumentError, "'resource' argument must be a HyperResource (got #{resource.inspect})"
           end
 
           apply_objects(response, resource)
@@ -40,54 +40,38 @@ class HyperResource
 
         def apply_objects(resp, rsrc)
           return unless resp['_embedded']
-          rc = rsrc.class
-          rsrc.objects = rc::Objects.new(rsrc)
           objs = rsrc.objects
 
           resp['_embedded'].each do |name, collection|
             if collection.is_a? Hash
-              r = rc.new(:root => rsrc.root,
-                         :headers => rsrc.headers,
-                         :namespace => rsrc.namespace)
-              r.body = collection
-              objs[name] = apply(collection, r)
+              objs[name] =
+                rsrc.new_from(:resource => rsrc,
+                              :body => collection,
+                              :href => collection['_links']['self']['href'] )
             else
               objs[name] = collection.map do |obj|
-                r = rc.new(:root => rsrc.root,
-                           :headers => rsrc.headers,
-                           :namespace => rsrc.namespace)
-                r.body = obj
-                apply(obj, r)
+                rsrc.new_from(:resource => rsrc,
+                              :body => obj,
+                              :href => obj['_links']['self']['href'] )
               end
             end
           end
-
-          objs._hr_create_methods!
         end
 
 
         def apply_links(resp, rsrc)
           return unless resp['_links']
-          rsrc.links = rsrc._hr_response_class::Links.new(rsrc)
           links = rsrc.links
 
           resp['_links'].each do |rel, link_spec|
-            keys = [rel]
-            if m=rel.match(/.+:(.+)/)
-              keys << m[1]
-            end
-            keys.each do |key|
-              if link_spec.is_a? Array
-                links[key] = link_spec.map do |link|
-                  new_link_from_spec(rsrc, link)
-                end
-              else
-                links[key] = new_link_from_spec(rsrc, link_spec)
+            if link_spec.is_a? Array
+              links[rel] = link_spec.map do |link|
+                new_link_from_spec(rsrc, link)
               end
+            else
+              links[rel] = new_link_from_spec(rsrc, link_spec)
             end
           end
-
-          links._hr_create_methods!
         end
 
         def new_link_from_spec(resource, link_spec)
@@ -96,8 +80,6 @@ class HyperResource
 
 
         def apply_attributes(resp, rsrc)
-          rsrc.attributes = rsrc._hr_response_class::Attributes.new(rsrc)
-
           given_attrs = resp.reject{|k,v| %w(_links _embedded).include?(k)}
           filtered_attrs = rsrc.incoming_body_filter(given_attrs)
 
@@ -106,7 +88,6 @@ class HyperResource
           end
 
           rsrc.attributes._hr_clear_changed
-          rsrc.attributes._hr_create_methods!
         end
 
       end

data/lib/hyper_resource/attributes.rb

@@ -3,49 +3,10 @@ class HyperResource
 
     attr_accessor :_resource # @private
 
-    def initialize(resource=nil) # @private
+    def initialize(resource=nil)
       self._resource = resource || HyperResource.new
     end
 
-    ## Creates accessor methods in self.class and self._resource.class.
-    ## Protects against method creation into HyperResource::Attributes and
-    ## HyperResource classes.  Just subclasses, please!
-    def _hr_create_methods!(opts={}) # @private
-      return if self.class.to_s == 'HyperResource::Attributes'
-      return if self._resource.class.to_s == 'HyperResource'
-      return if self.class.send(
-        :class_variable_defined?, :@@_hr_created_attributes_methods)
-
-      self.keys.each do |attr|
-        attr_sym = attr.to_sym
-        attr_eq_sym = "#{attr}=".to_sym
-
-        self.class.send(:define_method, attr_sym) do
-          self[attr]
-        end
-        self.class.send(:define_method, attr_eq_sym) do |val|
-          self[attr] = val
-        end
-
-        ## Don't stomp on _resource's methods
-        unless _resource.respond_to?(attr_sym)
-          _resource.class.send(:define_method, attr_sym) do
-            attributes.send(attr_sym)
-          end
-        end
-        unless _resource.respond_to?(attr_eq_sym)
-          _resource.class.send(:define_method, attr_eq_sym) do |val|
-            attributes.send(attr_eq_sym, val)
-          end
-        end
-      end
-
-      ## This is a good time to mark this object as not-changed
-      _hr_clear_changed
-
-      self.class.send(:class_variable_set, :@@_hr_created_attributes_methods, true) 
-    end
-
     ## Returns +true+ if the given attribute has been changed since creation
     ## time, +false+ otherwise.
     ## If no attribute is given, return whether any attributes have been
@@ -62,21 +23,24 @@ class HyperResource
       @_hr_changed.select{|k,v| v}.keys.inject({}) {|h,k| h[k]=self[k]; h}
     end
 
-    def []=(attr, value) # @private
-      return self[attr] if self[attr] == value
-      _hr_mark_changed(attr) 
+    # @private
+    def []=(attr, value)
+      return self[attr] if self.has_key?(attr.to_s) && self[attr] == value
+      _hr_mark_changed(attr)
       super(attr.to_s, value)
     end
 
-    def [](key) # @private
+    # @private
+    def [](key)
       return super(key.to_s) if self.has_key?(key.to_s)
       return super(key.to_sym) if self.has_key?(key.to_sym)
       nil
     end
 
-    def method_missing(method, *args) # @private
+    # @private
+    def method_missing(method, *args)
       method = method.to_s
-      if self[method]
+      if self.has_key?(method)
         self[method]
       elsif method[-1,1] == '='
         self[method[0..-2]] = args.first
@@ -85,11 +49,21 @@ class HyperResource
       end
     end
 
+    # @private
+    def respond_to?(method, *args)
+      method = method.to_s
+      return true if self.has_key?(method)
+      return true if method[-1,1] == '=' && self.has_key?(method[0..-2])
+      super
+    end
+
+    # @private
     def _hr_clear_changed # @private
       @_hr_changed = nil
     end
 
-    def _hr_mark_changed(attr, is_changed=true) # @private
+    # @private
+    def _hr_mark_changed(attr, is_changed=true)
       attr = attr.to_sym
       @_hr_changed ||= Hash.new(false)
       @_hr_changed[attr] = is_changed