ruby_event_store 0.24.0 → 0.25.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 7f3971fcea98161ee0fc07e8451d3acf1ceed3bb
-  data.tar.gz: bec1593c77019e7a152463d3963820b8081cd79a
+SHA256:
+  metadata.gz: 117724693784e5bf80bf4692eca63f78acf071bd7542ff4c45b1e588a267715e
+  data.tar.gz: ced1b8255f9994c47e8db8ad7442ee0a5b181720f37a1681130110f8480b1961
 SHA512:
-  metadata.gz: 6570c224f1f8e46d19d9527b4f4ff2354d3008ef377eab8d0fc38e9e3db43f6ba78e2a9d68ec99c0e3cbdebcf12e6bdaa9e58bcff86e54ec8922463e35c0a4a8
-  data.tar.gz: d0c6504dc2397c3dd00c9245009c101929ebbde23ab75ab82e9fd8072e61d2397f0c541460e40c4b51e4508ea26129749dc7f05c875d910626875c7167acb7fb
+  metadata.gz: 9310f649919f14d1d6b6a33b71f29103eacfb958c2c5c37902529a2154698c2292c5cb4342c38238352abfe7368479347a754a2b67f9788c637ec3188e515e40
+  data.tar.gz: 706c18cba2de9614d3dce903e64bdcafdeaa4efb17cb9b0129df7914f336a204c29ceb06d115e25de4ede0264424bb4e3d918f900ba894c4d77b0905a103d752

data/Makefile

@@ -1,32 +1,43 @@
-GEM_VERSION  = `cat ../RES_VERSION`
+GEM_VERSION = $(shell cat ../RES_VERSION)
+GEM_NAME    = ruby_event_store
+REQUIRE     = $(GEM_NAME)
+IGNORE      = RubyEventStore.const_missing \
+              RubyEventStore::InMemoryRepository\#append_with_synchronize \
+              RubyEventStore::InMemoryRepository\#normalize_to_array \
+              RubyEventStore::Client\#normalize_to_array \
+              RubyEventStore::SerializedRecord \
+              RubyEventStore::Projection\#read_events_from_stream \
+              RubyEventStore::Projection\#read_events_from_all_streams
+SUBJECT     ?= RubyEventStore*
 
 install: ## Install gem dependencies
 	@echo "Installing gem dependencies"
 	@bundle install
 
-test: ## Run tests
-	@echo "Running basic tests - beware: this won't guarantee build pass"
+test: ## Run unit tests
+	@echo "Running unit tests"
 	@bundle exec rspec
 
-mutate: test  ## Run mutation tests
-	@echo "Running mutation tests - only 100% free mutation will be accepted"
-	@bundle exec mutant --include lib --require ruby_event_store --use rspec "RubyEventStore*" \
-		--ignore-subject "RubyEventStore.const_missing" \
-		--ignore-subject "RubyEventStore::InMemoryRepository#append_with_synchronize" \
-		--ignore-subject "RubyEventStore::InMemoryRepository#normalize_to_array" \
-		--ignore-subject "RubyEventStore::Client#normalize_to_array" \
-		--ignore-subject "RubyEventStore::SerializedRecord" \
-		--ignore-subject "RubyEventStore::Projection#read_events_from_stream" \
-		--ignore-subject "RubyEventStore::Projection#read_events_from_all_streams"
-
+mutate: test ## Run mutation tests
+	@echo "Running mutation tests"
+	@bundle exec mutant --include lib \
+		$(addprefix --require ,$(REQUIRE)) \
+		$(addprefix --ignore-subject ,$(IGNORE)) \
+		--use rspec "$(SUBJECT)"
 
 build:
-	@gem build -V ruby_event_store.gemspec
+	@echo "Building gem package"
+	@gem build -V $(GEM_NAME).gemspec
 	@mkdir -p pkg/
-	@mv ruby_event_store-$(GEM_VERSION).gem pkg/
+	@mv $(GEM_NAME)-$(GEM_VERSION).gem pkg/
+
+push:
+	@echo "Pushing package to RubyGems"
+	@gem push pkg/$(GEM_NAME)-$(GEM_VERSION).gem
 
-release: build
-	@gem push pkg/ruby_event_store-$(GEM_VERSION).gem
+clean:
+	@echo "Removing previously built package"
+	-rm pkg/$(GEM_NAME)-$(GEM_VERSION).gem
 
 help:
 	@grep -E '^[a-zA-Z_-]+:.*?## .*$$' $(MAKEFILE_LIST) | sort | awk 'BEGIN {FS = ":.*?## "}; {printf "\033[36m%-30s\033[0m %s\n", $$1, $$2}'

data/lib/ruby_event_store/client.rb

@@ -15,7 +15,7 @@ module RubyEventStore
     def publish_events(events, stream_name: GLOBAL_STREAM, expected_version: :any)
       append_to_stream(events, stream_name: stream_name, expected_version: expected_version)
       events.each do |ev|
