has_helpers 5.0.2

data/lib/has_helpers/flattener/resource.rb

@@ -0,0 +1,114 @@
+# typed: true
+# frozen_string_literal: true
+
+module Flattener
+  class Resource
+    include ActiveModel::Model
+    include Flattener::ResourceGenerator
+    include Flattener::Utils
+
+    attr_accessor :association, :index, :type, :parent
+    attr_writer :base_flattener, :flattener
+
+    def name
+      combine_names(parent.name, resource_name) if association.present?
+    end
+
+    def prefix
+      return klass.name.underscore if parent.nil?
+      parent && "#{parent.prefix}[#{association.ar_association_name}_attributes]#{id_prefix}"
+    end
+
+    def id_prefix
+      return "[#{index}]" if index
+      "[#{type_name}]" if type
+    end
+
+    def attributes
+      @attributes ||= flattener.columns.
+        reject { |column| exclude_column?(column) }.
+        map { |column| Flattener::Attribute.new(resource: self, column: column) }
+    end
+
+    def resources
+      @resources ||= generate_resources
+    end
+
+    def associations
+      @associations ||= flattener.associations.
+        reject { |a| association.present? && a.reject_if.call(self) }
+    end
+
+    def merge_into_parent
+      association && association.merge_into_parent
+    end
+
+    def flatten(depth = 1)
+      return [*attributes, *generate_resources(associations.select(&:always_include)).flat_map { |r| r.flatten(0) }] if depth.zero?
+      [*attributes, *resources.flat_map { |r| r.flatten(depth - 1) }]
+    end
+
+    def flattener
+      @flattener ||= association.flattener
+    end
+
+    def klass
+      flattener.class.model_klass
+    end
+
+    def hide_owner_keys?
+      if klass.respond_to?(:owner_association_reflections) && parent.present?
+        klass.owner_association_reflections.map(&:klass).include? parent.klass
+      end
+    end
+
+    def is_constant?
+      klass.include?(HasHelpers::Constant)
+    end
+
+    def owner_keys
+      klass.owner_association_reflections.map(&:foreign_key)
+    end
+
+    private
+
+    def exclude_column?(column)
+      return column.reject_if.call(self) if column.reject_if # custom reject_if
+      if association.present?
+        (column.is_timestamp?) || # No timestamps on child resources
+          (column.name == "is_primary") || # No 'is_primary's
+          (column.is_primary_key? && association.macro != :has_many) || # No primary_keys on belongs_tos (id already in the parent)
+          (column.name == association.expand_on_column.to_s) || # If we expanded on `location`, we don't need `location_id`
+          (column.name == "organization_id") || # Don't include organization_id
+          (column.name == association.foreign_key.to_s) || # No foreign_keys back to parent, we know our parent
+          (hide_owner_keys? && owner_keys.include?(column.name)) # Don't need has_owner foreign_keys
+      end
+    end
+
+    def resource_name
+      combine_names(resource_name_prefix, index_prefix) unless merge_into_parent
+    end
+
+    def resource_name_prefix
+      type_name || association_name
+    end
+
+    def index_prefix
+      index if association && association.count != 1
+    end
+
+    def type_name
+      if type.is_a? Class
+        underscore_type(type.name)
+      elsif type.respond_to?(:name?)
+        combine_names(underscore_type(type.name), association_name)
+      else
+        combine_names(underscore_type(type), association_name)
+      end
+    end
+
+    def association_name
+      index.present? ? association.name.to_s.singularize : association.name.to_s
+    end
+  end
+end

data/lib/has_helpers/flattener/resource_generator.rb

