resto 0.0.9 → 0.1.0

data/lib/resto.rb

@@ -180,7 +180,7 @@ module Resto
     end
 
     def request
-      Extra::Copy.request_base(@request)
+      Copy.request_base(@request)
     end
 
     def response(response)
@@ -188,7 +188,7 @@ module Resto
     end
 
     def base_response
-      Extra::Copy.response_base(@response)
+      Copy.response_base(@response)
     end
 
     def property_handler

data/lib/resto/extra/assert_hash.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+module Resto
+
+  # @note This class is only used internally.
+  #
+  # AssertHash validates that a Hash only contain valid keys. The purpose
+  # is to assert that methods are used with correct arguments.
+  class AssertHash
+
+    # Asserts that keys in the Hash is valid. It also converts
+    # String keys to Symbol keys.
+    #
+    # === Examples:
+    #  hash = { :valid => 'I am valid' }
+    #  AssertHash.keys(hash, :valid)
+    #   # => { :valid => 'I am valid'}
+    #
+    #  hash = { 'valid' => 'I am valid' }
+    #  AssertHash.keys(hash, :valid)
+    #   # => { :valid => 'I am valid'}
+    #
+    #  hash = { :invalid => 'I am invalid' }
+    #  AssertHash.keys(hash, :valid)
+    #   # => raises ArgumentError
+    #
+    # @param hash [Hash]
+    # @param *valid_keys [Symbol, Symbol, ...]
+    #
+    # @return [Hash] string keys are converted to their corresponding Symbols.
+    #
+    # @raise [ArgumentError] if the Hash contains unknown key(s).
+    def self.keys(hash, *valid_keys)
+      hash ||= {}
+
+      hash.each { |key, value| hash[key.to_sym] = hash.delete(key) }
+
+      known_keys = [valid_keys].flatten
+      unknown_keys = hash.keys - known_keys
+      unless unknown_keys.empty?
+        unknown = "Invalid key(s): #{unknown_keys.join(", ")}"
+        known = "Valid key(s): #{known_keys.join(", ")}"
+        raise(ArgumentError, "#{unknown} \n #{known}")
+      end
+
+      hash
+    end
+  end
+end

data/lib/resto/extra/copy.rb

@@ -4,30 +4,55 @@ require 'resto/request/base'
 require 'resto/response/base'
 
 module Resto
-  module Extra
-    module Copy
 
-      def self.request_base(request_base)
-        Resto::Request::Base.new.tap do |copy|
-          copy_instance_variables(request_base, copy, ["@request"])
+  # @note This module is used internally by these classes/modules:
+  #  Resto::ClassMethods (see method {Resto::ClassMethods#request}, and
+  #  {Resto::ClassMethods#base_response}). Resto::Request::Base
+  #  (see method {Resto::Request::Base#construct_path}).
+  #
+  # This module has two helper methods that handles the process of copying the
+  # {Resto::Request::Base} object and {Resto::Response::Base} object correctly.
+  module Copy
 
-          request_klass = request_base.instance_variable_get("@request_klass")
-          copy.instance_variable_set("@request", request_klass.new(copy))
-        end
+    # Returns a copy of the {Resto::Request::Base} object.
+    #
+    # === Examples:
+    #   Copy.request_base(request)
+    #    # => new_request
+    #
+    # @param request_base [Request::Base]
+    #
+    # @return [Request::Base]
+    def self.request_base(request_base)
+      Resto::Request::Base.new.tap do |copy|
+        copy_instance_variables(request_base, copy, ["@request"])
+
+        request_klass = request_base.instance_variable_get("@request_klass")
+        copy.instance_variable_set("@request", request_klass.new(copy))
       end
+    end
 
-      def self.response_base(response_base)
-        Resto::Response::Base.new.tap do |copy|
-          copy_instance_variables(response_base, copy, ["@response"])
-        end
+
+    # Returns a copy of the {Resto::Response::Base} object.
+    #
+    # === Examples:
+    #   Copy.response_base(response)
+    #    # => new_response
+    #
+    # @param response_base [Response::Base]
+    #
+    # @return [Response::Base]
+    def self.response_base(response_base)
+      Resto::Response::Base.new.tap do |copy|
+        copy_instance_variables(response_base, copy, ["@response"])
       end
