hyperresource 0.1.9.2 → 0.1.9.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 294b14e1ecc640c411926b683c3b47755e00701f
-  data.tar.gz: 3a7ed8ec37100074abba126ec84509b61134d862
+  metadata.gz: a9eb3362f2f929049439543e8aa9cd140f808b9b
+  data.tar.gz: 6ae500a90b57bb69715db82268d8c8e56d5af4cd
 SHA512:
-  metadata.gz: 792029a5bc68c4a83d6699b6142318dd96ede36749ae080e4c5ec797aa4a1543565cf910eca7fd623489897b54a109d479112227395c8b8b778d568944525f3d
-  data.tar.gz: 46d604b2574111678c0a58f937c765e452e99d2d35b0ec07ae62ac184ffd6246dc381ebac2a4f24cd94e8bd7172fdacb14d7678f3bd9f37992dbee03307dff93
+  metadata.gz: b0b44a45fba55b7bf5b7e4522a46fb04705a3d3d9aa877a516e1582819513b9f622428a847d153f9f920a37644404929ecd7dc3ce4772711bc7298916e1cf313
+  data.tar.gz: c6143d7034ea27cc735706edf8b4aead7bb5717f745f866721a2c8e340cd88cc5bbfb2d2d0ef3e24fc0f65353d620bfeda177d18940b2de2d3abfccfff0fe6ce

data/lib/hyper_resource.rb

@@ -1,23 +1,8 @@
-require 'hyper_resource/version'
-require 'hyper_resource/attributes'
-require 'hyper_resource/links'
-require 'hyper_resource/link'
-require 'hyper_resource/objects'
-require 'hyper_resource/response'
-require 'hyper_resource/exceptions'
-
-require 'hyper_resource/modules/utils'
-require 'hyper_resource/modules/http'
-
-require 'hyper_resource/adapter'
-require 'hyper_resource/adapter/hal_json'
+this_dir = File.dirname(File.absolute_path(__FILE__))
+Dir.glob(this_dir + '/hyper_resource/**/*.rb') {|f| require f}
 
 require 'pp'
 
-## TODO:
-## as_json, to_json (in adapter?)
-## save, update, create, delete
-
 class HyperResource
   include HyperResource::Modules::Utils
   include HyperResource::Modules::HTTP
@@ -117,37 +102,15 @@ public
                       HyperResource::Adapter::HAL_JSON
   end
 
-private
-
-  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.response_object, self)
-  end
 
 public
 
+  ## Returns true if one or more of this object's attributes has been
+  ## reassigned.
   def changed?(*args)
     attributes.changed?(*args)
   end
 
-  ## Returns a new HyperResource based on the given link href.
-  def _new_from_link(href)
-    self.class.new(:root    => self.root,
-                   :auth    => self.auth,
-                   :headers => self.headers,
-                   :namespace => self.namespace,
-                   :href    => href)
-  end
-
-  def to_response_class
-    response_class = self.get_response_class
-    return self if self.class == response_class
-    response_class.new(self)
-  end
-
-
   ## +incoming_body_filter+ filters a hash of attribute keys and values
   ## on their way from a response body to a HyperResource.  Override this
   ## in a subclass of HyperResource to implement filters on incoming data.
@@ -171,30 +134,83 @@ public
   end
 
 
-  def get_response_class # :nodoc:
-    self.namespace ||= self.class.to_s unless self.class.to_s=='HyperResource'
-    self.class.get_response_class(self.response, self.namespace)
+  ## Returns the first object in the first collection of objects embedded
+  ## in this resource.  Equivalent to +self.objects.first+.
+  def first; self.objects.first end
+
+  ## Returns the *i*th object in the first collection of objects embedded
+  ## in this resource.  Equivalent to +self.objects[i]+.
+  def [](i); self.objects.ith(i) end
+
+  ## method_missing will load this resource if not yet loaded, then 
+  ## attempt to delegate to +attributes+, then +objects+, then +links+.
+  ## Override with care.
+  def method_missing(method, *args)
+    self.get unless self.loaded
+
+    method = method.to_s
+    if method[-1] == '='
+      return attributes[method[0..-2]] = args.first if attributes[method[0..-2]]
+    else
+      return attributes[method] if attributes && attributes[method]
+      return objects[method] if objects && objects[method]
+      if links && links[method]
+        if args.count > 0
+          return links[method].where(*args)
+        else
+          return links[method]
+        end
+      end
+    end
+
+    raise NoMethodError, "undefined method `#{method}' for #{self.inspect}"
+  end
+
+
+  def inspect # :nodoc:
+    "#<#{self.class}:0x#{"%x" % self.object_id} @root=#{self.root.inspect} "+
+    "@href=#{self.href.inspect} @loaded=#{self.loaded} "+
+    "@namespace=#{self.namespace.inspect} ...>"
   end
 
