libis-workflow-mongoid 2.0.2 → 2.0.3

data/lib/map_with_indifferent_access/normalization.rb

@@ -0,0 +1,92 @@
+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/normalization/deep_normalizer.rb

@@ -0,0 +1,104 @@
+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/values.rb

@@ -0,0 +1,39 @@
+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

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

data/lib/map_with_indifferent_access/wraps_collection.rb

@@ -0,0 +1,152 @@
+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/libis-workflow-mongoid.gemspec

@@ -27,7 +27,6 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
 
   spec.add_runtime_dependency 'libis-workflow', '~> 2.0'
-
   spec.add_runtime_dependency 'mongoid', '~> 5.0'
 
   spec.add_development_dependency 'bundler', '~> 1.6'

data/spec/items/test_dir_item.rb

@@ -12,7 +12,7 @@ class TestDirItem < TestItem
   end
 
   def name
-    self.properties['name'] || super
+    self.properties[:name] || super
   end
 
 end

data/spec/items/test_file_item.rb

@@ -15,15 +15,15 @@ class TestFileItem < TestItem
   end
 
   def name
-    self.properties['name'] || super
+    self.properties[:name] || super
   end
 
   def filesize
-    properties['size']
+    properties[:size]
   end
 
   def fixity_check(checksum)
-    properties['checksum'] == checksum
+    properties[:checksum] == checksum
   end
 
 end

data/spec/tasks/camelize_name.rb

@@ -6,7 +6,7 @@ class CamelizeName < ::Libis::Workflow::Task
 
   def process(item)
     return unless (item.is_a?(TestFileItem) || item.is_a?(TestDirItem))
-    item.properties['name'] = item.name.camelize
+    item.properties[:name] = item.name.camelize
     item.save!
   end
 

data/spec/workflow_spec.rb

@@ -190,8 +190,8 @@ STR
     item = run.items.first
     expect(item.nil?).to eq false
     expect(item.is_a? TestDirItem).to eq true
-    expect(item.properties['name']).to eq 'Items'
-    expect(item.properties['ingest_failed']).to eq false
+    expect(item.properties[:name]).to eq 'Items'
+    expect(item.properties[:ingest_failed]).to eq false
   end
 
   it 'move item in relation' do