curation_concerns-models 0.11.0 → 0.12.0.pre1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e881c65ab239adc59699d04c163a19ad8da5c37c
-  data.tar.gz: 503dfb42fb4c7c3b917f26918c589e062a5196e6
+  metadata.gz: 0dec0847b3aa12c5c48e251ea115b6e82412af96
+  data.tar.gz: 2691544f9ef15ac45d29d1dee7623fe42d8b1dcf
 SHA512:
-  metadata.gz: c1782ddd4011836926d9ba37cfe8e6bb65560887f9548103621605e86cd9c78875a3b35f57cdd95f255154565ddf80c0a83fe6a82116153d661db7cf595f2e29
-  data.tar.gz: e524b746fe47631184e947d2d119f60312940f4d90876d67c22b76e13144d4e8bdb7def9395961c600b1ae97a6fb8ce571f5a4dd238cea6cf873414f9784f1ca
+  metadata.gz: ba78b4f524e0e67269c5464761da644868bbc0189a667548abfd3684f57b1e114b642a73af249eaae983dede84f22b1ab7efcaa6859e4894bc7461d1c166705b
+  data.tar.gz: 9b42e31b848ff7b56a0ab75a46d650b3d27871008f2898215907bc3bc61f4a0db7ab696a914e3a1d8b14fcdff4122bf44cb067a459999c8e0b21dde5939e8dcf

data/app/actors/concerns/curation_concerns/manages_embargoes_actor.rb

@@ -19,73 +19,10 @@ module CurationConcerns
   #
   module ManagesEmbargoesActor
     extend ActiveSupport::Concern
+    extend Deprecation
 
-    # Interprets embargo & lease visibility if necessary
-    # returns false if there are any errors
-    def interpret_visibility(attributes = self.attributes)
-      should_continue = interpret_embargo_visibility(attributes) && interpret_lease_visibility(attributes)
-      if attributes[:visibility]
-        curation_concern.visibility = attributes[:visibility]
-      end
-      should_continue
-    end
-
-    # If user has set visibility to embargo, interprets the relevant information and applies it
-    # Returns false if there are any errors and sets an error on the curation_concern
-    def interpret_embargo_visibility(attributes = self.attributes)
-      if attributes[:visibility] == Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_EMBARGO
-        if !attributes[:embargo_release_date]
-          curation_concern.errors.add(:visibility, 'When setting visibility to "embargo" you must also specify embargo release date.')
-          should_continue = false
-        else
-          attributes.delete(:visibility)
-          curation_concern.apply_embargo(attributes[:embargo_release_date], attributes.delete(:visibility_during_embargo),
-                                         attributes.delete(:visibility_after_embargo))
-          if curation_concern.embargo
-            curation_concern.embargo.save # See https://github.com/projecthydra/hydra-head/issues/226
-          end
-          should_continue = true
-        end
-      else
-        should_continue = true
-        # clear embargo_release_date if it isn't being used. Otherwise it sets the embargo_date
-        # even though they didn't select embargo on the form.
-        attributes.delete(:embargo_release_date)
-      end
-
-      attributes.delete(:visibility_during_embargo)
-      attributes.delete(:visibility_after_embargo)
-
-      should_continue
-    end
-
-    # If user has set visibility to lease, interprets the relevant information and applies it
-    # Returns false if there are any errors and sets an error on the curation_concern
-    def interpret_lease_visibility(attributes = self.attributes)
-      if attributes[:visibility] == Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_LEASE
-        if !attributes[:lease_expiration_date]
-          curation_concern.errors.add(:visibility, 'When setting visibility to "lease" you must also specify lease expiration date.')
-          should_continue = false
-        else
-          curation_concern.apply_lease(attributes[:lease_expiration_date], attributes.delete(:visibility_during_lease),
-                                       attributes.delete(:visibility_after_lease))
-          if curation_concern.lease
-            curation_concern.lease.save # See https://github.com/projecthydra/hydra-head/issues/226
-          end
-          attributes.delete(:visibility)
-          should_continue = true
-        end
-      else
-        # clear lease_expiration_date if it isn't being used. Otherwise it sets the lease_expiration
-        # even though they didn't select lease on the form.
-        attributes.delete(:lease_expiration_date)
-        should_continue = true
-      end
-
-      attributes.delete(:visibility_during_lease)
-      attributes.delete(:visibility_after_lease)
-
-      should_continue
+    included do
+      Deprecation.warn(ManagesEmbargoesActor, "ManagesEmbargoesActor is deprecated and will be removed in CurationConcerns 1.0")
     end
   end
 end

