ephemeron 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 032a79004b77bffee915f105cd807beb01fcc60c52e829c478fcf615a8fa8184
+  data.tar.gz: 65168d9788376856e6745c083f2a0d467b18deace844719e59024e9027a47db4
+SHA512:
+  metadata.gz: 88ddba6984c039180c74433d9dc9447eae247b040700f3de02c0338e6a9ffe95dc3472c7eb982b81a867044d1c214c15cafe0ede0bf9286308d15f59664e403b
+  data.tar.gz: 6488f41b9df17130dbedb9f1db5bfa72e1aeded337863e46fe03e898728ed6aa5dfac2666f8cdaaf7004bf0623900f1073195327e06653994d4b974a17f67f1a

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2019 Zbigniew Humeniuk
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,28 @@
+# Ephemeron
+Short description and motivation.
+
+## Usage
+How to use my plugin.
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'ephemeron'
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install ephemeron
+```
+
+## Contributing
+Contribution directions go here.
+
+## License
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Ephemeron'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+require 'bundler/gem_tasks'
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+task default: :test

data/lib/ephemeron.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require 'ephemeron/railtie'
+
+require 'ephemeron/addons/controller_addons'
+require 'ephemeron/addons/model_addons'
+
+require 'ephemeron/writers/thread_store'
+require 'ephemeron/writers/callbacks'
+require 'ephemeron/writers/logger'
+require 'ephemeron/writers/store'
+
+require 'ephemeron/errors'
+require 'ephemeron/logger/convert'
+require 'ephemeron/logger/finders'
+require 'ephemeron/settings'
+require 'ephemeron/store/convert'
+require 'ephemeron/store/update'
+require 'ephemeron/validators/before_save'
+require 'ephemeron/validators/store'
+require 'ephemeron/validators/store_element'
+require 'ephemeron/validators/store/allowed_but_unsaved'
+require 'ephemeron/validators/store/unused'
+
+module Ephemeron
+  module_function
+
+  def configure
+    Ephemeron::Settings::CONFIG.new.tap do |config|
+      yield config
+      Ephemeron::Settings.configure config
+    end
+  end
+
+  def state
+    Store.store
+  end
+
+  def logs
+    Logger.logs
+  end
+
+  def add(model, as: nil)
+    Store.add model, as: as
+  end
+
+  def proxy
+    Logger.log nil, :proxy_start
+    yield
+    Logger.log nil, :proxy_end
+  end
+
+  def get(key)
+    Store.get key
+  end
+
+  def used(model_s)
+    log_used = ->(model) { Logger.log model, :used }
+    if model_s.is_a? ActiveRecord::Base
+      log_used.call model_s
+    else
+      model_s.each(&log_used)
+    end
+    model_s
+  end
+
+  def allow_save!(model)
+    model.tap { |m| Logger.log m, :save_allowed }
+  end
+
+  def skip_save!(model)
+    Logger.log model, :skip_save
+  end
+
+  def after_save!(&block)
+    Callbacks.add block
+  end
+
+  def finish
+    if Store.aliases[nil] != :abort
+      Store.validate
+      Store.persist
+      Callbacks.call
+    end
+    reset
+  end
+
+  def stop
+    Store.aliases[nil] = :abort
+  end
+
+  def reset
+    Store.reset
+    Logger.reset
+    Callbacks.reset
+    true
+  end
+end

data/lib/ephemeron/addons/controller_addons.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Ephemeron
+  module ControllerAddons
+    extend ActiveSupport::Concern
+
+    included do
+      after_action -> { Ephemeron.finish }
+    end
+  end
+end

data/lib/ephemeron/addons/model_addons.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Ephemeron
+  module ModelAddons
+    extend ActiveSupport::Concern
+
+    included do
+      after_find lambda { |model|
+        Ephemeron.add model
+      }
+
+      after_validation lambda { |model|
+        Logger.log model, :used, soft: true
+      }
+
+      before_save lambda { |model|
+        Validators::BeforeSave.call model
+      }
+
+      after_create lambda { |model|
+        Store::Update.call model
+      }
+
+      after_save lambda { |model|
+        Logger.log model, :saved
+      }
+
+      after_destroy lambda { |model|
+        Ephemeron::Store.destroy model
+      }
+    end
+  end
+end

data/lib/ephemeron/errors.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Ephemeron
+  class LoggerError < ArgumentError
+  end
+
+  class StoreError < StandardError
+  end
+
+  class PersistenceError < StandardError
+  end
+end

data/lib/ephemeron/logger/convert.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Ephemeron
+  class Logger
+    module Convert
+      module_function
+
+      def call(model, event)
+        "#{Store::Convert.call(model) if model} #{event}".strip
+      end
+    end
+  end
+end

data/lib/ephemeron/logger/finders.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Ephemeron
+  class Logger
+    module Finders
+      module_function
+
+      def find_all_events_for(model, *events)
+        Logger.logs
+              .filter { |l| events.any? { |e| l == Logger::Convert.call(model, e) } }
+      end
+
+      def find_first_allowed_but_unsaved
+        ary = Logger.logs
+                    .reverse
+                    .map { |line| line.split ' ' }
+                    .find { |arr| %w[save_allowed saved].include?(arr[1]) }
+        return nil if ary.nil? || ary[1] == 'saved'
+
+        Store.store[ary[0]]
+      end
+    end
+  end
+end

data/lib/ephemeron/railtie.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Ephemeron
+  class Railtie < ::Rails::Railtie
+  end
+end

data/lib/ephemeron/settings.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Ephemeron
+  class Settings
+    CONFIG = Struct.new :skip_models
+
+    class << self
+      attr_writer :skipped_models
+
+      def skipped_models
+        @skipped_models || []
+      end
+
+      def configure(config)
+        Ephemeron::Settings.skipped_models = config.skip_models
+      end
+    end
+  end
+end

data/lib/ephemeron/store/convert.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Ephemeron
+  class Store
+    class Convert
+      class << self
+        def call(model_s, as_new_record: false)
+          return class_name_and_id(model_s, as_new_record) if model_s.is_a?(ActiveRecord::Base)
+
+          model_s.map { |model| class_name_and_id(model) }.join ', '
+        end
+
+        private
+
+        def class_name_and_id(model, as_new_record = false)
+          new_record = as_new_record || model.new_record?
+          name = model.class.name.downcase
+          id = new_record ? "new_record##{model.object_id}" : model.id
+          "#{name}##{id}"
+        end
+      end
+    end
+  end
+end

data/lib/ephemeron/store/update.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Ephemeron
+  class Store
+    module Update
+      module_function
+
+      def call(model)
+        return unless Store.has? model, as_new_record: true
+
+        Store.add model
+        Store.store.delete Convert.call(model, as_new_record: true)
+
+        Store.aliases.find_all { |_, v| v == Convert.call(model, as_new_record: true) }
+             .to_h.keys
+             .each { |key| Store.aliases[key] = Convert.call(model) }
+      end
+    end
+  end
+end

data/lib/ephemeron/validators/before_save.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Ephemeron
+  module Validators
+    module BeforeSave
+      module_function
+
+      def call(model)
+        return unless Ephemeron::Store.has? model
+
+        last_event = Ephemeron::Logger::Finders
+                     .find_all_events_for(model, :save_allowed, :saved)
+                     .last
+        return if last_event == Logger::Convert.call(model, :save_allowed)
+
+        msg = "prior persistence for #{Ephemeron::Store::Convert.call(model)} is prohibited"
+        raise(PersistenceError, msg)
+      end
+    end
+  end
+end

data/lib/ephemeron/validators/store.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Ephemeron
+  module Validators
+    module Store
+      module_function
+
+      def call
+        AllowedButUnsaved.call
+        Unused.call
+      end
+    end
+  end
+end

data/lib/ephemeron/validators/store/allowed_but_unsaved.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Ephemeron
+  module Validators
+    module Store
+      module AllowedButUnsaved
+        module_function
+
+        def call
+          model = Ephemeron::Logger::Finders.find_first_allowed_but_unsaved
+          return if model.nil?
+
+          raise(
+            PersistenceError,
+            "save allowed for #{Ephemeron::Store::Convert.call(model)} but never saved"
+          )
+        end
+      end
+    end
+  end
+end

data/lib/ephemeron/validators/store/unused.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Ephemeron
+  module Validators
+    module Store
+      module Unused
+        module_function
+
+        def call
+          models = Ephemeron::Store
+                   .store
+                   .filter { |_, model| !model.changed? && !Logger.has?(model, :used) }
+                   .values
+          return if models.empty?
+
+          model_ids = Ephemeron::Store::Convert.call(models)
+          raise(
+            StoreError,
+            "#{model_ids} were added to store but neither fetched nor changed"
+          )
+        end
+      end
+    end
+  end
+end

data/lib/ephemeron/validators/store_element.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Ephemeron
+  module Validators
+    module StoreElement
+      module_function
+
+      def call(model)
+        return false if Logger.logs.last == Logger::Convert.call(nil, :proxy_start)
+        return false unless model.is_a?(ActiveRecord::Base)
+        return false if Settings.skipped_models.include? model.class.name
+
+        true
+      end
+    end
+  end
+end

data/lib/ephemeron/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Ephemeron
+  VERSION = '0.1.0'
+end

data/lib/ephemeron/writers/callbacks.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Ephemeron
+  class Callbacks < ThreadStore
+    attribute :ts_after_save_callbacks
+
+    def after_save_callbacks
+      self.ts_after_save_callbacks ||= []
+    end
+
+    def add(callback)
+      after_save_callbacks << callback
+    end
+
+    def call
+      after_save_callbacks.each(&:call)
+    end
+
+    def reset
+      self.ts_after_save_callbacks = []
+    end
+  end
+end

data/lib/ephemeron/writers/logger.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Ephemeron
+  class Logger < ThreadStore
+    attribute :ts_logs
+
+    PROXY_EVENTS = %i[proxy_start proxy_end].freeze
+    VALID_EVENTS = %i[saved save_allowed skip_save used] + PROXY_EVENTS
+
+    def logs
+      self.ts_logs ||= []
+    end
+
+    def has?(model, event)
+      validate model, event
+      logs.include? Convert.call(model, event)
+    end
+
+    def log(model, event, soft: false)
+      validate model, event
+      logs << Convert.call(model, event)
+    rescue LoggerError, StoreError => e
+      raise e unless soft
+    end
+
+    def reset
+      self.ts_logs = []
+    end
+
+    private
+
+    def validate(model, event)
+      raise(LoggerError, "event (#{event}) is invalid") if VALID_EVENTS.exclude?(event)
+      return true if validate_proxy_events model, event
+
+      raise(StoreError, "can't #{event_name_for_validate event} for nil") if model.nil?
+      return true if Store.has?(model)
+      return true if event == :saved
+
+      raise StoreError, "can't #{event_name_for_validate event} " \
+                        "if #{Store::Convert.call model} is not in store"
+    end
+
+    def validate_proxy_events(model, event)
+      return false if PROXY_EVENTS.exclude?(event)
+      return true if model.nil?
+
+      raise LoggerError, 'Proxy events can be logged for nil only'
+    end
+
+    def event_name_for_validate(event)
+      if event == :used
+        'mark as used'
+      else
+        'log'
+      end
+    end
+  end
+end

data/lib/ephemeron/writers/store.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Ephemeron
+  class Store < ThreadStore
+    attribute :ts_store, :ts_aliases
+
+    def store
+      self.ts_store ||= {}
+    end
+
+    def aliases
+      self.ts_aliases ||= {}
+    end
+
+    def has?(model, as_new_record: false)
+      !store[Convert.call(model, as_new_record: as_new_record)].nil?
+    end
+
+    def add(model, as: nil)
+      return unless Validators::StoreElement.call(model)
+
+      key = Convert.call model
+      in_store = !store[key].nil?
+      store[key] = model unless in_store
+      if !as.nil?
+        aliases[as] = key
+      elsif in_store
+        raise StoreError, "#{key} is already in the store"
+      end
+      model
+    end
+
+    def get(key)
+      store[aliases[key]].tap do |model|
+        Logger.log(model, :used) if model
+      end
+    end
+
+    def validate
+      Validators::Store.call
+    end
+
+    def persist
+      changed_models = store.filter { |_, v| v.changed? }.values
+                            .filter { |model| !Logger.has?(model, :skip_save) }
+      ActiveRecord::Base.transaction do
+        changed_models.each do |model|
+          Ephemeron.allow_save! model
+          model.save!
+        end
+      end
+    end
+
+    def destroy(model)
+      key = Convert.call model
+      return if store[key].nil?
+
+      store.delete key
+    end
+
+    def reset
+      self.ts_store = {}
+      self.ts_aliases = {}
+    end
+  end
+end

data/lib/ephemeron/writers/thread_store.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Ephemeron
+  class ThreadStore < ActiveSupport::CurrentAttributes
+    def reset
+      raise 'not implemented!'
+    end
+  end
+end

data/lib/tasks/ephemeron_tasks.rake

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+# desc "Explaining what the task does"
+# task :ephemeron do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,137 @@
+--- !ruby/object:Gem::Specification
+name: ephemeron
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Zbigniew Humeniuk
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-01-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7.0'
+- !ruby/object:Gem::Dependency
+  name: jb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.7.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.7.0
+- !ruby/object:Gem::Dependency
+  name: rspec-mocks
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.9'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |
+  Ephemeron improves the performance of your app.
+  It takes on itself the persistence of the ActiveRecord objects.
+  It protects you from saving the same object many times.
+  It checks whether a fetched from a database object was used.
+  It allows you to eliminate the controller's before_actions that are unnecessarily called.
+  Ephemeron works in the context of the thread and does the bulk of its job (i.a. persistence) at the end of the thread's lifecycle.
+  Although, you can trigger the finalization at any given moment.
+  You don't have to make a distinction in the code for the part that is responsible for the domain logic and the other responsible for the application layers.
+email:
+- hello@artofcode.co
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/ephemeron.rb
+- lib/ephemeron/addons/controller_addons.rb
+- lib/ephemeron/addons/model_addons.rb
+- lib/ephemeron/errors.rb
+- lib/ephemeron/logger/convert.rb
+- lib/ephemeron/logger/finders.rb
+- lib/ephemeron/railtie.rb
+- lib/ephemeron/settings.rb
+- lib/ephemeron/store/convert.rb
+- lib/ephemeron/store/update.rb
+- lib/ephemeron/validators/before_save.rb
+- lib/ephemeron/validators/store.rb
+- lib/ephemeron/validators/store/allowed_but_unsaved.rb
+- lib/ephemeron/validators/store/unused.rb
+- lib/ephemeron/validators/store_element.rb
+- lib/ephemeron/version.rb
+- lib/ephemeron/writers/callbacks.rb
+- lib/ephemeron/writers/logger.rb
+- lib/ephemeron/writers/store.rb
+- lib/ephemeron/writers/thread_store.rb
+- lib/tasks/ephemeron_tasks.rake
+homepage: https://artofcode.co
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+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: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: The organic DDD
+test_files: []