kaiwren-wrest 0.0.6 → 0.0.8

data/lib/wrest/components/attributes_container/typecaster.rb

@@ -0,0 +1,121 @@
+# 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::AttributesContainer
+    # An extension to AttributesContainer that adds support for
+    # specifying how the values associated with certain attribute keys
+    # should be typecast.
+    #
+    # This extension can be used in situations where the attributes
+    # hash consists of just strings with no associated tup information.
+    # For example, params recieved from a web browser may contain
+    # attributes like
+    #  'id' => '4', 'dateofbirth' => '1984-04-05'
+    # and we'd like to have these cast to an integer and a date
+    # respectively, rather than have to deal with them as strings.
+    module Typecaster
+      def self.included(klass) #:nodoc:
+        klass.extend Typecaster::ClassMethods
+        klass.class_eval{ include Typecaster::InstanceMethods }
+        klass.alias_method_chain  :initialize,  :typecasting
+      end
+
+      module ClassMethods
+        # Accepts a set of attribute-name/lambda pairs which are used
+        # to typecast string values injected through the constructor.
+        # Typically needed when populating an +AttributesContainer+
+        # directly from request params. Typecasting kicks in for
+        # a given value _only_ if it is a string.
+        #
+        # Typecast information is inherited by subclasses; however be
+        # aware that explicitly invoking +typecast+ in a subclass will
+        # discard inherited typecast information leaving only the casts
+        # defined in the subclass.
+        #
+        # Common typecasts such as integer, float, datetime etc. are
+        # available through predefined helpers. See TypecastHelpers
+        # for a full list.
+        #
+        # Example:
+        #
+        #  class Demon
+        #    include Wrest::Components::AttributesContainer
+        #    include Wrest::Components::AttributesContainer::Typecaster
+        #
+        #    typecast         :age          =>  as_integer,
+        #                     :chi          =>  lambda{|chi| Chi.new(chi)}
+        #  end
+        #
+        #  kai_wren = Demon.new('age' => '1500', 'chi' => '1024')
+        #  kai_wren.age           # => 1500
+        #  kai_wren.chi           # => #<Chi:0x113af8c @count="1024">
+        def typecast(cast_map)
+          @typecast_map = @typecast_map ? @typecast_map.merge(cast_map.symbolize_keys) : cast_map.symbolize_keys
+        end
+
+        def typecast_map #:nodoc:
+          if defined?(@typecast_map)
+            @typecast_map
+          elsif superclass != Object && superclass.respond_to?(:typecast_map)
+            superclass.typecast_map
+          else
+            {}
+          end
+        end
+
+        def as_base64Binary
+          ActiveSupport::CoreExtensions::Hash::Conversions::XML_PARSING['base64Binary']
+        end
+
+        def as_boolean
+          ActiveSupport::CoreExtensions::Hash::Conversions::XML_PARSING['boolean']
+        end
+
+        def as_decimal
+          ActiveSupport::CoreExtensions::Hash::Conversions::XML_PARSING['decimal']
+        end
+
+        def as_date
+          ActiveSupport::CoreExtensions::Hash::Conversions::XML_PARSING['date']
+        end
+
+        def as_datetime
+          ActiveSupport::CoreExtensions::Hash::Conversions::XML_PARSING['datetime']
+        end
+
+        def as_float
+          ActiveSupport::CoreExtensions::Hash::Conversions::XML_PARSING['float']
+        end
+
+        def as_integer
+          ActiveSupport::CoreExtensions::Hash::Conversions::XML_PARSING['integer']
+        end
+
+        def as_symbol
+          ActiveSupport::CoreExtensions::Hash::Conversions::XML_PARSING['symbol']
+        end
+
+        def as_yaml
+          ActiveSupport::CoreExtensions::Hash::Conversions::XML_PARSING['yaml']
+        end
+      end
+
+      module InstanceMethods # :nodoc:
+        def initialize_with_typecasting(attributes = {}) # :nodoc:
+          initialize_without_typecasting(attributes)
+          self.class.typecast_map.each do |key, typecaster|
+            value = @attributes[key]
+            @attributes[key] = typecaster.call(value) if value.is_a?(String)
+          end
+        end
+      end
+    end
+  end
+end

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