segmentor 0.0.1

data/lib/segmentor/receipt.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Segmentor
+  # Receipt is generated when a notification is sent to a target.
+  class Receipt < ActiveRecord::Base
+    self.table_name = :segmentor_receipts
+    store :metadata, accessors: %i[target_id session_id], coder: JSON
+
+    belongs_to :segment, class_name: '::Segmentor::Segment'
+    belongs_to :user
+
+    validates :sent_at, presence: true
+
+    def self.record_receipt(target, rendered_value = nil)
+      receipt = ::Segmentor::Receipt.new
+      receipt.segment = target.segment
+      receipt.user_id = target.user_id
+      receipt.target_id = target.id
+      receipt.session_id = target.session_id
+      receipt.rendered_value = rendered_value
+      receipt.sent_at = Time.now.utc
+      receipt.save!
+
+      receipt
+    end
+
+    def next
+      segment.receipts.where('id > ?', id).first
+    end
+
+    def prev
+      segment.receipts.where('id < ?', id).last
+    end
+  end
+end

data/lib/segmentor/segment.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+require 'active_record'
+
+module Segmentor
+  # Segment is a slice of data, based on a condition.
+  class Segment < ActiveRecord::Base
+    self.table_name = :segmentor_segments
+
+    NO_REPEAT = 0
+
+    has_many :receipts, class_name: '::Segmentor::Receipt', dependent: :destroy
+    has_many :sessions, class_name: '::Segmentor::Session', dependent: :destroy
+    has_one :source, class_name: '::Segmentor::Source', inverse_of: :segment, dependent: :destroy
+    has_one :notifier_context, class_name: '::Segmentor::NotifierContext', inverse_of: :segment, dependent: :destroy
+
+    accepts_nested_attributes_for :source
+    accepts_nested_attributes_for :notifier_context
+
+    class_attribute :_after_session_change
+
+    def self.after_session_change(method_name)
+      self._after_session_change = method_name
+    end
+
+    # repeat_frequency is in days, should be between 0 and 365. 0 means no repeat
+    validates :repeat_frequency, numericality: { only_integer: true,
+                                                 greater_than_or_equal_to: 0,
+                                                 less_than_or_equal_to: 365 }
+
+    validates :name, length: { minimum: 3, maximum: 255 }, presence: true
+    validates :description, length: { maximum: 255 }
+
+    # generate all the targets for this segment
+    # it then returns the session
+    def generate!
+      # start a new session
+
+      session = start_session
+      begin
+        # get the data from the source
+        returned_targets = source.execute
+        # replace the data in the segment in a transaction
+        returned_targets.each do |target|
+          target.session = session
+          target.save!
+        end
+
+        # mark the session as draft
+        end_session(session)
+
+        activate(session) if auto_activate
+
+        session
+      rescue ::Segmentor::Errors::EvaluationError => e
+        # mark the session as failed with a reason. don't raise
+        session.mark_as_failed!(e.message)
+        session
+      rescue StandardError
+        # delete the session and raise
+        session.destroy
+        raise
+      end
+    end
+
+    # notify! calls the given block for each target that can be notified
+    # if the block raises a Segmentor::Errors::NotificationError, the target is skipped
+    # and no receipt is issued but the rest of the targets are still notified
+    # as most notification systems do not support transactions, it is important
+    # to ensure only ::Segmentor::Errors::NotificationError is raised unless you are
+    # sure you want to rollback all notification receipts
+    def notify!(&block)
+      # get the active targets from the segment
+      # for each target, check if its receipt is within segment repeat frequency
+      # if not, send the notification and generate a receipt
+      # if so, do nothing
+      raise ::Segmentor::Errors::NoSessionError, 'no active session' unless active_session
+
+      ::ActiveRecord::Base.transaction do
+        active_session.targets.each do |target|
+          next unless target.can_be_notified?
+
+          # send the notification
+          # generate a receipt
+          result = block.call(target, notifier_context) if block_given?
+          target.issue_receipt!(result)
+        # catch ::Segmentor::Errors::NotificationError and do nothing
+        rescue ::Segmentor::Errors::NotificationError
+          # do nothing. so we only skip issue_receipt! but continue to the rest of the targets
+          # any other error will be raised and rollback the transaction
+        end
+        active_session.touch
+      end
+    end
+
+    # resets the last session of this segment to be in progress again
+    def reset!
+      latest_session.mark_as_draft!
+    end
+
+    # turns a session from draft into active and marks
+    # the current active session as archived.
+    # if no current active session is found. the latest session is marked as active
+    def activate(session)
+      ::ActiveRecord::Base.transaction do
+        # mark the current active session as archived
+        as = active_session
+        if as
+          as.status = ::Segmentor::Session::ARCHIVED
+          as.save!
+        end
+
+        # mark the new session as active
+        session.status = ::Segmentor::Session::ACTIVE
+        session.save!
+      end
+    end
+
+    def active_session
+      sessions.active.first
+    end
+
+    def active_session!
+      as = active_session
+      raise ::Segmentor::Errors::NoSessionError, 'no active session' unless as
+
+      as
+    end
+
+    def latest_session
+      # pick the latest session that's not in progress or archived
+      sessions.where
+              .not(status: [::Segmentor::Session::ARCHIVED, ::Segmentor::Session::IN_PROGRESS])
+              .order(created_at: :desc)
+              .first
+    end
+
+    private
+
+    def start_session
+      session = ::Segmentor::Session.new(segment: self)
+      session.save!
+
+      session
+    end
+
+    def end_session(session)
+      session.mark_as_draft!
+    end
+  end
+end

