barkest_core 1.5.3.0

data/lib/barkest_core/concerns/association_with_defaults.rb

@@ -0,0 +1,55 @@
+module BarkestCore
+
+  ##
+  # This module allows you to define defaults for a model's associations.
+  #
+  # While models can be setup with static defaults, this allows you to
+  # provide dynamic defaults.  You must define the +association_defaults+ method
+  # within the association block for it to work though.  This method should process
+  # the attributes in whatever way it needs.  In the example below, we would actually
+  # want to look for +org+ and +access+ attributes before overriding the +org_id+ and
+  # +access_id+ attributes.
+  #
+  # This method will override the +new+, +build+, +create+, and +create!+ methods
+  # of the association to ensure the dynamic defaults are processed properly.
+  #
+  #     class User
+  #       ...
+  #       has_many :accesses, ->{ extending BarkestCore::AssociationWithDefaults } do
+  #         def association_defaults(attributes = {})
+  #           {
+  #             org_id: proxy_association.owner.current_organization.id,
+  #             access_id: Access.default.id
+  #           }.merge(attributes || {})
+  #         end
+  #       end
+  #       ...
+  #     end
+  #
+  module AssociationWithDefaults
+    #  def association_defaults(attributes = {})
+    #   attributes[:some_value] ||= some_default
+    #   attributes
+    #  end
+
+    def new(attributes = {})
+      super association_defaults(attributes)
+    end
+
+    def build(*args)
+      args << {} if args.blank?
+      args = args.map { |a| a.is_a?(Hash) ? association_defaults(a) : a }
+      super(*args)
+    end
+
+    def create(attributes = {})
+      super association_defaults(attributes)
+    end
+
+    def create!(attributes = {})
+      super association_defaults(attributes)
+    end
+  end
+end
+
+

data/lib/barkest_core/concerns/boolean_parser.rb

@@ -0,0 +1,88 @@
+module BarkestCore
+  ##
+  # This module will add boolean parsing functions to a class.
+  #
+  module BooleanParser
+
+    ##
+    # Parses for a 3-way boolean.
+    #
+    # If the value is nil, then nil is returned.
+    # If the value is 'true', 'yes', 'on', '1', 't', or 'y' then true is returned.
+    # Otherwise false is returned.
+    #
+    def self.parse_for_boolean_column(value)
+      return nil if value.to_s.blank?
+      value = value.to_s.downcase
+      %w(true yes on 1 -1 t y).include? value
+    end
+
+    ##
+    # Parses the value for a 3-way SQL filter.
+    #
+    # If the value is nil, then 'NULL' is returned.
+    # If the value parses to true, then '1' is returned.
+    # Otherwise '0' is returned.
+    #
+    def self.parse_for_boolean_filter(value)
+      value = parse_for_boolean_column(value)
+      return 'NULL' if value.nil?
+      value ? '1' : '0'
+    end
+
+    # :nodoc:
+    def self.included(base)
+      base.class_eval do
+
+        ##
+        # Parses for a 3-way boolean.
+        #
+        # If the value is nil, then nil is returned.
+        # If the value is 'true', 'yes', 'on', '1', 't', or 'y' then true is returned.
+        # Otherwise false is returned.
+        #
+        def self.parse_for_boolean_column(value)
+          BarkestCore::BooleanParser.parse_for_boolean_column value
+        end
+
+        ##
+        # Parses the value for a 3-way SQL filter.
+        #
+        # If the value is nil, then 'NULL' is returned.
+        # If the value parses to true, then '1' is returned.
+        # Otherwise '0' is returned.
+        #
+        def self.parse_for_boolean_filter(value)
+          BarkestCore::BooleanParser.parse_for_boolean_filter value
+        end
+
+      end
+    end
+
+
+    protected
+
+    ##
+    # Parses for a 3-way boolean.
+    #
+    # If the value is nil, then nil is returned.
+    # If the value is 'true', 'yes', 'on', '1', 't', or 'y' then true is returned.
+    # Otherwise false is returned.
+    #
+    def parse_for_boolean_column(value)
+      BarkestCore::BooleanParser.parse_for_boolean_column value
+    end
+
+    ##
+    # Parses the value for a 3-way SQL filter.
+    #
+    # If the value is nil, then 'NULL' is returned.
+    # If the value parses to true, then '1' is returned.
+    # Otherwise '0' is returned.
+    #
+    def parse_for_boolean_filter(value)
+      BarkestCore::BooleanParser.parse_for_boolean_filter value
+    end
+
+  end
+end