-        event_broker.notify_subscribers(ev)
+        @event_broker.notify_subscribers(ev)
       end
       :ok
     end
@@ -27,75 +27,74 @@ module RubyEventStore
     def append_to_stream(events, stream_name: GLOBAL_STREAM, expected_version: :any)
       events = normalize_to_array(events)
       events.each{|event| enrich_event_metadata(event) }
-      repository.append_to_stream(events, stream_name, expected_version)
+      @repository.append_to_stream(events, stream_name, expected_version)
       :ok
     end
 
     def link_to_stream(event_ids, stream_name:, expected_version: :any)
-      repository.link_to_stream(event_ids, stream_name, expected_version)
+      @repository.link_to_stream(event_ids, stream_name, expected_version)
       self
     end
 
     def delete_stream(stream_name)
       raise IncorrectStreamData if stream_name.nil? || stream_name.empty?
-      repository.delete_stream(stream_name)
+      @repository.delete_stream(stream_name)
       :ok
     end
 
-    def read_events_forward(stream_name, start: :head, count: page_size)
+    def read_events_forward(stream_name, start: :head, count: @page_size)
       raise IncorrectStreamData if stream_name.nil? || stream_name.empty?
-      page = Page.new(repository, start, count)
-      repository.read_events_forward(stream_name, page.start, page.count)
+      page = Page.new(@repository, start, count)
+      @repository.read_events_forward(stream_name, page.start, page.count)
     end
 
-    def read_events_backward(stream_name, start: :head, count: page_size)
+    def read_events_backward(stream_name, start: :head, count: @page_size)
       raise IncorrectStreamData if stream_name.nil? || stream_name.empty?
-      page = Page.new(repository, start, count)
-      repository.read_events_backward(stream_name, page.start, page.count)
+      page = Page.new(@repository, start, count)
+      @repository.read_events_backward(stream_name, page.start, page.count)
     end
 
     def read_stream_events_forward(stream_name)
       raise IncorrectStreamData if stream_name.nil? || stream_name.empty?
-      repository.read_stream_events_forward(stream_name)
+      @repository.read_stream_events_forward(stream_name)
     end
 
     def read_stream_events_backward(stream_name)
       raise IncorrectStreamData if stream_name.nil? || stream_name.empty?
-      repository.read_stream_events_backward(stream_name)
+      @repository.read_stream_events_backward(stream_name)
     end
 
-    def read_all_streams_forward(start: :head, count: page_size)
-      page = Page.new(repository, start, count)
-      repository.read_all_streams_forward(page.start, page.count)
+    def read_all_streams_forward(start: :head, count: @page_size)
+      page = Page.new(@repository, start, count)
+      @repository.read_all_streams_forward(page.start, page.count)
     end
 
-    def read_all_streams_backward(start: :head, count: page_size)
-      page = Page.new(repository, start, count)
-      repository.read_all_streams_backward(page.start, page.count)
+    def read_all_streams_backward(start: :head, count: @page_size)
+      page = Page.new(@repository, start, count)
+      @repository.read_all_streams_backward(page.start, page.count)
     end
 
     def read_event(event_id)
-      repository.read_event(event_id)
+      @repository.read_event(event_id)
     end
 
     def get_all_streams
-      repository.get_all_streams
+      @repository.get_all_streams
     end
 
     def subscribe(subscriber, event_types, &proc)
-      event_broker.add_subscriber(subscriber, event_types).tap do |unsub|
+      @event_broker.add_subscriber(subscriber, event_types).tap do |unsub|
         handle_subscribe(unsub, &proc)
       end
     end
 
     def subscribe_to_all_events(subscriber, &proc)
-      event_broker.add_global_subscriber(subscriber).tap do |unsub|
+      @event_broker.add_global_subscriber(subscriber).tap do |unsub|
         handle_subscribe(unsub, &proc)
       end
     end
 
     private
-    attr_reader :repository, :page_size, :event_broker, :metadata_proc, :clock
 
     def normalize_to_array(events)
       return *events
@@ -103,8 +102,8 @@ module RubyEventStore
 
     def enrich_event_metadata(event)
       metadata = event.metadata
-      metadata[:timestamp] ||= clock.()
-      metadata.merge!(metadata_proc.call || {}) if metadata_proc
+      metadata[:timestamp] ||= @clock.()
+      metadata.merge!(@metadata_proc.call || {}) if @metadata_proc
 
       # event.class.new(event_id: event.event_id, metadata: metadata, data: event.data)
     end

data/lib/ruby_event_store/in_memory_repository.rb

@@ -19,11 +19,11 @@ module RubyEventStore
     end
 
     def delete_stream(stream_name)
-      streams.delete(stream_name)
+      @streams.delete(stream_name)
     end
 
     def has_event?(event_id)
-      all.any?{ |item| item.event_id.eql?(event_id) }
+      @all.any?{ |item| item.event_id.eql?(event_id) }
     end
 
     def last_stream_event(stream_name)
@@ -41,7 +41,7 @@ module RubyEventStore
     end
 
     def read_stream_events_forward(stream_name)
