yael 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 14cc29be49dd968570eb537527f0966466d2e335270b021af321ee44316ba6a3
+  data.tar.gz: 3d62f3a69076d0d2242e6f3395c9234e36de7b208e6ee497dd3d0f81c66d6271
+SHA512:
+  metadata.gz: c2c52a79448e78d5ee94d9e06fa4c659220b9cf7c7cb893752c0eff523e42be0d28f3b6fa0e1082f135ed197e82c936796a82258a55d561a44766e5a50acdfdf
+  data.tar.gz: 10f77c4d8ad62e0101778988b88c2ed675e2531b0f08831453c38461a6b68865429b296dc5dc71446892ab60feebcc2a2652fca5725f0d0b6315534d1f48487e

data/.editorconfig

@@ -0,0 +1,12 @@
+; EditorConfig is awesome: http://EditorConfig.org
+
+; top-most EditorConfig file
+root = true
+
+; Unix-style newlines with a newline ending every file
+[*]
+indent_style = spaces
+end_of_line = lf
+insert_final_newline = true
+trim_trailing_whitespace = true
+indent_size = 2

data/.gitignore

@@ -0,0 +1 @@
+/pkg

data/.rubocop.yml

@@ -0,0 +1,69 @@
+AllCops:
+  TargetRubyVersion: 2.4
+  DisplayCopNames: true
+  DisplayStyleGuide: true
+  NewCops: disable
+
+Layout/LineLength:
+  Enabled: false
+
+
+Layout/FirstArrayElementIndentation:
+  EnforcedStyle: consistent
+
+Layout/ParameterAlignment:
+  EnforcedStyle: with_fixed_indentation
+
+Style/ConditionalAssignment:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: false
+
+Style/EmptyMethod:
+  EnforcedStyle: expanded
+
+Style/MultilineBlockChain:
+  Enabled: false
+
+Style/DoubleNegation:
+  Enabled: false
+
+Layout/MultilineMethodCallIndentation:
+  EnforcedStyle: indented
+
+Style/NilComparison:
+  Enabled: false
+
+Style/ClassAndModuleChildren:
+  Enabled: false
+
+Style/NumericLiterals:
+  MinDigits: 15
+
+Style/NumericPredicate:
+  Enabled: false
+
+Style/WordArray:
+  EnforcedStyle: brackets
+
+Style/SymbolArray:
+  EnforcedStyle: brackets
+
+Style/RescueModifier:
+  Enabled: false
+
+Style/Lambda:
+  EnforcedStyle: literal
+
+Style/RegexpLiteral:
+  Enabled: false
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/Alias:
+  Enabled: false
+
+Metrics:
+  Enabled: false

data/Gemfile

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,17 @@
+PATH
+  remote: .
+  specs:
+    yael (0.0.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  yael!
+
+BUNDLED WITH
+   2.0.2

data/README.md

@@ -0,0 +1,78 @@
+# Yael
+
+Yael is **Y**et **A**nother **E**vent **L**ibrary based on top of ActiveJob. It helps you dispatching events asynchronously in your code base and react to them just like routing in Rails.
+
+## Usage
+Define your routes in `config/events.rb` like this:
+
+```ruby
+Yael::Bus.shared.routing do
+  dispatch :order_confirmed, to: "order_mailer#confirm", delay: 5.minutes, queue: :low_priority
+  dispatch :order_confirmed, to: "slack"
+end
+```
+
+Now include the publisher in your class and dispatch events:
+
+```ruby
+class Order < ApplicationRecord
+  include Yael::Publisher
+
+  def confirm_order
+    publish :order_confirmed, ip: some_id, some_other_data: data
+  end
+end
+
+class Slack
+  def self.on_order_confirmed(ip:)
+    # send a notification to slack
+  end
+end
+```
+
+Calling `confirm_order` now will invoke `OrderMailer.confirm` and `Slack.notify_order`.
+
+You can also request historical events of an object: `Yael::Event.for(Order.find(id))` will return all events recorded.
+
+### Some Things to Keep in Mind
+- the subscriber signature does not have to exactly match the published payload - yael will return all matching parameters
+- everything is executed asynchronously inside of a job, even dispatching events
+- you can not only publish from `ActiveRecord` models, but from any class by providing a stream name: `Yael::Bus.shared.dispatch(:event_name, stream: "my_stream", payload: {})`
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'yael'
+```
+
+And then execute:
+```bash
+bundle install
+```
+
+Generate a migration for your database:
+
+```ruby
+rails generate yeal:install
+rails db:migrate
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/yael. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/[USERNAME]/yael/blob/master/CODE_OF_CONDUCT.md).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the Yael project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/yael/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"