data/lib/barkest_core/concerns/date_parser.rb

@@ -0,0 +1,181 @@
+module BarkestCore
+  ##
+  # This module will add consistent date parsing functions to a class.
+  #
+  module DateParser
+
+    ##
+    # A regular expression to parse either American format MM/DD/YYYY or ISO format YYYY-MM-DD dates.
+    DATE_REGEX = /^(?:(?<M>\d{1,2})\/(?<D>\d{1,2})\/(?<Y>\d{2,4})|(?<Y>\d{2,4})-(?<M>\d{1,2})-(?<D>\d{1,2}))(?:\s.*)?$/
+
+    ##
+    # A regular expression to parse either American format MM/DD/YYYY or ISO format YYYY-MM-DD dates, but also allows for a blank value.
+    NULLABLE_DATE_REGEX = /^(?:(?:(?<M>\d{1,2})\/(?<D>\d{1,2})\/(?<Y>\d{2,4})|(?<Y>\d{2,4})-(?<M>\d{1,2})-(?<D>\d{1,2}))(?:\s.*)?)?$/
+
+    ##
+    # A regular expression to parse either American format MM/DD/YYY HH:MM:SS or ISO format YYYY-MM-DD HH:MM:SS times.
+    TIME_REGEX = /^(?:(?:(?<M>\d{1,2})\/(?<D>\d{1,2})\/(?<Y>\d{2,4})|(?<Y>\d{2,4})-(?<M>\d{1,2})-(?<D>\d{1,2}))\s+)?(?:(?<H>\d{1,2})\:(?<N>\d{1,2})(?:\:(?<S>\d{1,2}))?)(?:\s+(?<T>AM|PM).*)?$/i
+
+    ##
+    # A regular expression to parse either American format MM/DD/YYY HH:MM:SS or ISO format YYYY-MM-DD HH:MM:SS times, but also allows for a blank value.
+    NULLABLE_TIME_REGEX = /^(?:(?:(?:(?<M>\d{1,2})\/(?<D>\d{1,2})\/(?<Y>\d{2,4})|(?<Y>\d{2,4})-(?<M>\d{1,2})-(?<D>\d{1,2}))\s+)?(?:(?<H>\d{1,2})\:(?<N>\d{1,2})(?:\:(?<S>\d{1,2}))?)(?:\s+(?<T>AM|PM).*)?)?$/i
+
+    ##
+    # A simple hash that can be used to validate a date entry column.
+    #
+    # validates :my_date, :format => DATE_FORMAT
+    #
+    DATE_FORMAT = { with: DATE_REGEX, multiline: true, message: 'must be in MM/DD/YYYY or YYYY-MM-DD format' }
+
+    ##
+    # A simple hash that can be used to validate a nullable date entry column.
+    #
+    # validates :my_date, :format => NULLABLE_DATE_FORMAT
+    #
+    NULLABLE_DATE_FORMAT = { with: NULLABLE_DATE_REGEX, multiline: true, message: 'must be in MM/DD/YYYY or YYYY-MM-DD format' }
+
+
+    private_constant :DATE_REGEX, :TIME_REGEX, :NULLABLE_DATE_REGEX, :NULLABLE_TIME_REGEX
+
+    ##
+    # Parses a value for storage in a date/datetime column.
+    #
+    # Value should be a string in 'M/D/YYYY' or 'YYYY-MM-DD' format but can also be a Date or Time object.
+    #
+    # Returns a Time object or nil if value is invalid.
+    #
+    def self.parse_for_date_column(value)
+      Time.utc_parse(value).date rescue nil
+    end
+
+    ##
+    # Parses a value for storage in a datetime column.
+    #
+    # Value should be a string in 'M/D/YYYY HH:MM:SS' or 'YYYY-MM-DD HH:MM:SS' format, but can also be a Date or Time object.
+    #
+    # Returns a Time object or nil if value is invalid.
+    #
+    def self.parse_for_time_column(value)
+      Time.utc_parse(value) rescue nil
+    end
+
+    ##
+    # Parses a value for use in a SQL query.
+    #
+    # Returns NULL if the parsed date is nil.
+    # Otherwise returns the date in 'YYYY-MM-DD' format.
+    #
+    def self.parse_for_date_filter(value)
+      value = parse_for_date_column(value)
+      return 'NULL' unless value
+      value.strftime('\'%Y-%m-%d\'')
+    end
+
+    ##
+    # Parses a value for use in a SQL query.
+    #
+    # Returns NULL if the parsed time is nil.
+    # Otherwise returns the time in 'YYYY-MM-DD HH:MM:SS' format.
+    #
+    def self.parse_for_time_filter(value)
+      value = parse_for_time_column(value)
+      return 'NULL' unless value
+      value.strftime('\'%Y-%m-%d %H:%M:%S\'')
+    end
+
+    # :nodoc:
+    def self.included(base)
+      base.class_eval do
+
+        ##
+        # Parses a value for storage in a date/datetime column.
+        #
+        # Value should be a string in 'M/D/YYYY' or 'YYYY-MM-DD' format but can also be a Date or Time object.
+        #
+        # Returns a Time object or nil if value is invalid.
+        #
+        def self.parse_for_date_column(value)
+          BarkestCore::DateParser.parse_for_date_column value
+        end
+
+        ##
+        # Parses a value for storage in a datetime column.
+        #
+        # Value should be a string in 'M/D/YYYY HH:MM:SS' or 'YYYY-MM-DD HH:MM:SS' format, but can also be a Date or Time object.
+        #
+        # Returns a Time object or nil if value is invalid.
+        #
+        def self.parse_for_time_column(value)
+          BarkestCore::DateParser.parse_for_time_column value
+        end
+
+        ##
+        # Parses a value for use in a SQL query.
+        #
+        # Returns NULL if the parsed date is nil.
+        # Otherwise returns the date in 'YYYY-MM-DD' format.
+        #
+        def self.parse_for_date_filter(value)
+          BarkestCore::DateParser.parse_for_date_filter value
+        end
+
+        ##
+        # Parses a value for use in a SQL query.
+        #
+        # Returns NULL if the parsed time is nil.
+        # Otherwise returns the time in 'YYYY-MM-DD HH:MM:SS' format.
+        #
+        def self.parse_for_time_filter(value)
+          BarkestCore::DateParser.parse_for_time_filter value
+        end
+
+      end
+    end
+
+
+    protected
+
+    ##
+    # Parses a value for storage in a date/datetime column.
+    #
+    # Value should be a string in 'M/D/YYYY' or 'YYYY-MM-DD' format but can also be a Date or Time object.
+    #
+    # Returns a Time object or nil if value is invalid.
+    #
+    def parse_for_date_column(value)
+      BarkestCore::DateParser.parse_for_date_column value
+    end
+
+    ##
+    # Parses a value for storage in a datetime column.
+    #
+    # Value should be a string in 'M/D/YYYY HH:MM:SS' or 'YYYY-MM-DD HH:MM:SS' format, but can also be a Date or Time object.
+    #
+    # Returns a Time object or nil if value is invalid.
+    #
+    def parse_for_time_column(value)
+      BarkestCore::DateParser.parse_for_time_column value
+    end
+
+    ##
+    # Parses a value for use in a SQL query.
+    #
+    # Returns NULL if the parsed date is nil.
+    # Otherwise returns the date in 'YYYY-MM-DD' format.
+    #
+    def parse_for_date_filter(value)
+      BarkestCore::DateParser.parse_for_date_filter value
+    end
+
+    ##
+    # Parses a value for use in a SQL query.
+    #
+    # Returns NULL if the parsed time is nil.
+    # Otherwise returns the time in 'YYYY-MM-DD HH:MM:SS' format.
+    #
+    def parse_for_time_filter(value)
+      BarkestCore::DateParser.parse_for_time_filter value
+    end
+
+  end
+end