data/lib/segmentor/session.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Segmentor
+  # Session is a single segmentation session. It can be
+  # draft, in progress, or active.
+  # at any point, there is only 1 active session per segment is allowed
+  # while draft and in progress, there can be multiple sessions
+  # in progress is when a source is still generating targets and they
+  # are being saved.
+  # draft is when a session has the targets, but they are not the ones
+  # used for notification. This can be used to test a new source code for example.
+  class Session < ActiveRecord::Base
+    self.table_name = :segmentor_sessions
+
+    IN_PROGRESS = 0 # default
+    DRAFT = 1
+    ACTIVE = 2
+    ARCHIVED = 3
+    FAILED = 4
+
+    belongs_to :segment, class_name: '::Segmentor::Segment'
+    has_many :targets, class_name: '::Segmentor::Target', dependent: :destroy
+
+    validates :status, presence: true
+    validates :status, inclusion: { in: [IN_PROGRESS, DRAFT, ACTIVE, ARCHIVED, FAILED] }
+    validates :segment_id, presence: true
+    validate :only_one_active_session_per_segment
+    validates :reason, presence: true, if: :failed?
+
+    scope :active, -> { where(status: ACTIVE) }
+    scope :latest, -> { order(created_at: :desc).limit(1).first }
+
+    before_create :generate_session_id
+    after_commit :call_segment_callbacks
+
+    def mark_as_active!
+      # only draft sessions can be made active
+      raise ::Segmentor::Errors::SessionStateError, 'only draft sessions can be made active' unless status == DRAFT
+
+      self.status = ACTIVE
+      save!
+    end
+
+    def mark_as_draft!
+      # archived and failed sessions cannot be turned into draft
+      if status == ARCHIVED || status == FAILED
+        raise ::Segmentor::Errors::SessionStateError, 'failed and archived sessions cannot be turned into draft'
+      end
+
+      self.status = DRAFT
+      self.reason = nil
+      save!
+    end
+
+    def mark_as_archived!
+      # only active and failed sessions can be archived
+      unless status == ACTIVE || status == FAILED
+        raise ::Segmentor::Errors::SessionStateError, 'only active and failed sessions can be archived'
+      end
+
+      self.status = ARCHIVED
+      save!
+    end
+
+    def mark_as_failed!(reason)
+      # archived sessions cannot be marked as failed
+      raise ::Segmentor::Errors::SessionStateError, 'archived sessions cannot be marked as failed' if status == ARCHIVED
+
+      self.status = FAILED
+      self.reason = reason
+      save!
+    end
+
+    private
+
+    def only_one_active_session_per_segment
+      # only one active session per segment is allowed
+      if status == ACTIVE && ::Segmentor::Session.where(status: ACTIVE, segment_id: segment_id).count.positive?
+        raise ::Segmentor::Errors::SessionStateError, 'only one active session per segment is allowed'
+      end
+    end
+
+    def generate_session_id
+      # generate a session id
+      self.session_id ||= SecureRandom.uuid
+    end
+
+    def failed?
+      status == FAILED
+    end
+
+    def call_segment_callbacks
+      segment.send(segment.class._after_session_change, self) if segment.class._after_session_change.present?
+    end
+
+  end
+end

data/lib/segmentor/source.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Segmentor
+  # Source runs the code and returns an array of ::Segmentor::Target
+  # you can dervie from this for different types of code sources (ie Ruby, JS, etc)
+  class Source < ActiveRecord::Base
+    self.table_name = 'segmentor_sources'
+
+    belongs_to :segment, class_name: '::Segmentor::Segment', foreign_key: :segment_id
+
+    validates :code, presence: true
+    validates :type, presence: true
+    validates :segment, presence: true
+
+    def execute
+      raise NotImplementedError, 'execute must be implemented in a subclass'
+    end
+  end
+end

data/lib/segmentor/sources/ruby_source.rb

