wrest 0.0.6-java → 0.0.7-java

data/lib/wrest/components/mutators.rb

@@ -7,16 +7,33 @@
 # is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
 # See the License for the specific language governing permissions and limitations under the License. 
 
-module Wrest #:nodoc:
+module Wrest
   module Components
     # A mutator understands how to transform
     # one tuple(key/value pair) from a hash
     # into another
     module Mutators
+      # All sublasses of Mutators::Base are automatically
+      # registered here by underscored, symbolised class name.
+      REGISTRY = {}
+      
+      # Makes referencing and chaining mutators easy.
+      # 
+      # Example:
+      #  Mutators.chain(:xml_mini_type_caster, :camel_to_snake_case)
+      # is equivalent to
+      #  Wrest::Components::Mutators::XmlMiniTypeCaster.new(Wrest::Components::Mutators::CamelToSnakeCase.new)
+      def self.chain(*mutator_keys)
+        mutator_key = mutator_keys.pop
+        mutator_keys.reverse.inject(REGISTRY[mutator_key].new) do |next_instance, next_key| 
+          REGISTRY[next_key].new(next_instance)
+        end
+      end
     end
   end
 end
 
 require "#{WREST_ROOT}/wrest/components/mutators/base"
 require "#{WREST_ROOT}/wrest/components/mutators/xml_simple_type_caster"
+require "#{WREST_ROOT}/wrest/components/mutators/xml_mini_type_caster"
 require "#{WREST_ROOT}/wrest/components/mutators/camel_to_snake_case"

data/lib/wrest/components/mutators/base.rb

@@ -1,43 +1,56 @@
 # Copyright 2009 Sidu Ponnappa
 
-# Licensed under the Apache License, Version 2.0 (the "License"); 
-# you may not use this file except in compliance with the License. 
-# You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 
-# Unless required by applicable law or agreed to in writing, software distributed under the License 
-# is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-# See the License for the specific language governing permissions and limitations under the License. 
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software distributed under the License
+# is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and limitations under the License.
 
-# This is a base implementation of a
-# hash mutator that ensures that the <tt>mutate</tt> method
-# will chain to the next mutator by using a
-# template method.
-class Wrest::Components::Mutators::Base
-  attr_reader :next_mutator
-    
-  def initialize(next_mutator = nil)
-    @next_mutator = next_mutator
-  end
-  
-  # This is a template method which operates on a tuple (well, pair)
-  # from a hash map and guarantees mutator chaining.
-  #
-  # Iterating over any hash using <tt>each</tt> injects
-  # each key/value pair from the hash in the
-  # form of an array.
-  # This method expects of this form as an argument, i.e.
-  # an array with the structure [:key, :value]
-  #
-  # The implementation of the mutation is achieved by
-  # overriding the <tt>do_mutate</tt> method in a subclass.
-  # Note that failing to do so will result in an exception
-  # at runtime.
-  def mutate(tuple)
-    out_tuple = do_mutate(tuple)
-    next_mutator ? next_mutator.mutate(out_tuple) : out_tuple
-  end
-  
-  protected
-  def do_mutate(tuple)
-    raise Wrest::Exceptions::MethodNotOverriddenException
+module Wrest
+  module Components
+    # This is a base implementation of a
+    # hash mutator that ensures that the <tt>mutate</tt> method
+    # will chain to the next mutator by using a
+    # template method.
+    class Mutators::Base
+      attr_reader :next_mutator
+
+      # Registers all subclasses of Mutators::Base in
+      # Mutators::REGISTRY making it easy to reference
+      # and chain them later.
+      #
+      # See Mutators#chain for more information.
+      def self.inherited(subklass)
+        Wrest::Components::Mutators::REGISTRY[subklass.name.demodulize.underscore.to_sym] = subklass unless subklass.name.blank?
+      end
+
+      def initialize(next_mutator = nil)
+        @next_mutator = next_mutator
+      end
+
+      # This is a template method which operates on a tuple (well, pair)
+      # from a hash map and guarantees mutator chaining.
+      #
+      # Iterating over any hash using <tt>each</tt> injects
+      # each key/value pair from the hash in the
+      # form of an array.
+      # This method expects of this form as an argument, i.e.
+      # an array with the structure [:key, :value]
+      #
+      # The implementation of the mutation is achieved by
+      # overriding the <tt>do_mutate</tt> method in a subclass.
+      # Note that failing to do so will result in an exception
+      # at runtime.
+      def mutate(tuple)
+        out_tuple = do_mutate(tuple)
+        next_mutator ? next_mutator.mutate(out_tuple) : out_tuple
+      end
+
+      protected
+      def do_mutate(tuple)
+        raise Wrest::Exceptions::MethodNotOverriddenException
+      end
+    end
   end
-end
+end

data/lib/wrest/components/mutators/camel_to_snake_case.rb

@@ -7,14 +7,16 @@
 # is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and limitations under the License.
 
