octarine 0.0.1 → 0.0.2

data/README.rdoc

@@ -7,7 +7,7 @@ transforming one external request in to multiple internal requests.
 
 == Installation
 
-gem install octarine
+  $ gem install octarine
 
 == Usage
 

data/lib/octarine.rb

@@ -1,2 +1,4 @@
-libs = %W{app endpoint path request response}.map(&"../octarine/".method(:+))
-libs.map {|lib| File.expand_path(lib, __FILE__)}.each(&method(:require))
+libs = %W{app path path_template request response}
+libs.map {|lib| File.expand_path("../octarine/#{lib}", __FILE__)}.each do |lib|
+  require lib
+end

data/lib/octarine/app.rb

@@ -1,7 +1,7 @@
 require "forwardable"
 require "http_router"
 require_relative "request"
-require_relative "endpoint"
+require_relative "path"
 
 module Octarine # :nodoc:
   module App
@@ -45,22 +45,47 @@ module Octarine # :nodoc:
       
       [:add, :get, :post, :delete, :put, :default].each do |method|
         define_method(method) do |*args, &block|
+          if Hash === args.last
+            restrictions = Array(args.last[:restrict])
+          else
+            restrictions = []
+            args << {}
+          end
+          restrictions << @current_restriction if @current_restriction
+          args.last[:restrict] = restrictions.flatten
           (@handlers ||= []) << [method, *args, block]
         end
       end
       
-      def add_route(route) # :nodoc:
-        (@handlers ||= []) << [__method__, route, nil]
+      # :call-seq:
+      #   restriction(name, response=401) {|request| block }
+      #   restriction(name, response=401, proc)
+      # 
+      # Create a named restriction. response will be returned if the block
+      # returns true, otherwise the handler subject to the restriction will be
+      # executed as usual.
+      # 
+      def restriction(name, response=401, proc=nil, &block)
+        (@restrictions ||= {})[name] = [response, proc || block]
       end
       
-      # :call-seq: request_class(klass)
+      # :call-seq: restrict(name) { block }
       # 
+      # All handlers defined within the block will be subject to the named
+      # restriction.
+      # 
+      def restrict(restriction)
+        (@current_restriction ||= []) << restriction
+        yield
+      ensure
+        @current_restriction.pop
+      end
+      
       # Set the class of the request object handed to the path handler blocks.
       # Defaults to Octarine::Request.
       # 
-      def request_class(klass=nil)
-        klass ? @request_class = klass : @request_class || Octarine::Request
-      end
+      attr_writer :request_class
+      alias request_class request_class=
       
       # :call-seq: environment -> string
       # 
@@ -71,41 +96,76 @@ module Octarine # :nodoc:
       end
       
       def new(*args) # :nodoc:
-        instance = super
-        instance.router = HttpRouter.new
-        @handlers.each do |method, *args|
-          block = args.pop
-          instance.router.send(method, *args) do |env|
-            instance.instance_exec(request_class.new(env), &block)
-          end
+        request_class = @request_class || Octarine::Request
+        restrictions = @restrictions
+        handlers = @handlers
+        super.instance_eval do
+          @request_class ||= request_class
+          @router ||= HttpRouter.new
+          @restrictions = restrictions
+          handlers.each {|m,*args| register_handler(m, *args[0..-2], &args[-1])}
+          self
         end
-        instance
       end
+      
     end
     
-    attr_accessor :router # :nodoc:
+    extend Forwardable
+    
+    attr_reader :router, :request_class
     
     ##
     # :method: call
     # :call-seq: app.call(env) -> array
     # 
     # Rack-compatible #call method.
-    
-    extend Forwardable
-    def_delegators :router, :url, :call
+    # 
+    def_delegator :router, :call
     
     def self.included(includer) # :nodoc:
       includer.extend(ClassMethods)
     end
     
