libis-workflow-mongoid 2.0.5 → 2.0.6

data/lib/map_with_indifferent_access/normalization/deep_normalizer.rb

@@ -1,104 +0,0 @@
-module MapWithIndifferentAccess
-  module Normalization
-
-    class DeepNormalizer
-      attr_reader :strategy
-
-      # Initializes a new DeepNormalizer with a given object that
-      # extends {KeyStrategy}.
-      def initialize(strategy)
-        @strategy = strategy
-      end
-
-      # Given an `Array`-like or `Hash`-like object, returns a
-      # similar object with keys coerced according to the
-      # target {DeepNormalizer}'s strategy.
-      # Given an object that is not `Array`-like or `Hash`-like,
-      # then the given object is returned.
-      #
-      # During this process, any hash entry values or array
-      # items that are instances of
-      # {Map} or {List} are replaced with `Hash` or `Array`
-      # deconstructions respectively. If a {Map} or {List} is
-      # given, then the same type of object is returned.
-      #
-      # If a `Hash` or an object that resonds to `#to_hash` and
-      # `#each_pair` is given, then a `Hash` is returned. The
-      # same applies to each `Hash`/{Map} entry value or
-      # `Array`/{List} item that is traversed.
-      #
-      # If an `Array` or an object that resonds to `#to_ary` is
-      # given, then an `Array` is returned. The same applies to
-      # each `Hash`/{Map} entry value or `Array`/{List} item that
-      # is traversed.
-      #
-      # If any keys, `Hash` entry values, or `Array` items are
-      # replaced, then a new object is returned that includes
-      # those replacements.  Otherwise, the given object is
-      # returned. In either case, the contents of `obj` are not
-      # modified.
-      def call(obj)
-        if WrapsCollection === obj
-          coerced_inner_col = recursively_coerce( obj )
-          Values.externalize( coerced_inner_col )
-        else
-          recursively_coerce( obj )
-        end
-      end
-
-      private
-
-      def recursively_coerce(obj)
-        if ::Hash === obj
-          coerce_hash( obj )
-        elsif Map === obj
-          coerce_hash( obj.inner_map )
-        elsif ::Array === obj
-          coerce_array( obj )
-        elsif List === obj
-          coerce_array( obj.inner_array )
-        elsif obj.respond_to?(:to_hash) && obj.respond_to?(:each_pair)
-          coerce_hash( obj.to_hash )
-        elsif obj.respond_to?(:to_ary)
-          coerce_array( obj.to_ary )
-        else
-          obj
-        end
-      end
-
-      def coerce_hash(obj)
-        does_need_key_coercion = obj.each_key.any?{ |key|
-          strategy.needs_coercion?( key )
-        }
-        result = does_need_key_coercion ? {} : obj
-
-        obj.each_pair do |(key,value)|
-          key = strategy.coerce( key ) if strategy.needs_coercion?( key )
-          new_value = recursively_coerce( value )
-          if result.equal?( obj )
-            unless new_value.equal?( value )
-              result = obj.dup
-              result[ key ] = new_value
-            end
-          else
-            result[ key ] = new_value
-          end
-        end
-        result
-      end
-
-      def coerce_array( obj )
-        result = obj
-        obj.each_with_index do |item,i|
-          new_item = recursively_coerce(item)
-          unless new_item.equal?( item )
-            result = obj.dup if result.equal?( obj )
-            result[ i ] = new_item
-          end
-        end
-        result
-      end
-    end
-
-  end
-end

data/lib/map_with_indifferent_access/normalization.rb

