hyperresource 0.1.3 → 0.1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 36d09dbfdb629e25916386e38aec9638a5c92c55
-  data.tar.gz: 0432b16c0fe0f5891f4c4efc559ce833f9ee148c
+  metadata.gz: 4befe203aa8c4fc93c4ba6d09c03bcc9d76a2183
+  data.tar.gz: 1deed89d174bd9ac761763a731d69c06b70eb318
 SHA512:
-  metadata.gz: 2c3c9eb9d046bab3122d84be8e40905ccdfe84da104da78458dd44d853f64261410198ad33d6e695ee3c6c2aa8acf20244c94f2a239467354a908e93b5be6891
-  data.tar.gz: bc7f063ff01e95bd16cf246584c650b8456637ab0ff6d58bc5034834912382bddbeaec04f9a46fc4574dd5bf5b85ea8b55a69af198fe81d98c34d9e163e08c17
+  metadata.gz: 4122f5fb687c63252bb05724cc8477c4ae64f3f72a2340af09e21d070066165591292ad6756c16c27381eb6aff43c6ea294ae88d482f5e8520fc9c4adb4adfef
+  data.tar.gz: e5170d246d1642ce97b5cdb312d47d1a3af99c462ca16116a146af39d1dd54e95e91313226d79853a4d115cf102d1fa55183d8e2a567cf48ae2f66575ae3fa44

data/lib/hyper_resource.rb

@@ -8,31 +8,57 @@ require 'hyper_resource/exceptions'
 
 require 'hyper_resource/modules/utils'
 require 'hyper_resource/modules/http'
-require 'hyper_resource/modules/bless'
+
+require 'hyper_resource/adapter'
+require 'hyper_resource/adapter/hal_json'
 
 require 'pp'
 
+## TODO:
+## incoming_filter, outgoing_filter
+## as_json, to_json (in adapter?)
+## save, update, create, delete
+
 class HyperResource
   include HyperResource::Modules::Utils
   include HyperResource::Modules::HTTP
-  include HyperResource::Modules::Bless
 
 private
 
   def self._hr_class_attributes
-    %w( root auth headers namespace ).map(&:to_sym)
+    [ :root,             ## e.g. 'https://example.com/api/v1'
+      :auth,             ## e.g. {:basic => ['username', 'password']}
+      :headers,          ## e.g. {'Accept' => 'application/vnd.example+json'}
+      :namespace,        ## e.g. 'ExampleAPI', or the class ExampleAPI itself
+      :adapter           ## subclass of HR::Adapter
+    ]
   end
 
   def self._hr_attributes
-    %w( root href auth headers namespace
-        request response response_body
-        attributes links objects loaded).map(&:to_sym)
+    [ :root,
+      :href,
+      :auth,
+      :headers,
+      :namespace,
+      :adapter,
+
+      :request,
+      :response,
+      :response_object,
+
+      :attributes,
+      :links,
+      :objects,
+
+      :loaded
+    ]
   end
 
 public
 