-module Wrest::Components
-  class Mutators::CamelToSnakeCase < Mutators::Base
+module Wrest
+  module Components
     # Converts the key to snake case
     #
     # Example:
-    #  Mutators::CamelToSnakeCase.new.mutate(['Spirit-Sword', 'true'])  # => ['spirit_sword', 'true']
-    def do_mutate(tuple)
-      [tuple.first.underscore, tuple.last]
+    #  Mutators::CamelToSnakeCase.new.mutate(['Spirit-Sword', 'true'])  # => ['spirit_sword', 'true']**
+    class Mutators::CamelToSnakeCase < Mutators::Base
+      def do_mutate(tuple)
+        [tuple.first.underscore, tuple.last]
+      end
     end
   end
 end

data/lib/wrest/components/mutators/xml_mini_type_caster.rb

@@ -0,0 +1,43 @@
+# Copyright 2009 Sidu Ponnappa
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software distributed under the License
+# is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and limitations under the License.
+
+
+module Wrest
+  module Components
+    # This mutator undertands how do type casting
+    # using the type data embedded in a hash
+    # created by deserialising an xml using
+    # ActiveSupport::XmlMini
+    class Mutators::XmlMiniTypeCaster < Mutators::Base
+      def do_mutate(tuple)
+        out_key, in_value = tuple
+
+        case in_value
+        when Hash
+          if in_value['nil'] == 'true'
+            out_value = nil
+          elsif in_value.key?('type')
+            caster = ActiveSupport::CoreExtensions::Hash::Conversions::XML_PARSING[in_value['type']]
+            out_value = caster ? caster.call(in_value['__content__']) : in_value
+          elsif in_value.key?('__content__')
+            out_value = in_value['__content__']
+          else
+            out_value = in_value.mutate_using(self)
+          end
+        when Array
+          out_value = in_value.collect{|hash| hash.mutate_using(self)}
+        else
+          out_value = in_value
+        end
+
+        [out_key, out_value]
+      end
+    end
+  end
+end

data/lib/wrest/components/mutators/xml_simple_type_caster.rb

@@ -7,29 +7,31 @@
 # is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and limitations under the License.
 
-# This mutator undertands how do type casting
-# using the type data embedded in a hash
-# created by deserialising an xml using
-# xml-simple
-module Wrest::Components
-  class Mutators::XmlSimpleTypeCaster < Mutators::Base
-    def do_mutate(tuple)
-      out_key = tuple.first
-      in_value = tuple.last[0]
-      out_value = in_value
+module Wrest
+  module Components
+    # This mutator undertands how do type casting
+    # using the type data embedded in a hash
+    # created by deserialising an xml using
+    # xml-simple
+    class Mutators::XmlSimpleTypeCaster < Mutators::Base
+      def do_mutate(tuple)
+        out_key = tuple.first
+        in_value = tuple.last[0]
+        out_value = in_value
 
-      case in_value
-      when Hash
-        if in_value['nil'] == 'true'
-          out_value = nil
-        elsif in_value.key?('type')
-          out_value = ActiveSupport::CoreExtensions::Hash::Conversions::XML_PARSING[in_value['type']].call(in_value['content'])
-        else
-          out_value = in_value.mutate_using(self)
+        case in_value
+        when Hash
+          if in_value['nil'] == 'true'
+            out_value = nil
+          elsif in_value.key?('type')
+            out_value = ActiveSupport::CoreExtensions::Hash::Conversions::XML_PARSING[in_value['type']].call(in_value['content'])
+          else
+            out_value = in_value.mutate_using(self)
+          end
         end
-      end
 
-      [out_key, out_value]
+        [out_key, out_value]
+      end
     end
   end
 end

data/lib/wrest/components/translators.rb

@@ -1,25 +1,28 @@
 # Copyright 2009 Sidu Ponnappa
 
-# Licensed under the Apache License, Version 2.0 (the "License"); 
-# you may not use this file except in compliance with the License. 
-# You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 
-# Unless required by applicable law or agreed to in writing, software distributed under the License 
-# is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-# See the License for the specific language governing permissions and limitations under the License. 
- 
-module Wrest::Components #:nodoc:
-  # Contains strategies/lambdas which know how to deserialise
-  # different content types.
-  module Translators
-    # Loads the appropriate desirialisation strategy based on
-    # the content type
-    def self.lookup(content_type)
-      translator = CONTENT_TYPES[content_type]
-      translator || (raise Wrest::Exceptions::UnsupportedContentTypeException.new("Unsupported content type #{content_type}"))
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software distributed under the License
+# is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and limitations under the License.
+
+
+module Wrest
+  module Components
+    # Contains strategies/lambdas which know how to deserialise
+    # different content types.
+    module Translators
+      # Loads the appropriate desirialisation strategy based on
+      # the content type
+      def self.lookup(content_type)
+        translator = CONTENT_TYPES[content_type]
+        translator || (raise Wrest::Exceptions::UnsupportedContentTypeException.new("Unsupported content type #{content_type}"))
+      end
     end
   end
 end
 
 require "#{WREST_ROOT}/wrest/components/translators/xml"
 require "#{WREST_ROOT}/wrest/components/translators/json"
-require "#{WREST_ROOT}/wrest/components/translators/content_types"
+require "#{WREST_ROOT}/wrest/components/translators/content_types"

data/lib/wrest/components/translators/content_types.rb

@@ -7,8 +7,8 @@
 # is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
 # See the License for the specific language governing permissions and limitations under the License. 
 
-module Wrest::Components 
-  module Translators
+module Wrest
+  module Components::Translators
     # Maps content types to deserialisers
     CONTENT_TYPES = {
       'application/xml' => Wrest::Components::Translators::Xml,

data/lib/wrest/components/translators/json.rb

@@ -7,16 +7,19 @@
 # is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and limitations under the License.
 
-module Wrest::Components::Translators
-  module Json
-    extend self
 
-    def deserialise(response)
-      ActiveSupport::JSON.decode(response.body)
-    end
+module Wrest
+  module Components
+    module Translators::Json
+      extend self
+
+      def deserialise(response)
+        ActiveSupport::JSON.decode(response.body)
+      end
 
-    def serialise(hash)
-      ActiveSupport::JSON.encode(hash)
+      def serialise(hash)
+        ActiveSupport::JSON.encode(hash)
+      end
     end
   end
 end

data/lib/wrest/components/translators/xml.rb

@@ -7,20 +7,17 @@
 # is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and limitations under the License.
 
-require 'xmlsimple'
+module Wrest
+  module Components::Translators
+    module Xml
+      extend self
 
-module Wrest::Components::Translators
-  module Xml
-    extend self
+      def deserialise(response)
+        ActiveSupport::XmlMini.parse(response.body)
+      end
 
-    def deserialise(response)
-      XmlSimple.xml_in(
-      response.body,
-      'keeproot'  => true
-      )
-    end
-
-    def serialise(hash)
+      def serialise(hash)
+      end
     end
   end
 end

data/lib/wrest/core_ext/hash/conversions.rb

@@ -22,7 +22,7 @@ module Wrest
         # Yes, the name is misleading in that respect. However, one 
         # hopes the absence of an exclamation mark will increase clarity.
         #
-        # Uses include mutating the hash produced by xml-simple
+        # Uses include mutating the hash produced by deserialising xml
         # by using the meta data in the hash to type cast values.
         # 
         # Example:

data/lib/wrest/resource/base.rb

@@ -12,55 +12,67 @@ module Wrest::Resource #:nodoc:
   # It is a REST client targetted at Rails REST apps.
   class Base
     include Wrest::Components::AttributesContainer
-
-    has_attributes  :id
+    include Wrest::Components::AttributesContainer::Typecaster
+    
+    always_has  :id
     typecast        :id => as_integer
     attr_reader     :attributes
-    
+
     class << self
       def inherited(klass)
         klass.set_resource_name klass.name
       end
-      
+
       # Allows the resource name to be configured and creates
-      # a getter method for it. 
+      # a getter method for it.
       # This is a useful feature when using anonymous classes like
       # we often do while writing tests.
       # By default, the resource name is set to the name of the class.
       def set_resource_name(resource_name)
         self.class_eval "def self.resource_name; '#{resource_name}';end"
       end
-      
+
       # Allows the host url at which the resource is found to be configured
-      # and creates a getter method for it. 
+      # and creates a getter method for it.
       # For example in the url
       #  http://localhost:3000/users/1/settings
-      # you would set 
+      # you would set
       #  http://localhost:3000
       # as the host url.
       def set_host(host)
         self.class_eval "def self.host; '#{host}';end"
       end
       
-      def set_redirect_handler(method_object)
+      def set_default_format(format)
+        self.class_eval "def self.default_format; '#{format.to_s}';end"
       end
       
+      def set_redirect_handler(method_object)
+      end
+
       def resource_path
         @resource_path ||= "/#{resource_name.underscore.pluralize}"
       end
 
-      def resource_url
+      def resource_collection_url
         "#{host}#{resource_path}"
       end
-      
+
       def find_all
       end
 
+      def find(resource_type = [:one, :collection, :singleton], from = "")
+      end
+
       def find(id)
-        response_hash = "#{resource_url}/#{id}".to_uri.get.deserialise
+        response_hash = "#{resource_collection_url}/#{id}.#{default_format}".to_uri.get.deserialise.mutate_using(
+                                                                                          Wrest::Components::Mutators.chain(
+                                                                                            :xml_mini_type_caster, :camel_to_snake_case
+                                                                                          )
+                                                                                        )
         resource_type = response_hash.keys.first
         if(resource_type.underscore.camelize == self.name)
-          self.new(response_hash[resource_type].first)
+          self.new(response_hash[resource_type])
         else
           response_hash
         end