data/app/actors/curation_concerns/abstract_actor.rb

@@ -0,0 +1,28 @@
+module CurationConcerns
+  # The CurationConcern Abstract actor responds to two primary actions:
+  # * #create
+  # * #update
+  #
+  # and the following attributes
+  #
+  # * next_actor
+  # * curation_concern
+  # * user
+  #
+  # it must instantiate the next actor in the chain and instantiate it.
+  # it should respond to curation_concern, user and attributes.
+  # it ha to next_actor
+  class AbstractActor
+    attr_reader :next_actor
+
+    def initialize(_curation_concern, _user, next_actor)
+      @next_actor = next_actor
+    end
+
+    delegate :curation_concern, :user, to: :next_actor
+
+    delegate :create, to: :next_actor
+
+    delegate :update, to: :next_actor
+  end
+end

data/app/actors/curation_concerns/add_to_collection_actor.rb

@@ -0,0 +1,38 @@
+module CurationConcerns
+  class AddToCollectionActor < AbstractActor
+    def create(attributes)
+      collection_ids = attributes.delete(:collection_ids)
+      next_actor.create(attributes) && add_to_collections(collection_ids)
+    end
+
+    def update(attributes)
+      collection_ids = attributes.delete(:collection_ids)
+      add_to_collections(collection_ids) && next_actor.update(attributes)
+    end
+
+    private
+
+      # The default behavior of active_fedora's aggregates association,
+      # when assigning the id accessor (e.g. collection_ids = ['foo:1']) is to add
+      # to new collections, but not remove from old collections.
+      # This method ensures it's removed from the old collections.
+      def add_to_collections(new_collection_ids)
+        return true unless new_collection_ids
+        # remove from old collections
+        # TODO: Implement in_collection_ids https://github.com/projecthydra-labs/hydra-pcdm/issues/157
+        (curation_concern.in_collections.map(&:id) - new_collection_ids).each do |old_id|
+          collection = Collection.find(old_id)
+          collection.members.delete(curation_concern)
+          collection.save
+        end
+
+        # add to new
+        new_collection_ids.each do |coll_id|
+          collection = Collection.find(coll_id)
+          collection.members << curation_concern
+          collection.save
+        end
+        true
+      end
+  end
+end

data/app/actors/curation_concerns/apply_order_actor.rb

@@ -0,0 +1,24 @@
+module CurationConcerns
+  class ApplyOrderActor < AbstractActor
+    def update(attributes)
+      ordered_member_ids = attributes.delete(:ordered_member_ids)
+      apply_order(ordered_member_ids) && next_actor.update(attributes)
+    end
+
+    private
+
+      def apply_order(new_order)
+        return true unless new_order
+        curation_concern.ordered_member_proxies.each_with_index do |proxy, index|
+          unless new_order[index]
+            proxy.prev.next = curation_concern.ordered_member_proxies.last.next
+            break
+          end
+          proxy.proxy_for = ActiveFedora::Base.id_to_uri(new_order[index])
+          proxy.target = nil
+        end
+        curation_concern.list_source.order_will_change!
+        true
+      end
+  end
+end

data/app/actors/curation_concerns/assign_identifier_actor.rb

@@ -0,0 +1,7 @@
+module CurationConcerns
+  class AssignIdentifierActor < AbstractActor
+    def create(attributes)
+      curation_concern.assign_id && next_actor.create(attributes)
+    end
+  end
+end

data/app/actors/curation_concerns/assign_representative_actor.rb

@@ -0,0 +1,18 @@
+module CurationConcerns
+  class AssignRepresentativeActor < AbstractActor
+    def create(attributes)
+      next_actor.create(attributes) && assign_representative
+    end
+
+    private
+
+      def assign_representative
+        unless curation_concern.representative_id
+          # TODO: Possible optimization here. Does this cause a fetch of ordered_members if they're already loaded?
+          representative = nil # curation_concern.ordered_members.association.reader.first.target
+          curation_concern.representative = representative if representative
+        end
+        curation_concern.save
+      end
+  end
+end