+    end
 
-      def self.copy_instance_variables(from, to, exclude = [])
-        (from.instance_variables.map(&:to_s) - exclude).each do |name|
-          instance_variable = from.instance_variable_get(name)
+    def self.copy_instance_variables(from, to, exclude = [])
+      (from.instance_variables.map(&:to_s) - exclude).each do |name|
+        instance_variable = from.instance_variable_get(name)
 
-          to.instance_variable_set(name, instance_variable)
-        end
+        to.instance_variable_set(name, instance_variable)
       end
     end
   end

data/lib/resto/format.rb

@@ -6,15 +6,80 @@ require 'resto/format/json'
 require 'resto/format/xml'
 
 module Resto
+
+  # @note This module is only used internally by these classes/modules:
+  #  Resto::Request::Base (see method {Resto::Request::Header#format}).
+  #  Resto::Response::Base (see method {Resto::Response::Base#format}).
+  #
+  #== Add a Format
+  #
+  # If a user of Resto wants to handle a format different from whats
+  # available, she can create a class in the Format module. Then
+  # include the Format module into the meta class and override the methods
+  # that she wants to change. See example below.
+  #
+  # === Example:
+  #   module Resto
+  #     module Format
+  #       class Foo; end
+  #
+  #       class << Foo
+  #         include Format
+  #
+  #         def extension;         'foo'           end
+  #         def accept;            'foo';          end
+  #       end
+  #     end
+  #   end
+  #
+  #
   module Format
+
+    # Returns the class that corresponds to the symbol argument.
+    #
+    # === Examples:
+    #  Resto::Format.get(:json)
+    #   # => Resto::Format::Json
+    #
+    #  Resto::Format.get(:xml)
+    #   # => Resto::Format:Xml
+    #
+    # @param symbol [Symbol]
+    # @return [Format, #accept, #content_type, #decode, #encode, #extension]
+    #
+    # @raise [NameError] if the class doesn't exist.
     def self.get(symbol=:default)
-      format = Resto::Format.const_get("#{symbol.to_s.capitalize}")
+      Resto::Format.const_get("#{symbol.to_s.capitalize}")
     end
 
-    def extension;                         end
-    def accept;            '*/*';          end
-    def content_type;                      end
-    def encode(*args);    args.first       end
-    def decode(*args);    args.first       end
+    # The accept header. This method is overriden by the classes
+    # that includes this module if they want a different accept header.
+    #
+    # @return [String] "*/*"
+    def accept; '*/*'; end
+
+    # The content-type header. This method is overriden by the classes
+    # that includes this module if they want a different content-type header.
+    #
+    # @return [nil]
+    def content_type; end
+
+    # Returns the arguments as an Array. This method is overriden by classes
+    # that includes this module if they want a different behavior.
+    #
+    # @return [Array<Object>] the arguments as an Array.
+    def decode(*args); args end
+
+    # Returns the first argument. This method is overriden by classes that
+    # includes this module if they want a different behavior.
+    #
+    # @return [Object] the first argument.
+    def encode(*args); args.first end
+
+    # The extension. This method is overriden by the classes
+    # that includes this module if they want to have an extension.
+    #
+    # @return [nil]
+    def extension; end
   end
 end

data/lib/resto/format/default.rb

@@ -2,6 +2,12 @@
 
 module Resto
   module Format
+
+    # @note When no format is selected this class is used by the
+    #  {Request::Base} and {Response::Base} objects.
+    #
+    # This class includes the methods from the {Resto::Format} module without
+    # any change.
     class Default; end
 
     class << Default

data/lib/resto/format/json.rb

@@ -1,30 +1,74 @@
 # encoding: utf-8
 
-# http://en.wikipedia.org/wiki/JSON
 require 'yajl'
 
 module Resto
   module Format
+    # @note This class is only used internally by these classes/modules:
+    #  {Resto::Request::Base} (see method {Resto::Request::Header#formatter})
+    #  uses this class to create a valid JSON request. {Resto::Response::Base}
+    #  (see method {Resto::Response::Base#read_body})
+    #  uses this class to convert a JSON formatted String to a Hash.
     class Json; end
 
     class << Json
       include Format
