acts_as_living 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: de0cdd11d713c73fa97d94da8f0812ffbeeb5bf7b724c86a8f6d1fa01cf79ebc
+  data.tar.gz: fa9f2638f6e04047cbb7954792d1acdfb375939b65ede0af9f97055b31eef6f7
+SHA512:
+  metadata.gz: f944327ad557443227149617a1ecc5fc79bd78a3715d96e1db986e71d782c7d1b110e28ff88023cbea0b86d6f6eb4e079ae062d4a95b3427b827b5cdf73b0e2a
+  data.tar.gz: 3d96447eec1760afd73458b059d5659c58b6020edd38cd45295db1558463d6c6dc5b98484ccae61ace9b34c6d8cf5ed4c8c590d02670bc18d7566158c39ccec4

data/Changelog.md

@@ -0,0 +1,12 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.1.0] - 2020-07-01
+### Added
+- First Release with 2 included flight routes: Email and SMS. (plugged with Twilio and ActionMailer)
+- FlyJob included

data/README.md

@@ -0,0 +1,39 @@
+# Activerecord::ActsAsLiving
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/activerecord/acts_as_living`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'activerecord-acts_as_living'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install activerecord-acts_as_living
+
+## Usage
+
+TODO: Write usage instructions here
+
+## 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 tags, 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]/activerecord-acts_as_living.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/acts_as_living.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'active_support'
+require 'acts_as_living/version'
+require 'acts_as_living/class_methods'
+require 'acts_as_living/enum_definer'
+require 'acts_as_living/callbacks_definer'
+require 'acts_as_living/instance_methods_definer'
+require 'acts_as_living/scopes_definer'
+require 'acts_as_living/validations_definer'
+
+module ActsAsLiving
+  extend ActiveSupport::Autoload
+end
+
+require 'acts_as_living/railtie' if defined?(Rails)

data/lib/acts_as_living/callbacks_definer.rb

@@ -0,0 +1,136 @@
+# # frozen_string_literal: true
+
+# module ActsAsLiving::CallbacksDefiner #:nodoc:
+#   CALLBACK_TERMINATOR = if ::ActiveSupport::VERSION::MAJOR >= 5
+#                           ->(_target, result) { result.call == false }
+#                         else
+#                           ->(_target, result) { result == false }
+#                         end
+
+#   # defines before, after and around callbaks for each stage of the acts_as_living
+#   #   e.g. before_cancelled { do_something }
+#   #   e.g. after_activated :run_method
+#   #   e.g. after_status_change :run_method
+
+#   def self.call(klass)
+#     klass.class_eval do
+#       include ActiveSupport::Callbacks
+#       extend ClassMethods
+#       include InstanceMethods
+
+#       callbacks_for(:status_change)
+#       callbacks_for(:life_stage_change)
+#       status_keys.each(&method(:status_callbacks_for))
+#       @life_stages.keys.each(&method(:lifestage_callbacks_for))
+#     end
+#   end
+
+#   module InstanceMethods
+#     def save(*args)
+#       return super(*args) unless valid? && status_changed? ||  valid? && new_record?
+
+#       _run_status_change_callbacks do
+#         run_callbacks("status_change_to_#{status}") do
+#           binding.pry if notice_of_termination_received?
+#           life_stage_changed? ? run_life_stage_callbacks { binding.pry; 'hey'; super(*args) } : super(*args)
+#         end
+#       end
+#     end
+
+#     def save!(*args)
+#       return super(*args) unless valid? && status_changed? ||  valid? && new_record?
+
+#       _run_status_change_callbacks do
+#         run_callbacks("status_change_to_#{status}") do
+#           life_stage_changed? ? run_life_stage_callbacks { binding.pry; 'hey'; super(*args) } : super(*args)
+#         end
+#       end
+#     end
+
+#     protected
+
+#     def run_life_stage_callbacks(&block)
+#       _run_life_stage_change_callbacks do
+#         _run_life_stage_started_callbacks do
+#           _run_life_stage_ended_callbacks(&block)
+#         end
+#       end
+#     end
+
+#     def _run_life_stage_started_callbacks(&block)
+#       life_stages_started.inject(block) do |blk, stage|
+#         _run_stage_started_callbacks(stage, &blk)
+#       end
+#     end
+
+#     def _run_life_stage_ended_callbacks(&block)
+#       life_stages_ended.inject(block) do |blk, stage|
+#         _run_stage_ended_callbacks(stage, &blk)
+#       end
+#     end
+
+#     def _run_stage_started_callbacks(stage, &block)
+#       run_callbacks("#{stage}_started".to_sym, &block)
+#     end
+
+#     def _run_stage_ended_callbacks(stage, &block)
+#       run_callbacks("#{stage}_ended".to_sym, &block)
+#     end
+#   end
+
+#   module ClassMethods
+#     def lifestage_callbacks_for(stage)
+#       define_callback_methods_for("#{stage}_started".to_sym)
+#       define_callback_methods_for("#{stage}_ended".to_sym)
+#     end
+
+#     def callbacks_for(callback_name)
+#       define_callback_methods_for(callback_name)
+#     end
+
+#     def status_callbacks_for(status_name)
+#       define_callback_methods_for("status_change_to_#{status_name}")
+#     end
+
+#     def _normalize_callback_options(options)
+#       _normalize_callback_option(options, :only, :if)
+#       _normalize_callback_option(options, :except, :unless)
+#     end
+
+#     def _normalize_callback_option(options, from, to)
+#       return unless (from = options[from])
+
+#       from_set = Array(from).map(&:to_s).to_set
+#       from = proc { |c| from_set.include? c.notification_name.to_s }
+#       options[to] = Array(options[to]).unshift(from)
+#     end
+
+#     # rubocop:disable Metrics/MethodLength
+#     def define_callback_methods_for(callback_name)
+#       define_callbacks(
+#         callback_name,
+#         terminator: CALLBACK_TERMINATOR,
+#         skip_after_callbacks_if_terminated: true
+#       )
+
+#       define_singleton_method("before_#{callback_name}") do |method_or_block = nil, **options, &block|
+#         method_or_block ||= block
+#         _normalize_callback_options(options)
+#         set_callback callback_name, :before, method_or_block, options
+#       end
+
+#       define_singleton_method("after_#{callback_name}") do |method_or_block = nil, **options, &block|
+#         method_or_block ||= block
+#         _normalize_callback_options(options)
+#         set_callback callback_name, :after, method_or_block, options
+#       end
+
+#       define_singleton_method("around_#{callback_name}") do |method_or_block = nil, **options, &block|
+#         method_or_block ||= block
+#         _normalize_callback_options(options)
+#         set_callback callback_name, :around, method_or_block, options
+#       end
+#     end
+#     # rubocop:enable Metrics/MethodLength
+#   end
+# end

data/lib/acts_as_living/class_methods.rb

@@ -0,0 +1,97 @@
+
+module ActsAsLiving::ClassMethods
+  # validates :status, presence: true
+
+  def acts_as_living(keys, **options)
+    @status_keys = keys
+    @life_stages = options.dig(:life_stages)
+    @locked_statuses = options.dig(:lock_on)
+    @death = options.dig(:death)
+    @spread = options.dig(:spread)
+    @column = options.dig(:column)
+
+    ActsAsLiving::EnumDefiner.call(self)
+
+    run_definers
+  end
+
+  def run_definers
+    ActsAsLiving::ScopesDefiner.call(self)
+    ActsAsLiving::InstanceMethodsDefiner.call(self)
+    # ActsAsLiving::CallbacksDefiner.call(self)
+    ActsAsLiving::ValidationsDefiner.call(self)
+  end
+
+  def alive_statuses
+    statuses.except(@death).keys
+  end
+
+  def status_keys
+    statuses.keys
+  end
+
+  def statuses_after(status)
+    return [] if final_status?(status)
+
+    statuses[status_after(status)..]
+  end
+
+  def statuses_before(status)
+    return [] if initial_status?(status)
+
+    index = status_keys.find_index(status)
+    status_keys[0...index]
+  end
+
+  def status_after(status)
+    return if final_status?(status)
+
+    index = status_keys.find_index(status)
+    status_keys[index + 1]
+  end
+
+  def status_before(status)
+    return if initial_status?(status)
+
+    index = status_keys.find_index(status)
+    status_keys[index - 1]
+  end
+
+  def final_status
+    status_keys.last
+  end
+
+  def final_status?(status)
+    final_status == status
+  end
+
+  def initial_status
+    statuses.key(0)
+  end
+
+  def dead_status
+    @death
+  end
+
+  def initial_status?(status)
+    initial_status == status
+  end
+
+  def stages_with_ranges
+    @life_stages.map(&method(:to_stage_with_range)).to_h
+  end
+
+  def to_stage_with_range(stage, delimiter)
+    [stage, (statuses[delimiter.first]..statuses[delimiter.last])]
+  end
+
+  def life_stages
+    @life_stages
+  end
+
+  def life_stages_for(status)
+    stages_with_ranges.keys.select do |stage|
+      stages_with_ranges[stage].include? statuses[status]
+    end
+  end
+end

data/lib/acts_as_living/enum_definer.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module ActsAsLiving::EnumDefiner
+  def self.call(klass)
+    klass.class_eval do
+      extend ClassMethods
+
+      enum @column => enum_options
+    end
+  end
+
+  module ClassMethods
+    def enum_options
+      statuses = @status_keys.map.with_index(&method(:to_enum_map)).to_h
+      statuses.merge(@death => @spread * -1)
+    end
+
+    def to_enum_map(status, index)
+      [status, index * @spread]
+    end
+  end
+end

data/lib/acts_as_living/instance_methods_definer.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module ActsAsLiving::InstanceMethodsDefiner
+  def self.call(klass)
+    klass.class_eval do
+      extend ClassMethods
+      include InstanceMethods
+
+      @life_stages.each(&method(:define_stage_queries))
+
+      @status_keys.each(&method(:define_changed_queries))
+    end
+  end
+
+  module InstanceMethods
+    def status_after(status)
+      self.class.status_after(status)
+    end
+
+    def statuses
+      self.class.statuses
+    end
+
+    def status_before(status)
+      self.class.status_before(status)
+    end
+
+    def to_next_status
+      update(status: next_status)
+    end
+
+    def to_next_status!
+      update!(status: next_status)
+    end
+
+    def next_status
+      status_after(status) if status
+    end
+
+    def to_previous_status
+      update(status: previous_status)
+    end
+
+    def to_previous_status!
+      update!(status: previous_status)
+    end
+
+    def previous_status
+      status_before(status)
+    end
+
+    def final_status?
+      self.class.final_status?(status)
+    end
+
+    def initial_status?
+      self.class.initial_status?(status)
+    end
+
+    def dead_status?
+      self.class.dead_status == status
+    end
+
+    def dead_or_finalized?
+      dead_status? || final_status?
+    end
+
+    def klass_stages_with_ranges
+      self.class.stages_with_ranges
+    end
+
+    def klass_life_stages_for(status)
+      self.class.life_stages_for(status)
+    end
+
+    def klass_statuses
+      self.class.statuses
+    end
+
+    def locked?(&block)
+      return unless block
+
+      @locked_on.to_set.intersect? [status, status_was].to_set
+    end
+
+    def life_stages
+      klass_life_stages_for(status)
+    end
+
+    def life_stage_changed?
+      klass_life_stages_for(status) != klass_life_stages_for(status_was)
+    end
+
+    def life_stages_started
+      klass_life_stages_for(status) - klass_life_stages_for(status_was)
+    end
+
+    def life_stages_ended
+      klass_life_stages_for(status_was) - klass_life_stages_for(status)
+    end
+  end
+
+  module ClassMethods
+    def define_stage_queries(stage, delimiters)
+      define_method("#{stage}?") do
+        if delimiters.length == 1
+          klass_statuses[status] == klass_statuses[delimiters]
+        else
+          klass_statuses[status] >= klass_statuses[delimiters.first] &&
+            klass_statuses[status] <= klass_statuses[delimiters.second]
+        end
+      end
+
+      define_method("pre_#{stage}?") do
+        klass_statuses[status] < klass_statuses[delimiters.first] unless cancelled?
+      end
+
+      define_method("past_#{stage}?") do
+        klass_statuses[status] > klass_statuses[delimiters.last] || cancelled?
+      end
+    end
+
+    def define_changed_queries(status_key)
+      define_method("status_changed_to_#{status_key}?") do
+        status_changed? && status_was == status_key
+      end
+
+      define_method("pre_#{status_key}?") do
+        klass_statuses[status] < klass_statuses[status_key] unless cancelled?
+      end
+
+      define_method("past_#{status_key}?") do
+        klass_statuses[status] > klass_statuses[status_key] || cancelled?
+      end
+
+      define_method("cancelled_from_#{status_key}?") do
+        status == 'cancelled' && status_was == status_key
+      end
+    end
+  end
+end

data/lib/acts_as_living/railtie.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'active_support'
+require 'rails/railtie'
+
+module ActsAsLiving
+  class Railtie < Rails::Railtie
+    config.to_prepare do
+      ActiveSupport.on_load(:active_record) do
+        extend ActsAsLiving::ClassMethods
+      end
+    end
+  end
+end

data/lib/acts_as_living/scopes_definer.rb

@@ -0,0 +1,23 @@
+module ActsAsLiving::ScopesDefiner
+  def self.call(klass)
+    klass.class_eval do
+      statuses.each do |status, _num|
+        scope "past_#{status}", -> { where('status >= ?', statuses[status]) }
+        scope "pre_#{status}", -> { where('status < ?', statuses[status]) }
+        scope "not_#{status}", -> { where.not(status: status) }
+      end
+
+      scope :cancelled, -> { where('status < 0') }
+
+      @life_stages.each do |stage, delimiters|
+        if delimiters.length == 1
+          scope stage, -> { where(status: delimiters.first) }
+        else
+          scope stage, lambda {
+            where('status >= ? AND status <= ?', statuses[delimiters.first], statuses[delimiters.second])
+          }
+        end
+      end
+    end
+  end
+end

data/lib/acts_as_living/validations_definer.rb

@@ -0,0 +1,32 @@
+module ActsAsLiving::ValidationsDefiner
+  def self.call(klass)
+    klass.class_eval do
+      include InstanceMethods
+
+      validates :status, presence: true
+
+      validate :status_progression, on: :update, if: :status_changed?
+      validate :initialized_status, on: :create, if: :status_changed?
+    end
+  end
+
+  module InstanceMethods
+    def status_progression
+      return if status.to_s == self.class.dead_status.to_s || status == status_after(status_was)
+
+      message = if status_was == self.class.final_status
+                  "The contract can only be updated to '#{self.class.dead_status}'"
+                else
+                  "The contract can only be updated to '#{self.class.dead_status}' or '#{status_after(status_was)}'"
+                end
+
+      errors.add(:status, message)
+    end
+
+    def initialized_status
+      return if status == self.class.initial_status
+
+      errors.add(:status, "Contract has to be initialized with '#{self.class.initial_status}' status")
+    end
+  end
+end

data/lib/acts_as_living/version.rb

@@ -0,0 +1,3 @@
+module ActsAsLiving
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification
+name: acts_as_living
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Guilherme Andrade
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2020-07-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.3
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.3
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.3
+description: An ActiveRecord plugin that assists in acts_as_living status progressions.
+email:
+- guilherme.andrade.ao@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Changelog.md
+- README.md
+- lib/acts_as_living.rb
+- lib/acts_as_living/callbacks_definer.rb
+- lib/acts_as_living/class_methods.rb
+- lib/acts_as_living/enum_definer.rb
+- lib/acts_as_living/instance_methods_definer.rb
+- lib/acts_as_living/railtie.rb
+- lib/acts_as_living/scopes_definer.rb
+- lib/acts_as_living/validations_definer.rb
+- lib/acts_as_living/version.rb
+homepage: https://github.com/guilherme-andrade/acts_as_living
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/guilherme-andrade/acts_as_living
+  source_code_uri: https://github.com/guilherme-andrade/acts_as_living
+  changelog_uri: https://github.com/guilherme-andrade/acts_as_living/blob/master/Changelog.md
+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.0.3
+signing_key: 
+specification_version: 4
+summary: An ActiveRecord plugin that assists in acts_as_living status progressions.
+test_files: []