wrest 3.0.0 → 4.0.0

data/lib/wrest/components/container.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Copyright 2009 Sidu Ponnappa
 
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -8,176 +10,193 @@
 # See the License for the specific language governing permissions and limitations under the License.
 
 module Wrest
-  module Components::Container
+  module Components
+    module Container
+    end
   end
 end
 
-require "wrest/components/container/typecaster"
-require "wrest/components/container/alias_accessors"
-
-module Wrest::Components
-
-  # Adds behaviour allowing a class to
-  # contain attributes and providing support
-  # for dynamic getters, setters and query methods.
-  # These methods are added at runtime, on the first
-  # invocation and on a per instance basis.
-  # <tt>respond_to?</tt> however will respond as though
-  # they are all already present.
-  # This means that two different instances of the same
-  # Container could well have different attribute 
-  # getters/setters/query methods.
-  #
-  # Note that the first call to a particular getter/setter/query
-  # method will be slower because the method is defined
-  # at that point; subsequent calls will be much faster.
-  #
-  # Also keep in mind that attribute getter/setter/query methods
-  # will _not_ override any existing methods on the class.
-  #
-  # In situations where this is a problem, such as a client consuming Rails
-  # REST services where <tt>id</tt> is a common attribute and clashes with
-  # Object#id, it is recommended to create getter/setter/query methods
-  # on the class (which affects all instances) using the +always_has+ macro.
-  #
-  # If you're implementing your own initialize method
-  # remember to delegate to the default initialize
-  # of Container by invoking <tt>super(attributes)</tt>
-  #
-  # Example:
-  #  class ShenCoin
-  #    include Wrest::Components::Container
-  #    include Wrest::Components::Container::Typecaster
-  #
-  #    always_has   :id
-  #    typecast         :id   =>  as_integer
-  #  end
-  #  coin = ShenCoin.new(:id => '5', :chi_count => 500, :owner => 'Kai Wren')
-  #  coin.id    # => 5
-  #  coin.owner # => 'Kai Wren'
-  module Container
-    def self.included(klass) #:nodoc:
-      klass.extend Container::ClassMethods
-      klass.extend Container::Typecaster::Helpers
-      klass.class_eval do 
-        include Container::InstanceMethods
-        include Container::AliasAccessors
-      end  
-    end
-
-    def self.build_attribute_getter(attribute_name) #:nodoc:
-      "def #{attribute_name};@attributes[:#{attribute_name}];end;"
-    end
+require 'wrest/components/container/typecaster'
+require 'wrest/components/container/alias_accessors'
 
-    def self.build_attribute_setter(attribute_name) #:nodoc:
-      "def #{attribute_name}=(value);@attributes[:#{attribute_name}] = value;end;"
-    end
-
-    def self.build_attribute_queryer(attribute_name) #:nodoc:
-      "def #{attribute_name}?;not @attributes[:#{attribute_name}].nil?;end;"
-    end
-
-    module ClassMethods
-      # This macro explicitly creates getter, setter and query methods on
-      # an Container, overriding any exisiting methods with the same names.
-      # This can be used when attribute names clash with existing method names;
-      # an example would be Rails REST resources which frequently make use
-      # an attribute named <tt>id</tt> which clashes with Object#id. Also,
-      # this can be used as a performance optimisation if the incoming
-      # attributes are known beforehand.
-      def always_has(*attribute_names)
-        attribute_names.each do |attribute_name|
-          self.class_eval(
-          Container.build_attribute_getter(attribute_name) +
-          Container.build_attribute_setter(attribute_name) +
-          Container.build_attribute_queryer(attribute_name)
-          )
+module Wrest
+  module Components
+    # Adds behaviour allowing a class to
+    # contain attributes and providing support
+    # for dynamic getters, setters and query methods.
+    # These methods are added at runtime, on the first
+    # invocation and on a per instance basis.
+    # <tt>respond_to?</tt> however will respond as though
+    # they are all already present.
+    # This means that two different instances of the same
+    # Container could well have different attribute
+    # getters/setters/query methods.
+    #
+    # Note that the first call to a particular getter/setter/query
+    # method will be slower because the method is defined
+    # at that point; subsequent calls will be much faster.
+    #
+    # Also keep in mind that attribute getter/setter/query methods
+    # will _not_ override any existing methods on the class.
+    #
+    # In situations where this is a problem, such as a client consuming Rails
+    # REST services where <tt>id</tt> is a common attribute and clashes with
+    # Object#id, it is recommended to create getter/setter/query methods
+    # on the class (which affects all instances) using the +always_has+ macro.
+    #
+    # If you're implementing your own initialize method
+    # remember to delegate to the default initialize
+    # of Container by invoking <tt>super(attributes)</tt>
+    #
+    # Example:
+    #  class ShenCoin
+    #    include Wrest::Components::Container
+    #    include Wrest::Components::Container::Typecaster
+    #
+    #    always_has   :id
+    #    typecast         :id   =>  as_integer
+    #  end
+    #  coin = ShenCoin.new(:id => '5', :chi_count => 500, :owner => 'Kai Wren')
+    #  coin.id    # => 5
+    #  coin.owner # => 'Kai Wren'
+    module Container
+      def self.included(klass) # :nodoc:
+        klass.extend Container::ClassMethods
+        klass.extend Container::Typecaster::Helpers
+        klass.class_eval do
+          include Container::InstanceMethods
+          include Container::AliasAccessors
         end
       end
