wrest 3.0.0 → 4.0.0

data/lib/wrest/components/container/alias_accessors.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Copyright 2009 Sidu Ponnappa
 
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -8,56 +10,58 @@
 # See the License for the specific language governing permissions and limitations under the License.
 
 module Wrest
-  module Components::Container
-    module AliasAccessors
-      def self.included(klass) #:nodoc:
-        klass.extend AliasAccessors::ClassMethods
-      end
+  module Components
+    module Container
+      module AliasAccessors
+        def self.included(klass) # :nodoc:
+          klass.extend AliasAccessors::ClassMethods
+        end
 
-      def self.build_aliased_attribute_getter(attribute_name, alias_name) #:nodoc:
-        "def #{alias_name};#{attribute_name};end;"
-      end
+        def self.build_aliased_attribute_getter(attribute_name, alias_name) # :nodoc:
+          "def #{alias_name};#{attribute_name};end;"
+        end
 
-      def self.build_aliased_attribute_setter(attribute_name, alias_name) #:nodoc:
-        "def #{alias_name}=(value);self.#{attribute_name}=value;end;"
-      end
+        def self.build_aliased_attribute_setter(attribute_name, alias_name) # :nodoc:
+          "def #{alias_name}=(value);self.#{attribute_name}=value;end;"
+        end
 
-      def self.build_aliased_attribute_queryer(attribute_name, alias_name) #:nodoc:
-        "def #{alias_name}?;self.#{attribute_name}?;end;"
-      end
-      
-      module ClassMethods
-        # Creates an alias set of getter, setter and query methods for 
-        # attributes that aren't quite the way you'd like them to be; this
-        # is especially useful when you have no control over the source web
-        # sevice/resource.
-        #
-        # For example, lets say that a particular resource exposes a
-        # User's age as 'a' and sex as 's'. Typically, you'd have to access it as
-        # user.a and user.s whereas you's like to access it as user.age and user.sex.
-        # This is where alias_accessors comes into the picture. Your User class would
-        # look somethig like this:
-        #
-        #  class User
-        #    include Wrest::Components::Container
-        #
-        #    alias_accessors  :a => :age,
-        #                     :s => :sex
-        #  end
-        # This would create the methods user.age, user.age= and user.age? which delegates
-        # to user.a, user.a= and user.a? respectively.
-        #
-        # See examples/wow_realm_status.rb for a working example.
-        # 
-        # WARNING: If you try to create an alias with the same name as the attribute,
-        # and then use it, you _will_ cause an infinite loop.
-        def alias_accessors(alias_map)
-          alias_map.each do |attribute_name, alias_name|
-            self.class_eval(
-            AliasAccessors.build_aliased_attribute_getter(attribute_name, alias_name) +
-            AliasAccessors.build_aliased_attribute_setter(attribute_name, alias_name) +
-            AliasAccessors.build_aliased_attribute_queryer(attribute_name, alias_name)
-            )
+        def self.build_aliased_attribute_queryer(attribute_name, alias_name) # :nodoc:
+          "def #{alias_name}?;self.#{attribute_name}?;end;"
+        end
+
+        module ClassMethods
+          # Creates an alias set of getter, setter and query methods for
+          # attributes that aren't quite the way you'd like them to be; this
+          # is especially useful when you have no control over the source web
+          # sevice/resource.
+          #
+          # For example, lets say that a particular resource exposes a
+          # User's age as 'a' and sex as 's'. Typically, you'd have to access it as
+          # user.a and user.s whereas you's like to access it as user.age and user.sex.
+          # This is where alias_accessors comes into the picture. Your User class would
+          # look somethig like this:
+          #
+          #  class User
+          #    include Wrest::Components::Container
+          #
+          #    alias_accessors  :a => :age,
+          #                     :s => :sex
+          #  end
+          # This would create the methods user.age, user.age= and user.age? which delegates
+          # to user.a, user.a= and user.a? respectively.
+          #
+          # See examples/wow_realm_status.rb for a working example.
+          #
+          # WARNING: If you try to create an alias with the same name as the attribute,
+          # and then use it, you _will_ cause an infinite loop.
+          def alias_accessors(alias_map)
+            alias_map.each do |attribute_name, alias_name|
+              class_eval(
+                AliasAccessors.build_aliased_attribute_getter(attribute_name, alias_name) +
+                AliasAccessors.build_aliased_attribute_setter(attribute_name, alias_name) +
+                AliasAccessors.build_aliased_attribute_queryer(attribute_name, alias_name)
+              )
+            end
           end
         end
       end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Copyright 2009 Sidu Ponnappa
 
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -8,118 +10,166 @@
 # See the License for the specific language governing permissions and limitations under the License.
 
 module Wrest
