octarine 0.0.2 → 0.0.3

data/lib/octarine/app.rb

@@ -43,7 +43,8 @@ module Octarine # :nodoc:
       # 
       # Adds block as a handler for when no path is matched.
       
-      [:add, :get, :post, :delete, :put, :default].each do |method|
+      methods = [:add, :get, :post, :delete, :put, :options, :default]
+      methods.each do |method|
         define_method(method) do |*args, &block|
           if Hash === args.last
             restrictions = Array(args.last[:restrict])
@@ -144,11 +145,12 @@ module Octarine # :nodoc:
       end
     end
     
-    def register_handler(method, *args, &block)
+    def register_handler(method, path="/", opts={}, &block)
       return register_default(&block) if method == :default
-      restrictions = Hash === args[-1] ? Array(args[-1].delete(:restrict)) : []
+      restrictions = Array(opts.delete(:restrict))
       restrictions.map! {|name| @restrictions[name]}
-      route = router.send(method, *args)
+      opts[:request_method] = method unless method == :add
+      route = router.add(path, opts)
       route.to do |env|
         env.merge!("router.route" => route.original_path)
         request = request_class.new(env)

data/lib/octarine/request.rb

@@ -75,7 +75,9 @@ module Octarine # :nodoc:
     # 
     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)
+      res = if method == "OPTIONS" && client.respond_to?(:run_request)
+        client.run_request(:options, to_path, nil, header_for_rerequest)
+      elsif %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)

data/lib/octarine/response.rb

@@ -24,14 +24,14 @@ module Octarine # :nodoc:
     end
     
     # :call-seq: response.update {|body| block } -> response
-    # response.update(path) {|value| block } -> response
+    # response.update(path[, opts]) {|value| block } -> response
     # 
     # Called without an argument, the block will be supplied the response body,
     # and the response body will be set to the result of the block. The response
     # itself is returned.
     # 
-    # When called with an argument the body should be a hash, the body will be
-    # traversed accoring to the path supplied, the value of the body will be
+    # When called with a path argument the body should be a hash, the body will
+    # be traversed accoring to the path supplied, the value of the body will be
     # yielded to the block, and then replaced with the result of the block.
     # Example:
     #   response.body
@@ -42,11 +42,48 @@ module Octarine # :nodoc:
     #   response.body
     #   #=> {"data" => [{"user" => {"id" => "1234", ...}, "message" => "..."}]}
     # 
-    def update(path=nil, &block)
+    # Additional options can be passed as a hash, the options available are:
+    # [remove]    The full path to the element that should be removed if the
+    #             block returns nil. Must be a parent of the element targeted
+    #             by the main path argument
+    # [remove_if] If supplied along with the remove option the result of the
+    #             block will be tested againt this value (using ===) rather
+    #             than nil
+    # [link]      Should be supplied with a value of a hash, in which the key
+    #             is a path to an element to be updated, and the value is an
+    #             array of a an element and a method from which to derive a
+    #             value
+    # Example:
+    #   response.body
+    #   #=> {"data" => [1, 2, 3], "total" => 3}
+    #   
+    #   user_names = {1 => "Arthur", 2 => "Ford"}
+    #   
+    #   total_to_length = {"total" => ["data", :length]}
+    #   response.update("data.", remove: "data.", link: total_to_length) do |id|
+    #     user_names[id]
+    #   end
+    #   
+    #   response.body
+    #   # {"data" => ["Arthur", "Ford"], "total" => 2}
+    # 
+    def update(path=nil, options={}, &block)
       @body = if body.respond_to?(:to_ary) && path.nil?
         block.call(body)
       else
-        apply(body, path, &block)
+        path = nil if path == "."
+        remove_path = options[:remove]
+        remove_if = remove_path ? options[:remove_if] : -> x {false}
+        apply(body, path, remove_path, remove_if, &block)
+      end
+      (options[:link] || []).each do |dest, (source_path, source_method)|
+        update(dest) do |val|
+          source = body
+          source_path.split(".").each do |part|
+            source = source[part]
+          end
+          source.send(source_method)
+        end
       end
       self
     end
@@ -89,19 +126,39 @@ module Octarine # :nodoc:
     
     private
     