-      
-      # This is a convenience macro which includes 
-      # Wrest::Components::Container::Typecaster into
-      # the class (effectively overwriting this method) before delegating to 
-      # the actual typecast method that is a part of that module.
-      # This saves us the effort of explicitly doing the include. Easy to use API is king.
-      #
-      # Remember that using typecast carries a performance penalty.
-      # See Wrest::Components::Container::Typecaster for the actual docs.
-      def typecast(cast_map)
-        self.class_eval{ include Wrest::Components::Container::Typecaster }
-        self.typecast cast_map
-      end
-      
-      # This is the name of the class in snake-case, with any parent
-      # module names removed.
-      #
-      # The class will use as the root element when
-      # serialised to xml after replacing underscores with hyphens.
-      #
-      # This method can be overidden should you need a different name.
-      def element_name
-        @element_name ||= ActiveSupport::Inflector.demodulize(self.name).underscore.underscore
-      end
-    end
 
-    module InstanceMethods
-      # Sets up any class to act like
-      # an attributes container by creating
-      # two variables, @attributes and @interface.
-      # Remember not to use these two variable names
-      # when using Container in your own class.
-      def initialize(attributes = {})
-        @attributes = HashWithIndifferentAccess.new(attributes)
-      end
-      
-      # A translator is a anything that knows how to serialise a
-      # Hash. It must needs have a method named 'serialise' that
-      # accepts a hash and configuration options, and returns the serialised 
-      # result (leaving the hash unchanged, of course).
-      #
-      # Examples for JSON and XML can be found under Wrest::Components::Translators.
-      # These serialised output of these translators will work out of the box for Rails 
-      # applications; you may need to roll your own for anything else.
-      #
-      # Note: When serilising to XML, if you want the name of the class as the name of the root node
-      # then you should use the Container#to_xml helper.
-      def serialise_using(translator, options = {})
-        translator.serialise(@attributes, options)
+      def self.build_attribute_getter(attribute_name) # :nodoc:
+        "def #{attribute_name};@attributes[:#{attribute_name}];end;"
       end
-      
-      def to_xml(options = {})
-        serialise_using(Wrest::Components::Translators::Xml, {:root => self.class.element_name}.merge(options))
-      end
-      
-      def [](key)
-        @attributes[key.to_sym]
+
+      def self.build_attribute_setter(attribute_name) # :nodoc:
+        "def #{attribute_name}=(value);@attributes[:#{attribute_name}] = value;end;"
       end
 
-      def []=(key, value)
-        @attributes[key.to_sym] = value
+      def self.build_attribute_queryer(attribute_name) # :nodoc:
+        "def #{attribute_name}?;not @attributes[:#{attribute_name}].nil?;end;"
       end
 
-      def respond_to?(method_name, include_private = false)
-        super(method_name, include_private) ? true : @attributes.include?(method_name.to_s.gsub(/(\?$)|(=$)/, '').to_sym)
+      module ClassMethods
+        # This macro explicitly creates getter, setter and query methods on
+        # an Container, overriding any existing methods with the same names.
+        # This can be used when attribute names clash with existing method names;
+        # an example would be Rails REST resources which frequently make use
+        # an attribute named <tt>id</tt> which clashes with Object#id. Also,
+        # this can be used as a performance optimisation if the incoming
+        # attributes are known beforehand.
+        def always_has(*attribute_names)
+          attribute_names.each do |attribute_name|
+            class_eval(
+              Container.build_attribute_getter(attribute_name) +
+              Container.build_attribute_setter(attribute_name) +
+              Container.build_attribute_queryer(attribute_name)
+            )
+          end
+        end
+
+        # This is a convenience macro which includes
+        # Wrest::Components::Container::Typecaster into
+        # the class (effectively overwriting this method) before delegating to
+        # the actual typecast method that is a part of that module.
+        # This saves us the effort of explicitly doing the include. Easy to use API is king.
+        #
+        # Remember that using typecast carries a performance penalty.
+        # See Wrest::Components::Container::Typecaster for the actual docs.
+        def typecast(cast_map)
+          class_eval { include Wrest::Components::Container::Typecaster }
+          typecast cast_map
+        end
+
+        # This is the name of the class in snake-case, with any parent
+        # module names removed.
+        #
+        # The class will use as the root element when
+        # serialised to xml after replacing underscores with hyphens.
+        #
+        # This method can be overidden should you need a different name.
+        def element_name
+          @element_name ||= Utils.string_underscore(Utils.string_demodulize(name))
+        end
       end
 
