incline 0.1.5

data/lib/incline/extensions/active_record_base.rb

@@ -0,0 +1,308 @@
+require 'active_record'
+
+module Incline::Extensions
+  module ActiveRecordBase
+
+    def to_s # :nodoc:
+      if respond_to?(:name)
+        send :name
+      else
+        "ID = #{id}"
+      end
+    end
+
+    def inspect # :nodoc:
+      "#<#{self.class}:#{self.object_pointer} #{to_s}>"
+    end
+
+    ##
+    # Tests for equality on ID if available.
+    def ==(other)
+      if self.class.attribute_names.include?('id')
+        if other.is_a?(::Numeric)
+          id == other
+        elsif other.class == self.class
+          id == other.id
+        else
+          false
+        end
+      else
+        self.inspect == other.inspect
+      end
+    end
+
+    ##
+    # Compares by code, name, or to_s depending on if the code or name attributes are present.
+    def <=>(other)
+      m = self.class.default_sort_method
+      my_val = send(m)
+
+      # other can be a string or a model of the same type as this model.
+      other_val =
+          if other.is_a?(::String)
+            other
+          elsif other.class == self.class
+            other.send(m)
+          else
+            nil
+          end
+
+      my_val <=> other_val
+    end
+
+    ##
+    # Additional static methods for the ActiveRecord::Base class.
+    module ClassMethods
+
+      ##
+      # Gets the default sort method for this model.
+      #
+      # In order of preference this will be 'code', 'name', or 'to_s'.
+      #
+      # Specifying a search_attribute before using this method will change this behavior.
+      #
+      #     class MyModel
+      #       attr_accessor :id, :name, :employee_id
+      #     end
+      #     MyModel.default_sort_method   # 'name'
+      #
+      #     class MyModel
+      #       attr_accessor :id, :name, :employee_id
+      #       search_attribute :employee_id
+      #     end
+      #     MyModel.default_sort_method   # 'employee_id'
+      def default_sort_method
+        @default_sort_method ||= search_attributes.find{|a| attribute_names.include?(a)} || 'to_s'
+      end
+
+      ##
+      # Specifies an attribute to search in the get_id, get, and [] methods.
+      #
+      # The default attributes to search are 'code' and 'name'.  If you specify
+      # an additional attribute it will be prefixed to the list.  This affects
+      # sorting behavior, but not necessarily the search behavior since if the 'code'
+      # or 'name' attributes are also present, they will be searched as well.
+      #
+      #     class MyModel
+      #       attr_accessor :id, :name, :employee_id
+      #       search_attribute :employee_id
+      #     end
+      def search_attribute(attrib)
+        unless attrib.blank?
+          attrib = attrib.to_s.strip
+          search_attributes.insert(0, attrib) unless search_attributes.include?(attrib)
+        end
+      end
+
+      ##
+      # Gets the ID(s) based on the specified value.
+      #
+      # If a valid model is provided, then the :id attribute is returned.
+      #
+      # An integer simply gets returned.  No validation is done to ensure it is a valid ID.
+      # A string representing an integer gets converted and returned.  No validation is done.
+      #     get_id(1234) => 1234
+      #     get_id('1234') => 1234
+      #
+      # All further searches are against lowercased :code or :name attributes if either is a valid attribute.
+      # You can use the search_attribute method to add another attribute to compare against.
+      #
+      # A symbol is converted to a string and a humanized string.
+      #     get_id(:one_two_three) => searches for 'one_two_three' or 'one two three'.
+      #
+      # Strings are lowercased and compared against lowercased :code or :name if either of those is a valid attribute.
+      #     get_id('Alpha Bravo') => searches for 'alpha bravo'
+      #
+      # If a string begins with a # and contains only numbers after that, then it will allow you to search for a
+      # non-ID field that only contains numbers.  The value is searched as both the supplied value and only the numeric
+      # digits.
+      #
+      #     get_id('#1234') => searches for '#1234' or '1234'
+      #
+      # Arrays are mapped as above.
+      #
+      # In all cases, if one result is found that value is returned, if more than one is found then an array is returned,
+      # and if no results are found, nil is returned.  If the model does not include an :id attributes, then nil will
+      # always be returned because there can be no valid results.
+      #
+      #     # Assuming this data set:
+      #     #   ID   |  NAME
+      #     # -------|--------------------
+      #     #   1    |  Juliet
+      #     #   2    |  Romeo
+      #     #   3    |  4321
+      #     #   4    |  1234
+      #
+      #     get_id(1,3,5,7,'Romeo','#1234') # returns [ 1, 3, 5, 7, 2, 4 ]
+      #     # 1, 3, 5, & 7 are not verified, but :name is searched for "romeo", "#1234", and "1234" to add 2 & 4.
+      #
+      #     get_id('#4321') # returns 3 since there is only one valid result.
+      #
+      def get_id(*value)
+        return nil if value.blank?
+        return nil unless attribute_names.include?('id')
+
+        value = value.first if value.count == 1
+
+        return value.map{|v| get_id(v)} if value.is_a?(::Array)
+
+        return value.id if value.class == self
+        return value if value.is_a?(::Integer)
+        return value.to_i if value.to_s =~ /\A\d+\z/
+
+        result = search_for(value).order(:id).pluck(:id).to_a
+
+        return nil if result.blank?
+        return result.first if result.count == 1
+
+        result
+      end
+
+      ##
+      # Gets one or more items based on the value.
+      #
+      # Always returns an array of items or nil if no results were found.
+      #
+      # See #get_id for how the value is processed.  The only difference is
+      # numeric IDs must be valid for the models to be returned.
+      #
+      #     # Assuming this data set:
+      #     #   ID   |  NAME
+      #     # -------|--------------------
+      #     #   1    |  Juliet
+      #     #   2    |  Romeo
+      #     #   3    |  4321
+      #     #   4    |  1234
+      #
+      #     get(5)        # returns nil
+      #     get(1,3,5,7)  # returns [ { 1 => Juliet }, { 3 => 4321 } ]
+      #     get('Romeo')  # returns [ { 2 => Romeo } ]
+      #     get('#1234')  # returns [ { 4 => 1234 } ]
+      #
+      def get(*value)
+        return nil if value.blank?
+
+        value = value.first if value.count == 1
+
+        return value if value.class == self
+
+        result = search_for(value)
+        first_sort = search_attributes.find{|a| attribute_names.include?(a)}
+        if first_sort
+          result = result.order(first_sort, :id)
+        else
+          result = result.order(:id)
+        end
+        result = result.to_a
+        return nil if result.blank?
+        result
+      end
+
+      ##
+      # Gets one item based on the value.
+      #
+      # Always returns the first item found or nil if there were no matches.
+      #
+      # See #get_id for how the value is processed.  The only difference is
+      # numeric IDs must be valid for the model to be returned.
+      #
+      #     # Assuming this data set:
+      #     #   ID   |  NAME
+      #     # -------|--------------------
+      #     #   1    |  Juliet
+      #     #   2    |  Romeo
+      #     #   3    |  4321
+      #     #   4    |  1234
+      #
+      #     [5]           # returns nil
+      #     [1,3,5,7]     # returns { 1 => Juliet }
+      #     ['Romeo']     # returns { 2 => Romeo }
+      #     ['#1234']     # returns { 4 => 1234 }
+      #
+      def [](*value)
+        get(*value)&.first
+      end
+
+      private
+
+      def search_attributes
+        @search_attributes ||= %w(code name)
+      end
+
+      def search_for(values)
+        # make sure we have an array that we can safely modify.
+        values = values.is_a?(::Array) ? values.dup : [ values ]
+        values.reject!{|v| v.blank?}
+        values.flatten!
+
+        # return a query that will return no records.
+        return self.where('(1 = 0)') if values.blank?
+
+        # extract potential IDs.
+        ids =       values
+                        .select{|v| !v.is_a?(::Symbol) && v.to_s =~ /\A\d+\z/}
+                        .map{|v| v.to_i}
+
+        # convert models to IDs to force reloading them.
+        ids +=      values
+                        .select{|v| v.class == self}
+                        .map{|v| v.id}
+
+        # only unique IDs are kept.
+        ids.uniq!
+
+        # and then extract string/symbol values for further searching.
+        # purely numeric values and blank values are discarded.
+        values =    values
+                        .select{|v| (v.is_a?(::String) && !v.blank? && !(v =~ /\A\d+\z/)) || (v.is_a?(::Symbol) && !v.to_s.blank?)}
+                        .map{|v| (v.is_a?(::String) && v =~ /\A#\d+\z/) ? [ v, v[1..-1] ] : v}
+                        .map{|v| v.is_a?(::Symbol) ? [ v.to_s.downcase, v.to_s.humanize.downcase ] : v.to_s.humanize.downcase}
+                        .flatten
+
+        # only unique values are kept.
+        values.uniq!
+
+        # get the attributes to search.
+        attribs =   search_attributes
+                        .select{|attr| attribute_names.include?(attr)}
+                        .map{|a| a.to_s.gsub("'", "''").gsub('"','""') }
+
+        # do a sanity check.
+        raise 'No valid values to search for.' if ids.blank? && values.blank?
+        raise 'No ID attribute to search.' unless ids.blank? || attribute_names.include?('id')
+        raise 'No attributes to search.' unless values.blank? || attribs.any?
+
+        filters = []
+        filter_values = []
+        tbl = table_name.to_s.gsub("'", "''").gsub('"','""')
+
+        # include the ID filters.
+        ids.each do |id|
+          filters << "(\"#{tbl}\".\"id\" = ?)"
+          filter_values << id
+        end
+
+        # include the value filters.
+        values.each do |value|
+          attribs.each do |attr|
+            filters << "(LOWER(\"#{tbl}\".\"#{attr}\") = ?)"
+            filter_values << value
+          end
+        end
+
+        filters = filters.join(' OR ')
+
+        self.where(filters, *filter_values)
+      end
+
+    end
+
+    def self.included(base)
+      base.class_eval do
+        extend ClassMethods
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.include Incline::Extensions::ActiveRecordBase

data/lib/incline/extensions/application.rb

@@ -0,0 +1,137 @@
+require 'cgi/util'
+require 'yaml'
+require 'fileutils'
+require 'rails'
+
+module Incline::Extensions
+  ##
+  # Adds some informational methods to the Application class.
+  module Application
+
+    ##
+    # Is the rails server running?
+    def running?
+      path = File.join(Rails.root, 'tmp/pids/server.pid')
+      pid = File.exist?(path) ? File.read(path).to_i : -1
+      server_running = true
+      begin
+        Process.getpgid pid
+      rescue Errno::ESRCH
+        server_running = false
+      end
+      server_running
+    end
+
+    ##
+    # Gets the application name.
+    #
+    # You should override this method in your +application.rb+ file to return the appropriate value.
+    def app_name
+      default_notify :app_name
+      'Incline'
+    end
+
+    ##
+    # Gets the application instance name.
+    #
+    # This can be set by creating a +config/instance.yml+ configuration file and setting the 'name' property.
+    # The instance name is used to create unique cookies for each instance of an application.
+    # The default instance name is 'default'.
+    def app_instance_name
+      @app_instance_name ||=
+          begin
+            yaml = Rails.root.join('config','instance.yml')
+            if File.exist?(yaml)
+              yaml = (YAML.load_file(yaml) || {}).symbolize_keys
+              yaml[:name].blank? ? 'default' : yaml[:name]
+            else
+              'default'
+            end
+          end
+    end
+
+    ##
+    # Gets the application version.
+    #
+    # You should override this method in your +application.rb+ file to return the appropriate value.
+    def app_version
+      default_notify :app_version
+      '0.0.1'
+    end
+
+    ##
+    # Gets the company owning the copyright to the application.
+    #
+    # You should override this method in your +application.rb+ file to return the appropriate value.
+    def app_company
+      default_notify :app_company
+      'BarkerEST'
+    end
+
+    ##
+    # Gets the year of copyright ownership for the company.
+    #
+    # Defaults to the current year (at the time of execution).
+    def app_copyright_year
+      Time.now.year.to_s
+    end
+
+    ##
+    # Gets the application name and version.
+    def app_info
+      "#{app_name} v#{app_version}"
+    end
+
+    ##
+    # Gets the copyright statement for this application.
+    def app_copyright(html = true)
+      if html
+        "Copyright © #{CGI::escapeHTML app_copyright_year} #{CGI::escapeHTML app_company}".html_safe
+      else
+        "Copyright (C) #{app_copyright_year} #{app_company}"
+      end
+    end
+
+    ##
+    # Is a restart currently pending.
+    def restart_pending?
+      return false unless File.exist?(restart_file)
+      request_time = File.mtime(restart_file)
+      request_time > Incline.start_time
+    end
+
+    ##
+    # Updates the restart file to indicate we want to restart the web app.
+    def request_restart!
+      Incline::Log::info 'Requesting an application restart.'
+      FileUtils.touch restart_file
+      File.mtime restart_file
+    end
+
+    ##
+    # Generates a cookie name using the application name and instance name.
+    def cookie_name(cookie)
+      "_incline_#{app_name.downcase.scan(/[a-z0-9]+/).join('_')}_#{app_instance_name.downcase.scan(/[a-z0-9]+/).join('_')}_#{cookie}"
+    end
+
+
+    private
+
+    def default_notify(property)
+      @default_notify ||= {}
+      @default_notify[property] ||= 0
+      if @default_notify[property] == 0
+        @default_notify[property] = 1
+        Incline::Log::warn "Default \"#{property}\" is in use.  Please define \"#{property}\" in your \"application.rb\" file."
+      end
+    end
+
+    def restart_file
+      @restart_file ||= "#{self.config.root}/tmp/restart.txt"
+    end
+
+  end
+
+end
+
+Rails::Application.include Incline::Extensions::Application

data/lib/incline/extensions/application_configuration.rb

@@ -0,0 +1,50 @@
+require 'rails'
+
+module Incline::Extensions
+  ##
+  # Creates a default database configuration to use when config/database.yml is not present.
+  module ApplicationConfiguration
+
+    ##
+    # Override the +database_configuration+ method to return something in development mode if
+    # the +config/database.yml+ file is missing.
+    #
+    # A warning will be logged if the default configuration is used.  In production mode, an
+    # exception will be bubbled up.
+    #
+    # The default configuration for test and development environments is to use a sqlite
+    # database in the db folder using the environment name (eg - db/development.sqlite).
+    #
+    # The primary purpose of this is to allow +rake+ and +rails+ actions that may not depend on the
+    # database configuration or may actually be used to generate the configuration file.
+    def self.included(base) #:nodoc:
+      base.class_eval do
+        alias :incline_appconfig_original_database_configuration :database_configuration
+
+        def database_configuration
+          begin
+            incline_appconfig_original_database_configuration
+          rescue
+            raise unless $!.inspect.include?('No such file -') && (!Rails.env.production?)
+
+            default = {
+                'adapter' => 'sqlite3',
+                'pool' => 5,
+                'timeout' => 5000
+            }
+
+            Incline::Log::warn "Providing default database configuration for #{Rails.env} environment."
+
+            {
+                'test' => default.merge('database' => 'db/test.sqlite'),
+                'development' => default.merge('database' => 'db/development.sqlite')
+            }
+          end
+        end
+      end
+    end
+
+  end
+end
+
+Rails::Application::Configuration.include Incline::Extensions::ApplicationConfiguration

data/lib/incline/extensions/connection_adapter.rb

@@ -0,0 +1,55 @@
+require 'active_record'
+
+module Incline::Extensions
+  ##
+  # Adds some extra functionality to database connections.
+  module ConnectionAdapter
+
+    ##
+    # Searches the database to determine if an object with the specified name exists.
+    def object_exists?(object_name)
+      safe_name = "'#{object_name.gsub('\'','\'\'')}'"
+
+      sql =
+          case self.class.name
+            when 'ActiveRecord::ConnectionAdapters::SQLServerAdapter'
+              # use sysobjects table.
+              "SELECT COUNT(*) AS \"one\" FROM \"sysobjects\" WHERE \"name\"=#{safe_name}"
+            when 'ActiveRecord::ConnectionAdapters::SQLite3Adapter'
+              # use sqlite_master table.
+              "SELECT COUNT(*) AS \"one\" FROM \"sqlite_master\" WHERE (\"type\"='table' OR \"type\"='view') AND (\"name\"=#{safe_name})"
+            else
+              # query the information_schema TABLES and ROUTINES views.
+              "SELECT SUM(Z.\"one\") AS \"one\" FROM (SELECT COUNT(*) AS \"one\" FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME=#{safe_name} UNION SELECT COUNT(*) AS \"one\" FROM INFORMATION_SCHEMA.ROUTINES WHERE ROUTINE_NAME=#{safe_name}) AS Z"
+          end
+
+      result = exec_query(sql).first
+
+      result && result['one'] >= 1
+    end
+
+    ##
+    # Executes a stored procedure.
+    #
+    # For MS SQL Server, this will return the return value from the procedure.
+    # For other providers, this is the same as +execute+.
+    def exec_sp(stmt)
+      case self.class.name
+        when 'ActiveRecord::ConnectionAdapters::SQLServerAdapter'
+          rex = /^exec(?:ute)?\s+[\["]?(?<PROC>[a-z][a-z0-9_]*)[\]"]?(?<ARGS>\s.*)?$/i
+          match = rex.match(stmt)
+          if match
+            exec_query("DECLARE @SP__RET INTEGER; EXECUTE @SP__RET=[#{match['PROC']}]#{match['ARGS']}; SELECT @SP__RET AS [RET]").first['RET']
+          else
+            execute stmt
+          end
+        else
+          execute stmt
+      end
+    end
+
+
+  end
+end
+
+ActiveRecord::ConnectionAdapters::AbstractAdapter.include Incline::Extensions::ConnectionAdapter

data/lib/incline/extensions/date_time_value.rb

@@ -0,0 +1,123 @@
+require 'incline/date_time_formats'
+require 'incline/extensions/time_zone_converter'
+require 'active_record'
+
+module Incline::Extensions
+
+  ##
+  # Patches the ActiveRecord DateTime value to accept more date formats.
+  #
+  # Specifically this will allow ActiveRecord models to receive dates in US format or ISO format.
+  module DateTimeValue
+
+    ##
+    # Patches the ActiveRecord DateTime value type.
+    def self.included(base)
+      base.class_eval do
+
+        private
+
+        undef cast_value
+
+        def cast_value(string)
+          return nil if string.blank?
+          return string if string.is_a?(::Time)
+
+          if string.is_a?(::String)
+
+            begin
+              # if it matches either of our formats, we can try using it.
+              if (match = (Incline::DateTimeFormats::US_DATE_FORMAT.match(string) || Incline::DateTimeFormats::ALMOST_ISO_DATE_FORMAT.match(string)))
+
+                year = match['YEAR'].to_s.to_i
+                year += 2000 if year < 50
+                year += 1900 if year < 100
+                month = match['MONTH'].to_s.to_i
+                mday = match['DAY'].to_s.to_i
+
+                # ensure the date portion is valid.
+                dt =
+                    begin
+                      Time.utc(year, month, mday)
+                    rescue
+                      raise "Invalid date (#{$!.message})."
+                    end
+
+                raise 'Invalid date (day of month is invalid for month).' unless dt.year == year && dt.month == month && dt.mday == mday
+
+                hour = match['HOUR'].to_s.to_i
+                minute = match['MINUTE'].to_s.to_i
+                second = match['SECOND'].to_s.to_i
+
+                # make sure the fraction is 6 chars in length, then convert to microseconds.
+                micros = match['FRACTION'].to_s[0...6].ljust(6,'0').to_i
+
+                if match.names.include?('AMPM')
+                  if match['AMPM'].to_s.upcase == 'P' && hour < 12
+                    hour += 12
+                  elsif match['AMPM'].to_s.upcase == 'A' && hour == 12
+                    hour = 0
+                  end
+                end
+
+                raise 'Invalid time (hour must be 0 to 24).' unless (0..24) === hour
+                raise 'Invalid time (minute must be 0 to 59).' unless (0...60) === minute
+                raise 'Invalid time (second must be 0 to 59).' unless (0...60) === second
+                raise 'Invalid time (minute and second must be 0 if hour is 24).' if hour == 24 && (minute != 0 || second != 0)
+
+                if hour == 24
+                  dt += 86400
+                  year = dt.year
+                  month = dt.month
+                  mday = dt.mday
+                  hour = 0
+                end
+
+                # compute the tz offset in seconds.
+                offset =
+                    if match.names.include?('TZ')
+                      if match['TZ']
+                        tz = match['TZ'].to_s.gsub(':','').upcase
+                        if %w(Z +0000 -0000).include?(tz)
+                          0
+                        else
+                          (tz[0] == '-' ? -1 : 1) * ((tz[1..2].to_i * 3600) + (tz[3..4].to_i * 60))
+                        end
+                      else
+                        nil
+                      end
+                    else
+                      nil
+                    end
+
+                # use the new_time method to honor the ActiveRecord::Base.default_timezone
+                new_time(year, month, mday, hour, minute, second, micros, offset)
+              else
+                # use the fallback if it doesn't match our formats.
+                fallback_string_to_time(string)
+              end
+            rescue
+              Incline::Log::warn "Failed to parse #{string.inspect}: #{$!.message}"
+              nil
+            end
+
+          elsif string.respond_to?(:to_time)
+            begin
+              string.to_time
+            rescue
+              Incline::Log::warn "Failed to convert #{string.inspect} to time: #{$!.message}"
+              nil
+            end
+          else
+            nil
+          end
+        end
+      end
+    end
+
+  end
+
+end
+
+ActiveRecord::Type::DateTime.include Incline::Extensions::DateTimeValue
+