nayati 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0bbc6f00148eadad1b96f8e72de1c6c6d2b69572
+  data.tar.gz: 232650a7d477b49b88bf0ed33e275d7282d622bc
+SHA512:
+  metadata.gz: ef068a11d3264a28b870a818ad9bd1791e2aca115662ebfe920e21ff05cf79a7ce56e856a3e60e8ab51995a950c5a4318578cfaee9325ba8eaed7480494291fb
+  data.tar.gz: 551b829e305bd72fb39deddf7793b1f7effcf840a8725c7d84f237a6fe33840162cc6612435d486d56e50c09d4ddea068e5f41105c4d7712ca9820430d1afac8

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2018 Tanmay Tupe
+
+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,79 @@
+# Nayati
+Nayati is a Rails engine that helps in creating a clean and maintainable multi tenant Rails application. Creating multitenant application with Nayati allows you to have models that do just database talking and business logic gets handled by a layer I like to call 'Operation layer'. The sequence in which these operations get executed for a tenant is put in database.
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'nayati'
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install nayati
+```
+First run the install generator
+```bash
+$ rails generator nayati:install
+```
+
+## How to use
+Nayati is meant to help in handling functional changes across tenants in your application.
+Lets say you have a attendance system. Your company installs devices which have fingerprint scanning functionality. Your clients vary from
+scools, gym, private companies. Now lets say you have 5 'operations' that can happen
+in this workflow viz marking_attendace, notify_parents, give_extra_marks_for_consistency, notify_sitting_position, late_marking, notify_missing_registration
+notify_number_of_late_marks
+
+After installing, first generate a workflow e.g. attendance_management in example above.
+
+```bash
+$ rails generate nayati:workflow attendance_management
+```
+
+This will create a service class AttendanceManagementNayatiService which you are supposed to call in controller.
+
+Service classes do following tasks
+1. Find which workflow is supposed to run based on information passed from controller.
+2. Create context that will be passed to every operation.
+3. Return result object. By convention, this will return instance Nayati::WorkflowResults::Base object. You can have your own result object. Just create a class in app/models/nayati/workflow_results/#{workflow_name}.rb and nayati will pass instance of this class to operation classes.
+
+Next we will create our operation classes. RESPONSIBILITIES OF A SINGLE OPERATION CLASS SHOULD NOT CHANGE ACROSS TENANTS. Rather this is how I define operation class. It is that piece of functionality which does not change across tenant. to create an operation class belonging to a workflow run
+
+```bash
+$ rails generate nayati:operation attendance_management marking_attendance
+```
+
+Next we will configure a workflow for a tenant. Lets say we are going to identify this workflow by name 'tenant_1_attendance_marking'. This tenant is a school and needs only marking_attendance and late_marking piece of functionality and if marking_attendance fails, you are supposed to nottify to register first. Nayati comes with a method to configure a workflow in database.
+
+workflow_hash corresponding to sequence mentioned in above paragraph would be
+workflow_sequence_hash = {
+  name: 'marking_attendance',
+  workflow_identifier: 'tenant_1_attendance_marking',
+  initial_operation_name: 'marking_attendance',
+  operations: [
+    { name: 'marking_attendance', after_failure_operation_name: 'notify_missing_registration', after_success_operation_name: 'late_marking' },
+    { name: 'notify_missing_registration'},
+    { name: 'late_marking'}
+  ]
+}
+
+You can put this workflow in database by calling
+```ruby
+Nayati::Workflow.create_or_update_from_workflow_json(workflow_sequence_hash)
+```
+
+Next we will have a look at operation class
+nayati:operation will generate operation class in app/nayati_operations/{workflow_name}/ directory which will automatically be initialized with operation_context that you created in nayati service class and result object when you call the 'call' method on service class.
+
+By default nayati will first call to_fail? method of a operation class. If this method returns true, nayati will call perform_failure and next operation will be after_failure operation configured in database. If this method returns false, nayati will call perform method and next operation will be after_success operation configured in database. Nayati will stop when there is no operation to run.
+
+## Sample
+
+You can find a sample multitenant application 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,32 @@
+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    = 'Nayati'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("spec/dummy/Rakefile", __dir__)
+load 'rails/tasks/engine.rake'
+
+load 'rails/tasks/statistics.rake'
+
+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/app/models/nayati/application_record.rb

@@ -0,0 +1,5 @@
+module Nayati
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/models/nayati/master_operation.rb

@@ -0,0 +1,46 @@
+module Nayati
+  class MasterOperation
+    attr_reader :name
+    def initialize(master_workflow, operation_name)
+      @master_workflow = master_workflow
+      @name = operation_name
+      @edit_errors = []
+    end
+
+    def edit(new_name)
+      @new_name = ::Nayati::NameBasedConstantable.name_as_namespace(new_name.to_s)
+      @is_name_changed = true unless @new_name == @name
+      @valid_edit_called = false
+    end
+
+    def exists?
+      @master_workflow.operation_names.include?(@name)
+    end
+
+    def save
+      OperationConfiguration.add_operation_unless_present(@master_workflow.name, @name)
+    end
+
+    def valid_edit?
+      validate_name_for_edit if @is_name_changed
+      @edit_errors.empty?
+      @valid_edit_called = true
+    end
+
+    def update
+      raise 'Please check valid edit first' unless @valid_edit_called
+      OperationConfiguration.update_operation(@master_workflow.name, @name, @new_name)
+    end
+
+    def edit_error_message
+      @edit_errors.join(', ')
+    end
+
+    private
+
+    def validate_name_for_edit
+      @edit_errors << 'New name is not valid' unless @new_name.present?
+      @edit_errors << 'New name already exists' if @master_workflow.operation_names.include?(@new_name)
+    end
+  end
+end

data/app/models/nayati/master_workflow.rb

@@ -0,0 +1,67 @@
+module Nayati
+  class MasterWorkflow
+    attr_reader :name
+    def initialize(name)
+      @name = name
+      @errors = []
+      @operation_addition_errors = []
+      @name_as_sym = @name.to_sym
+    end
+
+    def operation_names
+      Nayati::OperationConfiguration.operation_names(self.name)
+    end
+
+    def add_operation(operation_name)
+      Nayati::OperationConfiguration.add_operation_unless_present(self.name, operation_name)
+    end
+
+    def save!
+      Nayati::OperationConfiguration.add_workflow_unless_present(self.name)
+    end
+
+    def exists?
+      Nayati::OperationConfiguration.workflow_names.include?(@name_as_sym)
+    end
+
+    def valid?
+      validate_name
+      @errors.empty?
+    end
+
+    def valid_to_add_operation?(operation_name)
+      validate_operation_uniqueness(operation_name)
+      @operation_addition_errors.empty?
+    end
+
+    class << self
+      def all_workflow_names
+        Nayati::OperationConfiguration.workflow_names
+      end
+
+    end
+
+    def error_message
+      @errors.join(', ')
+    end
+
+    def operation_addition_error_message
+      @operation_addition_errors.join(', ')
+    end
+
+    private
+
+    def validate_operation_uniqueness(operation_name)
+      @operation_addition_errors << 'Already exists' if operation_exists?(operation_name)
+    end
+
+    def operation_exists?(operation_name)
+      operation_namespace = ::Nayati::NameBasedConstantable.name_as_namespace(operation_name.to_s)
+      operation_names.include?(operation_namespace)
+    end
+
+    def validate_name
+      @errors << 'Name already exists' if Nayati::OperationConfiguration.workflow_exists?(self.name)
+    end
+  end
+end

data/app/models/nayati/name_based_constantable.rb

@@ -0,0 +1,30 @@
+module Nayati
+  module NameBasedConstantable
+    def camelcased_name
+      return "" if name.nil?
+      Nayati::NameBasedConstantable.name_as_constant(self.name)
+    end
+
+    def namespaced_name
+      return "" if name.nil?
+      Nayati::NameBasedConstantable.name_as_namespace(self.name)
+    end
+
+    def underscored_name
+      return "" if name.nil?
+      Nayati::NameBasedConstantable.underscored_name(name)
+    end
+
+    def self.name_as_constant(name)
+      name.to_s.split(' ').join('_').camelcase
+    end
+
+    def self.name_as_namespace(name)
+      name.to_s.downcase.split(' ').join('_')
+    end
+
+    def self.underscored_name(name)
+      name.to_s.underscore.split(' ').join('_')
+    end
+  end
+end

data/app/models/nayati/operation.rb

@@ -0,0 +1,29 @@
+module Nayati
+  class Operation < ApplicationRecord
+    include NameBasedConstantable
+
+    belongs_to :workflow
+    belongs_to :after_success_operation, class_name: "Operation", foreign_key: :after_success_operation_id, required: false
+    belongs_to :after_failure_operation, class_name: "Operation", foreign_key: :after_failure_operation_id, required: false
+    before_save :format_name
+
+
+    validates :name, presence: true
+
+    def operation_implementer_klass_name
+      "#{workflow.camelcased_name}NayatiWorkflow::#{self.camelcased_name}NayatiOperation"
+    end
+
+    def build_implementer(operation_context, result_object)
+      operation_implementer_klass_name.constantize.new(operation_context, result_object)
+    end
+
+    def details_hash
+      { name: self.name, after_success_operation: after_success_operation.try(:name), after_failure_operation: after_failure_operation.try(:name)}
+    end
+
+    def format_name
+      self.name = namespaced_name
+    end
+  end
+end

data/app/models/nayati/operation_configuration.rb

@@ -0,0 +1,73 @@
+module Nayati
+  module OperationConfiguration
+    class << self
+      def configuration
+        @configuration ||= YAML.load(File.open(yaml_file_path)) || {}
+      end
+
+      def operation_names(workflow_name)
+        wf_name = ::Nayati::NameBasedConstantable.name_as_namespace(workflow_name.to_s)
+        (configuration[wf_name.to_sym] || []).map { |operation_conf| operation_conf.try(:[], :name) }
+      end
+
+      def add_workflow_unless_present(workflow_name)
+        wf_namespace = ::Nayati::NameBasedConstantable.name_as_namespace(workflow_name.to_s)
+        unless workflow_names.include?(wf_namespace.to_sym)
+          configuration[wf_namespace.to_sym] = []
+          write_configuration
+        end
+      end
+
+      def add_operation_unless_present(workflow_name, operation_name)
+        wf_namespace = ::Nayati::NameBasedConstantable.name_as_namespace(workflow_name.to_s)
+        op_namespace = ::Nayati::NameBasedConstantable.name_as_namespace(operation_name.to_s)
+
+        add_workflow_unless_present(wf_namespace)
+
+        unless operation_names(wf_namespace).include?(op_namespace)
+          configuration[wf_namespace.to_sym] << { name: op_namespace }
+          write_configuration
+        end
+      end
+
+      def workflow_exists?(workflow_name)
+        wf_namespace = ::Nayati::NameBasedConstantable.name_as_namespace(workflow_name.to_s)
+        workflow_names.include?(wf_namespace.to_sym)
+      end
+
+      def yaml_file_path
+        "#{Rails.root}/config/operations.yml"
+      end
+
+      def write_configuration
+        File.open(yaml_file_path, 'w') { |f| f.write configuration.to_yaml }
+      end
+
+      def workflow_names
+        configuration.keys
+      end
+
+      def update_operation(workflow_name, old_name, new_name)
+        op_conf = operation_configuration(workflow_name, old_name)
+
+        op_conf[:name] = ::Nayati::NameBasedConstantable.name_as_namespace(new_name.to_s)
+        write_configuration
+      end
+
+      private
+
+      def operation_configuration(workflow_name, operation_name)
+        wf_namespace = ::Nayati::NameBasedConstantable.name_as_namespace(workflow_name.to_s)
+        op_namespace = ::Nayati::NameBasedConstantable.name_as_namespace(operation_name.to_s)
+
+        wf_conf = workflow_configuration(wf_namespace)
+        wf_conf.detect { |operation| operation[:name] == op_namespace }
+
+      end
+
+      def workflow_configuration(workflow_namespace)
+        configuration[workflow_namespace.to_sym]
+      end
+    end
+  end
+end

data/app/models/nayati/operation_implementer_base.rb

@@ -0,0 +1,21 @@
+module Nayati
+  class OperationImplementerBase
+    attr_accessor :operation_context
+    def initialize(operation_context)
+      @operation_context = operation_context
+    end
+
+    def to_fail?
+      puts "#{__callee__} called on #{self.class.name}"
+      false
+    end
+
+    def perform_failure
+      puts "#{__callee__} called on #{self.class.name}"
+    end
+
+    def perform
+      puts "#{__callee__} called on #{self.class.name}"
+    end
+  end
+end

data/app/models/nayati/workflow.rb

@@ -0,0 +1,170 @@
+require 'pry'
+require 'nayati/workflow_results/base'
+module Nayati
+  class Workflow < ApplicationRecord
+    include NameBasedConstantable
+
+    attr_accessor :context, :initial_operation_name
+
+    has_many :operations
+    after_initialize :set_initial_creation_flag
+    belongs_to :initial_operation, class_name: 'Operation', optional: true
+    after_create :create_initial_operation
+
+    validates :name, presence: true
+    validates :identifier, uniqueness: true
+    validates :initial_operation, presence: true, unless: :initial_creation_flag_set?
+    validates :initial_operation_name, presence: { message: 'Please set initial_operation_name'}, if: :initial_creation_flag_set?
+
+    def name_space
+      name.parameterize.underscore
+    end
+
+    def klass_name
+      name_space.camelcase + 'Workflow'
+    end
+
+    def klass
+      raise ContextNotSetError.new unless context.present?
+      klass_name.constantize.new(context)
+    end
+
+    def specific_result_obj_klass_constant_name
+      "Nayati::WorkflowResults::#{klass_name}"
+    end
+
+    def result_obj
+      result_class = begin
+                      Module.const_get(specific_result_obj_klass_constant_name)
+                    rescue NameError
+                      ::Nayati::WorkflowResults::Base
+                    end
+      result_class.new
+    end
+
+    def entire_workflow_as_hash
+      {
+        name: self.name,
+        initial_operation_name: self.initial_operation.try(:name),
+        workflow_identifier: self.identifier,
+        operations: operations.map { |operation| operation.details_hash }
+      }
+    end
+
+    class << self
+      def name_selection_options
+        Nayati::OperationConfiguration.workflow_names.map { |name| [name, name] }
+      end
+
+      # Workflow json has following structure
+      # {
+      #   name: 'workflow_name'
+      #   initial_operation_name: 'operation_name',
+      #   workflow_identifier: 'workflow_identifier',
+      #   operations: [
+      #     { name: 'operation_name', after_failure_operation_name: 'afo_name', after_success_operation_name: 'aso_name' },
+      #     .
+      #     .
+      #     .
+
+      #   ]
+      # }
+
+      def create_or_update_from_workflow_json(workflow_hash)
+        ActiveRecord::Base.transaction do
+          workflow_name = workflow_hash[:name]
+          workflow_identifier = workflow_hash[:workflow_identifier]
+          initial_operation_name = workflow_hash[:initial_operation_name]
+
+          wf = find_or_initialize_by(name: workflow_name.to_s, identifier: workflow_identifier)
+          wf.initial_operation_name = initial_operation_name
+          wf.save!
+
+          initial_operation_record = wf.operations.find_or_initialize_by(name: initial_operation_name)
+          initial_operation_record.save!
+
+          workflow_hash[:operations].each do |operation_hash|
+            operation_name = operation_hash[:name].to_s
+            operation_record = wf.operations.find_or_initialize_by(name: operation_name)
+
+            after_failure_operation_name = operation_hash[:after_failure_operation_name].to_s
+            if after_failure_operation_name.present?
+              after_failure_operation_record = wf.operations.find_or_initialize_by(name: after_failure_operation_name)
+              after_failure_operation_record.save!
+              operation_record.after_failure_operation = after_failure_operation_record
+            end
+
+            after_success_operation_name = operation_hash[:after_success_operation_name].to_s
+            if after_success_operation_name.present?
+              after_success_operation_record = wf.operations.find_or_initialize_by(name: after_success_operation_name)
+              after_success_operation_record.save!
+              operation_record.after_success_operation = after_success_operation_record
+            end
+
+            operation_record.save!
+          end
+          # puts "---------------- printing operation sequences ----------------"
+          # wf.print_sequences
+          # puts "-----------------------------------------------------------------"
+        end
+      end
+    end
+
+    private
+
+    def configuration
+      @configuration ||= OperationConfiguration.new
+    end
+
+    def set_initial_creation_flag
+      @creation_flag = true
+    end
+
+    def initial_creation_flag_set?
+      @creation_flag
+    end
+
+    def create_initial_operation
+      op = self.operations.new(name: initial_operation_name)
+      op.save
+      self.initial_operation = op
+      self.save
+    end
+
+    def assign_from_creation_params(params)
+
+    end
+
+
+    # class Master
+    #   attr_reader :name, :name_as_namespace, :operations
+    #   def initialize(workflow_name)
+    #     @name = @workflow_name
+    #     @operations = operations_from_configuration(workflow_name)
+    #     @name_as_namespace = Nayati::NameBasedConstantable.name_as_namespace(workflow_name)
+    #   end
+
+      class << self
+        def assign_from_creation_params(params)
+          wf = self.new(name: params[:name])
+          wf.initial_operation_name = params[:initial_operation_name]
+          wf
+        end
+      end
+
+    #   private
+
+    #   def operations_from_configuration(workflow_name)
+    #     configuration[@name_as_namespace]
+    #   end
+
+    #   def configuration
+    #     @configuration ||= ( YAML.load(File.open("#{Rails.root}/config/operations.yml")) || {} )
+    #   end
+    # end
+
+    class ContextNotSetError < StandardError
+    end
+
+  end
+end