data/lib/generators/yael/install/install_generator.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "rails/generators/base"
+
+module Yael
+  module Generators
+    class InstallGenerator < ::Rails::Generators::Base
+      desc "This generator installs Yael"
+      source_root File.expand_path("templates", __dir__)
+
+      def copy_dispatch_map
+        template "events.rb", "config/events.rb"
+      end
+
+      def copy_migration
+        template "create_events.rb", "db/migrate/#{DateTime.current.strftime '%Y%m%d%H%M%S'}_create_yael_events.rb"
+      end
+    end
+  end
+end

data/lib/generators/yael/install/templates/create_events.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class CreateYaelEvents < ActiveRecord::Migration[5.1]
+  def change
+    create_table :yael_events do |t|
+      t.string :name, null: false
+      t.string :stream, null: false
+      t.jsonb :payload, null: false
+      t.datetime :created_at, null: false, default: "NOW()"
+    end
+
+    add_index :yael_events, :name
+    add_index :yael_events, :stream
+  end
+end

data/lib/generators/yael/install/templates/events.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+Yael::Bus.shared.routing do
+  # dispatch :order_confirmed, to: "order_mailer#confirm", queue: :low_priority
+end

data/lib/yael.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative "yael/version"
+require_relative "yael/bus"
+require_relative "yael/dispatch_job"
+require_relative "yael/dispatch_map"
+require_relative "yael/event"
+require_relative "yael/execution_job"
+require_relative "yael/publisher"
+require_relative "yael/route"
+
+module Yael
+  class Error < StandardError; end
+  # Your code goes here...
+end

data/lib/yael/bus.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Yael
+  class Bus
+    class << self
+      def shared
+        unless @shared
+          @shared = Bus.new
+          path = Rails.root.join("config/events.rb")
+          if path.exist?
+            reloader = Rails.configuration.file_watcher.new([path]) do
+              load path
+            end
+            Rails.application.reloader.to_prepare do
+              reloader.execute_if_updated
+            end
+            Rails.application.reloaders << reloader
+            reloader.execute
+          end
+        end
+        @shared
+      end
+    end
+
+    def routes
+      @routes ||= []
+    end
+
+    def routing(&block)
+      @routes = DispatchMap.new(block).routes
+    end
+
+    def dispatch(name, stream:, payload:)
+      stream = Event.stream_for(stream) unless stream.is_a?(String)
+      DispatchJob.perform_later(name: name, stream: stream, payload: payload, created_at: DateTime.current)
+    end
+
+    def process(event)
+      routes.each do |route|
+        route.dispatch(event) if route.matches? event.name
+      end
+    end
+  end
+end

data/lib/yael/dispatch_job.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Yael
+  class DispatchJob < ActiveJob::Base
+    retry_on ActiveRecord::Deadlocked
+
+    queue_as :dispatch
+
+    def perform(name:, stream:, payload:, created_at:, persist: true)
+      event = Event.new id: SecureRandom.uuid, name: name, stream: stream, payload: payload, created_at: created_at
+      event.save! if persist
+      Yael::Bus.shared.process(event)
+    end
+  end
+end

data/lib/yael/dispatch_map.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Yael
+  class DispatchMap
+    def initialize(block)
+      @routes = []
+      instance_eval(&block)
+    end
+
+    attr_reader :routes
+
+    protected
+
+    def dispatch(descriptor, to:, queue: :default, after: nil)
+      @routes.push Route.new descriptor: descriptor, target: to, queue: queue, delay: after
+    end
+  end
+end