-    # :call-seq: app.endpoint(string) -> endpoint
-    # app.endpoint(client) -> endpoint
-    # 
-    # Create an Octarine::Endpoint with either a string of the host:port or
-    # a client instance API compatible with Octarine::SimpleHTTP.
-    # 
-    def endpoint(host_or_client)
-      Octarine::Endpoint.new(host_or_client)
+    private
+    
+    def to_rack_response(res)
+      if res.respond_to?(:status) && res.respond_to?(:headers) &&
+        res.respond_to?(:body)
+        status, headers, body = res.status, res.headers, res.body
+        [status, headers, body.respond_to?(:each) ? body : [body].compact]
+      elsif res.respond_to?(:to_ary)
+        res.to_ary
+      elsif res.respond_to?(:to_str)
+        [200, {}, [res.to_str]]
+      elsif res.respond_to?(:to_i)
+        [res.to_i, {}, []]
+      else
+        [200, {}, res]
+      end
+    end
+    
+    def register_handler(method, *args, &block)
+      return register_default(&block) if method == :default
+      restrictions = Hash === args[-1] ? Array(args[-1].delete(:restrict)) : []
+      restrictions.map! {|name| @restrictions[name]}
+      route = router.send(method, *args)
+      route.to do |env|
+        env.merge!("router.route" => route.original_path)
+        request = request_class.new(env)
+        response, = restrictions.find {|_,restr| instance_exec(request, &restr)}
+        if response.respond_to?(:to_proc)
+          response = instance_exec(request, &response)
+        elsif response.nil?
+          response = instance_exec(request, &block)
+        end
+        to_rack_response(response)
+      end
+    end
+    
+    def register_default(&block)
+      router.default(Proc.new do |env|
+        to_rack_response(instance_exec(request_class.new(env), &block))
+      end)
     end
     
   end

data/lib/octarine/path.rb

@@ -1,4 +1,5 @@
 require "forwardable"
+require_relative "path_template"
 
 module Octarine # :nodoc:
   
@@ -19,75 +20,115 @@ module Octarine # :nodoc:
   #   path["history"]     #=> "true"
   #   path.to_s           #=> "/users/1234/messages/4567?history=true"
   #   path.path           #=> "/users/1234/messages/4567"
-  #   path.query_string   #=> "history=true"
   #   path.to_hash        #=> {:user_id=>"1234", :message_id=>"5678", "history"=>"true"}
-  #   path.query          #=> {"history"=>"true"}
   # 
   # The following methods are available and behave as if the path was a hash:
-  # assoc, [], each_key, each_pair, each_value, empty?, fetch, has_key?,
-  # has_value?, key, key?, keys, merge, rassoc, to_a, to_hash, value?, values,
+  # assoc, [], each, each_key, each_pair, each_value, empty?, fetch, has_key?,
+  # has_value?, key, key?, keys, rassoc, to_a, to_hash, value?, values,
   # values_at and all Enumerable methods
   # 
   # The following methods are available and behave as if path was a string:
-  # +, =~, bytesize, gsub, length, size, sub, to_str, to_s
+  # =~, bytesize, length, size
   # 
   class Path
-    # String of the path, without the query string.
-    attr_reader :path
-    # String of the query string.
-    attr_reader :query_string
-    # Hash of the query string.
-    attr_reader :query
+    attr_reader :params
+    attr_accessor :template
+    protected :params, :template, :template=
     
     extend Forwardable
-    def_delegators :@params, :assoc, :[], :each_key, :each_pair,
+    def_delegators :@params, :assoc, :[], :each, :each_key, :each_pair,
       :each_value, :empty?, :fetch, :has_key?, :has_value?, :key, :key?, :keys,
-      :merge, :rassoc, :to_a, :value?, :values, :values_at,
+      :rassoc, :to_a, :value?, :values, :values_at,
       *Enumerable.public_instance_methods
     def_delegator :@params, :dup, :to_hash
-    def_delegators :@full_path, :+, :=~, :bytesize, :gsub, :length, :size, :sub,
-      :to_str, :to_s
+    def_delegators :@full_path, :=~, :bytesize, :length, :size
     
-    # :call-seq: Path.new(string, path_params, query_string) -> path
+    # :call-seq: Path.new(template, path_string) -> path
     # 
-    # Create a new Path instance from the a string or the path, the path
-    # parameters as a hash, and a string of the query string.
+    # Create a new Path instance from a path template and a string of the path.
     # 
-    def initialize(path, params, query_string)
-      @path = path
-      params.each do |key, value|
-        self.class.class_eval do
-          define_method(key) {@params[key]}
-        end
+    def initialize(template, path)
+      @template = Octarine::PathTemplate.new(template)
+      @params = @template.recognize(path)
+      
+      @params.each do |key, value|
+        next unless Symbol === key
+        self.class.class_eval {define_method(key) {@params[key]}}
       end
-      @query_string = query_string
-      @query = parse_query(@query_string)
-      @full_path = @path.dup
-      @full_path << "?#{@query_string}" if @query_string && !@query_string.empty?
-      @params = params.merge(@query)
     end
     