@@ -1,92 +0,0 @@
-require "map_with_indifferent_access/normalization/deep_normalizer"
-
-module MapWithIndifferentAccess
-  module Normalization
-    class << self
-      # Deeply normalizes `Hash`-like and `Array`-like hash entry
-      # values and array items, preserving all of the existing key
-      # values (`String`, `Symbol`, or otherwise) from the inner
-      # collections.
-      #
-      # @see DeepNormalizer#call
-      def deeply_normalize(obj)
-        deep_basic_normalizer.call( obj )
-      end
-
-      # Deeply coerces keys to `Symbol` type.
-      #
-      # @see DeepNormalizer#call
-      def deeply_symbolize_keys(obj)
-        deep_key_symbolizer.call( obj )
-      end
-
-      # Deeply coerces keys to `String` type.
-      #
-      # @see DeepNormalizer#call
-      def deeply_stringify_keys(obj)
-        deep_key_stringifier.call( obj )
-      end
-
-      private
-
-      def deep_basic_normalizer
-        @deep_basic_normalizer ||= DeepNormalizer.new( NullKeyStrategy )
-      end
-
-      def deep_key_symbolizer
-        @deep_key_symbolizer ||= DeepNormalizer.new( SymbolizationKeyStrategy )
-      end
-
-      def deep_key_stringifier
-        @deep_key_stringifier ||= DeepNormalizer.new( StringificationKeyStrategy )
-      end
-    end
-
-    module KeyStrategy
-      def self.needs_coercion?(key)
-        raise NotImplementedError, "Including-module responsibility"
-      end
-
-      def self.coerce(key)
-        raise NotImplementedError, "Including-module responsibility"
-      end
-    end
-
-    module NullKeyStrategy
-      extend Normalization::KeyStrategy
-
-      def self.needs_coercion?(key)
-        false
-      end
-
-      def self.coerce(key)
-        key
-      end
-    end
-
-    module SymbolizationKeyStrategy
-      extend Normalization::KeyStrategy
-
-      def self.needs_coercion?(key)
-        !( Symbol === key )
-      end
-
-      def self.coerce(key)
-        key.to_s.to_sym
-      end
-    end
-
-    module StringificationKeyStrategy
-      extend Normalization::KeyStrategy
-
-      def self.needs_coercion?(key)
-        !( String === key )
-      end
-
-      def self.coerce(key)
-        key.to_s
-      end
-    end
-
-  end
-end

data/lib/map_with_indifferent_access/values.rb

@@ -1,39 +0,0 @@
-module MapWithIndifferentAccess
-
-  module Values
-
-    class << self
-      # Converts `obj` to a {Map} or {List} if possible, otherwise
-      # returns `obj`.
-      #
-      # @return [Map, List, Object]
-      def externalize(obj)
-        (
-          Map.try_convert( obj ) ||
-          List.try_convert( obj ) ||
-          obj
-        )
-      end
-
-      alias >> externalize
-
-      # Converts `obj`, which might be a {Map} or {List} to a
-      # `Hash` or `Array` if possible.  Returns `obj` if no
-      # conversion is possible.
-      #
-      # @return [Hash, Array, Object]
-      def internalize(obj)
-        (
-          Map.try_deconstruct( obj ) ||
-          List.try_deconstruct( obj ) ||
-          obj
-        )
-      end
-
-      alias << internalize
-    end
-
-  end
-
-end
-

data/lib/map_with_indifferent_access/version.rb

@@ -1,3 +0,0 @@
-module MapWithIndifferentAccess
-  VERSION = "0.1.0"
-end

data/lib/map_with_indifferent_access/wraps_collection.rb