data/lib/barkest_core/concerns/email_tester.rb

@@ -0,0 +1,55 @@
+require 'resolv'
+
+module BarkestCore
+
+  ##
+  # Adds helper methods to the model to allow verifying email addresses.
+  module EmailTester
+
+    ##
+    # A regex that can be used to verify most email addresses.
+    #
+    # When used, the match will include a USER and DOMAIN element to represent the broken down email address.
+    VALID_EMAIL_REGEX = /\A(?<USER>[\w+\-.]+)@(?<DOMAIN>[a-z\d\-]+(\.[a-z\d\-]+)*\.[a-z]+)\z/i
+
+
+    ##
+    # Validates the supplied email address against the VALID_EMAIL_REGEX.
+    #
+    # The +check_dns+ option ensures that an MX record can be found for the email address.
+    def self.valid_email?(email, check_dns = false)
+      match = VALID_EMAIL_REGEX.match(email)
+      return false unless match
+      if check_dns
+        return false if Resolv::DNS.open{ |dns| dns.getresources match['DOMAIN'], Resolv::DNS::Resource::IN::MX }.blank?
+      end
+      true
+    end
+
+    # :nodoc:
+    def self.included(base)
+      base.class_eval do
+        ##
+        # Validates the supplied email address against the VALID_EMAIL_REGEX.
+        #
+        # The +check_dns+ option ensures that an MX record can be found for the email address.
+        def self.valid_email?(email, check_dns = false)
+          BarkestCore::EmailTester.valid_email? email, check_dns
+        end
+
+      end
+    end
+
+    protected
+
+    ##
+    # Validates the supplied email address against the VALID_EMAIL_REGEX.
+    #
+    # The +check_dns+ option ensures that an MX record can be found for the email address.
+    def valid_email?(email, check_dns = false)
+      BarkestCore::EmailTester.valid_email? email, check_dns
+    end
+
+
+  end
+end