-    # :call-seq: path.lchomp(separator=$/) -> string
+    # :call-seq: path.without(part) -> new_path
     # 
-    # Like String#chomp, but removes seperator from the left of the path.
+    # Return a new path without part.
     # 
-    def lchomp(separator=$/)
-      string = to_s
-      string.start_with?(separator) ? string[separator.length..-1] : string
+    #   path = Path.new("/users/:id", "/users/1")
+    #   path.without("users").to_s   #=> "/1"
+    # 
+    #   path = Path.new("/users/:id", "/users/1")
+    #   path.without(":id").to_s     #=> "/users"
+    # 
+    def without(part)
+      dup.tap do |cp|
+        cp.template = @template.without(part)
+        cp.params.delete(part)
+      end
     end
     
-    private
+    # :call-seq: path.merge(hash) -> new_path
+    # 
+    # Returns a new path with contents of hash merged in to the path parameters.
+    # 
+    #   path = Path.new("/users/:id/favourites", "/users/1/favourites?limit=10")
+    #   new_path = path.merge(:id => 2, "offset" => 20)
+    #   new_path.to_s   #=> "users/2/favourites?limit=10&offset=20"
+    # 
+    def merge(other)
+      dup.tap {|cp| cp.params.merge!(other)}
+    end
     
-    def parse_query(string)
-      string.split("&").each_with_object({}) do |key_value, out|
-        key, value = key_value.split("=")
-        key, value = url_decode(key), url_decode(value)
-        out[key] = out.key?(key) ? [*out[key]].push(value) : value
-      end
+    # :call-seq: path + string -> new_path
+    # 
+    # Returns a new path with string appended.
+    # 
+    #   path = Path.new("/users/:id", "/users/1")
+    #   new_path = (path + "favourites/:favourite_id").merge(:favourite_id => 2)
+    #   new_path.to_s   #=> "/users/1/favourites/2"
+    # 
+    def +(part)
+      dup.tap {|cp| cp.template = @template + part}
+    end
+    
+    # :call-seq: path.to_s -> string
+    # 
+    # Returns the path as a string.
+    # 
+    def to_s
+      @template.apply(@params)
+    end
+    alias to_str to_s
+    
+    # :call-seq: path == other -> bool
+    # 
+    # Returns true if other is equal to path, false otherwise.
+    # 
+    def ==(other)
+      self.class === other && to_s == other.to_s
+    end
+    
+    # :call-seq: path === other -> bool
+    # 
+    # Returns true if other as a string is equal to path as a string, false
+    # otherwise.
+    # 
+    def ===(other)
+      to_s === other.to_s
     end
     
-    def url_decode(str)
-      str.tr("+", " ").gsub(/(%[0-9a-f]{2})+/i) {|m| [m.delete("%")].pack("H*")}
+    def initialize_copy(source) # :nodoc:
+      super
+      @template = @template.dup
+      @params = @params.dup
     end
+    
   end
 end

data/lib/octarine/path_template.rb