+  ## +response_body+ is deprecated in favor of +response_object+.
+  def response_body; response_object end # :nodoc:
+
+
+  #######################################################################
+  ####   Underscored functions are not meant to be used outside of   ####
+  ####   HyperResource machinery.  You have been warned.             ####
+
+
+  ## Return a new HyperResource based on this object and a given href.
+  def _new_from_link(href) # :nodoc:
+    self.class.new(:root    => self.root,
+                   :auth    => self.auth,
+                   :headers => self.headers,
+                   :namespace => self.namespace,
+                   :href    => href)
+  end
+
+
   ## Returns the class into which the given response should be cast.
   ## If the object is not loaded yet, or if +opts[:namespace]+ is
   ## not set, returns +self+.
   ##
-  ## Otherwise, +get_response_class+ uses +get_response_data_type+ to
+  ## Otherwise, +_get_response_class+ uses +_get_response_data_type+ 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.get_response_class(response, namespace)
+  def self._get_response_class(response, namespace) # :nodoc:
     if self.to_s == 'HyperResource'
       return self unless namespace
     end
 
     namespace ||= self.to_s
 
-    type_name = self.get_response_data_type(response)
+    type_name = self._get_response_data_type(response)
     return self unless type_name
 
     class_name = "#{namespace}::#{type_name}"
@@ -216,11 +232,12 @@ public
     eval(class_name)
   end
 
-
-  def get_response_data_type
-    self.class.get_response_data_type(self.response)
+  def _get_response_class # :nodoc:
+    self.namespace ||= self.class.to_s unless self.class.to_s=='HyperResource'
+    self.class._get_response_class(self.response, self.namespace)
   end
 
+
   ## Inspects the given response, and returns a string describing this
   ## resource's data type.
   ##
@@ -229,48 +246,31 @@ public
   ##
   ## Override this method in a subclass to alter HyperResource's behavior.
 
-  def self.get_response_data_type(response)
+  def self._get_response_data_type(response) # :nodoc:
     return nil unless response
     return nil unless content_type = response['content-type']
     return nil unless m=content_type.match(/;\s* type=(?<type> [0-9A-Za-z:]+)/x)
     m[:type][0].upcase + m[:type][1..-1]
   end
 
-
-
-  ## Returns the first object in the first collection of objects embedded
-  ## in this resource.  Equivalent to +self.objects.first+.
-  def first; self.objects.first end
-
-  ## Returns the *i*th object in the first collection of objects embedded
-  ## in this resource.  Equivalent to +self.objects[i]+.
-  def [](i); self.objects.ith(i) end
-
-  ## method_missing will load this resource if not yet loaded, then 
-  ## attempt to delegate to +attributes+, then +objects+, then +links+.
-  def method_missing(method, *args)
-    self.get unless self.loaded
-
-    method = method.to_s
-    if method[-1] == '='
-      return attributes[method[0..-2]] = args.first if attributes[method[0..-2]]
-    else
-      return attributes[method] if attributes && attributes[method]
-      return objects[method] if objects && objects[method]
-      return links[method] if links && links[method]
-    end
-
-    raise NoMethodError, "undefined method `#{method}' for #{self.inspect}"
+  def _get_response_data_type # :nodoc:
+    self.class._get_response_data_type(self.response)
   end
 
+private
 
-  def inspect # :nodoc:
-    "#<#{self.class}:0x#{"%x" % self.object_id} @root=#{self.root.inspect} "+
-    "@href=#{self.href.inspect} @loaded=#{self.loaded} "+
-    "@namespace=#{self.namespace.inspect} ...>"
+  ## Return this object, "cast" into its proper response class.
+  def to_response_class # :nodoc:
+    response_class = self._get_response_class
+    return self if self.class == response_class
+    response_class.new(self)
   end
 
-  ## +response_body+ is deprecated in favor of +response_object+.
-  def response_body; response_object end
+  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.response_object, self)
+  end
 
 end

data/lib/hyper_resource/adapter/hal_json.rb

@@ -58,7 +58,7 @@ class HyperResource
 
         def apply_links(resp, rsrc)
           return unless resp['_links']
-          rsrc.links = rsrc.get_response_class::Links.new(rsrc)
+          rsrc.links = rsrc._get_response_class::Links.new(rsrc)
           links = rsrc.links
 
           resp['_links'].each do |rel, link_spec|
@@ -80,7 +80,7 @@ class HyperResource
 
 
         def apply_attributes(resp, rsrc)
