ritikesh

module AccountJoinCondition
  def join_with_account(table, constraint)
    s_r = reflection.source_reflection
    # source reflection can be polymorphic
    s_r = reflection if s_r && s_r.options[:polymorphic]
    t_r = reflection.through_reflection
    if s_r && t_r && has_account?(s_r) && has_account?(t_r)
      sr_account_column = account_col(s_r)
      tr_account_column = account_col(t_r)
      constraint = constraint.and(sr_account_column.eq(tr_account_column)) if direct_through_join?(sr_account_column, tr_account_column, constraint)

ritikesh

# memoize db/memcache results in instance variable dynamically
def memoize_results(key)
  return instance_variable_get(key) if instance_variable_defined?(key)
  instance_variable_set key, yield  
end

# usage
MY_CONSTANT = [:active, :inactive]
MY_CONSTANT.each { |key|
  define_method("#{key}_users") do

ritikesh

module Enumerable
  def deep_freeze
    obj = self
    obj.each do |iterator|
      case iterator
        when Enumerable
          iterator.deep_freeze
        when Symbol, Fixnum, NilClass
          iterator
        else

ritikesh

module BelongsToTenant
  extend ActiveSupport::Concern

  included do
    belongs_to :tenant
    
    default_scope {
      Tenant.current ? where(tenant_id: Tenant.current.id) : where(nil)
    }
  end

ritikesh

module ActsAsCurrent
    extend ActiveSupport::Concern

    included do
        self._current_human_name = self.name.underscore.to_sym
    end

    def make_current
        Thread.current[self.class._current_human_name] = self
    end

ritikesh

module Creator
    extend ActiveSupport::Concern
    
    included do
        before_validation -> {
            self.creator_id = User.current.id if User.current
        }, on: :create

        belongs_to :creator, class_name: 'User', foreign_key: :creator_id
    end

ritikesh

module MemoizeExtensions
  def memoize_methods(method_name, *params)
      @@hash ||= {}
      return @@hash[params] if @@hash[params]
      @@hash[params] = send(method_name, *params)
  end
end

class User < ActiveRecord::Base
  

ritikesh

const redis = require('redis');
const redis_client = redis.createClient();

const MemoizeUntil = require('memoize_until').MemoizeUntil

MemoizeUntil.init({ 
    min: ['api_key']
})

MemoizeUntil.fetch('min', 'api_key', () => { 

ritikesh

default: &default
  adapter: mysql2
  encoding: utf8mb4
  pool: 5

development:
  <<: *default
  database: development

test:

ritikesh

ActiveRecord::Base.logger = nil

subject = "Benchmarking"
description = "Benchmarking " * 1000
type = "Incident"
email = "andrea@freshservice.com"
status = 2
source = 2
priority = 1