@@ -0,0 +1,163 @@
+module Octarine
+  class PathTemplate
+    BadTemplateError = Class.new(ArgumentError)
+    
+    module StringExtention
+      def /(arg)
+        PathTemplate.new(self).apply(*arg.respond_to?(:to_ary) ? arg : [arg])
+      end
+    end
+    
+    attr_reader :parts
+    protected :parts
+    
+    def initialize(string)
+      @parts = parse(string)
+    end
+    
+    def apply(*args)
+      params = args.last.respond_to?(:each) ? args.pop.dup : {}
+      
+      @parts.find {|type, val| params[val] ||= args.pop if type == :format}
+      @parts.select do |type, value|
+        params[value] ||= args.shift if type == :variable && !args.empty?
+      end
+      @parts.find {|type, val| params[val] ||= args if type == :glob}
+      
+      format = nil
+      path = []
+      @parts.each do |type, value|
+        case type
+        when :variable
+          path << params.delete(value)
+        when :glob
+          path << params.delete(value).join("/")
+        when :format
+          format = params.delete(value)
+        else
+          path << value
+        end
+      end
+      
+      out = path == [nil] ? "/" : path.join("/")
+      out << ".#{format}" if format
+      out << query(params) if !params.empty?
+      out
+    end
+    
+    def recognize(string)
+      other_parts = parse(string).each
+      params = {}
+      
+      @parts.each do |type, value|
+        other_type, other_value = (other_parts.next rescue nil)
+        case type
+        when :variable
+          return unless other_value
+          params[value] = other_value
+        when :glob
+          params[value] = other_value ? [other_value] : []
+          while (other_parts.peek.first == :string rescue nil)
+            other_type, other_value = other_parts.next
+            params[value] << other_value
+          end
+        when :format
+          return nil unless type == other_type
+          params[value] = other_value.to_s
+        when :string
+          return nil unless type == other_type && value == other_value
+        end
+      end
+      other_type, other_value = (other_parts.next rescue nil)
+      return nil unless other_type == :query_string || other_type.nil?
+      if other_value
+        query = parse_query(other_value)
+        params.merge!(query)
+      end
+      params
+    end
+    alias === recognize
+    
+    def +(string)
+      parts = parse(string)
+      parts.shift if parts.first == [:leading_joiner, nil]
+      dup.tap {|cp| cp.parts.concat(parts)}
+    end
+    
+    def without(string)
+      part = parse(string).first
+      dup.tap {|cp| cp.parts.reject! {|pt| pt == part}}
+    end
+    alias - without
+    
+    def ==(other)
+      self.class === other && parts == other.parts
+    end
+    
+    def initialize_copy(source)
+      super
+      @parts = @parts.dup
+    end
+    
+    private
+    
+    def query(params)
+      return nil if !params || params.empty?
+      "?" << params.map {|kv| kv.join("=")}.join("&")
+    end
+    
+    def tokenize(string)
+      string.scan(%r{([/:*.?]|[^/:*.?]+)}).flatten
+    end
+    
+    def lex(tokens)
+      enum = tokens.each
+      parts = []
+      seen_glob = false
+      seen_format = false
+      
+      parts << [:leading_joiner, nil] if enum.peek == "/"
+      while part = enum.next
+        raise BadTemplateError.new(".format must be last") if seen_format
+        
+        case part
+        when "/"
+        when ":"
+          raise BadTemplateError.new(":variable cannot follow *glob") if seen_glob
+          parts << [:variable, enum.next.to_sym]
+        when "*"
+          raise BadTemplateError.new("multiple *glob not allowed") if seen_glob
+          seen_glob = true
+          parts << [:glob, enum.next.to_sym]
+        when "."
+          seen_format = true
+          parts << [:format, enum.next.to_sym]
+        when "?"
+          parts << [:query_string, enum.next.freeze]
+        else
+          parts << [:string, part.freeze]
+        end
+      end
+    rescue StopIteration
+      parts
+    end
+    
+    def parse(string)
+      string = Symbol === string ? ":#{string}" : string.to_s
+      lex(tokenize(string))
+    end
+    
+    def parse_query(string)
+      string.split("&").each_with_object({}) do |key_value, out|
+        key, value = key_value.split("=")
+        key, value = url_decode(key), url_decode(value)
+        out[key] = out.key?(key) ? [*out[key]].push(value) : value
+      end
+    end
+    
+    def url_decode(str)
+      str.tr("+", " ").gsub(/(%[0-9a-f]{2})+/i) {|m| [m.delete("%")].pack("H*")}
+    end
+    
+  end
+end

data/lib/octarine/request.rb

@@ -1,5 +1,6 @@
 require_relative "response"
-require_relative "endpoint"
+require_relative "path"
+require_relative "simple_http"
 
 module Octarine # :nodoc:
   class Request
@@ -23,18 +24,22 @@ module Octarine # :nodoc:
     def initialize(env)
       @env = env
       env.delete("router")
-      path_params = env.delete("router.params")
+      env.delete("router.params")
+      template = env.delete("router.route")
       @method = env["REQUEST_METHOD"]
       @host = env["SERVER_NAME"]
       @port = env["SERVER_PORT"]
-      @path = Path.new(env["SCRIPT_NAME"] || env["PATH_INFO"], path_params,
-        env["QUERY_STRING"])
+      path = env["SCRIPT_NAME"] || ""
+      path << env["PATH_INFO"] unless env["PATH_INFO"].empty?
+      full_path = path.dup
+      full_path << "?" << env["QUERY_STRING"] unless env["QUERY_STRING"].empty?
+      @path = Path.new(template || path, full_path)
       @input = env["rack.input"]
     end
     
     # :call-seq: request[header_name] -> header_value
     # 
-    # Retrieve headers.
+    # Retrieve header.
     #   request["Content-Length"]   #=> "123"
     #   request["Content-Type"]     #=> "application/json"
     # 