@@ -1,152 +0,0 @@
-require 'forwardable'
-
-module MapWithIndifferentAccess
-
-  module WrapsCollection
-    extend Forwardable
-    include Enumerable
-
-    # The encapsulated collection object.
-    attr_reader :inner_collection
-
-    # @!method length
-    #   The number of entries in the collection.
-    #
-    #   @return [Fixnum]
-    #   @see #size
-
-    # @!method size
-    #   The number of entries in the collection.
-    #
-    #   @return [Fixnum]
-    #   @see #length
-
-    # @!method empty?
-    #   Returns `true` if the collection contains no entries.
-    #
-    #   Returns `false` if the collection contains 1 or more
-    #   entries.
-    #
-    #   @return [Boolean]
-
-    # @!method _frozen?
-    #   Returns true when the target object (the wrapper) is
-    #   frozen.
-    #
-    #   There are some cases in which this returns `false` when
-    #   {#frozen?} would return `true`.
-    #
-    #   @return [Boolean]
-    #   @see #frozen?
-
-    # Using `class_eval` to hide the aliasing from YARD, so it
-    # does not document this alias to the implementation
-    # inherited from `Object` as an alias to the subsequent
-    # override.
-    class_eval 'alias _frozen? frozen?', __FILE__, __LINE__
-
-    # @!method tainted?
-    #   Reflects the tainted-ness of its #inner_collection.
-    #   @return [Boolean]
-
-    # @!method untrusted?
-    #   Reflects the untrusted-ness of its #inner_collection.
-    #   @return [Boolean]
-
-    # @!method frozen?
-    #   Reflects the frozen-ness of its {#inner_collection}.
-    #
-    #   Returns `true` when the {#inner_collection} is frozen (
-    #   and the target/wrapper might be frozen or not).
-    #
-    #   Returns `false` when the {#inner_collection} is not
-    #   frozen (and neither is the target/wrapper).
-    #
-    #   When the {#inner_collection} is frozen, but the target
-    #   object is not, then the target behaves as if frozen in
-    #   most ways, but some of the restrictions that Ruby applies
-    #   to truly frozen (such as preventing instance methods from
-    #   being dynamically added to the object) do not apply.
-    #
-    #   @return [Boolean]
-    #   @see #_frozen?
-
-    # @!method hash
-    #   Compute a hash-code for this collection wrapper. Two
-    #   wrappers with the same type and the same
-    #   {#inner_collection} content will have the same hash code
-    #   (and will match using {#eql?}).
-    #
-    #   @return [Fixnum]
-
-    def_delegators(
-      :inner_collection,
-      :length,
-      :size,
-      :empty?,
-      :tainted?,
-      :untrusted?,
-      :frozen?,
-      :hash,
-    )
-
-    # @!method taint
-    # Causes the target's #inner_collection to be tainted.
-
-    # @!method untaint
-    # Causes the target's #inner_collection to be untainted.
-
-    # @!method untrust
-    # Causes the target's #inner_collection to be untrusted.
-
-    # @!method trust
-    # Causes the target's {#inner_collection} to be trusted.
-
-    [:taint, :untaint, :untrust, :trust ].each do |method_name|
-      class_eval <<-EOS, __FILE__, __LINE__ + 1
-        def #{method_name}
-          inner_collection.#{method_name}
-          self
-        end
-      EOS
-    end
-
-    # Removes all entries from the target's {#inner_collection}.
-    def clear
-      inner_collection.clear
-      self
-    end
-
-    # Freezes both the target map and its {#inner_collection}
-    # object.
-    def freeze
-      super
-      inner_collection.freeze
-      self
-    end
-
-    # Returns `true` for another instance of the same class as
-    # the target where the target's {#inner_collection} is
-    # `#eql?` to the given object's {#inner_collection}. Returns
-    # `false` otherwise.
-    #
-    # @return [Boolean]
-    def eql?(other)
-      self.class == other.class &&
-        self.inner_collection.eql?( other.inner_collection )
-    end
-
-    private
-
-    def initialize_dup(orig)
-      super
-      @inner_collection = inner_collection.dup
-    end
-
-    def initialize_clone(orig)
-      super
-      @inner_collection = inner_collection.clone
-    end
-  end
-
-end

data/lib/map_with_indifferent_access.rb

@@ -1,20 +0,0 @@
-require "map_with_indifferent_access/version"
-require "map_with_indifferent_access/wraps_collection"
-require "map_with_indifferent_access/map"
-require "map_with_indifferent_access/list"
-require "map_with_indifferent_access/values"
-require "map_with_indifferent_access/normalization"
-require 'forwardable'
-
-module MapWithIndifferentAccess
-  class << self
-    extend Forwardable
-
-    # @!method new
-    #   Creates and returns a new instance of {Map}.
-    #
-    #   @return [Map]
-    #   @see Map#initialize
-    def_delegator Map, :new
-  end
-end