+      # The accept header when sending JSON data.
+      #
+      # === Example:
+      #  headers["accept"] = Resto::Format::Json.accept
+      #
+      # @return [String] "application/json, */*"
+      def accept; 'application/json, */*'; end
 
-      def extension;       'json';                   end
-      def accept;          'application/json, */*';  end
-      def content_type;    'application/json';       end
+      # The content-type header when sending JSON data.
+      #
+      # === Example:
+      #  headers["content-type"] = Resto::Format::Json.content_type
+      #
+      # @return [String] "application/json"
+      def content_type; 'application/json'; end
 
+      # Converts a JSON formatted String to an Array of a Hashes.
+      #
+      # === Example:
+      #   Json.decode("{\"root\":{\"body\":\"I am a body\"}}")
+      #     # => [{ 'root': { 'body': 'I am a body' } }]
+      #
+      # @param json [String]
+      # @param options is not used.
+      #
+      # @return [Array<Hash>]
+      def decode(json, options=nil)
+        raise ArgumentError unless json.is_a?(String)
+
+        result = Yajl::Parser.parse(json)
+        result.is_a?(Array) ? result : [result].compact
+      end
+
+      # Converts a Hash to a JSON formatted String.
+      #
+      # @param hash [Hash]
+      # @param options is not used.
+      #
+      # === Example:
+      #   Json.encode({ root: { body: 'I am a body' } })
+      #     # => "{\"root\":{\"body\":\"I am a body\"}}"
+      #
+      # @return [String]
       def encode(hash, options = nil)
         raise ArgumentError unless hash.is_a?(Hash)
 
         Yajl::Encoder.encode(hash)
       end
 
-      def decode(json, options=nil)
-        raise ArgumentError unless json.is_a?(String)
-
-        Yajl::Parser.parse(json)
-      end
+      # The extension name used (if required) as the URL suffix.
+      #
+      # === Example:
+      #   http://myhost.com:8085/bamboo/rest/api/latest/plan.json
+      #
+      # @return [String] "json"
+      def extension; 'json'; end
     end
   end
 end

data/lib/resto/format/plain.rb

@@ -2,12 +2,28 @@
 
 module Resto
   module Format
+
+    # This class is used when sending plain text requests.
     class Plain; end
 
     class << Plain
       include Format
 
+      # The accept header when sending text data.
+      #
+      # === Example:
+      #  headers["accept"] = Resto::Format::Plain.accept
+      #
+      # @return [String] "text/plain, */*"
       def accept;        'text/plain, */*';   end
+
+
+      # The content-type header when sending text data.
+      #
+      # === Example:
+      #  headers["content-type"] = Resto::Format::Plain.content_type
+      #
+      # @return [String] "text/plain"
       def content_type;  'text/plain';        end
     end
   end

data/lib/resto/format/xml.rb

@@ -3,38 +3,87 @@
 # https://tools.ietf.org/html/rfc3023
 require 'resto/format'
 require 'nokogiri'
+require 'resto/extra/assert_hash.rb'
 
 module Resto
   module Format
+
+    # Used when sending and receiveing XML data.
     class Xml; end
 
     class << Xml
       include Format
 
-      def extension;       'xml';                           end
-      def accept;          'application/xml, */*';          end
-      def content_type;    'application/xml;charset=utf-8'; end
+      # The accept header when sending XML data.
+      #
+      # === Example:
+      #  headers["accept"] = Resto::Format::Xml.accept
+      #
+      # @return [String] "application/xml, */*"
+      def accept; 'application/xml, */*'; end
 
-      def encode(hash, options = nil)
-        Nokogiri::XML::Builder.new { |xml| to_xml(hash, xml) }.to_xml
-      end
+      # The content-type header when sending XML data.
+      #
+      # === Example:
+      #  headers["content-type"] = Resto::Format::Xml.content_type
+      #
+      # @return [String] "application/xml;charset=utf-8"
+      def content_type; 'application/xml;charset=utf-8'; end
 