-      # Creates getter, setter and query methods for
-      # attributes on the first call.
-      def method_missing(method_sym, *arguments)
-        method_name = method_sym.to_s
-        attribute_name = method_name.gsub(/(\?$)|(=$)/, '')
-        if @attributes.include?(attribute_name.to_sym) || method_name.last == '=' || method_name.last == '?'
-          case method_name.last
+      module InstanceMethods
+        # Sets up any class to act like
+        # an attributes container by creating
+        # two variables, @attributes and @interface.
+        # Remember not to use these two variable names
+        # when using Container in your own class.
+        def initialize(attributes = {})
+          @attributes = HashWithIndifferentAccess.new(attributes)
+        end
+
+        # A translator is a anything that knows how to serialise a
+        # Hash. It must needs have a method named 'serialise' that
+        # accepts a hash and configuration options, and returns the serialised
+        # result (leaving the hash unchanged, of course).
+        #
+        # Examples for JSON and XML can be found under Wrest::Components::Translators.
+        # These serialised output of these translators will work out of the box for Rails
+        # applications; you may need to roll your own for anything else.
+        #
+        # Note: When serilising to XML, if you want the name of the class as the name of the root node
+        # then you should use the Container#to_xml helper.
+        def serialise_using(translator, options = {})
+          payload = {
+            self.class.element_name => @attributes.dup
+          }
+          translator.serialise(payload, options)
+        end
+
+        def to_xml(options = {})
+          serialise_using(Wrest::Components::Translators::Xml, { root: self.class.element_name }.merge(options))
+        end
+
+        def [](key)
+          @attributes[key.to_sym]
+        end
+
+        def []=(key, value)
+          @attributes[key.to_sym] = value
+        end
+
+        def respond_to_missing?(method_name, *)
+          if super.respond_to?(method_name)
+            true
+          else
+            @attributes.include?(method_name.to_s.gsub(/(\?$)|(=$)/,
+                                                       '').to_sym)
+          end
+        end
+
+        # Creates getter, setter and query methods for
+        # attributes on the first call.
+        def method_missing(method_sym, *arguments)
+          method_name = method_sym.to_s
+          attribute_name = method_name.gsub(/(\?$)|(=$)/, '')
+          if @attributes.include?(attribute_name.to_sym) || method_name[-1] == '=' || method_name[-1] == '?'
+            generate_methods!(attribute_name, method_name)
+            send(method_sym, *arguments)
+          else
+            super(method_sym, *arguments)
+          end
+        end
+
+        private
+
+        def generate_methods!(attribute_name, method_name)
+          case method_name[-1]
           when '='
-            self.instance_eval Container.build_attribute_setter(attribute_name)
+            instance_eval Container.build_attribute_setter(attribute_name)
           when '?'
-            self.instance_eval Container.build_attribute_queryer(attribute_name)
+            instance_eval Container.build_attribute_queryer(attribute_name)
           else
-            self.instance_eval Container.build_attribute_getter(attribute_name)
+            instance_eval Container.build_attribute_getter(attribute_name)
           end
-          send(method_sym, *arguments)
-        else
-          super(method_sym, *arguments)
         end
       end
     end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Copyright 2009 Sidu Ponnappa
 
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -13,43 +15,50 @@ module Wrest
     # 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
+    module Mutators
+      class Base
+        attr_reader :next_mutator
 
-      def initialize(next_mutator = nil)
-        @next_mutator = next_mutator
-      end
+        # 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)
+          super
+          return if Utils.string_blank?(subklass.name)
 
-      # 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
+          key = Utils.string_underscore(Utils.string_demodulize(subklass.name)).to_sym
+          Wrest::Components::Mutators.registry[key] = subklass
+        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
 