@@ -0,0 +1,26 @@
+module Segmentor
+  module Sources
+    # RubySource is a source that evaluates ruby code to generate a list of targets
+    # DO NOT USE THIS SOURCE IN UNSECURE ENVIRONMENTS
+    class RubySource < ::Segmentor::Source
+      def execute
+        # evaluate the code
+        # return the result
+        begin
+          targets = eval(code)
+        rescue StandardError => e
+          raise ::Segmentor::Errors::EvaluationError, e.message
+        end
+
+        targets = targets.is_a?(Array) ? targets : [targets]
+
+        # all targets should be a ::Segment::Target
+        if targets.any? { |target| !target.is_a?(::Segmentor::Target) }
+          raise ::Segmentor::Errors::EvaluationError, 'all returned items should be ::Segment::Target'
+        end
+
+        targets
+      end
+    end
+  end
+end

data/lib/segmentor/target.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Segmentor
+  # Target is single piece of data, returned by a
+  class Target < ActiveRecord::Base
+    self.table_name = :segmentor_targets
+
+    belongs_to :session, class_name: '::Segmentor::Session'
+    belongs_to :segment, class_name: '::Segmentor::Segment'
+    belongs_to :user
+
+    validates :user_id, presence: true
+    validates :user_id, uniqueness: { scope: :session_id }
+    validates :segment_id, presence: true
+    validates :session_id, presence: true
+
+    before_validation :set_segment_if_nil
+
+    def self.new_with_user(user)
+      ::Segmentor::Target.new(user_id: user.id, payload: {})
+    end
+
+    def self.new_with_user_and_payload(user, payload)
+      ::Segmentor::Target.new(user_id: user.id, payload: payload)
+    end
+
+    def issue_receipt!(rendered_value = nil)
+      ::Segmentor::Receipt.record_receipt(self, rendered_value)
+    end
+
+    def most_recent_receipt
+      segment.receipts.where(user_id: user_id).order(:sent_at).last
+    end
+
+    def get_binding
+      binding
+    end
+
+    def preview(&block)
+      raise ArgumentError, 'block required' unless block_given?
+
+      block.call(self, segment.notifier_context)
+    end
+
+    def can_be_notified?
+      most_recent_receipt = segment.receipts.where(user_id: user_id).order(:sent_at).last
+
+      # notification can be sent if there is a receipt for this target that
+      # is older than the repeat frequency of its segment
+      return true if most_recent_receipt.nil?
+
+      # we have a receipt. notify only if:
+      # segment repeat frequency is not NO_REPEAT
+      # receipt is older than segment repeat frequency
+      segment.repeat_frequency != ::Segmentor::Segment::NO_REPEAT &&
+        most_recent_receipt.sent_at < segment.repeat_frequency.days.ago
+    end
+
+    private
+
+    def set_segment_if_nil
+      self.segment_id ||= session.segment_id
+    end
+
+  end
+end

data/lib/segmentor/version.rb

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

data/lib/segmentor.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'active_support/all'
+require 'rails/all'
+
+Dir["#{File.dirname(__FILE__)}/segmentor/**/*.rb"].each { |f| load(f) }
+load "#{File.dirname(__FILE__)}/generators/segmentor/segmentor.rb"
+
+# Segmentor module
+module Segmentor
+end

data/segmentor.gemspec

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'segmentor/version'
+
+Gem::Specification.new do |spec|
+  spec.name = 'segmentor'
+  spec.version = Segmentor::VERSION
+  spec.authors = ['Khash Sajadi']
+  spec.email = ['khash@cloud66.com']
+  spec.license = 'Apache-2.0'
+  spec.homepage = 'https://github.com/cloud66-oss/segmentor'
+  spec.required_ruby_version = '>= 3.0.0'
+
+  spec.summary = 'Segmentor creates slices from your data that can be used for notifications'
+
+  # 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{^(test|spec|features)/}) }
+  end
+  spec.bindir = 'exe'
+  spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'actionpack', '~> 6.1'
+  spec.add_dependency 'activerecord', '~> 6.1'
+  spec.add_dependency 'activesupport', '~> 6.1'
+
+  spec.add_development_dependency 'bootsnap', '~> 1.9'
+  spec.add_development_dependency 'bundler', '~> 2.0'
+  spec.add_development_dependency 'factory_bot', '~> 6.2'
+  spec.add_development_dependency 'generator_spec', '~> 0.9'
+  spec.add_development_dependency 'parser', '3.0.0.0'
+  spec.add_development_dependency 'pry', '~> 0.13.1'
+  spec.add_development_dependency 'rails', '~> 6.1'
+  spec.add_development_dependency 'rake', '~> 13.0'
+  spec.add_development_dependency 'rspec', '~> 3.10'
+  spec.add_development_dependency 'rspec-rails', '~> 5.0'
+  spec.add_development_dependency 'rubocop', '~> 1.4'
+  spec.add_development_dependency 'rubocop-performance', '~> 1.9'
+  spec.add_development_dependency 'rufo', '~> 0.12'
+  spec.add_development_dependency 'sqlite3', '~> 1.4'
+end