@@ -0,0 +1,21 @@
+# typed: false
+# frozen_string_literal: true
+
+module Flattener
+  module ResourceGenerator
+    def generate_resources(for_associations = associations)
+      for_associations.flat_map do |a|
+        args = { parent: self, association: a }
+        [].tap do |genrated_resources|
+          if !a.is_pivot?
+            genrated_resources.push self.class.new(**args) if a.count.zero?
+            # rubocop:disable Performance/TimesMap
+            genrated_resources.push(*a.expand_on.flat_map { |t| a.count.times.map { |i| self.class.new(index: i + 1, type: t, **args) } }) if a.expand_on
+            genrated_resources.push(*a.count.times.map { |i| self.class.new(index: i + 1, **args) }) if a.count && !a.expand_on
+            # rubocop:enable Performance/TimesMap
+          end
+        end
+      end
+    end
+  end
+end

data/lib/has_helpers/flattener/utils.rb

@@ -0,0 +1,14 @@
+# typed: true
+# frozen_string_literal: true
+
+module Flattener
+  module Utils
+    def combine_names(*args)
+      args.delete_if(&:blank?).join("_")
+    end
+
+    def underscore_type(name)
+      name.gsub(/( )/, "_").underscore if name.present?
+    end
+  end
+end

data/lib/has_helpers/flattener.rb

@@ -0,0 +1,53 @@
+# typed: true
+# frozen_string_literal: true
+
+require "has_helpers/flattener/utils"
+require "has_helpers/flattener/association"
+require "has_helpers/flattener/attribute"
+require "has_helpers/flattener/base"
+require "has_helpers/flattener/column"
+require "has_helpers/flattener/resource_generator"
+require "has_helpers/flattener/resource"
+require "has_helpers/flattener/pivot"
+require "has_helpers/flattener/reset"
+
+module Flattener
+  @@config_ran = false
+  @@config_block = nil
+
+  def self.for(klass)
+    run_config
+    flattener_klass = "::Flatteners::#{klass.name}".safe_constantize
+    return flattener_klass if flattener_klass
+    module_name = klass.name.deconstantize.presence
+    flattener_module =
+      if module_name
+        "::Flatteners::#{module_name}".safe_constantize ||
+          module_name.split("::").reduce(::Flatteners) do |mod, name|
+            mod.const_defined?(name, false) ? mod.const_get(name) : mod.const_set(name, Module.new)
+          end
+      else
+        ::Flatteners
+      end
+    flattener_klass = flattener_module.const_set(klass.name.demodulize, Class.new(::Flattener::Base))
+
+    flattener_klass
+  end
+
+  def self.default_for(type)
+    Flattener::Base.default_for.map { |k, v| k if v.include? type }.compact
+  end
+
+  def self.config(&block)
+    @@config_block = block
+    @@config_ran = false
+  end
+
+  def self.run_config
+    return false if @@config_ran
+    @@config_ran = true
+    class_eval(&@@config_block) if @@config_block
+  end
+end
+
+module Flatteners; end

data/lib/has_helpers/hash_accessors.rb

@@ -0,0 +1,62 @@
+# typed: false
+# frozen_string_literal: true
+
+module HasHelpers
+  module HashAccessors
+    # Create accessors to root-level settings, where the settings is a Hash attribute, e.g.
+    # serialized Hash, JSON-column, etc.
+    #
+    # When assigning a blank value (e.g. +nil+ or +""+) the key corresponding to the accessor will
+    # be removed from the backing data store. There is currently no way to disable this.
+    #
+    # +source:+
+    # The underlying Hash store for the accessor.
+    #
+    # === Examples
+    #   class ApplicationSetting
+    #     extend HasHelpers::HashAccessors
+    #     hash_attr_accessor :search_provider
+    #   end
+    #
+    #   application_setting = ApplicationSetting.new
+    #   application_setting.settings                        #=> nil
+    #   application_setting.search_provider                 #=> nil
+    #
+    #   application_setting.search_provider = "::SQLSearch"
+    #   application_setting.settings                        #=> { "search_provider" => "::SQLSearch" }
+    #   application_setting.search_provider                 #=> "::SQLSearch"
+    #
+    # Using the +source+ option to override the default.
+    #
+    #   class Template
+    #     extend HasHelpers::HashAccessors
+    #     attr_accessor :colors
+    #     hash_attr_accessor :header_bg, :header_font, :source => :colors
+    #   end
+    #
+    #   template = Template.new
+    #   template.header_bg = "#011134"
+    #   template.header_font = "#CCC"
+    #   template.colors                  # => { :header_bg => "#011134", :header_font => "#CCC" }
+    def hash_attr_accessor(*attrs, source: :settings, **_options)
+      attrs.each do |a|
+        attr = a.to_s # Keys are only store as strings to ease compatibility with serializers.
+
+        define_method(attr) do
+          send(source)[attr] if send(source)
+        end
+
+        define_method("#{ attr }=") do |value|
+          send("#{ source }=", {}) unless send(source)
+          if value.blank?
+            send(source).delete(attr) # Remove the key (attr) from the data store if the given value is blank.
+          else
+            send(source)[attr] = value
+          end
+        end
+      end
+    end
+
+    alias setting_attr_accessor hash_attr_accessor
+  end
+end