data/app/actors/curation_concerns/attach_files_actor.rb

@@ -0,0 +1,39 @@
+module CurationConcerns
+  class AttachFilesActor < AbstractActor
+    def create(attributes)
+      files = [attributes.delete(:files)].flatten.compact
+      attach_files(files, visibility_attributes(attributes)) &&
+        next_actor.create(attributes)
+    end
+
+    def update(attributes)
+      files = [attributes.delete(:files)].flatten.compact
+      next_actor.update(attributes) &&
+        attach_files(files, visibility_attributes(attributes))
+    end
+
+    private
+
+      def attach_files(files, visibility_attr)
+        files.all? do |file|
+          attach_file(file, visibility_attr)
+        end
+      end
+
+      def attach_file(file, visibility_attr)
+        file_set = ::FileSet.new
+        file_set_actor = CurationConcerns::FileSetActor.new(file_set, user)
+        file_set_actor.create_metadata(curation_concern, visibility_attr)
+        file_set_actor.create_content(file)
+      end
+
+      # The attributes used for visibility - used to send as initial params to
+      # created FileSets.
+      def visibility_attributes(attributes)
+        attributes.slice(:visibility, :visibility_during_lease,
+                         :visibility_after_lease, :lease_expiration_date,
+                         :embargo_release_date, :visibility_during_embargo,
+                         :visibility_after_embargo)
+      end
+  end
+end

data/app/actors/curation_concerns/base_actor.rb

@@ -1,34 +1,23 @@
-
 module CurationConcerns
-  # The CurationConcern base actor should respond to three primary actions:
+  # The CurationConcern base actor responds to two primary actions:
   # * #create
   # * #update
-  # * #delete
-  class BaseActor
-    attr_reader :curation_concern, :user, :attributes, :cloud_resources
-    def initialize(curation_concern, user, input_attributes)
-      @curation_concern = curation_concern
-      @user = user
-      @attributes = input_attributes.dup.with_indifferent_access
-      @visibility = attributes[:visibility]
-      @cloud_resources = attributes.delete(:cloud_resources.to_s)
-    end
+  # it must instantiate the next actor in the chain and instantiate it.
+  # it should respond to curation_concern, user and attributes.
+  class BaseActor < AbstractActor
+    attr_reader :cloud_resources
 
-    attr_reader :visibility
-    protected :visibility
-
-    delegate :visibility_changed?, to: :curation_concern
-
-    def create
+    def create(attributes)
+      @cloud_resources = attributes.delete(:cloud_resources.to_s)
       apply_creation_data_to_curation_concern
-      apply_save_data_to_curation_concern
-      save
+      apply_save_data_to_curation_concern(attributes)
+      next_actor.create(attributes) && save
     end
 
-    def update
+    def update(attributes)
       apply_update_data_to_curation_concern
-      apply_save_data_to_curation_concern
-      save
+      apply_save_data_to_curation_concern(attributes)
+      next_actor.update(attributes) && save
     end
 
     protected
@@ -55,9 +44,9 @@ module CurationConcerns
         curation_concern.save
       end
 
-      def apply_save_data_to_curation_concern
+      def apply_save_data_to_curation_concern(attributes)
         attributes[:rights] = Array(attributes[:rights]) if attributes.key? :rights
-        remove_blank_attributes!
+        remove_blank_attributes!(attributes)
         curation_concern.attributes = attributes.symbolize_keys
         curation_concern.date_modified = CurationConcerns::TimeService.time_in_utc
       end
@@ -68,14 +57,14 @@ module CurationConcerns
       #   remove_blank_attributes!
       #   self.attributes
       # => { 'title' => ['first', 'second'] }
-      def remove_blank_attributes!
-        multivalued_form_attributes.each_with_object(attributes) do |(k, v), h|
+      def remove_blank_attributes!(attributes)
+        multivalued_form_attributes(attributes).each_with_object(attributes) do |(k, v), h|
           h[k] = v.instance_of?(Array) ? v.select(&:present?) : v
         end
       end
 
       # Return the hash of attributes that are multivalued and not uploaded files