-          rsrc.attributes = rsrc.get_response_class::Attributes.new(rsrc)
+          rsrc.attributes = rsrc._get_response_class::Attributes.new(rsrc)
 
           given_attrs = resp.reject{|k,v| %w(_links _embedded).include?(k)}
           filtered_attrs = rsrc.incoming_body_filter(given_attrs)

data/lib/hyper_resource/modules/http.rb

@@ -2,62 +2,65 @@ require 'faraday'
 require 'uri'
 require 'json'
 
-module HyperResource::Modules::HTTP
-
-  ## Loads and returns the resource pointed to by +href+.  The returned
-  ## resource will be blessed into its "proper" class, if
-  ## +self.class.namespace != nil+.
-  def get
-    self.response = faraday_connection.get(self.href || '')
-    finish_up
-  end
+module HyperResource::Modules
+  module HTTP
 
-  ## Returns a per-thread Faraday connection for this object.
-  def faraday_connection(url=nil)
-    url ||= self.root
-    key = "faraday_connection_#{url}"
-    return Thread.current[key] if Thread.current[key]
-
-    fc = Faraday.new(:url => url)
-    fc.headers.merge!('User-Agent' => "HyperResource #{HyperResource::VERSION}")
-    fc.headers.merge!(self.headers || {})
-    if ba=self.auth[:basic]
-      fc.basic_auth(*ba)
+    ## Loads and returns the resource pointed to by +href+.  The returned
+    ## resource will be blessed into its "proper" class, if
+    ## +self.class.namespace != nil+.
+    def get
+      self.response = faraday_connection.get(self.href || '')
+      finish_up
     end
-    Thread.current[key] = fc
-  end
 
-private
-
-  def finish_up
-    begin
-      self.response_object = self.adapter.deserialize(self.response.body)
-    rescue Exception => e
-      raise HyperResource::ResponseError.new(
-        "Error when deserializing response body",
-        :response => self.response,
-        :cause => e
-      )
+    ## Returns a per-thread Faraday connection for this object.
+    def faraday_connection(url=nil)
+      url ||= self.root
+      key = "faraday_connection_#{url}"
+      return Thread.current[key] if Thread.current[key]
+
+      fc = Faraday.new(:url => url)
+      fc.headers.merge!('User-Agent' => "HyperResource #{HyperResource::VERSION}")
+      fc.headers.merge!(self.headers || {})
+      if ba=self.auth[:basic]
+        fc.basic_auth(*ba)
+      end
+      Thread.current[key] = fc
     end
 
-    self.adapter.apply(self.response_object, self)
-    self.loaded = true
-
-    status = self.response.status
-    if status / 100 == 2
-      return self.to_response_class
-    elsif status / 100 == 3
-      ## TODO redirect logic?
-    elsif status / 100 == 4
-      raise HyperResource::ClientError.new(status.to_s,
-                                           :response => self.response)
-    elsif status / 100 == 5
-      raise HyperResource::ServerError.new(status.to_s,
-                                           :response => self.response)
-    else ## 1xx? really?
-      raise HyperResource::ResponseError.new("Got status #{status}, wtf?",
+  private
+
+    def finish_up
+      begin
+        self.response_object = self.adapter.deserialize(self.response.body)
+      rescue Exception => e
+        raise HyperResource::ResponseError.new(
+          "Error when deserializing response body",
+          :response => self.response,
+          :cause => e
+        )
+      end
+
+      self.adapter.apply(self.response_object, self)
+      self.loaded = true
+
+      status = self.response.status
+      if status / 100 == 2
+        return to_response_class
+      elsif status / 100 == 3
+        ## TODO redirect logic?
+      elsif status / 100 == 4
+        raise HyperResource::ClientError.new(status.to_s,
+                                             :response => self.response)
+      elsif status / 100 == 5
+        raise HyperResource::ServerError.new(status.to_s,
                                              :response => self.response)
+      else ## 1xx? really?
+        raise HyperResource::ResponseError.new("Got status #{status}, wtf?",
+                                               :response => self.response)
+      end
     end
-  end
 
+  end
 end
+

data/lib/hyper_resource/version.rb

@@ -1,4 +1,4 @@
 class HyperResource
-  VERSION = '0.1.9.2'
-  VERSION_DATE = '2013-09-27'
+  VERSION = '0.1.9.3'
+  VERSION_DATE = '2013-10-02'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hyperresource
 version: !ruby/object:Gem::Version
-  version: 0.1.9.2
+  version: 0.1.9.3
 platform: ruby
 authors:
 - Pete Gamache
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-27 00:00:00.000000000 Z
+date: 2013-10-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: uri_template
@@ -80,6 +80,20 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: 0.13.3
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.4.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.4.0
 description: |2
       HyperResource is a hypermedia client library for Ruby.  Its goals are to
       interface directly with well-behaved hypermedia APIs, to allow the data