data/lib/has_helpers/helpers/application.rb

@@ -0,0 +1,291 @@
+# typed: false
+# frozen_string_literal: true
+
+module HasHelpers
+  module Helpers
+    module Application
+      def self.included(klass)
+        klass.send(:include, InstanceMethods)
+
+        klass.class_eval do
+          extend self # Turn all instance methods into module methods
+        end
+      end
+
+      module InstanceMethods
+        def format_account(account, n = account.to_s.length)
+          account.to_s.split(//).last(4).join.rjust(n, "X")
+        end
+
+        def format_date(date, standard_format: false)
+          if date.is_a?(String)
+            date = standard_format ? Date.parse(date) : Chronic.parse(date)
+          end
+          date.strftime("%m/%d/%Y") if date
+        end
+
+        alias format_dob format_date # We have owner-details data under the heading DOB. That seems like an appropriately descriptive term, however, "date" seems appropriate for other situations, so here we support both.
+
+        def mask_birth_date(birth_date, display_mode = nil)
+          default = { value: birth_date ? format_dob(birth_date) : nil, disabled: false, hide_age: false }
+          return default unless birth_date
+
+          case display_mode
+          when "Masked birth date"
+            { value: "**/**/#{birth_date.year}", disabled: true, hide_age: false }
+          when "Hide birth date"
+            { value: "**/**/****", disabled: true, hide_age: true }
+          else
+            default
+          end
+        end
+
+        def format_html(markdown)
+          return unless markdown
+
+          render = Redcarpet::Render::HTML.new(filter_html: true, safe_links_only: true)
+          parser = Redcarpet::Markdown.new(render)
+          parser.render(markdown).html_safe # rubocop:disable Rails/OutputSafety
+        end
+
+        # === Examples
+        # format_short_date(Date.current) # => "October 2"
+        # format_short_date(Date.current + 1.year) # => "October 2, 2015"
+        def format_short_date(date)
+          date.strftime("%B %-d#{ ", %Y" unless date.year == Date.current.year }") if date
+        end
+
+        def format_time(time)
+          time.strftime("%l:%M %p") if time
+        end
+
+        def days_ago(date)
+          Date.current.jd - date.jd
+        end
+
+        def format_datetime(datetime, standard_format: false)
+          if datetime.is_a?(String)
+            datetime = standard_format ? Time.zone.parse(datetime) : Chronic.parse(datetime)
+          end
+          datetime.strftime("%m/%d/%Y %l:%M %p") if datetime
+        end
+
+        def format_boolean(boolean)
+          boolean ? "Yes" : "No"
+        end
+
+        def format_delimited(number, **options)
+          # TODO: why Rails? number.to_s(:delimited, strip_insignificant_zeros: true, delimiter: ",", separator: ".")
+          ActionController::Base.helpers.number_with_precision(number, options.merge(precision: 2, strip_insignificant_zeros: true, delimiter: ","))
+        end
+
+        def format_percent(percent, **options)
+          return nil if percent.blank?
+
+          formatted = ActiveSupport::NumberHelper.number_to_percentage(
+            percent.to_d,
+            options.merge(precision: 6, strip_insignificant_zeros: true)
+          )
+
+          formatted.partition(".").last.length == 2 ? formatted.insert(-2, "0") : formatted
+        end
+
+        def format_dollar(currency, **options)
+          return nil if currency.blank?
+
+          ActiveSupport::NumberHelper.number_to_currency(
+            currency.to_d,
+            options
+          )
+        end
+
+        alias_method :format_currency, :format_dollar # TODO: can we clean this up?
+
+        # Formats a currency value without a decimal place, i.e. it omits the cents
+        #=== Examples
+        #   format_short_dollar(2_345_678.90)  # => "$2,345,678"
+        def format_short_dollar(currency, **options)
+          format_dollar(currency, precision: 0, **options)
+        end
+
+        def format_human_dollar(currency)
+          return nil if currency.blank?
+
+          ActiveSupport::NumberHelper.number_to_human(
+            currency.to_d,
+            precision: 3,
+            significant: true,
+            units: {
+              thousand: "Thousand",
+              million: "Million",
+              billion: "Billion"
+            }
+          )
+        end
+
+        def format_ssn(ssn)
+          ssn && [ssn[0..2], ssn[3..4], ssn[5..8]].compact.join("-")
+        end
+
+        def format_interval(interval)
+          new_interval = interval.is_a?(String) ? ActiveSupport::Duration.parse(interval) : ::ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Interval.new.deserialize(interval)
+          parts = []
+          new_interval.parts.each do |part|
+            unit_of_time = part[1] > 1 ? part[0] : part[0].to_s.singularize
+            parts << "#{part[1]} #{unit_of_time}"
+          end
+          parts.join(" ")
+        end
+
+        def mask_ssn(ssn, display_mode = "Masked SSN")
+          case display_mode
+          when "Full SSN"
+            format_ssn(ssn)
+          when "Masked SSN"
+            ssn && "***-**-#{ssn[5..8]}"
+          when "Hide SSN"
+            "***-**-****"
+          else
+            "Invalid Option"
+          end
+        end
+
+        def valid_mask_or_get_default(ssn_mask)
+          ssn_mask ? Option.find(ssn_mask).name : "Masked SSN"
+        end
+
+        def mask(id_to_mask, display_mode = "Masked")
+          case display_mode
+          when "Full"
+            id_to_mask
+          when "Masked"
+            visible_count = (id_to_mask.length * 0.4).ceil
+            masked_part = "*" * (id_to_mask.length - visible_count)
+            visible_part = id_to_mask[-visible_count, visible_count]
+            masked_part + visible_part
+          when "Hide"
+            "*" * id_to_mask.length
+          else
+            "Invalid Option"
+          end
+        end
+
+        def format_phone_number_url(web_dial, extension, phone_number, phone_extension)
+          if web_dial && extension
+            "<a class=\"value\" href=\"#{Mustache.render(web_dial, extension: extension, phone_number: phone_number)}\"><span>#{phone_number.gsub(/([0-9]{3})([0-9]{3})([0-9]{4})$/, "(\\1) \\2-\\3") if phone_number}</span></a>"
+          elsif phone_number
+            %Q[<span class="value">#{format_tel(phone_number)}#{ " #{format_tel_extension(phone_extension)}" if phone_extension }</span>]
+          end
+        end
+
+        # TODO: use this instead number.to_s(:phone, area_code: true, extension: 555)
+        def format_tel(number)
+          number && number.sub(/([0-9]{3})([0-9]{3})([0-9]{4})$/, "(\\1) \\2-\\3")
+        end
+
+        alias format_phone format_tel # The term "Phone" is used commonly through HQ, but "tel" is the HTML5 field type for phone numbers. This is why both named formats are supported.
+
+        def format_tel_extension(extension)
+          "x#{extension}" if extension.present?
+        end
+
+        def format_zip_code(zip_code)
+          if zip_code.present? && zip_code.length == 9 && zip_code.scan(/^\d+$/).any? # US regex
+            /(?<zip>\d{5})(?<ext>\d{4})?/ =~ zip_code # Name regex groups zip and ext will be set as local variables
+            [zip, ext].reject(&:blank?).join("-")
+          else # other country cases
+            zip_code
+          end
+        end
+
+        def format_map_url(address)
+          "http://maps.google.com?daddr=#{ ::CGI.escape(address.display_address) }"
+        end
+
+        def format_nickname(nickname)
+          nickname && %Q["#{nickname}"]
+        end
+
+        def format_label(label)
+          label.dup.
+            sub(/[^\A]percent\z/i, " %") # E.g. "Commission Percent" => "Commission %"
+        end
+
+        # Creates a more human-readable name from the filename. It also truncates
+        # the name if it is longer than the size limit specified.
+        # NOTE: Assumes the filename has already been sanitized to remove control
+        # characters.
+        def format_filename(filename, limit: nil)
+          # Remove the file extension if one is present and titleize
+          att_name = File.basename(filename, ".*").titleize
+
+          # Truncate if too long
+          (limit && att_name.size > limit) ? (att_name.slice(0, limit - 3) + "...") : att_name
+        end
+
+        def encode(s)
+          return nil unless s.class == String
+          s.encode(xml: :text)
+        end
+
+        # Accepts a photo info string formatted as "resource_typish, resource_id, photo_filename, unix_timestamp".
+        # Returns a Service to the corresponding photo.
+        #
+        #=== Examples
+        #
+        #   photo_info_service("carriers,1291,photo.png,1445445346")
+        #
+        #=== Options
+        # +application+: This may be assigned as a string or a Proc. When a proc is given, it is called and passed
+        #   the pieces extracted from the photo info string. The value returned is used as the application name.
+        #
+        #     photo_info_service("carriers,1291,photo.png,1445445346", application: "agencieshq")
+        #     photo_info_service("carriers,1291,photo.png,1445445346", application: proc(resource_typish, id, file_name, unix_timestamp") { resource_typish == "users" ? "hqadmin" : "agencieshq" })
+        #
+        # +env+: The environment name to use when generating the service. Defaults to the current Rails environment.
+        #     photo_info_service("carriers,1291,photo.png,1445445346", env: "production")
+        #
+        # +style+: The photo style, e.g. `:thumbnail`, `:original`, to request. Defaults to `:thumbnail`.
+        #     photo_info_service("carriers,1291,photo.png,1445445346", style: :original)
+        def photo_info_service(photo_info, application: Rails.application.class.name.deconstantize.underscore.dasherize, env: ::HasUtils::Env.current_environment, style: :thumbnail)
+          if photo_info
+            organization_id, resource_typish, resource_id, filename, unix_timestamp, photo_category = photo_info.split(/\s*,\s*/)
+            photo_category ||= :photos
+            if filename
+              application_name = application.respond_to?(:call) ? application.call(resource_typish, resource_id, filename, unix_timestamp) : application
+              "https://s3.amazonaws.com/#{ application_name }-#{ env }/#{ organization_id }/#{ photo_category }/#{ resource_typish }/#{ resource_id }/#{ style }#{ File.extname(filename) }?#{ unix_timestamp }".to_service
+            end
+          end
+        end
+
+        # Takes an IO wrapping image data and the image content type, and
+        # returns a Base64 inline image data URI (a String) for that image like:
+        #   data:img/png;base64,R0lGODlhyAAiAL...
+        # Note that io doesn't have to be an IO object; it just needs to support
+        # a read method that returns the image binary data.
+        def image_io_to_data_uri(io, content_type)
+          "data:#{ content_type };base64,#{ Rack::Utils.escape(Base64.strict_encode64(io.read)) }"
+        end
+      end
+
+      # Creates Global Search Group with Base Resources without saving it.
+      # It will be a default global search for all organizations
+      def create_default_search_group(organization_id)
+        search_group_name = "Global"
+        search_group = ::HasHelpers::ResourceGroup.new(organization_id: organization_id, name: search_group_name)
+        search_group_resource_array = []
+        ::HasHelpers::Resource.where(resource_type: ::HasHelpers::ResourceType::BASE).find_each do |rs|
+          search_group_resource = ::HasHelpers::OrganizationResource.new(
+            resource_group: search_group,
+            resource: rs
+          )
+          search_group_resource_array << search_group_resource
+        end
+        search_group.organization_resources = search_group_resource_array
+        search_group
+      end
+
+      included(self)
+    end
+  end
+end

data/lib/has_helpers/index/config.rb

@@ -0,0 +1,15 @@
+# typed: true
+# frozen_string_literal: true
+
+module HasHelpers
+  module Index
+    class Config < T::Struct
+      extend T::Sig
+      sig { params(block: T.proc.params(arg0: Symbol, arg1: Symbol).void).void }
+      prop :after_index, T.proc.params(arg0: Symbol, arg1: Symbol).void, default: proc { [] }
+      prop :filter_hidden_constants, T.proc.params(arg0: Symbol, arg1: Symbol).void, default: proc { nil }
+      sig { params(object: T.untyped).returns(T.nilable(Integer)) }
+      prop :before_index, T.nilable(T.proc.params(object: T.untyped).returns(T.nilable(Integer))), default: proc { nil }
+    end
+  end
+end

data/lib/has_helpers/lazy_config.rb

@@ -0,0 +1,61 @@
+# typed: false
+# frozen_string_literal: true
+
+module HasHelpers
+  class LazyConfig
+    INVALID_INIT_PARAMS_ERR_MSG = "Cannot give a LazyConfig both a file path and a block."
+    attr_reader :config_source
+
+    # LazyConfig can take two different kinds of arguments when you initialize it
+    # You can pass in a string which is the path to a YML file (which is
+    # organized by environment) - i.e., the typical YML config files we have
+    # been using. You can also give it a block that returns a hash of config
+    # properties. The purpose of the block usage is in case the config
+    # properties rely on classes or other data sources that might not be loaded
+    # at initializer time (so we can use a block to defer evaluation of the
+    # properties). Giving it both a string argument and a block will raise an
+    # error.
+    #
+    # Examples:
+    # SendGridConf = ::HasHelpers::LazyConfig.new(File.dirname(__FILE__) + "/../sendgrid.yml")
+    # - or -
+    # SomeConf = ::HasHelpers::LazyConfig.new do
+    #   { setting_1: "a", setting_2: ::SomeClass.foo }
+    # end
+    def initialize(config_location = nil, &block)
+      @config_source =
+        if block_given?
+          raise INVALID_INIT_PARAMS_ERR_MSG if config_location
+          block
+        else
+          config_location
+        end
+    end
+
+    def config
+      @config ||= begin
+                    conf_hash = if config_source.is_a?(Proc)
+                      config_source.call
+                    else
+                      raw_config = ERB.new(File.read(config_source)).result
+                      YAML.safe_load(
+                        raw_config,
+                        permitted_classes: [],
+                        permitted_symbols: [],
+                        aliases: true
+                      )[::HasUtils::Env.current_environment]
+                    end
+                    OpenStruct.new(conf_hash)
+                  end
+    end
+
+    def method_missing(method_name, *args, &block)
+      (class << self; self; end).class_eval do
+        define_method method_name do |*a, &b|
+          config.send(method_name, *a, &b)
+        end
+      end
+      send(method_name, *args, &block)
+    end
+  end
+end