-      def decode(xml, options)
-        xpath = options.fetch(:xpath)
+      # Converts an XML formatted String to an Array of Hashes.
+      #
+      # === Example:
+      #   xml = '<?xml version="1.0"?>
+      #          <user>
+      #            <name>Anders Törnqvist</name>
+      #          </user>'
+      #   Xml.decode(xml, :xpath => 'user')
+      #     # => [{ 'user': { 'name': 'Anders Törnqvist' } }]
+      #
+      # @param xml [String]
+      # @param [Hash] opts the options used when decoding the xml.
+      # @option opts [String] :xpath the xpath to where the elements are found.
+      #
+      # @return [Array<Hash>]
+      #
+      def decode(xml, opts)
+        xpath = AssertHash.keys(opts, :xpath).fetch(:xpath)
 
         doc =  Nokogiri::XML(xml)
         nodes =  doc.xpath(xpath)
 
         case nodes.size
         when 0
-          {}
+          [{}]
         when 1
-          elements_to_hash(nodes.first.children)
+          [elements_to_hash(nodes.first.children)]
         else
           nodes.map { |node| elements_to_hash(node.children) }
         end
       end
 
+      # Converts a Hash to a XML formatted String.
+      #
+      # @param hash [Hash]
+      # @param options is not used.
+      #
+      # === Example:
+      #   Xml.encode({ root: { body: 'I am a body' } })
+      #     # => "<?xml version=\"1.0\"?><root><body>I am a body</body></root>"
+      #
+      # @return [String]
+      def encode(hash, options = nil)
+        Nokogiri::XML::Builder.new { |xml| to_xml(hash, xml) }.to_xml
+      end
+
+      # The extension name used (if required) as the URL suffix.
+      #
+      # === Example:
+      #   http://myhost.com:8085/bamboo/rest/api/latest/plan.xml
+      #
+      # @return [String] "xml"
+      def extension; 'xml'; end
+
     private
 
       def elements_to_hash(children)

data/lib/resto/request/base.rb

@@ -1,23 +1,23 @@
 # encoding: utf-8
 
-require 'resto/extra/delegation'
+require 'forwardable'
+require 'resto/extra/copy'
 require 'resto/request/uri'
 require 'resto/request/header'
 require 'resto/request/option'
 require 'resto/request/factory'
 require 'resto/translator/request_factory'
-require 'resto/extra/copy'
 
 module Resto
   module Request
     class Base
-      extend  Resto::Extra::Delegation
+      extend Forwardable
       include Resto::Request::Header
       include Resto::Request::Uri
       include Resto::Request::Option
 
-      delegate   :head, :head!, :get, :get!, :post, :post!,
-                :put, :put!, :delete, :delete!, :to => :@request
+      def_delegators :@request, :head, :head!, :get, :get!, :post, :post!,
+                :put, :put!, :delete, :delete!
 
       def initialize(request=Resto::Request::Factory)
         @request_klass = request