@@ -43,47 +48,59 @@ module Octarine # :nodoc:
       unless upper_key == "CONTENT_LENGTH" || upper_key == "CONTENT_TYPE"
         upper_key[0,0] = "HTTP_"
       end
-      @env[key]
+      @env[upper_key]
     end
     
-    # :call-seq: request.to(endpoint) -> response
-    # request.to(endpoint, path) -> response
-    # request.to(endpoint, path, input) -> response
+    # :call-seq: request.header -> hash
+    # request.headers -> hash
     # 
-    # Re-issue request to new host/path.
+    # Get header as a hash.
+    #   request.header
+    #   #=> {"content-length" => "123", "content-type" => "application/json"}
     # 
-    def to(endpoint=Octarine::Endpoint.new(host), to_path=path, to_input=input)
-      res = if %W{POST PUT}.include?(method)
-        header = {"content-type" => "application/json"}
-        endpoint.send(method.downcase, to_path, to_input, header)
-      else
-        endpoint.send(method.downcase, to_path)
-      end
-      headers = res.headers
-      headers.delete("transfer-encoding")
-      headers.delete("content-length")
-      Octarine::Response.new(res.body, headers, res.status)
+    def header
+      Hash[@env.select do |k,v|
+        k =~ /^HTTP_[^(VERSION)]/ || %W{CONTENT_LENGTH CONTENT_TYPE}.include?(k)
+      end.map do |key, value|
+        [key.sub(/HTTP_/, "").tr("_", "-").downcase, value]
+      end]
     end
+    alias headers header
     
-    # :call-seq: request.redirect(path) -> response
+    # :call-seq: request.to(host) -> response
+    # request.to(host, path) -> response
+    # request.to(host, path, input) -> response
     # 
-    # Issue redirect to path.
+    # Re-issue request to new host/path.
     # 
-    def redirect(path)
-      
+    def to(client, to_path=path, to_input=input)
+      client = SimpleHTTP.new(client.to_str) if client.respond_to?(:to_str)
+      res = if %W{POST PUT}.include?(method)
+        client.__send__(method.downcase, to_path, to_input, header_for_rerequest)
+      else
+        client.__send__(method.downcase, to_path, header_for_rerequest)
+      end
+      response_headers = res.headers
+      response_headers.delete("transfer-encoding")
+      response_headers.delete("content-length")
+      Octarine::Response.new(res.body, response_headers, res.status)
     end
     
     def to_s # :nodoc:
-      header = Hash[@env.select do |k,v|
-        k =~ /^HTTP_[^(VERSION)]/ || %W{CONTENT_LENGTH CONTENT_TYPE}.include?(k)
-      end.map do |key, value|
-        [key.sub(/HTTP_/, "").split(/_/).map(&:capitalize).join("-"), value]
-      end]
       version = " " + @env["HTTP_VERSION"] if @env.key?("HTTP_VERSION")
       "#{method} #{path}#{version}\r\n" << header.map do |key, value|
+        key = key.split(/-/).map(&:capitalize).join("-")
         "#{key}: #{value}"
       end.join("\r\n") << "\r\n\r\n"
     end
     
+    private
+    
+    def header_for_rerequest
+      head = header
+      head.delete("host")
+      head
+    end
+    
   end
 end

data/lib/octarine/response.rb

@@ -73,7 +73,7 @@ module Octarine # :nodoc:
       when 2
         @body = value
       else
-        raise ArgumentError("Unexpected key #{key}")
+        raise ArgumentError.new("Unexpected key #{key}")
       end
     end
     
@@ -91,6 +91,7 @@ module Octarine # :nodoc:
     
     def apply(object, path=nil, &block)
       if object.respond_to?(:to_ary)
+        path = nil if path == "."
         return object.to_ary.map {|obj| apply(obj, path, &block)}
       end
       

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: octarine
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-11-02 00:00:00.000000000Z
+date: 2012-06-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: http_router
-  requirement: &2153077060 !ruby/object:Gem::Requirement
+  requirement: &2152395640 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,7 +21,7 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *2153077060
+  version_requirements: *2152395640
 description: Sinatra-like DSL for writing a HTTP routing proxy.
 email: mat@sourcetagsandcodes.com
 executables: []
@@ -30,8 +30,8 @@ extra_rdoc_files:
 - README.rdoc
 files:
 - lib/octarine/app.rb
-- lib/octarine/endpoint.rb
 - lib/octarine/path.rb
+- lib/octarine/path_template.rb
 - lib/octarine/request.rb
 - lib/octarine/response.rb
 - lib/octarine/simple_http.rb