-    def apply(object, path=nil, &block)
+    def apply(object, path=nil, remove_path=nil, remove_flag=nil, &block)
       if object.respond_to?(:to_ary)
-        path = nil if path == "."
-        return object.to_ary.map {|obj| apply(obj, path, &block)}
+        return object.to_ary.each_with_object([]) do |obj, collection|
+          result = catch :remove do
+            apply(obj, path, remove_path, remove_flag, &block)
+          end
+          if result != :__remove__
+            collection << result
+          elsif remove_path.nil?
+            throw :remove, :__remove__
+          end
+        end
       end
       
+      remove_key, remove_rest = remove_path.split(".", 2) if remove_path
+      
       key, rest = path.split(".", 2) if path
       if rest
-        object[key] = apply(object[key], rest, &block)
+        object[key] = apply(object[key], rest, remove_rest, remove_flag, &block)
       elsif key
-        object[key] = block.call(object[key])
+        result = block.call(object[key])
+        should_remove = remove_flag === result
+        if should_remove && key == remove_path
+          object.delete(key)
+        elsif should_remove
+          throw :remove, :__remove__
+        else
+          object[key] = result
+        end
       else
-        return block.call(object)
+        result = block.call(object)
+        throw :remove, :__remove__ if remove_flag === result
+        return result
       end
       object
     end

data/lib/octarine/simple_http.rb

@@ -28,7 +28,7 @@ module Octarine # :nodoc:
     # #headers, and #body
     # 
     def head(path, headers={})
-      request(Net::HTTP::Head.new(path, headers))
+      run_request(:head, path, nil, headers)
     end
     
     # :call-seq: simple_http.get(path, headers={}) -> response
@@ -37,7 +37,7 @@ module Octarine # :nodoc:
     # #headers, and #body
     # 
     def get(path, headers={})
-      request(Net::HTTP::Get.new(path, headers))
+      run_request(:get, path, nil, headers)
     end
     
     # :call-seq: simple_http.post(path, body=nil, headers={}) -> response
@@ -46,9 +46,7 @@ module Octarine # :nodoc:
     # #headers, and #body
     # 
     def post(path, body=nil, headers={})
-      req = Net::HTTP::Post.new(path, headers)
-      req.body = body if body
-      request(req)
+      run_request(:post, path, body, headers)
     end
     
     # :call-seq: simple_http.put(path, body=nil, headers={}) -> response
@@ -57,9 +55,7 @@ module Octarine # :nodoc:
     # #headers, and #body
     # 
     def put(path, body=nil, headers={})
-      req = Net::HTTP::Put.new(path, headers)
-      req.body = body if body
-      request(req)
+      run_request(:put, path, body, headers)
     end
     
     # :call-seq: simple_http.delete(path, headers={}) -> response
@@ -68,7 +64,28 @@ module Octarine # :nodoc:
     # #headers, and #body
     # 
     def delete(path, headers={})
-      request(Net::HTTP::Delete.new(path, headers))
+      run_request(:delete, path, nil, headers)
+    end
+    
+    # :call-seq: simple_http.options(path, headers={}) -> response
+    # 
+    # Perform an OPTIONS request, returns a response that responds to #status,
+    # #headers, and #body
+    # 
+    def options(path, headers)
+      run_request(:options, path, nil, headers)
+    end
+    
+    # :call-seq: simple_http.run_request(method, path, body, headers) -> res
+    # 
+    # Perform request, returns a response that responds to #status, #headers,
+    # and #body
+    # 
+    def run_request(method, path, body, headers)
+      klass = Net::HTTP.const_get(method.to_s.capitalize)
+      req.klass.new(path, headers)
+      req.body = body if body
+      request(req)
     end
     
     private

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: octarine
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-06-07 00:00:00.000000000 Z
+date: 2012-07-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: http_router
-  requirement: &2152395640 !ruby/object:Gem::Requirement
+  requirement: &2154507480 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,7 +21,7 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *2152395640
+  version_requirements: *2154507480
 description: Sinatra-like DSL for writing a HTTP routing proxy.
 email: mat@sourcetagsandcodes.com
 executables: []