-  _hr_class_attributes.each {|attr| class_attribute attr}
-  _hr_attributes.each       {|attr| attr_accessor   attr}
+  _hr_class_attributes.each                    {|attr| class_attribute    attr}
+  (_hr_attributes & _hr_class_attributes).each {|attr| fallback_attribute attr}
+  (_hr_attributes - _hr_class_attributes).each {|attr| attr_accessor      attr}
 
   # :nodoc:
   DEFAULT_HEADERS = {
@@ -53,10 +79,7 @@ public
   ## [headers] Headers to send along with requests for this resource (as
   ##           well as its eventual child resources, if any).
   def initialize(opts={})
-    if opts.is_a?(HyperResource)
-      self.class._hr_attributes.each {|attr| self.send("#{attr}=".to_sym, opts.send(attr))}
-      return
-    end
+    return init_from_resource(opts) if opts.kind_of?(HyperResource)
 
     self.root       = opts[:root] || self.class.root
     self.href       = opts[:href] || ''
@@ -65,54 +88,141 @@ public
     self.headers    = DEFAULT_HEADERS.merge(self.class.headers || {}).
                                       merge(opts[:headers]     || {})
 
-    self.attributes = Attributes.new(self)
-    self.links      = Links.new(self)
-    self.objects    = Objects.new(self)
+    ## There's a little acrobatics in getting Attributes, Links, and Objects
+    ## into the correct subclass.
+    if self.class != HyperResource
+      if self.class::Attributes == HyperResource::Attributes
+        Object.module_eval(
+          "class #{self.class}::Attributes < HyperResource::Attributes; end"
+        )
+      end
+      if self.class::Links == HyperResource::Links
+        Object.module_eval(
+          "class #{self.class}::Links < HyperResource::Links; end"
+        )
+      end
+      if self.class::Objects == HyperResource::Objects
+        Object.module_eval(
+          "class #{self.class}::Objects < HyperResource::Objects; end"
+        )
+      end
+    end
+
+    self.attributes = self.class::Attributes.new(self)
+    self.links      = self.class::Links.new(self)
+    self.objects    = self.class::Objects.new(self)
+
     self.loaded     = false
+
+    self.adapter    = opts[:adapter] || self.class.adapter ||
+                      HyperResource::Adapter::HAL_JSON
   end
 
-  ## Returns a new HyperResource based on the given HyperResource object.
-  def new_from_resource(rsrc); self.class.new_from_resource(rsrc) end
-  def self.new_from_resource(rsrc)
-    new_rsrc = self.new 
-    _hr_attributes.each do |attr|
-      new_rsrc.send("#{attr}=".to_sym, rsrc.send(attr))
+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
-    new_rsrc
+    self.adapter.apply(self.response_object, self)
   end
 
-  ## Returns a new HyperResource based on the given HAL document.
-  def new_from_hal(obj)
-    rsrc = self.class.new(:root    => self.root,
-                          :auth    => self.auth,
-                          :headers => self.headers,
-                          :namespace => self.namespace,
-                          :href    => obj['_links']['self']['href'])
-    rsrc.response_body = Response[obj]
-    rsrc.init_from_response_body!
-    rsrc
+public
+
+  def changed?(*args)
+    attributes.changed?(*args)
   end
 
   ## Returns a new HyperResource based on the given link href.
-  def new_from_link(href)
-    rsrc = self.class.new(:root    => self.root,
-                          :auth    => self.auth,
-                          :headers => self.headers,
-                          :namespace => self.namespace,
-                          :href    => 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
+
+  def incoming_filter(attr_hash)
+    attr_hash
+  end
+
+  def outgoing_filter(attr_hash)
+    attr_hash
+  end
+
+  def get_response_class
+    self.namespace ||= self.class.to_s unless self.class.to_s=='HyperResource'
+    self.class.get_response_class(self.response, self.namespace)
+  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
+  ## 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)
+    if self.to_s == 'HyperResource'
+      return self unless namespace
+    end
+
+    namespace ||= self.to_s
+
+    type_name = self.get_response_data_type(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 get_response_data_type
+    self.class.get_response_data_type(self.response)
   end
 
-  ## Populates +attributes+, +links+, and +objects+ from the contents of
-  ## +response+. Sets +loaded = true+.
-  def init_from_response_body!
-    return unless self.response_body
-    self.objects.   init_from_hal(self.response_body);
-    self.links.     init_from_hal(self.response_body);
-    self.attributes.init_from_hal(self.response_body);
-    self.loaded = true
-    self
+  ## Inspects the given 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_response_data_type(response)
+    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
@@ -122,27 +232,20 @@ public
   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+.  When it finds a match, it will define a method class-wide
-  ## if self.class != HyperResource, instance-wide otherwise.
+  ## attempt to delegate to +attributes+, then +objects+, then +links+.
   def method_missing(method, *args)
     self.get unless self.loaded
 
-    [:attributes, :objects, :links].each do |field|
-      if self.send(field).respond_to?(method)
-        if self.class == HyperResource
-          define_singleton_method(method) do |*args|
-            self.send(field).send(method, *args)
-          end
-        else
-          self.class.send(:define_method, method) do |*args|
-            self.send(field).send(method, *args)
-          end
-        end
-        return self.send(field).send(method, *args)
-      end
+    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
-    super
+
+    raise NoMethodError, "undefined method `#{method}' for #{self.inspect}"
   end
 
 
@@ -152,4 +255,7 @@ public
     "@namespace=#{self.namespace.inspect} ...>"
   end
 
+  ## +response_body+ is deprecated in favor of +response_object+.
+  def response_body; response_object end
+
 end

data/lib/hyper_resource/adapter.rb

@@ -0,0 +1,26 @@
+class HyperResource
+  class Adapter
+    class << self
+
+      ## Serialize the object into a string.
+      def serialize(object)
+        raise NotImplementedError, "This is an abstract method -- subclasses "+
+          "of HyperResource::Adapter must implement it."
+      end
+
+      ## Deserialize a string into an object.
+      def deserialize(string)
+        raise NotImplementedError, "This is an abstract method -- subclasses "+
+          "of HyperResource::Adapter must implement it."
+      end
+
+      ## Apply a response object (generally parsed JSON or XML) to the given
+      ## HyperResource object.  Returns the updated resource.
+      def apply(object, resource, opts={})
+        raise NotImplementedError, "This is an abstract method -- subclasses "+
+          "of HyperResource::Adapter must implement it."
+      end
+
+    end
+  end
+end

data/lib/hyper_resource/adapter/hal_json.rb

@@ -0,0 +1,97 @@
+require 'json'
+
+class HyperResource
+  class Adapter
+    class HAL_JSON < Adapter
+      class << self
+
+        def serialize(object)
+          JSON.dump(object)
+        end
+
+        def deserialize(string)
+          JSON.parse(string)
+        end
+
+        def apply(response, resource, opts={})
+          if !response.kind_of?(Hash)
+            raise ArgumentError, "'response' argument must be a Hash"
+          end
+          if !resource.kind_of?(HyperResource)
+            raise ArgumentError, "'resource' argument must be a HyperResource"
+          end
+
+          apply_objects(response, resource)
+          apply_links(response, resource)
+          apply_attributes(response, resource)
+          resource.loaded = true
+          resource.href = response['_links']['self']['href'] rescue nil
+          resource
+        end
+
+
+      private
+
+        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
+              r.response_object = collection
+              objs[name] = apply(collection, r)
+            else
+              objs[name] = collection.map do |obj|
+                r = rc.new
+                r.response_object = obj
+                apply(obj, r)
+              end
+            end
+          end
+
+          objs.create_methods!
+        end
+
+
+        def apply_links(resp, rsrc)
+          return unless resp['_links']
+          rsrc.links = rsrc.get_response_class::Links.new(rsrc)
+          links = rsrc.links
+
+          resp['_links'].each do |rel, 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.create_methods!
+        end
+
+        def new_link_from_spec(resource, link_spec) # :nodoc:
+          resource.class::Link.new(resource, link_spec)
+        end
+
+
+        def apply_attributes(resp, rsrc)
+          rsrc.attributes = rsrc.get_response_class::Attributes.new(rsrc)
+          attrs = rsrc.attributes
+
+          (resp.keys - ['_links', '_embedded']).map(&:to_s).each do |attr|
+            attrs[attr] = resp[attr]
+          end
+
+          attrs.create_methods!
+        end
+
+      end
+    end
+  end
+end
+

data/lib/hyper_resource/attributes.rb

@@ -1,27 +1,85 @@
-class HyperResource::Attributes < Hash
-  attr_accessor :parent_resource
+class HyperResource
+  class Attributes < Hash
 
-  def initialize(resource=nil)
-    self.parent_resource = resource || HyperResource.new
-  end
+    attr_accessor :_resource # :nodoc:
 
-  ## Initialize attributes from a HAL response.
-  def init_from_hal(hal_resp)
-    (hal_resp.keys - ['_links', '_embedded']).map(&:to_s).each do |attr|
-      self[attr] = hal_resp[attr]
+    def initialize(resource=nil) # :nodoc:
+      self._resource = resource || HyperResource.new
+    end
 
-      unless self.respond_to?(attr.to_sym)
-        define_singleton_method(attr.to_sym)       {    self[attr]  }
-        define_singleton_method("#{attr}=".to_sym) {|v| self[attr]=v}
-      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 create_methods!(opts={})
+      return if self.class.to_s == 'HyperResource::Attributes' ||
+                self._resource.class.to_s == 'HyperResource'
+
+      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
 
-      unless self.parent_resource.respond_to?(attr.to_sym)
-        self.parent_resource.define_singleton_method(attr.to_sym) {
-          self.attributes[attr]}
-        self.parent_resource.define_singleton_method("#{attr}=".to_sym) do |v|
-          self.attributes[attr] = v
+        ## 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
+    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
+    ## changed.
+    def changed?(attr=nil)
+      @_hr_changed ||= Hash.new(false)
+      return @_hr_changed[attr.to_sym] if attr
+      return @_hr_changed.keys.count > 0
+    end
+
+    def []=(attr, value) # :nodoc:
+      _hr_mark_changed(attr)
+      super(attr.to_s, value)
+    end
+
+    def [](key) # :nodoc:
+      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) # :nodoc:
+      return self[method] if self[method]
+      raise NoMethodError, "undefined method `#{method}' for #{self.inspect}"
+    end
+
+  private
+
+    def _hr_mark_changed(attr, is_changed=true) # :nodoc:
+      attr = attr.to_sym
+      @_hr_changed ||= Hash.new(false)
+      @_hr_changed[attr] = is_changed
+    end
+
+    def _hr_clear_changed
+      @_hr_changed = nil
     end
+
   end
 end
+

data/lib/hyper_resource/exceptions.rb

@@ -1,9 +1,12 @@
 class HyperResource::Exception < Exception
 end
 
-class HyperResource::ClientError < HyperResource::Exception
+class HyperResource::ResponseError < HyperResource::Exception
 end
 
-class HyperResource::ServerError < HyperResource::Exception
+class HyperResource::ClientError < HyperResource::ResponseError
+end
+
+class HyperResource::ServerError < HyperResource::ResponseError
 end
 

data/lib/hyper_resource/link.rb

@@ -2,6 +2,7 @@ require 'uri_template'
 
 class HyperResource::Link
   attr_accessor :base_href,
+                :name,
                 :templated,
                 :params,
                 :parent_resource
@@ -11,6 +12,7 @@ class HyperResource::Link
   def initialize(resource=nil, link_spec={})
     self.parent_resource = resource || HyperResource.new
     self.base_href = link_spec['href']
+    self.name = link_spec['name']
     self.templated = !!link_spec['templated']
     self.params    = link_spec['params'] || {}
   end
@@ -29,13 +31,14 @@ class HyperResource::Link
   def where(params)
     self.class.new(self.parent_resource,
                    'href' => self.base_href,
+                   'name' => self.name,
                    'templated' => self.templated,
                    'params' => self.params.merge(params))
   end
 
   ## Returns a HyperResource representing this link
   def resource
-    parent_resource.new_from_link(self.href)
+    parent_resource._new_from_link(self.href)
   end
 
   ## Returns a HyperResource representing this link, and fetches it.

data/lib/hyper_resource/links.rb

@@ -1,35 +1,53 @@
 class HyperResource
   class Links < Hash
-    attr_accessor :resource
+    attr_accessor :_resource
 
     def initialize(resource=nil)
-     self.resource = resource || HyperResource.new
+     self._resource = resource || HyperResource.new
     end
 
-    # Initialize links from a HAL response.
-    def init_from_hal(hal_resp)
-      return unless hal_resp['_links']
-      hal_resp['_links'].each do |rel, link_spec|
-        self[rel] = new_link_from_spec(link_spec)
-        create_methods_for_link_rel(rel) unless self.respond_to?(rel.to_sym)
+    ## Creates accessor methods in self.class and self._resource.class.
+    ## Protects against method creation into HyperResource::Links and
+    ## HyperResource classes.  Just subclasses, please!
+    def create_methods!(opts={})
+      return if self.class.to_s == 'HyperResource::Links' ||
+                self._resource.class.to_s == 'HyperResource'
+
+      self.keys.each do |attr|
+        attr_sym = attr.to_sym
+
+        self.class.send(:define_method, attr_sym) do |*args|
+          if args.count > 0
+            self[attr].where(*args)
+          else
+            self[attr]
+          end
+        end
+
+        ## Don't stomp on _resource's methods
+        unless _resource.respond_to?(attr_sym)
+          _resource.class.send(:define_method, attr_sym) do |*args|
+            links.send(attr_sym, *args)
+          end
+        end
       end
     end
 
-  protected
+    def []=(attr, value) # :nodoc:
+      super(attr.to_s, value)
+    end
 
-    def new_link_from_spec(link_spec) # :nodoc:
-      HyperResource::Link.new(resource, link_spec)
+    def [](key) # :nodoc:
+      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 create_methods_for_link_rel(rel) # :nodoc:
-      link = self[rel]
-      define_singleton_method(rel.to_sym) do |*args|
-        return link if args.empty?
-        link.where(*args)
-      end
+    def method_missing(method, *args) # :nodoc:
+      return self[method] if self[method]
+      raise NoMethodError, "undefined method `#{method}' for #{self.inspect}"
     end
 
   end
 end
 
-

data/lib/hyper_resource/modules/http.rb

@@ -30,11 +30,13 @@ module HyperResource::Modules::HTTP
 private
 
   def finish_up
+    self.loaded = true
+    self.response_object = self.adapter.deserialize(self.response.body)
+    self.adapter.apply(self.response_object, self)
+
     status = self.response.status
     if status / 100 == 2
-      self.response_body = JSON.parse(self.response.body)
-      self.init_from_response_body!
-      self.blessed
+      return self.to_response_class
     elsif status / 100 == 3
       ## TODO redirect logic?
     elsif status / 100 == 4
@@ -42,7 +44,7 @@ private
     elsif status / 100 == 5
       raise HyperResource::ServerError, status.to_s
     else ## 1xx? really?
-      raise HyperResource::Exception, "Got status #{status}, wtf?"
+      raise HyperResource::ResponseError, "Got status #{status}, wtf?"
     end
   end
 

data/lib/hyper_resource/modules/utils.rb

@@ -23,6 +23,22 @@ module HyperResource::Modules
         end
       end
 
+      ## Instance attributes which fall back to class attributes.
+      def fallback_attribute(*names)
+        names.map(&:to_sym).each do |name|
+          class_eval <<-EOT
+            def #{name}=(val)
+              @#{name} = val
+            end
+            def #{name}
+              return @#{name} if defined?(@#{name})
+              return self.class.#{name} if self.class.respond_to?(:#{name})
+              nil
+            end
+          EOT
+        end
+      end
+
     end # module ClassMethods
 
   end

data/lib/hyper_resource/objects.rb

@@ -1,33 +1,59 @@
-class HyperResource::Objects < Hash
-  attr_accessor :parent_resource
-  def initialize(parent_resource=nil)
-    self.parent_resource = parent_resource || HyperResource.new
-  end
-  def init_from_hal(hal_resp)
-    return unless hal_resp['_embedded']
-    hal_resp['_embedded'].each do |name, collection|
-      self[name] = collection.map do |obj|
-        self.parent_resource.new_from_hal(obj)
-      end
-      unless self.respond_to?(name.to_sym)
-        define_singleton_method(name.to_sym) { self[name] }
-      end
-      unless self.parent_resource.respond_to?(name.to_sym)
-        self.parent_resource.define_singleton_method(name.to_sym) do
-          self.objects[name]
+class HyperResource
+  class Objects < Hash
+    attr_accessor :_resource
+
+    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::Objects and
+    ## HyperResource classes.  Just subclasses, please!
+    def create_methods!(opts={})
+      return if self.class.to_s == 'HyperResource::Objects' ||
+                self._resource.class.to_s == 'HyperResource'
+
+      self.keys.each do |attr|
+        attr_sym = attr.to_sym
+
+        self.class.send(:define_method, attr_sym) do
+          self[attr]
+        end
+
+        ## Don't stomp on _resource's methods
+        unless _resource.respond_to?(attr_sym)
+          _resource.class.send(:define_method, attr_sym) do
+            objects.send(attr_sym)
+          end
         end
       end
     end
-  end
 
-  ## Returns the first item in the first collection in +self+.
-  alias_method :first_orig, :first
-  def first
-    self.first_orig[1][0] rescue caller
-  end
+    ## Returns the first item in the first collection in +self+.
+    alias_method :first_orig, :first
+    def first
+      self.first_orig[1][0] rescue caller
+    end
+
+    ## Returns the ith item in the first collection in +self+.
+    def ith(i)
+      self.first_orig[1][i] rescue caller
+    end
+
+    def []=(attr, value) # :nodoc:
+      super(attr.to_s, value)
+    end
+
+    def [](key) # :nodoc:
+      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) # :nodoc:
+      return self[method] if self[method]
+      raise NoMethodError, "undefined method `#{method}' for #{self.inspect}"
+    end
 
-  ## Returns the ith item in the first collection in +self+.
-  def ith(i)
-    self.first_orig[1][i] rescue caller
   end
 end

data/lib/hyper_resource/version.rb

@@ -1,4 +1,4 @@
 class HyperResource
-  VERSION = '0.1.3'
-  VERSION_DATE = '2013-04-22'
+  VERSION = '0.1.9'
+  VERSION_DATE = '2013-09-27'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hyperresource
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.9
 platform: ruby
 authors:
 - Pete Gamache
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-22 00:00:00.000000000 Z
+date: 2013-09-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: uri_template
@@ -90,18 +90,19 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/hyperresource.rb
-- lib/hyper_resource.rb
+- lib/hyper_resource/adapter/hal_json.rb
+- lib/hyper_resource/adapter.rb
+- lib/hyper_resource/attributes.rb
+- lib/hyper_resource/exceptions.rb
 - lib/hyper_resource/link.rb
 - lib/hyper_resource/links.rb
-- lib/hyper_resource/exceptions.rb
-- lib/hyper_resource/version.rb
-- lib/hyper_resource/objects.rb
-- lib/hyper_resource/attributes.rb
-- lib/hyper_resource/modules/utils.rb
 - lib/hyper_resource/modules/http.rb
-- lib/hyper_resource/modules/bless.rb
+- lib/hyper_resource/modules/utils.rb
+- lib/hyper_resource/objects.rb
 - lib/hyper_resource/response.rb
+- lib/hyper_resource/version.rb
+- lib/hyper_resource.rb
+- lib/hyperresource.rb
 homepage: https://github.com/gamache/hyperresource
 licenses:
 - MIT
@@ -127,3 +128,4 @@ signing_key:
 specification_version: 4
 summary: Extensible hypermedia client for Ruby
 test_files: []
+has_rdoc: true

data/lib/hyper_resource/modules/bless.rb

@@ -1,57 +0,0 @@
-module HyperResource::Modules::Bless
-
-  ## Returns this resource as an instance of +self.resource_class+.
-  ## The returned object will share structure with the source object;
-  ## beware.
-  def blessed
-    return self unless self.namespace
-    self.resource_class.new(self)
-  end
-
-  ## Returns the class into which this resource should be cast.
-  ## If the object is not loaded yet, or if +self.namespace+ is
-  ## not set, returns +self.class+.
-  ##
-  ## Otherwise, +resource_class+ looks at the returned content-type, and 
-  ## attempts to match a 'type=...' modifier.  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 resource_class
-    return self.class unless self.namespace
-    return self.class unless type_name = self.data_type_name
-    class_name = "#{self.namespace}::#{type_name}".
-                   gsub(/[^_0-9A-Za-z:]/, '')
-
-    ## 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 self.namespace != ''
-      nsc = eval(self.namespace) rescue :bzzzzzt
-      unless nsc.is_a?(Class)
-        Object.module_eval "class #{self.namespace} < #{self.class}; end"
-      end
-    end
-    Object.module_eval "class #{class_name} < #{self.namespace}; end"
-    eval(class_name)
-  end
-
-  ## Inspects the 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+.  Override this method in a 
-  ## HyperResource subclass in order to implement different data type
-  ## detection.
-  def data_type_name
-    return nil unless self.response
-    return nil unless content_type = self.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
-
-
-end