entity_store 0.2.15 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f6957074ac4594c6b4a1068ad4131fab670763a0
-  data.tar.gz: 7a975bf8fc65eacf1a15914d973371a1267f0295
+  metadata.gz: 80ef2d2f7cb967ed15151bd5d3fa17c5526c4022
+  data.tar.gz: ee08573ec53e96fa70df0cb30c48db9df19d56de
 SHA512:
-  metadata.gz: 9865c283a793d09f4d22b57fe4c0bb40c2d8b58b3049708692050539856663e252e19d63e0fed878967ce2d56977328606e72dcadc3fb8b0e60e655068427b1d
-  data.tar.gz: d3ce7d96186648e7f44152be97694393d4b783f3a1c0ebcca08feac5c4aee73dfb50dc6f6ce4cca6e90d84bb753b25dee54c0c061a1619ca52c9766a1a3968a9
+  metadata.gz: 653358d1589d59332805e9501e41c637bc2bbb4a4292b19ca0586871cb7352cbb709f2a23e97813cfdcb2be823414b61a9f50acd01e5983c002d08dfcd4d05e3
+  data.tar.gz: e2fde849bd73b14d086f78fb2268304c55771f85f74d21db3c0b74b4f800c8856e369767e82cdc353c8efa9cbf9d06ac7027f4ad69c8daa7cc289c903eb7d7b3

data/lib/entity_store/entity.rb

@@ -6,7 +6,6 @@ module EntityStore
       klass.class_eval do
         include HashSerialization
         include Attributes