-  module Components::Container
-    # An extension to Container 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.send(:alias_method, :initialize_without_typecasting, :initialize)
-        klass.send(:alias_method, :initialize, :initialize_with_typecasting)
-      end
+  module Components
+    module Container
+      # An extension to Container 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
+        PARSING = {
+          'symbol' => proc { |symbol| symbol.to_s.to_sym },
+          'date' => proc { |date| ::Date.parse(date) },
+          'datetime' => proc { |time|
+            begin
+              Time.xmlschema(time).utc
+            rescue StandardError
+              ::DateTime.parse(time).utc
+            end
+          },
+          'integer' => proc { |integer| integer.to_i },
+          'float' => proc { |float| float.to_f },
+          'decimal' => proc do |number|
+            if number.is_a?(String)
+              number.to_d
+            else
+              BigDecimal(number)
+            end
+          end,
+          'boolean' => proc { |boolean| %w[1 true].include?(boolean.to_s.strip) },
+          'string' => proc { |string| string.to_s },
+          'yaml' => proc { |yaml|
+            begin
+              YAML.safe_load(yaml)
+            rescue StandardError
+              yaml
+            end
+          },
+          'base64Binary' => proc { |bin| ::Base64.decode64(bin) },
+          'binary' => proc { |bin, entity| _parse_binary(bin, entity) },
+          'file' => proc { |file, entity| _parse_file(file, entity) },
+          'double' => proc { |float| float.to_f },
+          'dateTime' => proc { |time|
+            begin
+              Time.xmlschema(time).utc
+            rescue StandardError
+              ::DateTime.parse(time).utc
+            end
+          }
+        }.freeze
 
-      module Helpers
-        def as_base64Binary
-          ActiveSupport::XmlMini::PARSING['base64Binary']
+        def self.included(klass)
+          # :nodoc:
+          klass.extend Typecaster::ClassMethods
+          klass.class_eval { include Typecaster::InstanceMethods }
+          klass.send(:alias_method, :initialize_without_typecasting, :initialize)
+          klass.send(:alias_method, :initialize, :initialize_with_typecasting)
         end
 
-        def as_boolean
-          ActiveSupport::XmlMini::PARSING['boolean']
-        end
+        module Helpers
+          def as_base64_binary
+            PARSING['base64Binary']
+          end
 
-        def as_decimal
-          ActiveSupport::XmlMini::PARSING['decimal']
-        end
+          def as_boolean
+            PARSING['boolean']
+          end
 
-        def as_date
-          ActiveSupport::XmlMini::PARSING['date']
-        end
+          def as_decimal
+            PARSING['decimal']
+          end
 
-        def as_datetime
-          ActiveSupport::XmlMini::PARSING['datetime']
-        end
+          def as_date
+            PARSING['date']
+          end
 
-        def as_float
-          ActiveSupport::XmlMini::PARSING['float']
-        end
+          def as_datetime
+            PARSING['datetime']
+          end
 
-        def as_integer
-          ActiveSupport::XmlMini::PARSING['integer']
-        end
+          def as_float
+            PARSING['float']
+          end
 
-        def as_symbol
-          ActiveSupport::XmlMini::PARSING['symbol']
-        end
+          def as_integer
+            PARSING['integer']
+          end
 
-        def as_yaml
-          ActiveSupport::XmlMini::PARSING['yaml']
-        end
-      end
+          def as_symbol
+            PARSING['symbol']
+          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 +Container+
-        # directly from request params. Typecasting kicks in for
-        # a given value _only_ if it is a String, Hash or Array, the
-        # three classes that deserilisation can produce.
-        #
-        # 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.
-        #
-        # Note that this _will_ increase the time needed to initialize
-        # instances.
-        #
-        # 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::Container
-        #    include Wrest::Components::Container::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
+          def as_yaml
+            PARSING['yaml']
+          end
         end
 
-        def typecast_map #:nodoc:
-          if defined?(@typecast_map)
-            @typecast_map
-          elsif superclass != Object && superclass.respond_to?(:typecast_map)
-            superclass.typecast_map
-          else
-            {}
+        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 +Container+
+          # directly from request params. Typecasting kicks in for
+          # a given value _only_ if it is a String, Hash or Array, the
+          # three classes that deserilisation can produce.
+          #
+          # 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.
+          #
+          # Note that this _will_ increase the time needed to initialize
+          # instances.
+          #
+          # 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::Container
+          #    include Wrest::Components::Container::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.transform_keys(&:to_sym)) : cast_map.transform_keys(&:to_sym)
+          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
         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) || value.is_a?(Hash) || value.is_a?(Array))
+        module InstanceMethods # :nodoc:
+          def initialize_with_typecasting(attributes = {})
+            # :nodoc:
+            initialize_without_typecasting(attributes)
+            self.class.typecast_map.each do |key, typecaster|
+              value = @attributes[key]
+              if value.is_a?(String) || value.is_a?(Hash) || value.is_a?(Array)
+                @attributes[key] =
+                  typecaster.call(value)
+              end
+            end
           end
         end
       end