-      def multivalued_form_attributes
+      def multivalued_form_attributes(attributes)
         attributes.select { |_, v| v.respond_to?(:select) && !v.respond_to?(:read) }
       end
   end

data/app/actors/curation_concerns/file_set_actor.rb

@@ -1,15 +1,11 @@
 module CurationConcerns
   # Actions are decoupled from controller logic so that they may be called from a controller or a background job.
   class FileSetActor
-    include CurationConcerns::ManagesEmbargoesActor
     include CurationConcerns::Lockable
 
-    attr_reader :file_set, :user, :attributes, :curation_concern
+    attr_reader :file_set, :user, :attributes
 
     def initialize(file_set, user)
-      # we're setting attributes and curation_concern to bridge the difference
-      # between CurationConcerns::FileSetActor and ManagesEmbargoesActor
-      @curation_concern = file_set
       @file_set = file_set
       @user = user
     end
@@ -30,7 +26,7 @@ module CurationConcerns
       file_set.date_modified = now
       file_set.creator = [user.user_key]
 
-      interpret_visibility file_set_params if assign_visibility?(file_set_params)
+      CurationConcern::ActorStack.new(file_set, user, [InterpretVisibilityActor]).create(file_set_params) if assign_visibility?(file_set_params)
       attach_file_to_work(work, file_set, file_set_params) if work
       yield(file_set) if block_given?
     end
@@ -70,13 +66,13 @@ module CurationConcerns
     end
 
     def update_metadata(attributes)
-      update_visibility(attributes)
-      # attributes.delete(:visibility) # Applying this attribute is handled by update_visibility
-      file_set.attributes = attributes
-      file_set.date_modified = CurationConcerns::TimeService.time_in_utc
-      save do
+      stack = CurationConcern::ActorStack.new(file_set,
+                                              user,
+                                              [InterpretVisibilityActor, BaseActor])
+      if result = stack.update(attributes)
         CurationConcerns.config.callback.run(:after_update_metadata, file_set, user)
       end
+      result
     end
 
     def destroy
@@ -128,11 +124,6 @@ module CurationConcerns
         !((file_set_params || {}).keys & %w(visibility embargo_release_date lease_expiration_date)).empty?
       end
 
-      # This method can be overridden in case there is a custom approach for visibility (e.g. embargo)
-      def update_visibility(attributes)
-        interpret_visibility(attributes) # relies on CurationConcerns::ManagesEmbargoesActor to interpret and apply visibility
-      end
-
       # copy visibility from source_concern to destination_concern
       def copy_visibility(source_concern, destination_concern)
         destination_concern.visibility =  source_concern.visibility

data/app/actors/curation_concerns/interpret_visibility_actor.rb

@@ -0,0 +1,123 @@
+module CurationConcerns
+  class InterpretVisibilityActor < AbstractActor
+    class Intention
+      def initialize(attributes)
+        @attributes = attributes
+      end
+
+      # returns a copy of attributes with the necessary params removed
+      # If the lease or embargo is valid, or if they selected something besides lease
+      # or embargo, remove all the params.
+      def sanitize_params
+        if valid_lease?
+          @attributes.except(:visibility,
+                             :embargo_release_date,
+                             :visibility_during_embargo,
+                             :visibility_after_embargo)
+        elsif valid_embargo?
+          @attributes.except(:visibility,
+                             :lease_expiration_date,
+                             :visibility_during_lease,
+                             :visibility_after_lease)
+        elsif !wants_lease? && !wants_embargo?
+          @attributes.except(:lease_expiration_date,
+                             :visibility_during_lease,
+                             :visibility_after_lease,
+                             :embargo_release_date,
+                             :visibility_during_embargo,
+                             :visibility_after_embargo)
+        else
+          @attributes
+        end
+      end
+
+      def wants_lease?
+        visibility == Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_LEASE
+      end
+
+      def wants_embargo?
+        visibility == Hydra::AccessControls::AccessRight::VISIBILITY_TEXT_VALUE_EMBARGO
+      end
+
+      def valid_lease?
+        wants_lease? && @attributes[:lease_expiration_date].present?
+      end
+
+      def valid_embargo?
+        wants_embargo? && @attributes[:embargo_release_date].present?
+      end
+
+      def lease_params
+        [:lease_expiration_date,
+         :visibility_during_lease,
+         :visibility_after_lease].map { |key| @attributes[key] }
+      end
+
+      def embargo_params
+        [:embargo_release_date,
+         :visibility_during_embargo,
+         :visibility_after_embargo].map { |key| @attributes[key] }
+      end
+
+      private
+
+        def visibility
+          @attributes[:visibility]
+        end
+    end
+
+    def create(attributes)
+      @intention = Intention.new(attributes)
+      attributes = @intention.sanitize_params
+      validate && apply_visibility(attributes) && next_actor.create(attributes)
+    end
+
+    def update(attributes)
+      @intention = Intention.new(attributes)
+      attributes = @intention.sanitize_params
+      validate && apply_visibility(attributes) && next_actor.update(attributes)
+    end
+
+    private
+
+      def validate
+        validate_lease && validate_embargo
+      end
+
+      def apply_visibility(attributes)
+        result = apply_lease && apply_embargo
+        if attributes[:visibility]
+          curation_concern.visibility = attributes[:visibility]
+        end
+        result
+      end
+
+      def validate_lease
+        return true unless @intention.wants_lease? && !@intention.valid_lease?
+        curation_concern.errors.add(:visibility, 'When setting visibility to "lease" you must also specify lease expiration date.')
+        false
+      end
+
+      def validate_embargo
+        return true unless @intention.wants_embargo? && !@intention.valid_embargo?
+        curation_concern.errors.add(:visibility, 'When setting visibility to "embargo" you must also specify embargo release date.')
+        false
+      end
+
+      # If they want a lease, we can assume it's valid
+      def apply_lease
+        return true unless @intention.wants_lease?
+        curation_concern.apply_lease(*@intention.lease_params)
+        return unless curation_concern.lease
+        curation_concern.lease.save # see https://github.com/projecthydra/hydra-head/issues/226
+      end
+
+      # If they want an embargo, we can assume it's valid
+      def apply_embargo
+        return true unless @intention.wants_embargo?
+        curation_concern.apply_embargo(*@intention.embargo_params)
+        return unless curation_concern.embargo
+        curation_concern.embargo.save # see https://github.com/projecthydra/hydra-head/issues/226
+      end
+  end
+end

data/app/actors/curation_concerns/root_actor.rb

@@ -0,0 +1,17 @@
+module CurationConcerns
+  class RootActor
+    attr_reader :curation_concern, :user, :cloud_resources
+    def initialize(curation_concern, user, _more_actors)
+      @curation_concern = curation_concern
+      @user = user
+    end
+
+    def create(_)
+      true
+    end
+
+    def update(_)
+      true
+    end
+  end
+end

data/app/actors/curation_concerns/work_actor_behavior.rb

@@ -1,99 +1,8 @@
 module CurationConcerns::WorkActorBehavior
-  include CurationConcerns::ManagesEmbargoesActor
-  attr_accessor :raw_attributes
+  extend ActiveSupport::Concern
+  extend Deprecation
 
-  def create
-    # set the @files ivar then remove the files attribute so it isn't set by default.
-    files && attributes.delete(:files)
-    self.raw_attributes = attributes.dup
-    # Files must be attached before saving in order to persist their relationship to the work
-    assign_pid && interpret_visibility && attach_files && super && assign_representative
+  included do
+    Deprecation.warn(CurationConcerns::WorkActorBehavior, "CurationConcerns::WorkActorBehavior is deprecated and will be removed in CurationConcerns 1.0")
   end
-
-  def update
-    add_to_collections(attributes.delete(:collection_ids)) &&
-      interpret_visibility && apply_order(attributes.delete(:ordered_member_ids)) && super && attach_files
-  end
-
-  delegate :visibility_changed?, to: :curation_concern
-
-  protected
-
-    # Is this here to ensure that the curation_concern has a pid set before any of the other methods are executed?
-    def assign_pid
-      curation_concern.send(:assign_id)
-    end
-
-    def files
-      return @files if defined?(@files)
-      @files = [attributes[:files]].flatten.compact
-    end
-
-    def attach_files
-      files.all? do |file|
-        attach_file(file)
-      end
-    end
-
-    def apply_order(new_order)
-      return true unless new_order
-      curation_concern.ordered_member_proxies.each_with_index do |proxy, index|
-        unless new_order[index]
-          proxy.prev.next = curation_concern.ordered_member_proxies.last.next
-          break
-        end
-        proxy.proxy_for = ActiveFedora::Base.id_to_uri(new_order[index])
-        proxy.target = nil
-      end
-      curation_concern.list_source.order_will_change!
-      true
-    end
-
-    # The default behavior of active_fedora's aggregates association,
-    # when assigning the id accessor (e.g. collection_ids = ['foo:1']) is to add
-    # to new collections, but not remove from old collections.
-    # This method ensures it's removed from the old collections.
-    def add_to_collections(new_collection_ids)
-      return true unless new_collection_ids
-      # remove from old collections
-      # TODO: Implement in_collection_ids https://github.com/projecthydra-labs/hydra-pcdm/issues/157
-      (curation_concern.in_collections.map(&:id) - new_collection_ids).each do |old_id|
-        collection = Collection.find(old_id)
-        collection.members.delete(curation_concern)
-        collection.save
-      end
-
-      # add to new
-      new_collection_ids.each do |coll_id|
-        collection = Collection.find(coll_id)
-        collection.members << curation_concern
-        collection.save
-      end
-      true
-    end
-
-    def assign_representative
-      @file_sets ||= []
-      unless curation_concern.representative_id
-        curation_concern.representative = @file_sets.first unless @file_sets.empty?
-      end
-      curation_concern.save
-    end
-
-  private
-
-    def attach_file(file)
-      file_set = ::FileSet.new
-      file_set_actor = CurationConcerns::FileSetActor.new(file_set, user)
-      file_set_actor.create_metadata(curation_concern, visibility_attributes)
-      file_set_actor.create_content(file)
-      @file_sets ||= []
-      @file_sets << file_set # This is so that other methods like assign_representative can access the file_sets without reloading them from fedora
-    end
-
-    # The attributes used for visibility - used to send as initial params to
-    # created FileSets.
-    def visibility_attributes
-      raw_attributes.slice(:visibility, :visibility_during_lease, :visibility_after_lease, :lease_expiration_date, :embargo_release_date, :visibility_during_embargo, :visibility_after_embargo)
-    end
 end

data/lib/curation_concerns/models/version.rb

@@ -1,5 +1,5 @@
 module CurationConcerns
   module Models
-    VERSION = "0.11.0".freeze
+    VERSION = "0.12.0.pre1".freeze
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: curation_concerns-models
 version: !ruby/object:Gem::Version
-  version: 0.11.0
+  version: 0.12.0.pre1
 platform: ruby
 authors:
 - Justin Coyne
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-31 00:00:00.000000000 Z
+date: 2016-04-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: active_attr
@@ -198,11 +198,19 @@ files:
 - README.md
 - Rakefile
 - app/actors/concerns/curation_concerns/manages_embargoes_actor.rb
+- app/actors/curation_concerns/abstract_actor.rb
+- app/actors/curation_concerns/add_to_collection_actor.rb
+- app/actors/curation_concerns/apply_order_actor.rb
+- app/actors/curation_concerns/assign_identifier_actor.rb
+- app/actors/curation_concerns/assign_representative_actor.rb
+- app/actors/curation_concerns/attach_files_actor.rb
 - app/actors/curation_concerns/base_actor.rb
 - app/actors/curation_concerns/embargo_actor.rb
 - app/actors/curation_concerns/file_actor.rb
 - app/actors/curation_concerns/file_set_actor.rb
+- app/actors/curation_concerns/interpret_visibility_actor.rb
 - app/actors/curation_concerns/lease_actor.rb
+- app/actors/curation_concerns/root_actor.rb
 - app/actors/curation_concerns/work_actor_behavior.rb
 - app/indexers/curation_concerns/collection_indexer.rb
 - app/indexers/curation_concerns/file_set_indexer.rb
@@ -297,9 +305,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.5.1