@@ -31,7 +31,7 @@ module Resto
           new_path.gsub!(/:#{substitute}/, options[substitute].to_s)
         end
 
-        Extra::Copy.request_base(self).path(new_path)
+        Copy.request_base(self).path(new_path)
       end
 
       def url(url)
@@ -62,6 +62,11 @@ module Resto
       end
 
       def params(hash)
+        @params ||= {}
+        tap { @params.update(hash) }
+      end
+
+      def params!(hash)
         tap { @params = hash }
       end
 

data/lib/resto/request/factory.rb

@@ -1,16 +1,16 @@
 # encoding: utf-8
 
 require 'net/https'
-require 'resto/extra/delegation'
+require 'forwardable'
 
 module Resto
   module Request
     class Factory
-      extend Resto::Extra::Delegation
+      extend Forwardable
 
-      delegate :read_host, :read_port, :options, :read_body, :composed_path,
-        :composed_headers, :scheme, :use_ssl, :current_formatter,
-        :to => :@request
+      def_delegators :@request, :read_host, :read_port, :options, :read_body,
+                     :composed_path, :composed_headers, :scheme, :use_ssl,
+                     :current_formatter
 
       def initialize(request)
         @request = request

data/lib/resto/request/header.rb

@@ -1,15 +1,6 @@
 # encoding: utf-8
 require 'resto/format'
-
-require 'resto/extra/hash_args'
-class BasicAuth < Resto::Extra::HashArgs
-  key :username
-  key :password
-end
-
-class FormatExtension < Resto::Extra::HashArgs
-  key :extension
-end
+require 'resto/extra/assert_hash'
 
 module Resto
   module Request
@@ -20,8 +11,8 @@ module Resto
       end
 
       def formatter(formatter, options=nil)
-        @add_extension =
-          FormatExtension.new(options).fetch(:extension) { false }
+        options = AssertHash.keys(options, :extension)
+        @add_extension = options.fetch(:extension) { false }
         @formatter = formatter
         accept(formatter.accept)
         content_type(formatter.content_type)
@@ -44,7 +35,7 @@ module Resto
       end
 
       def basic_auth(options)
-        options = BasicAuth.new(options)
+        options = AssertHash.keys(options, :username, :password)
 
         username = options.fetch(:username)
         password = options.fetch(:password)

data/lib/resto/response/base.rb

@@ -63,7 +63,9 @@ module Resto
       def to_object
         return self unless @translator
 
-        @translator.call(@klass, read_body).tap do |instance|
+        body = read_body ? read_body.first : nil
+
+        @translator.call(@klass, body).tap do |instance|
           instance.response = self
         end
       end
@@ -71,9 +73,7 @@ module Resto
       def to_collection
         return self unless @translator
 
-        body = read_body.is_a?(Hash) ? [read_body] : read_body
-
-        (body || []).map do |hash|
+        (read_body || []).map do |hash|
           @translator.call(@klass, hash).tap do |instance|
             instance.response = self
           end

data/lib/resto/version.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
 
 module Resto
-  VERSION = "0.0.9"
+  VERSION = "0.1.0"
 end

data/resto.gemspec

@@ -1,6 +1,5 @@
 # encoding: utf-8
 
-
 require File.expand_path("../lib/resto/version", __FILE__)
 
 Gem::Specification.new do |s|
@@ -17,7 +16,7 @@ Gem::Specification.new do |s|
   s.required_rubygems_version = ">= 1.3.6"
   s.rubyforge_project         = "resto"
 
-  s.add_runtime_dependency "yajl-ruby", "0.8.2"
+  s.add_runtime_dependency "yajl-ruby", ">= 0.8.2"
   s.add_runtime_dependency "nokogiri", ">=1.4.4"
   # s.add_dependency "activesupport", "3.0.0" ???
   s.add_development_dependency "bundler", ">= 1.0.13"

data/spec/resto/extra/copy_spec.rb

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 require 'resto/extra/copy'
-describe Resto::Extra::Copy do
+describe Resto::Copy do
   describe ".request_base" do
     before do
       @request_base = Resto::Request::Base.new.port(40).
@@ -10,7 +10,7 @@ describe Resto::Extra::Copy do
         query('q=adam').
         path('contacts')
 
-      @new_request_base = Resto::Extra::Copy.request_base(@request_base).
+      @new_request_base = Resto::Copy.request_base(@request_base).
         url('http://new.se:99/other').
         query('q=not-same').
         path('other-contacts/').
@@ -47,7 +47,7 @@ describe Resto::Extra::Copy do
   describe ".response_base" do
     before do
       @response_base = Resto::Response::Base.new.format(:json)
-      @new_response_base = Resto::Extra::Copy.response_base(@response_base).
+      @new_response_base = Resto::Copy.response_base(@response_base).
         http_response('response')
     end
 

data/spec/resto/format/json_spec.rb

@@ -7,10 +7,16 @@ require 'yajl'
 describe "Resto::Format.get(:json)" do
   subject { Resto::Format.get(:json) }
 
-  its(:extension)      { should == 'json' }
   its(:accept)         { should == 'application/json, */*' }
   its(:content_type)   { should == 'application/json' }
 
+  describe '.decode(json)' do
+    json = Yajl::Encoder.encode( { :foo => 12425125, :bar => "some string" })
+    expected =  [{ 'foo' => 12425125, 'bar' => "some string" }]
+
+    it { subject.decode(json).should == expected }
+  end
+
   describe ".encode(hash)" do
     before { @result = subject.encode({ :bar => "some string",
                                         :foo => 12425125}) }
@@ -19,11 +25,5 @@ describe "Resto::Format.get(:json)" do
     it { @result.should =~ /foo\":12425125/      }
   end
 
-  describe '.decode(json)' do
-    json = Yajl::Encoder.encode( { :foo => 12425125, :bar => "some string" })
-    expected = { 'foo' => 12425125, 'bar' => "some string" }
-
-    it { subject.decode(json).should == expected }
-  end
-
+  its(:extension) { should == 'json' }
 end

data/spec/resto/format/xml_spec.rb

@@ -87,11 +87,11 @@ describe "Resto::Format.get(:xml)" do
 
   describe '.decode(xml, xpath)' do
     context 'when one item' do
-      it { subject.decode(xml, :xpath => '//zone').should == attributes }
+      it { subject.decode(xml, :xpath => '//zone').should == [attributes] }
     end
 
     context 'when 0 items' do
-      it { subject.decode(xml, :xpath => '//xx0').should == {} }
+      it { subject.decode(xml, :xpath => '//xx0').should == [{}] }
     end
 
     context 'when a collection of two items' do

data/spec/resto_spec.rb

@@ -531,14 +531,14 @@ describe Resto do
       it { Bitly.all.code.should == "200" }
     end
 
-    describe ".all('shortUrl' => short)" do
+    describe ".all('short' => sh)" do
       before do
-        stub_request(:get, "http://bit.ly/v3?format=json&shortUrl=short").
+        stub_request(:get, "http://bit.ly/v3?format=json&longUrl=ll&short=sh").
           with(:headers => headers("content-type" => "text/html")).
           to_return(:status => 200)
       end
 
-      it { Bitly.all('shortUrl' => 'short').code.should == "200" }
+      it { Bitly.all('short' => 'sh').code.should == "200" }
     end
   end
 

metadata

@@ -1,8 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: resto
 version: !ruby/object:Gem::Version 
+  hash: 27
   prerelease: 
-  version: 0.0.9
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
 platform: ruby
 authors: 
 - "Anders T\xC3\xB6rnqvist"
@@ -10,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-05-17 00:00:00 Z
+date: 2011-06-15 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: yajl-ruby
@@ -18,8 +23,13 @@ dependencies:
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - "="
+    - - ">="
       - !ruby/object:Gem::Version 
+        hash: 59
+        segments: 
+        - 0
+        - 8
+        - 2
         version: 0.8.2
   type: :runtime
   version_requirements: *id001
@@ -31,6 +41,11 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 1
+        - 4
+        - 4
         version: 1.4.4
   type: :runtime
   version_requirements: *id002
@@ -42,6 +57,11 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 13
+        segments: 
+        - 1
+        - 0
+        - 13
         version: 1.0.13
   type: :development
   version_requirements: *id003
@@ -53,6 +73,11 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 2
+        - 6
+        - 0
         version: 2.6.0
   type: :development
   version_requirements: *id004
@@ -64,6 +89,11 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 0
+        - 0
+        - 4
         version: 0.0.4
   type: :development
   version_requirements: *id005
@@ -75,6 +105,11 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 11
+        segments: 
+        - 1
+        - 6
+        - 2
         version: 1.6.2
   type: :development
   version_requirements: *id006
@@ -86,6 +121,11 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 59
+        segments: 
+        - 0
+        - 8
+        - 2
         version: 0.8.2
   type: :development
   version_requirements: *id007
@@ -97,6 +137,9 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
         version: "0"
   type: :development
   version_requirements: *id008
@@ -108,6 +151,9 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
         version: "0"
   type: :development
   version_requirements: *id009
@@ -119,6 +165,9 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
         version: "0"
   type: :development
   version_requirements: *id010
@@ -130,6 +179,9 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
         version: "0"
   type: :development
   version_requirements: *id011
@@ -143,11 +195,9 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
-- lib/blankslate.rb
 - lib/resto/attributes.rb
+- lib/resto/extra/assert_hash.rb
 - lib/resto/extra/copy.rb
-- lib/resto/extra/delegation.rb
-- lib/resto/extra/hash_args.rb
 - lib/resto/format/default.rb
 - lib/resto/format/json.rb
 - lib/resto/format/plain.rb
@@ -173,7 +223,6 @@ files:
 - lib/resto/version.rb
 - lib/resto.rb
 - spec/resto/extra/copy_spec.rb
-- spec/resto/extra/hash_args_spec.rb
 - spec/resto/format/default_spec.rb
 - spec/resto/format/json_spec.rb
 - spec/resto/format/plain_spec.rb
@@ -202,17 +251,27 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 57
+      segments: 
+      - 1
+      - 8
+      - 7
       version: 1.8.7
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 23
+      segments: 
+      - 1
+      - 3
+      - 6
       version: 1.3.6
 requirements: []
 
 rubyforge_project: resto
-rubygems_version: 1.7.2
+rubygems_version: 1.8.5
 signing_key: 
 specification_version: 3
 summary: Restful Web Service

data/lib/blankslate.rb

@@ -1,110 +0,0 @@
-# encoding: utf-8
-#!/usr/bin/env ruby
-#--
-# Copyright 2004, 2006 by Jim Weirich (jim@weirichhouse.org).
-# All rights reserved.
-
-# Permission is granted for use, copying, modification, distribution,
-# and distribution of modified versions of this work as long as the
-# above copyright notice is included.
-#++
-
-######################################################################
-# BlankSlate provides an abstract base class with no predefined
-# methods (except for <tt>\_\_send__</tt> and <tt>\_\_id__</tt>).
-# BlankSlate is useful as a base class when writing classes that
-# depend upon <tt>method_missing</tt> (e.g. dynamic proxies).
-#
-class BlankSlate
-  class << self
-
-    # Hide the method named +name+ in the BlankSlate class.  Don't
-    # hide +instance_eval+ or any method beginning with "__".
-    def hide(name)
-      if instance_methods.include?(name.to_s) and
-        name !~ /^(__|instance_eval)/
-        @hidden_methods ||= {}
-        @hidden_methods[name.to_sym] = instance_method(name)
-        undef_method name
-      end
-    end
-
-    def find_hidden_method(name)
-      @hidden_methods ||= {}
-      @hidden_methods[name] || superclass.find_hidden_method(name)
-    end
-
-    # Redefine a previously hidden method so that it may be called on a blank
-    # slate object.
-    def reveal(name)
-      hidden_method = find_hidden_method(name)
-      fail "Don't know how to reveal method '#{name}'" unless hidden_method
-      define_method(name, hidden_method)
-    end
-  end
-
-  instance_methods.each { |m| hide(m) }
-end
-
-######################################################################
-# Since Ruby is very dynamic, methods added to the ancestors of
-# BlankSlate <em>after BlankSlate is defined</em> will show up in the
-# list of available BlankSlate methods.  We handle this by defining a
-# hook in the Object and Kernel classes that will hide any method
-# defined after BlankSlate has been loaded.
-#
-module Kernel
-  class << self
-    alias_method :blank_slate_method_added, :method_added
-
-    # Detect method additions to Kernel and remove them in the
-    # BlankSlate class.
-    def method_added(name)
-      result = blank_slate_method_added(name)
-      return result if self != Kernel
-      BlankSlate.hide(name)
-      result
-    end
-  end
-end
-
-######################################################################
-# Same as above, except in Object.
-#
-class Object
-  class << self
-    alias_method :blank_slate_method_added, :method_added
-
-    # Detect method additions to Object and remove them in the
-    # BlankSlate class.
-    def method_added(name)
-      result = blank_slate_method_added(name)
-      return result if self != Object
-      BlankSlate.hide(name)
-      result
-    end
-
-    def find_hidden_method(name)
-      nil
-    end
-  end
-end
-
-######################################################################
-# Also, modules included into Object need to be scanned and have their
-# instance methods removed from blank slate.  In theory, modules
-# included into Kernel would have to be removed as well, but a
-# "feature" of Ruby prevents late includes into modules from being
-# exposed in the first place.
-#
-class Module
-  alias blankslate_original_append_features append_features
-  def append_features(mod)
-    result = blankslate_original_append_features(mod)
-    return result if mod != Object
-    instance_methods.each do |name|
-      BlankSlate.hide(name)
-    end
-    result
-  end
-end

data/lib/resto/extra/delegation.rb

@@ -1,26 +0,0 @@
-# encoding: utf-8
-
-module Resto
-  module Extra
-    module Delegation
-
-      def delegate(*methods)
-        options = methods.pop
-        to = options[:to]
-        unless options.is_a?(Hash) && to
-          raise ArgumentError, "Delegation needs a target. Supply an options
-            hash with a :to key as the last argument
-            (e.g. delegate :hello, :to => :greeter)."
-        end
-
-        methods.each do |method|
-          class_eval <<-EOS
-            def #{method}(*args, &block)
-              #{to}.__send__(#{method.inspect}, *args, &block)
-            end
-          EOS
-        end
-      end
-    end
-  end
-end

data/lib/resto/extra/hash_args.rb

@@ -1,56 +0,0 @@
-# encoding: utf-8
-
-class Resto::Extra::HashArgs; end
-
-class << Resto::Extra::HashArgs
-
-  def key(key)
-    @keys ||= []
-
-    unless key.is_a?(Symbol)
-      raise ArgumentError, "The key '#{key}' must be a symbol"
-    end
-
-    if @keys.include?(key)
-      raise ArgumentError, "The key '#{key}' has already been defined."
-    end
-
-    @keys << key
-  end
-
-private
-  def assert_key(key)
-    unless @keys.include?(key.to_sym)
-      raise ArgumentError, "The key '#{key}' is not valid.
-        Valid keys are: #{@keys.join(' ,')}"
-    end
-  end
-end
-
-class Resto::Extra::HashArgs
-
-  def initialize(hash)
-    hash ||= {}
-    raise ArgumentError, "'#{hash}' must be a Hash" unless hash.is_a?(Hash)
-    keys = hash.keys
-    keys_as_symbols = keys.map(&:to_sym)
-    if (keys_as_symbols.uniq.size != keys_as_symbols.size)
-      raise ArgumentError, "duplicated keys: #{keys.join(', ')}"
-    end
-
-    @hash = {}
-    keys.each do |key|
-      self.class.send(:assert_key, key)
-      @hash[key.to_sym] = hash.fetch(key)
-    end
-  end
-
-  def fetch(key, &block)
-    self.class.send(:assert_key, key)
-    @hash.fetch(key, &block)
-  end
-
-  def keys
-    @hash.keys
-  end
-end

data/spec/resto/extra/hash_args_spec.rb

@@ -1,71 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-require 'resto/extra/hash_args'
-
-describe Resto::Extra::HashArgs do
-
-  class_context(%Q{
-    class BasicAuthication < Resto::Extra::HashArgs
-      key :username
-      key :password
-    end}) do
-
-    it "returns the value from the block when no value is found by key" do
-      BasicAuthication.new(nil).fetch(:username) { 'anders' }.should == 'anders'
-    end
-
-    it "returns the value found by the key"  do
-      BasicAuthication.new({'username' => 'anders', :password => 'secret'}).
-        fetch(:password) { 'other' }.should == 'secret'
-    end
-
-    it "the key is translated to its symbol" do
-      BasicAuthication.new({'username' => 'anders', :password => 'secret'}).
-        fetch(:username) { 'other' }.should == 'anders'
-    end
-  end
-
-  class_context(%Q{
-    class FormatExt < Resto::Extra::HashArgs
-      key :extension
-    end}) do
-
-    it "returns the value from the block" do
-      FormatExt.new({}).fetch(:extension) { 'block' }.should == 'block'
-    end
-
-    if RUBY_VERSION < '1.9'
-
-      it "raises IndexError when no value and no block" do
-        expect { FormatExt.new({}).fetch(:extension) }.
-          to raise_error(IndexError, 'key not found')
-      end
-
-    else
-
-      it "raises KeyError when no value and no block" do
-        lambda { FormatExt.new({}).fetch(:extension) }.
-          should raise_error(KeyError, 'key not found: :extension')
-      end
-
-    end
-
-    it "raises" do
-      expect { FormatExt.new({:username => "anders"}) }.
-        to raise_error(ArgumentError, /The key 'username'/)
-
-      expect { FormatExt.new("string") }.
-        to raise_error(ArgumentError, "'string' must be a Hash")
-
-      expect { FormatExt.new(:extension => 'value', 'extension' => 'value') }.
-        to raise_error(ArgumentError, "duplicated keys: extension, extension")
-
-      expect { FormatExt.new({:invalid_key => 'invalid' }) }.
-        to raise_error(ArgumentError, /The key 'invalid_key' is not valid/)
-
-      expect { FormatExt.new({:extension => 'value' }).fetch(:invalid_key) }.
-        to raise_error(ArgumentError, /The key 'invalid_key' is not valid/)
-    end
-  end
-end