data/lib/yael/event.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Yael
+  class Event < ActiveRecord::Base
+    class << self
+      def stream_for(object)
+        "#{object.class.name.tableize}_#{object.id}"
+      end
+    end
+
+    self.table_name = "yael_events"
+  end
+end

data/lib/yael/execution_job.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Yael
+  class ExecutionJob < ActiveJob::Base
+    retry_on ActiveRecord::Deadlocked
+
+    def perform(target_name, method, args)
+      target_constant = target_name.constantize
+      parameters = extract_parameters(target_constant.method(method), args)
+      target_constant.public_send method, **parameters
+    end
+
+    private
+
+    def extract_parameters(method, args)
+      requested = method.parameters.select { |e| e.first == :keyreq }.map(&:second)
+      args.slice(*requested)
+    end
+  end
+end

data/lib/yael/publisher.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Yael
+  module Publisher
+    extend ActiveSupport::Concern
+
+    def publish(name, on: self, **payload)
+      Yael::Bus.shared.dispatch(name, stream: on, payload: payload)
+    end
+  end
+end

data/lib/yael/route.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Yael
+  class Route
+    attr_reader :descriptor, :target, :queue, :delay
+
+    def initialize(descriptor:, target:, queue: :default, delay: nil)
+      @descriptor = descriptor
+      @target = target
+      @queue = queue
+      @delay = delay
+      @target_name = target.split("#").first.classify
+      @target_method = target.split("#").second
+    end
+
+    def matches?(stream)
+      return true if descriptor == :all
+
+      descriptor.to_s == stream
+    end
+
+    def dispatch(event)
+      method = target_method || "on_#{event.name}"
+      args = event.payload.symbolize_keys
+      ExecutionJob.set(queue: queue, wait: delay).perform_later(target_name, method, args)
+    end
+
+    private
+
+    attr_reader :target_name, :target_method
+  end
+end

data/lib/yael/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Yael
+  VERSION = "0.0.1"
+end

data/yael.gemspec

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative "lib/yael/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "yael"
+  spec.version       = Yael::VERSION
+  spec.authors       = ["Jens Ravens"]
+  spec.email         = ["jens@nerdgeschoss.de"]
+
+  spec.summary       = "Event based Rails with ActiveJob"
+  spec.description   = "Yael is Yet Another Event Library based on top of ActiveJob. It helps you dispatching events asynchronously in your code base and react to them just like routing in Rails."
+  spec.homepage      = "https://nerdgeschoss.de"
+  spec.license       = "MIT"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.4.0")
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/nerdgeschoss/yael"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  # Uncomment to register a new dependency of your gem
+  # spec.add_dependency "example-gem", "~> 1.0"
+
+  # For more information and examples about making a new gem, checkout our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification
+name: yael
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Jens Ravens
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2021-02-01 00:00:00.000000000 Z
+dependencies: []
+description: Yael is Yet Another Event Library based on top of ActiveJob. It helps
+  you dispatching events asynchronously in your code base and react to them just like
+  routing in Rails.
+email:
+- jens@nerdgeschoss.de
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".editorconfig"
+- ".gitignore"
+- ".rubocop.yml"
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- lib/generators/yael/install/install_generator.rb
+- lib/generators/yael/install/templates/create_events.rb
+- lib/generators/yael/install/templates/events.rb
+- lib/yael.rb
+- lib/yael/bus.rb
+- lib/yael/dispatch_job.rb
+- lib/yael/dispatch_map.rb
+- lib/yael/event.rb
+- lib/yael/execution_job.rb
+- lib/yael/publisher.rb
+- lib/yael/route.rb
+- lib/yael/version.rb
+- yael.gemspec
+homepage: https://nerdgeschoss.de
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://nerdgeschoss.de
+  source_code_uri: https://github.com/nerdgeschoss/yael
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.4.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.4
+signing_key: 
+specification_version: 4
+summary: Event based Rails with ActiveJob
+test_files: []