-      streams[stream_name] || Array.new
+      @streams[stream_name] || Array.new
     end
 
     def read_stream_events_backward(stream_name)
@@ -49,23 +49,22 @@ module RubyEventStore
     end
 
     def read_all_streams_forward(start_event_id, count)
-      read_batch(all, start_event_id, count)
+      read_batch(@all, start_event_id, count)
     end
 
     def read_all_streams_backward(start_event_id, count)
-      read_batch(all.reverse, start_event_id, count)
+      read_batch(@all.reverse, start_event_id, count)
     end
 
     def read_event(event_id)
-      all.find { |e| event_id.eql?(e.event_id) } or raise EventNotFound.new(event_id)
+      @all.find { |e| event_id.eql?(e.event_id) } or raise EventNotFound.new(event_id)
     end
 
     def get_all_streams
-      [Stream.new("all")] + streams.keys.map { |name| Stream.new(name) }
+      [Stream.new("all")] + @streams.keys.map { |name| Stream.new(name) }
     end
 
     private
-    attr_accessor :streams, :all
 
     def normalize_to_array(events)
       return *events
@@ -107,12 +106,12 @@ module RubyEventStore
       events.each do |event|
         raise EventDuplicatedInStream if stream.any?{|ev| ev.event_id.eql?(event.event_id) }
         if include_global
-          raise EventDuplicatedInStream if all.any?{|ev| ev.event_id.eql?(event.event_id) }
-          all.push(event)
+          raise EventDuplicatedInStream if @all.any?{|ev| ev.event_id.eql?(event.event_id) }
+          @all.push(event)
         end
         stream.push(event)
       end
-      streams[stream_name] = stream
+      @streams[stream_name] = stream
       self
     end
 

data/lib/ruby_event_store/mappers/default.rb

@@ -12,24 +12,20 @@ module RubyEventStore
       def event_to_serialized_record(domain_event)
         SerializedRecord.new(
           event_id:         domain_event.event_id,
-          metadata:   serializer.dump(domain_event.metadata),
-          data:       serializer.dump(domain_event.data),
+          metadata:   @serializer.dump(domain_event.metadata),
+          data:       @serializer.dump(domain_event.data),
           event_type: domain_event.class.name
         )
       end
 
       def serialized_record_to_event(record)
-        event_type = events_class_remapping.fetch(record.event_type) { record.event_type }
+        event_type = @events_class_remapping.fetch(record.event_type) { record.event_type }
         ActiveSupport::Inflector.constantize(event_type).new(
           event_id: record.event_id,
-          metadata: serializer.load(record.metadata),
-          data:     serializer.load(record.data)
+          metadata: @serializer.load(record.metadata),
+          data:     @serializer.load(record.data)
         )
       end
-
-      private
-
-      attr_reader :serializer, :events_class_remapping
     end
   end
 end

data/lib/ruby_event_store/pub_sub/broker.rb

@@ -23,25 +23,24 @@ module RubyEventStore
 
       def notify_subscribers(event)
         all_subscribers_for(event.class).each do |subscriber|
-          dispatcher.call(subscriber, event)
+          @dispatcher.call(subscriber, event)
         end
       end
 
       private
-      attr_reader :subscribers, :dispatcher
 
       def verify_subscriber(subscriber)
         raise SubscriberNotExist if subscriber.nil?
-        dispatcher.verify(subscriber)
+        @dispatcher.verify(subscriber)
       end
 
       def subscribe(subscriber, event_types)
-        event_types.each{ |type| subscribers[type.name] << subscriber }
-        ->() {event_types.each{ |type| subscribers.fetch(type.name).delete(subscriber) } }
+        event_types.each{ |type| @subscribers[type.name] << subscriber }
+        ->() {event_types.each{ |type| @subscribers.fetch(type.name).delete(subscriber) } }
       end
 
       def all_subscribers_for(event_type)
-        subscribers[event_type.name] + @global_subscribers
+        @subscribers[event_type.name] + @global_subscribers
       end
     end
   end

data/lib/ruby_event_store/spec/event_repository_lint.rb

@@ -1,5 +1,6 @@
+TestDomainEvent = Class.new(RubyEventStore::Event)
+
 RSpec.shared_examples :event_repository do |repository_class|
-  TestDomainEvent = Class.new(RubyEventStore::Event)
   let(:repository) { subject || repository_class.new }
 
   it 'just created is empty' do

data/lib/ruby_event_store/version.rb

@@ -1,3 +1,3 @@
 module RubyEventStore
-  VERSION = "0.24.0"
+  VERSION = "0.25.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby_event_store
 version: !ruby/object:Gem::Version
-  version: 0.24.0
+  version: 0.25.0
 platform: ruby
 authors:
 - Arkency
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-01-24 00:00:00.000000000 Z
+date: 2018-02-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -129,7 +129,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.13
+rubygems_version: 2.7.5
 signing_key: 
 specification_version: 4
 summary: Event Store in Ruby