-        extend ClassMethods
 
         version_incremented_event_class = "#{self.name}VersionIncremented".split('::').inject(Object) {|obj, name|
             obj.const_defined?(name) ? obj.const_get(name) : obj.const_set(name, Class.new)
@@ -24,28 +23,6 @@ module EntityStore
       end
     end
 
-    module ClassMethods
-
-      def related_entities(*names)
-        names.each do |name|
-          # attr accessor for the id
-          define_method("#{name}_id") { instance_variable_get("@#{name}_id")}
-          define_method("#{name}_id=") do |value| instance_variable_set("@#{name}_id", value) end
-
-          # lazy loader for related entity
-          define_method(name) {
-            if instance_variable_get("@#{name}_id") && @_related_entity_loader
-              instance_variable_get("@_#{name}") || instance_variable_set("@_#{name}", @_related_entity_loader.get(instance_variable_get("@#{name}_id")))
-            end
-          }
-        end
-
-        define_method(:loaded_related_entities) {
-          names.collect{ |name| instance_variable_get("@_#{name}") }.select{|entity| !entity.nil? }
-        }
-      end
-    end
-
     def type
       self.class.name
     end
@@ -63,12 +40,6 @@ module EntityStore
       event_class.new(:entity_id => id, :version => version)
     end
 
-    # Holds a reference to the store used to load this entity so the same store
-    # can be used for related entities
-    def related_entity_loader=(value)
-      @_related_entity_loader = value
-    end
-
     def pending_events
       @pending_events ||= []
     end

data/lib/entity_store/mongo_entity_store.rb

@@ -51,7 +51,7 @@ module EntityStore
       entities.update({'_id' => BSON::ObjectId.from_string(entity.id)}, { '$set' => { 'version' => entity.version } })
     end
 
-    # Public - create a snapshot of the entity and store in the entities collection
+    # Public: create a snapshot of the entity and store in the entities collection
     #
     def snapshot_entity(entity)
       query = {'_id' => BSON::ObjectId.from_string(entity.id)}
@@ -74,7 +74,7 @@ module EntityStore
       entities.update({'_id' => BSON::ObjectId.from_string(id)}, { '$unset' => { 'snapshot' => 1}})
     end
 
-    # Public - remove all snapshots
+    # Public: remove all snapshots
     #
     # type        - String optional class name for the entity
     #
@@ -88,19 +88,26 @@ module EntityStore
       events.insert({'_type' => event.class.name, '_entity_id' => BSON::ObjectId.from_string(event.entity_id) }.merge(event.attributes) ).to_s
     end
 
-    def get_entity!(id)
-      get_entity(id, true)
-    end
-
-    # Public - loads the entity from the store, including any available snapshots
+    # Public: loads the entity from the store, including any available snapshots
     # then loads the events to complete the state
     #
-    # id                - String representation of BSON::ObjectId
-    # raise_exception   - Boolean indicating whether to raise an exception if not found (default=false)
+    # ids           - Array of Strings representation of BSON::ObjectId
+    # options       - Hash of options (default: {})
+    #                 :raise_exception - Boolean (default: true)
     #
-    # Returns an object of the entity type
-    def get_entity(id, raise_exception=false)
-      if attrs = entities.find_one('_id' => BSON::ObjectId.from_string(id))
+    # Returns an array of entities
+    def get_entities(ids, options={})
+
+      object_ids = ids.map do |id|
+        begin
+          BSON::ObjectId.from_string(id)
+        rescue BSON::InvalidObjectId
+          raise NotFound.new(id) if options.fetch(:raise_exception, true)
+          nil
+        end
+      end
+
+      entities.find('_id' => { '$in' => object_ids }).map do |attrs|
         begin
           entity_type = EntityStore::Config.load_type(attrs['_type'])
 
@@ -111,41 +118,55 @@ module EntityStore
             attrs.delete('snapshot') unless active_key == attrs['snapshot_key']
           end
 
-          entity = entity_type.new(attrs['snapshot'] || {'id' => id })
+          entity = entity_type.new(attrs['snapshot'] || {'id' => attrs['_id'].to_s })
         rescue => e
           log_error "Error loading type #{attrs['_type']}", e
           raise
         end
 
         entity
-      else
-        raise NotFound.new(id) if raise_exception
-        nil
       end
-    rescue BSON::InvalidObjectId
-      raise NotFound.new(id) if raise_exception
-      nil
+
     end
 
-    def get_events(id, since_version=nil)
-      query = { '_entity_id' => BSON::ObjectId.from_string(id) }
+    # Public:  get events for an array of criteria objects
+    #           because each entity could have a different reference
+    #           version this allows optional criteria to be specifed
+    #
+    #
+    # criteria  - Hash :id mandatory, :since_version optional
+    #
+    # Examples
+    #
+    # get_events_for_criteria([ { id: "23232323"}, { id: "2398429834", since_version: 4 } ] )
+    #
+    # Returns Hash with id as key and Array of Event instances as value
+    def get_events(criteria)
+      return {} if criteria.empty?
+
+      query_items = criteria.map do |item|
+        raise ArgumentError.new(":id missing from criteria") unless item[:id]
+        item_query = { '_entity_id' => BSON::ObjectId.from_string(item[:id]) }
+        item_query['entity_version'] = { '$gt' => item[:since_version] } if item[:since_version]
+        item_query
+      end
 
-      query['entity_version'] = { '$gt' => since_version } if since_version
+      query = { '$or' => query_items }
 
       options = {
         :sort => [['entity_version', Mongo::ASCENDING], ['_id', Mongo::ASCENDING]]
       }
 
-      loaded_events = events.find(query, options).collect do |attrs|
+      result = Hash[ criteria.map { |item| [ item[:id], [] ] } ]
+
+      events.find(query, options).each do |attrs|
         begin
-          EntityStore::Config.load_type(attrs['_type']).new(attrs)
+          result[attrs['_entity_id'].to_s] << EntityStore::Config.load_type(attrs['_type']).new(attrs)
         rescue => e
           log_error "Error loading type #{attrs['_type']}", e
-          nil
         end
       end
-
-      loaded_events.compact
+      result
     end
   end
 end

data/lib/entity_store/store.rb

@@ -20,12 +20,6 @@ module EntityStore
     end
 
     def save(entity)
-      do_save entity
-      entity.loaded_related_entities.each do |e| do_save e end if entity.respond_to?(:loaded_related_entities)
-      entity
-    end
-
-    def do_save(entity)
       # need to look at concurrency if we start storing version on client
       unless entity.pending_events.empty?
         entity.version += 1
@@ -42,7 +36,7 @@ module EntityStore
       end
       entity
     rescue => e
-      log_error "Store#do_save error: #{e.inspect} - #{entity.inspect}", e
+      log_error "Store#save error: #{e.inspect} - #{entity.inspect}", e
       raise e
     end
 
@@ -74,29 +68,67 @@ module EntityStore
     end
 
     def get(id, raise_exception=false)
-      log_debug { "Store#get #{id}"}
-      if entity = storage_client.get_entity(id, raise_exception)
+      options = {
+        raise_exception: raise_exception
+      }
 
-        storage_client.get_events(id, entity.version).each do |event|
+      get_with_ids([id], options).first
+    end
+
+    # Public: get a series of entities
+    #
+    # ids           - Array of id strings
+    # options       - Hash of options (default: {})
+    #                 :raise_exception - Boolean (default true)
+    #
+    # Returns an Array of entities
+    def get_with_ids(ids, options={})
+
+      entities = Hash[ storage_client.get_entities(ids, options).map { |e| [ e.id, e] } ]
+
+      if options.fetch(:raise_exception, true)
+        ids.each do |id|
+          raise NotFound.new(id) unless entities[id]
+        end
+      end
+
+      criteria = entities.map do |id, entity|
+        { id: id, since_version: entity.version }
+      end
+
+      events = storage_client.get_events(criteria)
+
+      entities.each do |id, entity|
+
+        next unless entity_events = events[id]
+
+        entity_events.each do |event|
           begin
             event.apply(entity)
             log_debug { "Applied #{event.inspect} to #{id}" }
           rescue => e
             log_error "Failed to apply #{event.class.name} #{event.attributes} to #{id} with #{e.inspect}", e
+            raise if options.fetch(:raise_exception, true)
           end
           entity.version = event.entity_version
         end
 
-        # assign this entity loader to allow lazy loading of related entities
-        entity.related_entity_loader = self
       end
-      entity
+
+      # ensure entities are returned in same order as requested
+      ids.map { |id| entities[id] }
+
     end
 
-    # Public : USE AT YOUR PERIL this clears the ENTIRE data store
+    # Public: USE AT YOUR PERIL this clears the ENTIRE data store
+    #
+    # confirm     - Symbol that must equal :i_am_sure
     #
     # Returns nothing
-    def clear_all
+    def clear_all(confirm)
+      unless confirm == :i_am_sure
+        raise "#clear_all call with :i_am_sure in order to do this"
+      end
       storage_client.clear
       @_storage_client = nil
     end
@@ -105,7 +137,7 @@ module EntityStore
       @_event_bus ||= EventBus.new
     end
 
-    # Public : returns an array representing a full audit trail for the entity.
+    # Public: returns an array representing a full audit trail for the entity.
     # After each event is applied the state of the entity is rendered.
     # Optionally accepts a block which should return true or false to indicate
     # whether to render the line. The block yields entity, event, lines collection

data/lib/entity_store/version.rb

@@ -1,3 +1,3 @@
 module EntityStore
-  VERSION = "0.2.15".freeze
+  VERSION = "0.3.1".freeze
 end

data/spec/entity_store/entity_spec.rb

@@ -9,76 +9,16 @@ end
 class DummyEntity
   include Entity
 
-  related_entities :club, :user
-
   attr_accessor :name, :description, :members
   entity_value_array_attribute :things, ThingEntityValue
   entity_value_dictionary_attribute :other_things, ThingEntityValue
 end
 
 describe Entity do
-  describe ".related_entities" do
-    before(:each) do
-      @entity_loader = double(Store)
-      @club = double('Entity', :id => random_string)
-      @user = double('Entity', :id => random_string)
-      @entity = DummyEntity.new(:related_entity_loader => @entity_loader, :club_id => @club.id, :user_id => @user.id)
-      @entity_loader.stub(:get) { |id| 
-        case id
-        when @club.id
-          @club 
-        when @user.id
-          @user
-        end
-      }
-    end
-
-    it "should have the club_id set" do
-      @entity.club_id.should eq(@club.id)
-    end
-    it "should load club" do
-      @entity.club.should eq(@club)
-    end
-    it "should call entity_loader with club id" do
-      @entity_loader.should_receive(:get).with(@club.id)
-      @entity.club
-    end
-    it "should have the user_id set" do
-      @entity.user_id.should eq(@user.id)
-    end
-    it "should load user" do
-      @entity.user.should eq(@user)
-    end
-    it "should call entity_loader with user id" do
-      @entity_loader.should_receive(:get).with(@user.id)
-      @entity.user
-    end
-
-    context "when only user loaded" do
-      before(:each) do
-        @entity.user
-      end
-
-      it "should only have user in the loaded related entities collection" do
-        @entity.loaded_related_entities.should eq([@user])
-      end
-    end
-
-    context "when both user and club loaded" do
-      before(:each) do
-        @entity.club
-        @entity.user
-      end
-
-      it "should only have user in the loaded related entities collection" do
-        @entity.loaded_related_entities.should eq([@club, @user])
-      end
-    end
-  end
 
   describe "#attributes" do
     before(:each) do
-      @entity = DummyEntity.new(:id => @id = random_object_id, :club_id => @club_id = random_string, 
+      @entity = DummyEntity.new(:id => @id = random_object_id, :club_id => @club_id = random_string,
         :user_id => @user_id = random_string, :name => @name = random_string, :version => @version = random_integer,
         :members => [], things: [ ThingEntityValue.new(name: random_string), ThingEntityValue.new(name: random_string) ],
         other_things_dictionary: { random_string => ThingEntityValue.new(name: random_string) } )
@@ -88,8 +28,7 @@ describe Entity do
 
     it "returns a hash of the attributes" do
       subject.should eq({
-        :id => @id, :version => @version, :name => @name, :club_id => @club_id, 
-        :user_id => @user_id, :description => nil, :members => [], 
+        :id => @id, :version => @version, :name => @name, :description => nil, :members => [],
         :things => @entity.things.map { |t| { name: t.name } },
         :other_things_dictionary => { @entity.other_things_dictionary.keys.first => { name: @entity.other_things_dictionary.values.first.name }}
         })
@@ -183,7 +122,7 @@ describe Entity do
         end
         it "should set items" do
           entity.things.each_with_index do |item, i| item.should be(items[i]) end
-        end   
+        end
       end
       context "when something else in array" do
         let(:items) { [ random_string, random_string ] }
@@ -248,7 +187,7 @@ describe Entity do
 
         it "should set items" do
           ids.each do |id| entity.other_things_dictionary[id].name.should eq(items[id].name) end
-        end   
+        end
       end
       context "when something else in array" do
         let(:items) { { ids[0] => random_string, ids[1] => random_string } }
@@ -268,7 +207,7 @@ describe Entity do
     end
 
     describe "hash initialisation, ie from snapshot" do
-      let(:attributes) { { other_things_dictionary: { ids[0] => { name: random_string }, ids[1] => { name: random_string } } } } 
+      let(:attributes) { { other_things_dictionary: { ids[0] => { name: random_string }, ids[1] => { name: random_string } } } }
 
       subject { DummyEntity.new(attributes) }
 

data/spec/entity_store/mongo_entity_store_spec.rb

@@ -56,7 +56,7 @@ describe MongoEntityStore do
       store.add_event(third_event)
     end
 
-    subject { store.get_events(event_entity_id, since_version) }
+    subject { store.get_events( [{ id: event_entity_id, since_version: since_version }])[event_entity_id] }
 
     context "all events" do
       let(:event_entity_id) { entity_id }
@@ -86,7 +86,7 @@ describe MongoEntityStore do
     end
   end
 
-  describe "#get_entity" do
+  describe "#get_entities" do
     let(:entity_class) { DummyEntity }
 
     let(:saved_entity) do
@@ -95,23 +95,26 @@ describe MongoEntityStore do
       entity
     end
 
-    subject { store.get_entity(saved_entity.id) }
+    let(:id) { saved_entity.id }
+    let(:options) { { } }
+
+    subject { store.get_entities( [ id ], options) }
 
     it "should retrieve an entity from the store with the same ID" do
-      subject.id.should == saved_entity.id
+      subject.first.id.should == saved_entity.id
     end
 
     it "should retrieve an entity from the store with the same class" do
-      subject.class.should == saved_entity.class
+      subject.first.class.should == saved_entity.class
     end
 
     it "should have the same version" do
-      subject.version.should == saved_entity.version
+      subject.first.version.should == saved_entity.version
     end
 
     context "when a snapshot does not exist" do
       it "should not have set the name" do
-        subject.name.should be_nil
+        subject.first.name.should be_nil
       end
     end
 
@@ -123,7 +126,7 @@ describe MongoEntityStore do
 
       context "when a snapshot key not in use" do
         it "should have set the name" do
-          subject.name.should == saved_entity.name
+          subject.first.name.should == saved_entity.name
         end
       end
 
@@ -132,7 +135,7 @@ describe MongoEntityStore do
 
         context "when the key matches the class's key" do
           it "should have set the name" do
-            subject.name.should == saved_entity.name
+            subject.first.name.should == saved_entity.name
           end
         end
 
@@ -142,29 +145,26 @@ describe MongoEntityStore do
           end
 
           it "should ignore the invalidated snapshot" do
-            subject.name.should be_nil
+            subject.first.name.should be_nil
           end
         end
       end
     end
-  end
-
-  describe "#get_entity!" do
-    context "when invalid id format passed" do
-      subject { store.get_entity!(random_string) }
 
-      it "should raise not found" do
-        expect { subject }.to raise_error(NotFound)
+    describe "context when enable exceptions" do
+      let(:options) do
+        { raise_exception: true }
       end
-    end
 
-    context "when valid id format passed but no object exists" do
-      subject { store.get_entity!(random_object_id) }
+      context "when invalid id format passed" do
+        let(:id) { random_string }
 
-      it "should raise not found" do
-        expect { subject }.to raise_error(NotFound)
+        it "should raise not found" do
+          expect { subject }.to raise_error(NotFound)
+        end
       end
     end
+
   end
 
   describe "#snapshot_entity" do

data/spec/entity_store/store_spec.rb

@@ -77,30 +77,7 @@ describe Store do
   end
 
   describe "#save" do
-    context "when entity has related entities loaded" do
-      before(:each) do
-        @entity = DummyEntityForStore.new(:id => random_string)
-        @entity.version = random_integer * EntityStore::Config.snapshot_threshold + 1
-        @store = Store.new
-        @related_entity = double('Entity')
-        @entity.stub(:loaded_related_entities) { [ @related_entity ] }
-        @store.stub(:do_save)
-      end
-
-      subject { @store.save(@entity) }
-
-      it "should save the entity" do
-        @store.should_receive(:do_save).with(@entity)
-        subject
-      end
-      it "should save them as well" do
-        @store.should_receive(:do_save).with(@related_entity)
-        subject
-      end
-    end
-  end
 
-  describe "#do_save" do
     before(:each) do
       @new_id = random_string
       @entity = DummyEntityForStore.new(:id => random_string)
@@ -112,7 +89,7 @@ describe Store do
       @entity.stub(:pending_events) { [ double('Event') ] }
     end
 
-    subject { @store.do_save(@entity) }
+    subject { @store.save(@entity) }
 
     it "increments the entity version number" do
       expect { subject }.to change { @entity.version }.by 1
@@ -176,45 +153,84 @@ describe Store do
 
   end
 
-  describe "#get" do
-    before(:each) do
-      @id = random_integer
-      @entity = DummyEntityForStore.new(id: random_string, version: random_integer)
-      DummyEntityForStore.stub(:new).and_return(@entity)
-      @events = [
-        double("Event", apply: true, entity_version: @entity.version + 1),
-        double("Event", apply: true, entity_version: @entity.version + 2)
-      ]
-
-      @storage_client = double("StorageClient", :get_entity => @entity, :get_events => @events)
-      @store = Store.new
-      @store.stub(:storage_client) { @storage_client }
+  describe "getters" do
+    let(:ids) { [ random_string, random_string, random_string ] }
+    let(:entities) { ids.map { |id| DummyEntityForStore.new(id: id, version: random_integer) } }
+    let(:events) do
+      Hash[ ids.map do |id|
+        [
+          id,
+          [
+            double("Event", apply: true, entity_version: entities.find { |e| e.id == id } .version + 1),
+            double("Event", apply: true, entity_version: entities.find { |e| e.id == id } .version + 2)
+          ]
+        ]
+      end ]
     end
 
-    subject { @store.get(@id) }
+    let(:storage_client) { double("StorageClient") }
+    let(:store) { Store.new }
 
-    it "should retrieve object from the storage client" do
-      @storage_client.should_receive(:get_entity).with(@id, false)
-      subject
-    end
-    it "should assign itself as the related_entity_loader" do
-      @entity.should_receive(:related_entity_loader=).with(@store)
-      subject
-    end
-    it "should return a ride" do
-      subject.should eq(@entity)
-    end
-    it "should retrieve it's events" do
-      @storage_client.should_receive(:get_events).with(@id, @entity.version)
-      subject
+    before(:each) do
+      storage_client.stub(:get_entities) do |ids|
+        entities.select { |e| ids.include?(e.id) }
+      end
+
+      storage_client.stub(:get_events) do |criteria|
+        Hash[ criteria.map { |c| [ c[:id], events[c[:id]] ] }]
+      end
+      store.stub(:storage_client) { storage_client }
     end
-    it "should apply each event to the entity" do
-      @events.each do |event| event.should_receive(:apply).with(@entity) end
-      subject
+    describe "#get" do
+      let(:entity) { entities[1] }
+      let(:id) { entity.id }
+
+      subject { store.get(id) }
+
+      it "should retrieve object from the storage client" do
+        storage_client.should_receive(:get_entities).with([id], { raise_exception: false })
+        subject
+      end
+      it "should return the entity" do
+        subject.id.should eq(entity.id)
+      end
+      it "should apply each event to the entity" do
+        events[id].each do |event|
+          event.should_receive(:apply).with(entity)
+        end
+        subject
+      end
+      it "should set the entity version to that of the last event" do
+        subject
+        entity.version.should eq(events[id].last.entity_version)
+      end
     end
-    it "should set the entity version to that of the last event" do
-      subject
-      @entity.version.should eq(@events.last.entity_version)
+
+    describe "#get_with_ids" do
+
+      subject { store.get_with_ids(ids) }
+
+      it "should retrieve object from the storage client" do
+        storage_client.should_receive(:get_entities).with(ids, {})
+        subject
+      end
+      it "should return the entities" do
+        subject.map { |e| e.id }.should eq(ids)
+      end
+      it "should apply each event to the entities" do
+        entities.each do |entity|
+          events[entity.id].each do |event|
+            event.should_receive(:apply).with(entity)
+          end
+        end
+        subject
+      end
+      it "should set the entity version to that of the last event" do
+        subject
+        entities.each do |entity|
+          entity.version.should eq(events[entity.id].last.entity_version)
+        end
+      end
     end
   end
 end

metadata

@@ -1,55 +1,55 @@
 --- !ruby/object:Gem::Specification
 name: entity_store
 version: !ruby/object:Gem::Version
-  version: 0.2.15
+  version: 0.3.1
 platform: ruby
 authors:
 - Adam Bird
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-24 00:00:00.000000000 Z
+date: 2014-05-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mongo
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.8'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.8'
 - !ruby/object:Gem::Dependency
   name: bson_ext
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.8'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.8'
 - !ruby/object:Gem::Dependency
   name: hatchet
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0.2'
 description: Event sourced entity store with a replaceable body
@@ -96,12 +96,12 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []