sandthorn_sequel_projection 0.0.1

data/lib/sandthorn_sequel_projection/manifest.rb

@@ -0,0 +1,10 @@
+module SandthornSequelProjection
+  class Manifest
+
+    attr_reader :projections
+
+    def initialize(*projections)
+      @projections = Array.wrap(projections).flatten
+    end
+  end
+end

data/lib/sandthorn_sequel_projection/processed_events_tracker.rb

@@ -0,0 +1,94 @@
+require 'forwardable'
+
+module SandthornSequelProjection
+  class ProcessedEventsTracker
+    extend Forwardable
+
+    def_delegator self, :table_name
+    def_delegators :db_connection, :transaction
+
+    attr_reader :db_connection, :identifier, :lock, :event_store
+
+    DEFAULT_TABLE_NAME = :processed_events_trackers
+
+    def initialize(identifier:, event_store:, db_connection: nil)
+      @identifier = identifier.to_s
+      @event_store = event_store
+      @db_connection = db_connection || SandthornSequelProjection.configuration.db_connection
+      @lock = Lock.new(identifier, @db_connection)
+      ensure_row
+    end
+
+    def with_lock
+      @lock.acquire do
+        yield
+      end
+    end
+
+    def process_events(&block)
+      with_lock do
+        cursor = Cursor.new(after_sequence_number: last_processed_sequence_number, event_store: event_store)
+        events = cursor.get_batch
+        transaction do
+          until(events.empty?)
+            block.call(events)
+            events = cursor.get_batch
+          end
+          write_sequence_number(cursor.last_sequence_number)
+        end
+      end
+    end
+
+    def last_processed_sequence_number
+      row[:last_processed_sequence_number]
+    end
+
+    def table
+      db_connection[table_name]
+    end
+
+    def row_exists?
+      !row.nil?
+    end
+
+    def row
+      table.where(identifier: identifier).first
+    end
+
+    def reset
+      with_lock do
+        write_sequence_number(0)
+      end
+    end
+
+    def self.table_name
+      DEFAULT_TABLE_NAME
+    end
+
+    def self.migrate!(db_connection)
+      db_connection.create_table?(table_name) do
+        String    :identifier
+        Integer   :last_processed_sequence_number, default: 0
+        DateTime  :locked_at, null: true
+      end
+      db_connection.add_index(table_name, :identifier, unique: true)
+    rescue Exception => e
+      raise Errors::MigrationError, e
+    end
+
+  private
+
+    def write_sequence_number(number)
+      table.where(identifier: identifier).update(last_processed_sequence_number: number)
+    end
+
+    def ensure_row
+      create_row unless row_exists?
+    end
+
+    def create_row
+      table.insert(identifier: identifier)
+    end
+
+  end
+end

data/lib/sandthorn_sequel_projection/projection.rb

@@ -0,0 +1,65 @@
+require 'forwardable'
+
+ module SandthornSequelProjection
+  class Projection
+    extend Forwardable
+    include SimpleMigrator::Migratable
+
+    def_delegators self, :identifier, :event_store
+    def_delegators :tracker, :last_processed_sequence_number
+
+    attr_reader :db_connection, :event_handlers, :tracker
+
+    def initialize(db_connection = nil)
+      @db_connection = db_connection || SandthornSequelProjection.configuration.db_connection
+      @tracker = ProcessedEventsTracker.new(
+          identifier: identifier,
+          db_connection: @db_connection,
+          event_store: event_store)
+      @event_handlers = self.class.event_handlers
+    end
+
+    def update!
+      tracker.process_events do |batch|
+        event_handlers.handle(self, batch)
+      end
+    end
+
+    def migrator
+      SimpleMigrator.migrator(db_connection)
+    end
+
+    class << self
+      attr_reader :event_store_name
+
+      def event_store(event_store = nil)
+        if event_store
+          @event_store_name = event_store
+        else
+          find_event_store
+        end
+      end
+
+      def find_event_store
+        SandthornSequelProjection.find_event_store(@event_store_name)
+      end
+
+      attr_reader :event_store_name
+      attr_accessor :event_handlers
+
+      def define_event_handlers
+        @event_handlers ||= EventHandlerCollection.new
+        yield(@event_handlers)
+      end
+
+      def identifier
+        self.name.gsub(/::/, '_').
+            gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+            gsub(/([a-z\d])([A-Z])/,'\1_\2').
+            tr("-", "_").
+            downcase
+      end
+    end
+
+  end
+end

data/lib/sandthorn_sequel_projection/runner.rb

@@ -0,0 +1,62 @@
+module SandthornSequelProjection
+  class Runner
+
+    DEFAULT_INTERVAL = 0.5
+
+    attr_reader :manifest, :interval
+
+    def initialize(manifest, interval = DEFAULT_INTERVAL)
+      @manifest = manifest
+      @interval = interval
+    end
+
+    def run(infinite = true)
+      @projections = manifest.projections.map do |projection_class|
+        projection_class.new(db_connection)
+      end
+      migrate!
+      if infinite
+        start_loop
+      else
+        loop_once
+      end
+    end
+
+  private
+
+    def start_loop
+      while true
+        loop_once
+      end
+    end
+
+    def loop_once
+      @projections.each do |projection|
+        projection.update!
+      end
+      sleep(interval)
+    end
+
+    def db_connection
+      SandthornSequelProjection.configuration.db_connection
+    end
+
+    def migrate!
+      @projections.each(&:migrate!)
+    end
+
+  end
+
+  class CircularQueue < Queue
+
+    # = CircularQueue
+    # Automatically pushes popped elements to the back of the queue
+    # In other words, can never be emptied by use of pop
+    def pop
+      super.tap do |el|
+        self << el
+      end
+    end
+
+  end
+end

data/lib/sandthorn_sequel_projection/tasks.rb

@@ -0,0 +1,14 @@
+require 'rake/dsl_definition'
+
+module SandthornSequelProjections
+  class RakeTasks
+    include Rake::DSL if defined? Rake::DSL
+    def install
+      namespace :sandthorn_projections do
+        task :init do
+          SandthornSequelProjections.start
+        end
+      end
+    end
+  end
+end

data/lib/sandthorn_sequel_projection/utilities.rb

@@ -0,0 +1,5 @@
+module Utilities
+end
+
+require "sandthorn_sequel_projection/utilities/null_proc"
+require "sandthorn_sequel_projection/utilities/core_extensions/array_wrap"

data/lib/sandthorn_sequel_projection/utilities/core_extensions/array_wrap.rb

@@ -0,0 +1,13 @@
+# Copied from ActiveSupport
+# https://github.com/rails/rails/blob/master/activesupport/lib/active_support/core_ext/array/wrap.rb
+class Array
+  def self.wrap(object)
+    if object.nil?
+      []
+    elsif object.respond_to?(:to_ary)
+      object.to_ary || [object]
+    else
+      [object]
+    end
+  end
+end

data/lib/sandthorn_sequel_projection/utilities/null_proc.rb

@@ -0,0 +1,9 @@
+module SandthornSequelProjection
+  module Utilities
+    class NullProc < Proc
+      def self.new
+        super() { |*| }
+      end
+    end
+  end
+end

data/lib/sandthorn_sequel_projection/version.rb

@@ -0,0 +1,3 @@
+module SandthornSequelProjection
+  VERSION = "0.0.1"
+end

data/sandthorn_sequel_projection.gemspec

@@ -0,0 +1,37 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'sandthorn_sequel_projection/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "sandthorn_sequel_projection"
+  spec.version       = SandthornSequelProjection::VERSION
+  spec.authors       = ["Lars Krantz"]
+  spec.email         = ["lars.krantz@alaz.se"]
+  spec.summary       = %q{Helps creating sql projections from sandthorn events}
+  spec.description   = spec.summary
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.required_ruby_version = ">= 2.0"
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "sandthorn_driver_sequel"
+  spec.add_development_dependency "awesome_print"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "sqlite3"
+  spec.add_development_dependency "codeclimate-test-reporter"
+
+  spec.add_runtime_dependency     "sandthorn", "~> 0.6"
+  spec.add_runtime_dependency     "sandthorn_event_filter", "~> 0.0.4"
+  spec.add_runtime_dependency     "sequel"
+  spec.add_runtime_dependency     "simple_migrator"
+
+end

data/spec/cursor_spec.rb

@@ -0,0 +1,44 @@
+module SandthornSequelProjection
+  describe Cursor do
+
+    let(:first_page) { [ { sequence_number: 1 } ] }
+    let(:second_page) { [ { sequence_number: 2 } ] }
+    let(:third_page) { [] }
+    let(:event_store) do
+      store = Object.new
+      env = self
+      store.tap do |store|
+        store.define_singleton_method(:get_events) do |after_sequence_number: 0, take: 1|
+          case after_sequence_number
+            when 0
+              env.first_page
+            when 1
+              env.second_page
+            else
+              env.third_page
+          end
+        end
+      end
+    end
+    let(:cursor) { Cursor.new(after_sequence_number: 0, batch_size: 1, event_store: event_store) }
+
+    it "has the correct starting sequence number and batch size" do
+      expect(cursor.batch_size).to eq(1)
+      expect(cursor.last_sequence_number).to eq(0)
+    end
+
+    describe "#get_batch" do
+      describe "sequential calls" do
+        it "returns pages until empty and keeps track of seen sequence numbers" do
+          expect(cursor.get_batch.events).to eq(first_page)
+          expect(cursor.last_sequence_number).to eq(first_page.last[:sequence_number])
+          expect(cursor.get_batch.events).to eq(second_page)
+          expect(cursor.last_sequence_number).to eq(second_page.last[:sequence_number])
+          expect(cursor.get_batch.events).to eq(third_page)
+          expect(cursor.last_sequence_number).to eq(second_page.last[:sequence_number])
+        end
+      end
+    end
+
+  end
+end

data/spec/event_handler_collection_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+module SandthornSequelProjection
+  describe EventHandlerCollection do
+    let(:collection) { EventHandlerCollection.new }
+    let(:projection) { Object.new }
+
+    describe "#add" do
+      it "adds the handler to the collection" do
+        handler_data = :foo
+        collection.define(handler_data)
+        expect(collection.handlers.length).to eq(1)
+        handler = collection.handlers.first
+        expect(handler.message).to eq(:foo)
+      end
+    end
+
+    describe "#handle" do
+      it "calls handle on each handler for every event, in order" do
+        events = [1,2]
+        handler1 = :foo
+        handler2 = :bar
+        handlers = [handler1, handler2]
+        handlers.each do |handler|
+          collection.define(handler)
+        end
+        collection.handlers.each do |handler|
+          expect(handler).to receive(:handle).ordered.with(projection, 1).once
+        end
+        collection.handlers.each do |handler|
+          expect(handler).to receive(:handle).ordered.with(projection, 2).once
+        end
+        collection.handle(projection, events)
+      end
+    end
+
+
+  end
+end

data/spec/event_handler_spec.rb

@@ -0,0 +1,82 @@
+require "spec_helper"
+
+module SandthornSequelProjection
+  describe EventHandler do
+
+    class TestProjection
+      def foo(event); event; end
+    end
+
+    let(:projection) { TestProjection.new }
+    let(:simple_handler) { EventHandler.new(:foo)}
+
+    describe "::initialize" do
+
+      context "when given just a symbol" do
+
+        it "creates a handler with an empty filter" do
+          expect(simple_handler.filter).to be_empty
+        end
+
+        it "creates a handler with the proper method handle" do
+          expect(simple_handler.message).to eq(:foo)
+        end
+
+      end
+
+      context "when given filters" do
+        context "and given singular keywords" do
+          let(:handler) { EventHandler.new(foo: { aggregate_type: "FooBar", event_name: "new" })}
+          let(:extractor) { handler.filter.matchers.matchers.first }
+          let(:matching_event) { { aggregate_type: "FooBar", event_name: "new" } }
+
+          it "creates a handler with an extract filter" do
+            expect(extractor).to be_a_kind_of(SandthornEventFilter::Matchers::Extract)
+            expect(extractor).to match(matching_event)
+          end
+        end
+
+        context "when given plural keywords" do
+          let(:handler) { EventHandler.new(foo: { aggregate_types: ["FooBar"], event_names: ["new"] })}
+          let(:extractor) { handler.filter.matchers.matchers.first }
+          let(:matching_event) { { aggregate_type: "FooBar", event_name: "new" } }
+
+          it "creates the correct handler" do
+            expect(extractor).to be_a_kind_of(SandthornEventFilter::Matchers::Extract)
+            expect(extractor).to match(matching_event)
+          end
+        end
+      end
+    end
+
+    describe "#handle" do
+
+      let(:event) { {foo: :bar} }
+
+      context "when given just a symbol" do
+        it "always calls the handler method" do
+          input = {foo: :bar}
+          expect(simple_handler.handle(projection, event)).to eq(event)
+        end
+      end
+
+      context "when given a symbol and filter" do
+        let(:handler) { EventHandler.new(foo: { aggregate_type: "FooBar", event_name: "new" })}
+        context "when the filter matches" do
+          it "calls the method" do
+            allow(handler.filter).to receive(:match?) { true }
+            expect(handler.handle(projection, event)).to eq(event)
+          end
+        end
+
+        context "when the filter doesn't match" do
+          it "doesn't call the method" do
+            allow(handler.filter).to receive(:match?) { false }
+            expect(handler.handle(projection, event)).to be_falsey
+          end
+        end
+      end
+
+    end
+  end
+end