wadl 0.1.2 → 0.1.3.1

data/lib/wadl/representation_container.rb

@@ -0,0 +1,47 @@
+#--
+###############################################################################
+#                                                                             #
+# A component of wadl, the super cheap Ruby WADL client.                      #
+#                                                                             #
+# Copyright (C) 2006-2008 Leonard Richardson                                  #
+# Copyright (C) 2010 Jens Wille                                               #
+#                                                                             #
+# Authors:                                                                    #
+#     Leonard Richardson <leonardr@segfault.org> (Original author)            #
+#     Jens Wille <jens.wille@uni-koeln.de>                                    #
+#                                                                             #
+# wadl is free software; you can redistribute it and/or modify it under the   #
+# terms of the GNU General Public License as published by the Free Software   #
+# Foundation; either version 3 of the License, or (at your option) any later  #
+# version.                                                                    #
+#                                                                             #
+# wadl is distributed in the hope that it will be useful, but WITHOUT ANY     #
+# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS   #
+# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more       #
+# details.                                                                    #
+#                                                                             #
+# You should have received a copy of the GNU General Public License along     #
+# with wadl. If not, see <http://www.gnu.org/licenses/>.                      #
+#                                                                             #
+###############################################################################
+#++
+
+require 'wadl'
+
+module WADL
+
+  # A mixin for objects that contain representations
+
+  module RepresentationContainer
+
+    def find_representation_by_media_type(type)
+      representations.find { |r| r.mediaType == type }
+    end
+
+    def find_form
+      representations.find { |r| r.is_form_representation? }
+    end
+
+  end
+
+end

data/lib/wadl/representation_format.rb

@@ -0,0 +1,73 @@
+#--
+###############################################################################
+#                                                                             #
+# A component of wadl, the super cheap Ruby WADL client.                      #
+#                                                                             #
+# Copyright (C) 2006-2008 Leonard Richardson                                  #
+# Copyright (C) 2010 Jens Wille                                               #
+#                                                                             #
+# Authors:                                                                    #
+#     Leonard Richardson <leonardr@segfault.org> (Original author)            #
+#     Jens Wille <jens.wille@uni-koeln.de>                                    #
+#                                                                             #
+# wadl is free software; you can redistribute it and/or modify it under the   #
+# terms of the GNU General Public License as published by the Free Software   #
+# Foundation; either version 3 of the License, or (at your option) any later  #
+# version.                                                                    #
+#                                                                             #
+# wadl is distributed in the hope that it will be useful, but WITHOUT ANY     #
+# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS   #
+# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more       #
+# details.                                                                    #
+#                                                                             #
+# You should have received a copy of the GNU General Public License along     #
+# with wadl. If not, see <http://www.gnu.org/licenses/>.                      #
+#                                                                             #
+###############################################################################
+#++
+
+require 'cgi'
+require 'wadl'
+
+module WADL
+
+  class RepresentationFormat < HasDocs
+
+    in_document 'representation'
+    has_attributes :id, :mediaType, :element
+    has_many Param
+    may_be_reference
+
+    def is_form_representation?
+      mediaType == 'application/x-www-form-encoded' || mediaType == 'multipart/form-data'
+    end
+
+    # Creates a representation by plugging a set of parameters
+    # into a representation format.
+    def %(values)
+      unless mediaType == 'application/x-www-form-encoded'
+        raise "wadl.rb can't instantiate a representation of type #{mediaType}"
+      end
+
+      representation = []
+
+      params.each { |param|
+        name = param.name
+
+        if param.fixed
+          p_values = [param.fixed]
+        elsif p_values = values[name] || values[name.to_sym]
+          p_values = [p_values] if !param.repeating? || !p_values.respond_to?(:each) || p_values.respond_to?(:to_str)
+        else
+          raise ArgumentError, "Your proposed representation is missing a value for #{param.name}" if param.required?
+        end
+
+        p_values.each { |v| representation << "#{CGI::escape(name)}=#{CGI::escape(v.to_s)}" } if p_values
+      }
+
+      representation.join('&')
+    end
+
+  end
+
+end

data/lib/wadl/request_format.rb