-      protected
-      def do_mutate(tuple)
-        raise Wrest::Exceptions::MethodNotOverridden
+        def do_mutate(_tuple)
+          raise Wrest::Exceptions::MethodNotOverridden
+        end
       end
     end
   end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Copyright 2009 Sidu Ponnappa
 
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -13,9 +15,11 @@ module Wrest
     #
     # Example:
     #  Mutators::CamelToSnakeCase.new.mutate(['Spirit-Sword', 'true'])  # => ['spirit_sword', 'true']**
-    class Mutators::CamelToSnakeCase < Mutators::Base
-      def do_mutate(tuple)
-        [tuple.first.underscore, tuple.last]
+    module Mutators
+      class CamelToSnakeCase < Mutators::Base
+        def do_mutate(tuple)
+          [Utils.string_underscore(tuple.first), tuple.last]
+        end
       end
     end
   end

data/lib/wrest/components/mutators/{xml_mini_type_caster.rb → xml_type_caster.rb}

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Copyright 2009 Sidu Ponnappa
 
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -7,36 +9,47 @@
 # 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
+    module Mutators
+      class XmlTypeCaster < Mutators::Base
+        def do_mutate(tuple)
+          out_key, in_value = tuple
 
-        case in_value
-        when Hash
+          out_value = case in_value
+                      when Hash
+                        process_hash_value(in_value)
+                      when Array
+                        in_value.collect { |hash| hash.mutate_using(self) }
+                      else
+                        in_value
+                      end
+
+          [out_key, out_value]
+        end
+
+        private
+
+        def process_hash_value(in_value)
           if in_value['nil'] == 'true'
-            out_value = nil
+            nil
           elsif in_value.key?('type')
-            caster = ActiveSupport::XmlMini::PARSING[in_value['type']]
-            out_value = caster ? caster.call(in_value['__content__']) : in_value
+            typecast_value(in_value)
           elsif in_value.key?('__content__')
-            out_value = in_value['__content__']
+            in_value['__content__']
           else
-            out_value = in_value.mutate_using(self)
+            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]
+        def typecast_value(in_value)
+          caster = Container::Typecaster::PARSING[in_value['type']]
+          caster ? caster.call(in_value['__content__']) : in_value
+        end
       end
     end
   end

data/lib/wrest/components/mutators.rb

@@ -1,11 +1,13 @@
+# frozen_string_literal: true
+
 # 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.
 
 module Wrest
   module Components
@@ -15,26 +17,26 @@ module Wrest
     module Mutators
       # All sublasses of Mutators::Base are automatically
       # registered here by underscored, symbolised class name.
-      REGISTRY = {}
-      
+      def self.registry
+        @registry ||= {}
+      end
+
       # Makes referencing and chaining mutators easy.
-      # 
+      #
       # Example:
-      #  Mutators.chain(:xml_mini_type_caster, :camel_to_snake_case)
+      #  Mutators.chain(:xml_type_caster, :camel_to_snake_case)
       # is equivalent to
-      #  Wrest::Components::Mutators::XmlMiniTypeCaster.new(Wrest::Components::Mutators::CamelToSnakeCase.new)
+      #  Wrest::Components::Mutators::XmlTypeCaster.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)
+        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/core_ext/hash"
-require "wrest/components/mutators/base"
-require "wrest/components/mutators/xml_simple_type_caster"
-require "wrest/components/mutators/xml_mini_type_caster"
-require "wrest/components/mutators/camel_to_snake_case"
-
+require 'wrest/core_ext/hash'
+require 'wrest/components/mutators/base'
+require 'wrest/components/mutators/xml_type_caster'
+require 'wrest/components/mutators/camel_to_snake_case'

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

@@ -1,21 +1,25 @@
+# frozen_string_literal: true
+
 # 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.
 
 module Wrest
-  module Components::Translators
-    # Maps content types to deserialisers
-    CONTENT_TYPES = {
-      'application/xml' => Wrest::Components::Translators::Xml,
-      'text/xml' => Wrest::Components::Translators::Xml,
-      'application/json' => Wrest::Components::Translators::Json,
-      'text/javascript' => Wrest::Components::Translators::Json,
-      'text/plain' => Wrest::Components::Translators::Txt
-    }
+  module Components
+    module Translators
+      # Maps content types to deserialisers
+      CONTENT_TYPES = {
+        'application/xml' => Wrest::Components::Translators::Xml,
+        'text/xml' => Wrest::Components::Translators::Xml,
+        'application/json' => Wrest::Components::Translators::Json,
+        'text/javascript' => Wrest::Components::Translators::Json,
+        'text/plain' => Wrest::Components::Translators::Txt
+      }.freeze
+    end
   end
-end
+end