@@ -61,7 +61,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.7
+rubygems_version: 1.8.11
 signing_key: 
 specification_version: 3
 summary: HTTP routing proxy DSL

data/lib/octarine/endpoint.rb

@@ -1,125 +0,0 @@
-require "forwardable"
-require_relative "simple_http"
-require_relative "response"
-
-module Octarine # :nodoc:
-  
-  # Octarine::Endpoint is a wrapper round a http client that presents a DSL for
-  # generating paths and making requests.
-  # 
-  # Examples:
-  # 
-  #   # GET users/123/messages/567
-  #   endpoint.users(123).messages[567]
-  # 
-  #   # GET 123/details/address
-  #   endpoint.(123).details["address"]
-  # 
-  #   # POST users/123/messages
-  #   endpoint.users(123).post("messages", body)
-  # 
-  class Endpoint
-    attr_accessor :path
-    protected :path, :path=
-    attr_reader :client
-    private :client
-    
-    extend Forwardable
-    def_delegators :@client, :host, :port
-    
-    # :call-seq: Endpoint.new(host) -> endpoint
-    # Endpoint.new(client) -> endpoint
-    # 
-    # Create a new Endpoint instance, either with a string of host:port, or a
-    # http client instance API compatible with Octarine::SimpleHTTP
-    # 
-    def initialize(host_or_client)
-      if host_or_client.respond_to?(:get)
-        @client = host_or_client
-      else
-        @client = Octarine::SimpleHTTP.new(host_or_client)
-      end
-      @path = ""
-    end
-    
-    # :call-seq: endpoint.call(obj) -> new_endpoint
-    # endpoint.(obj) -> new_endpoint
-    # 
-    # Returns a new endpoint with the string respresentation of obj added to the
-    # path. E.g. `endpoint.(123)` will return an endpoint with `/123` appended
-    # to the path.
-    # 
-    def call(id)
-      method_missing(id)
-    end
-    
-    # :call-seq: endpoint.method_missing(name, id) -> new_endpoint
-    # endpoint.method_missing(name) -> new_endpoint
-    # endpoint.anything(id) -> new_endpoint
-    # endpoint.anything -> new_endpoint
-    # 
-    # Implements the path generation DSL.
-    #   endpoint.foo(1).bar   #=> new endpoint with path set to /foo/1/bar
-    # 
-    def method_missing(name, *args)
-      super unless args.length <= 1 && !block_given?
-      copy = dup
-      copy.path = join(copy.path, name.to_s, *args)
-      copy
-    end
-    
-    # :call-seq: endpoint.head(id, headers={}) -> response
-    # 
-    # Make a HEAD request to endpoint's path plus `/id`.
-    # 
-    def head(id, headers={})
-      response = client.head(join(path, id.to_s), headers)
-      Octarine::Response.new(response.body, response.headers, response.status)
-    end
-    
-    # :call-seq: endpoint.head(id, headers={}) -> response
-    # endpoint[id] -> response
-    # 
-    # Make a GET request to endpoint's path plus `/id`.
-    # 
-    def get(id, headers={})
-      response = client.get(join(path, id.to_s), headers)
-      Octarine::Response.new(response.body, response.headers, response.status)
-    end
-    alias [] get
-    
-    # :call-seq: endpoint.head(id, body=nil, headers={}) -> response
-    # 
-    # Make a POST request to endpoint's path plus `/id`.
-    # 
-    def post(id, body=nil, headers={})
-      response = client.post(join(path, id.to_s), body, headers)
-      Octarine::Response.new(response.body, response.headers, response.status)
-    end
-    
-    # :call-seq: endpoint.head(id, body=nil, headers={}) -> response
-    # 
-    # Make a PUT request to endpoint's path plus `/id`.
-    # 
-    def put(id, body=nil, headers={})
-      response = client.put(join(path, id.to_s), body, headers)
-      Octarine::Response.new(response.body, response.headers, response.status)
-    end
-    
-    # :call-seq: endpoint.head(id, headers={}) -> response
-    # 
-    # Make a DELETE request to endpoint's path plus `/id`.
-    # 
-    def delete(id, headers={})
-      response = client.delete(join(path, id.to_s), headers)
-      Octarine::Response.new(response.body, response.headers, response.status)
-    end
-    
-    private
-    
-    def join(*paths)
-      paths.map {|path| path.gsub(%r{(^/|/$)}, "")}.join("/")
-    end
-    
-  end
-end