@@ -0,0 +1,68 @@
+#--
+###############################################################################
+#                                                                             #
+# A component of wadl, the super cheap Ruby WADL client.                      #
+#                                                                             #
+# Copyright (C) 2006-2008 Leonard Richardson                                  #
+# Copyright (C) 2010 Jens Wille                                               #
+#                                                                             #
+# Authors:                                                                    #
+#     Leonard Richardson <leonardr@segfault.org> (Original author)            #
+#     Jens Wille <jens.wille@uni-koeln.de>                                    #
+#                                                                             #
+# wadl is free software; you can redistribute it and/or modify it under the   #
+# terms of the GNU General Public License as published by the Free Software   #
+# Foundation; either version 3 of the License, or (at your option) any later  #
+# version.                                                                    #
+#                                                                             #
+# wadl is distributed in the hope that it will be useful, but WITHOUT ANY     #
+# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS   #
+# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more       #
+# details.                                                                    #
+#                                                                             #
+# You should have received a copy of the GNU General Public License along     #
+# with wadl. If not, see <http://www.gnu.org/licenses/>.                      #
+#                                                                             #
+###############################################################################
+#++
+
+require 'wadl'
+
+module WADL
+
+  class RequestFormat < HasDocs
+
+    include RepresentationContainer
+
+    in_document 'request'
+    has_many RepresentationFormat, Param
+
+    # Returns a URI and a set of HTTP headers for this request.
+    def uri(resource, args = {})
+      uri = resource.uri(args)
+
+      query_values  = args[:query]   || {}
+      header_values = args[:headers] || {}
+
+      params.each { |param|
+        name = param.name
+
+        if param.style == 'header'
+          value = header_values[name] || header_values[name.to_sym]
+          value = param % value
+
+          uri.headers[name] = value if value
+        else
+          value = query_values[name] || query_values[name.to_sym]
+          value = param.format(value, nil, 'query')
+
+          uri.query << value if value
+        end
+      }
+
+      uri
+    end
+
+  end
+
+end

data/lib/wadl/resource.rb

@@ -0,0 +1,163 @@
+#--
+###############################################################################
+#                                                                             #
+# A component of wadl, the super cheap Ruby WADL client.                      #
+#                                                                             #
+# Copyright (C) 2006-2008 Leonard Richardson                                  #
+# Copyright (C) 2010 Jens Wille                                               #
+#                                                                             #
+# Authors:                                                                    #
+#     Leonard Richardson <leonardr@segfault.org> (Original author)            #
+#     Jens Wille <jens.wille@uni-koeln.de>                                    #
+#                                                                             #
+# wadl is free software; you can redistribute it and/or modify it under the   #
+# terms of the GNU General Public License as published by the Free Software   #
+# Foundation; either version 3 of the License, or (at your option) any later  #
+# version.                                                                    #
+#                                                                             #
+# wadl is distributed in the hope that it will be useful, but WITHOUT ANY     #
+# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS   #
+# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more       #
+# details.                                                                    #
+#                                                                             #
+# You should have received a copy of the GNU General Public License along     #
+# with wadl. If not, see <http://www.gnu.org/licenses/>.                      #
+#                                                                             #
+###############################################################################
+#++
+
+require 'set'
+require 'wadl'
+
+module WADL
+
+  class Resource < HasDocs
+
+    include ResourceContainer
+
+    in_document 'resource'
+    has_attributes :id, :path
+    has_many Resource, HTTPMethod, Param, ResourceType
+    may_be_reference  # not conforming to spec (20090831), but tests make use of it
+
+    def initialize(*args)
+      super
+    end
+
+    def dereference_with_context(child)
+      ResourceAndAddress.new(child, parent.address)
+    end
+
+    # Returns a ResourceAndAddress object bound to this resource
+    # and the given query variables.
+    def bind(args = {})
+      ResourceAndAddress.new(self).bind!(args)
+    end
+
+    # Sets basic auth parameters
+    def with_basic_auth(user, pass, header = 'Authorization')
+      bind(:headers => { header => "Basic #{["#{user}:#{pass}"].pack('m')}" })
+    end
+
+    # Sets OAuth parameters
+    #
+    # Args:
+    #  :consumer_key
+    #  :consumer_secret
+    #  :access_token
+    #  :token_secret
+    def with_oauth(*args)
+      header, prefix = HTTPMethod::OAUTH_HEADER, HTTPMethod::OAUTH_PREFIX
+      bind(:headers => { header => "#{prefix}#{args.to_yaml}" })
+    end
+
+    def uri(args = {}, working_address = nil)
+      address(working_address).uri(args)
+    end
+
+    # Returns an Address object refering to this resource
+    def address(working_address = nil)
+      working_address &&= working_address.deep_copy
+
+      working_address ||= if parent.respond_to?(:base)
+        address = Address.new
+        address.path_fragments << parent.base
+        address
+      else
+        parent.address.deep_copy
+      end
+
+      working_address.path_fragments << path.dup
+
+      # Install path, query, and header parameters in the Address. These
+      # may override existing parameters with the same names, but if
+      # you've got a WADL application that works that way, you should
+      # have bound parameters to values earlier.
+      new_path_fragments = []
+      embedded_param_names = Set.new(Address.embedded_param_names(path))
+
+      params.each { |param|
+        name = param.name
+
+        if embedded_param_names.include?(name)
+          working_address.path_params[name] = param
+        else
+          if param.style == 'query'
+            working_address.query_params[name] = param
+          elsif param.style == 'header'
+            working_address.header_params[name] = param
+          else
+            new_path_fragments << param
+            working_address.path_params[name] = param
+          end
+        end
+      }
+
+      working_address.path_fragments << new_path_fragments unless new_path_fragments.empty?
+
+      working_address
+    end
+
+    def representation_for(http_method, request = true, all = false)
+      method = find_method_by_http_method(http_method)
+      representations = (request ? method.request : method.response).representations
+
+      all ? representations : representations[0]
+    end
+
+    def find_by_id(id)
+      id = id.to_s
+      resources.find { |r| r.dereference.id == id }
+    end
+
+    # Find HTTP methods in this resource and in the mixed-in types
+    def each_http_method
+      [self, *resource_types].each { |t| t.http_methods.each { |m| yield m } }
+    end
+
+    def find_method_by_id(id)
+      id = id.to_s
+      each_http_method { |m| return m if m.dereference.id == id }
+    end
+
+    def find_method_by_http_method(action)
+      action = action.to_s.downcase
+      each_http_method { |m| return m if m.dereference.name.downcase == action }
+    end
+
+    # Methods for reading or writing this resource
+    def self.define_http_methods(klass = self, methods = %w[get post put delete])
+      methods.each { |method|
+        klass.class_eval <<-EOT, __FILE__, __LINE__ + 1
+          def #{method}(*args, &block)
+            find_method_by_http_method(:#{method}).call(self, *args, &block)
+          end
+        EOT
+      }
+    end
+
+    define_http_methods
+
+  end
+
+end

data/lib/wadl/resource_and_address.rb

@@ -0,0 +1,108 @@
+#--
+###############################################################################
+#                                                                             #
+# A component of wadl, the super cheap Ruby WADL client.                      #
+#                                                                             #
+# Copyright (C) 2006-2008 Leonard Richardson                                  #
+# Copyright (C) 2010 Jens Wille                                               #
+#                                                                             #
+# Authors:                                                                    #
+#     Leonard Richardson <leonardr@segfault.org> (Original author)            #
+#     Jens Wille <jens.wille@uni-koeln.de>                                    #
+#                                                                             #
+# wadl is free software; you can redistribute it and/or modify it under the   #
+# terms of the GNU General Public License as published by the Free Software   #
+# Foundation; either version 3 of the License, or (at your option) any later  #
+# version.                                                                    #
+#                                                                             #
+# wadl is distributed in the hope that it will be useful, but WITHOUT ANY     #
+# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS   #
+# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more       #
+# details.                                                                    #
+#                                                                             #
+# You should have received a copy of the GNU General Public License along     #
+# with wadl. If not, see <http://www.gnu.org/licenses/>.                      #
+#                                                                             #
+###############################################################################
+#++
+
+require 'delegate'
+require 'wadl'
+
+module WADL
+
+  # A resource bound beneath a certain address. Used to keep track of a
+  # path through a twisting resource hierarchy that includes references.
+
+  class ResourceAndAddress < DelegateClass(Resource)
+
+    def initialize(resource, address = nil, combine_address_with_resource = true)
+      @resource = resource
+      @address  = combine_address_with_resource ? resource.address(address) : address
+
+      super(resource)
+    end
+
+    # The id method is not delegated, because it's the name of a
+    # (deprecated) built-in Ruby method. We wnat to delegate it.
+    def id
+      @resource.id
+    end
+
+    def to_s
+      inspect
+    end
+
+    def inspect
+      "ResourceAndAddress\n Resource: #{@resource}\n #{@address.inspect}"
+    end
+
+    def address
+      @address
+    end
+
+    def bind(*args)
+      ResourceAndAddress.new(@resource, @address.deep_copy, false).bind!(*args)
+    end
+
+    def bind!(args = {})
+      @address.bind!(args)
+      self
+    end
+
+    def uri(args = {})
+      @address.deep_copy.bind!(args).uri
+    end
+
+    # method_missing is to catch generated methods that don't get delegated.
+    def method_missing(name, *args, &block)
+      if @resource.respond_to?(name)
+        result = @resource.send(name, *args, &block)
+        result.is_a?(Resource) ? ResourceAndAddress.new(result, @address.dup) : result
+      else
+        super
+      end
+    end
+
+    # method_missing won't catch these guys because they were defined in
+    # the delegation operation.
+    def resource(*args, &block)
+      resource = @resource.resource(*args, &block)
+      resource && ResourceAndAddress.new(resource, @address)
+    end
+
+    def find_resource(*args, &block)
+      resource = @resource.find_resource(*args, &block)
+      resource && ResourceAndAddress.new(resource, @address)
+    end
+
+    def find_resource_by_path(*args, &block)
+      resource = @resource.find_resource_by_path(*args, &block)
+      resource && ResourceAndAddress.new(resource, @address)
+    end
+
+    Resource.define_http_methods(self)
+
+  end
+
+end