data/lib/barkest_core/concerns/encrypted_fields.rb

@@ -0,0 +1,156 @@
+require 'encrypted_strings'
+
+module BarkestCore
+
+  ##
+  # Adds helper methods to the model to allow easy manipulation of fields stored as encrypted values.
+  #
+  # The encryption password is specified in +secrets.yml+.
+  #
+  # For a class MyNamespace::MyClass you can specify the encryption password using +my_namespace_my_class+
+  # or +my_class+ keys in the appropriate section of +secrets.yml+.
+  #
+  # If no specific encryption password is provided, then +secret_key_base+ is used instead.
+  #
+  module EncryptedFields
+
+    # :nodoc:
+    def self.included(base)
+      base.class_eval do
+
+        private
+
+        def self.crypto_password
+          @crypto_password ||=
+              begin
+                klass = self.class.name.to_s.underscore
+                if klass.include?('/')
+                  Rails.application.secrets[klass.gsub('/','_').to_sym] ||
+                      Rails.application.secrets[klass.rpartition('/')[2].to_sym] ||
+                      Rails.application.secrets[:secret_key_base]
+                else
+                  Rails.application.secrets[klass.to_sym] ||
+                      Rails.application.secrets[:secret_key_base]
+                end
+              end
+        end
+
+        def self.crypto_cipher
+          @crypto_cipher ||= EncryptedStrings::SymmetricCipher.new(password: crypto_password)
+        end
+
+        def self.decrypt_value(value)
+          return nil if value.nil?
+          return '' if value == ''
+          crypto_cipher.decrypt(value)
+        end
+
+        public
+
+        ##
+        # Encrypts a value using this model's key.
+        #
+        # Will not encrypt nil or empty strings.
+        def self.encrypt_value(value)
+          return nil if value.nil?
+          return '' if value == ''
+          crypto_cipher.encrypt(value)
+        end
+
+        protected
+
+        ##
+        # Defines methods to allow accessing an encrypted field easily.
+        #
+        # Simplest usage:
+        #   encrypted_field :encrypted_field_name
+        #
+        # Detailed usage:
+        #   encrypted_field :encrypted => :encrypted_field_name,
+        #       :decrypted => :field_name,
+        #       :read_only => false
+        #
+        # In both usages, the model will receive two new methods:
+        #   def field_name
+        #     ...
+        #   end
+        #
+        #   def field_name=(value)
+        #     ...
+        #   end
+        #
+        # If you specify :read_only => true, then only one method will be defined:
+        #   def field_name
+        #     ...
+        #   end
+        #
+        # Raises a StandardError if the attribute names cannot be determined or if the
+        # encrypted attribute is not defined.
+        #
+        def self.encrypted_field(options = {})
+          unless options.is_a?(Hash)
+            attr_name = options.to_s
+            if attr_name[0...10] == 'encrypted_' ||
+                attr_name[0...4] == 'enc_' ||
+                attr_name[-4..-1] == '_enc' ||
+                attr_name[-10..-1] == '_encrypted'
+              options = {
+                  encrypted: attr_name
+              }
+            else
+              options = {
+                  decrypted: attr_name
+              }
+            end
+          end
+
+          raise StandardError.new('Options must contain either :decrypted or :encrypted key.') if options[:encrypted].blank? && options[:decrypted].blank?
+
+          if options[:encrypted].blank?
+            attr_name = options[:decrypted]
+            %W(encrypted_#{attr_name} enc_#{attr_name} #{attr_name}_enc #{attr_name}_encrypted).each do |attr|
+              if method_defined?(attr) || columns.find{|a| a.name == attr}
+                options[:encrypted] = attr
+              end
+            end
+          elsif options[:decrypted].blank?
+            attr_name = options[:encrypted]
+            if attr_name[0...10] == 'encrypted_' || attr_name[0...4] == 'enc_'
+              options[:decrypted] = attr_name.partition('_')[2]
+            elsif attr_name[-4..-1] == '_enc' || attr_name[-10..-1] == '_encrypted'
+              options[:decrypted] = attr_name.rpartition('_')[0]
+            end
+          end
+
+          raise StandardError.new("Cannot locate encrypted attribute with #{options[:decrypted]} as the decypted attribute name.") if options[:encrypted].blank?
+          raise StandardError.new("Cannot determine decrypted attribute name with #{options[:encrypted]} as the encrypted attribute.") if options[:decrypted].blank?
+
+          define_method options[:decrypted].to_sym do
+            self.class.decrypt_value send(options[:encrypted])
+          end
+
+          unless options[:read_only]
+            define_method :"#{options[:decrypted]}=" do |value|
+              send "#{options[:encrypted]}=", self.class.encrypt_value(value)
+            end
+          end
+
+        end
+
+        ##
+        # Encrypts a value and returns the result in base64 encoding.
+        def encrypt(value)
+          self.class.encrypt_value(value)
+        end
+
+        ##
+        # Decodes a base64 value and returns the decrypted value.
+        def decrypt(value)
+          self.class.decrypt_value(value)
+        end
+
+      end
+    end
+
+  end
+end