incline 0.1.5

data/lib/incline/extensions/time_zone_converter.rb

@@ -0,0 +1,40 @@
+require 'active_record'
+
+module Incline::Extensions
+  ##
+  # Patches the TimeZoneConverter to call super.
+  module TimeZoneConverter
+
+    ##
+    # Patches the TimeZoneConverter to call super.
+    def self.included(base)
+      base.class_eval do
+
+        undef type_cast_from_user
+
+        def type_cast_from_user(value)
+          if value.is_a?(::Array)
+            value.map { |v| type_cast_from_user(v) }
+          else
+            # Convert to time first.
+            value = super
+
+            # Then convert the time zone if necessary.
+            if value.respond_to?(:in_time_zone)
+              begin
+                value.in_time_zone
+              rescue ArgumentError
+                nil
+              end
+            else
+              nil
+            end
+          end
+        end
+      end
+    end
+
+  end
+end
+
+ActiveRecord::AttributeMethods::TimeZoneConversion::TimeZoneConverter.include Incline::Extensions::TimeZoneConverter

data/lib/incline/global_status.rb

@@ -0,0 +1,236 @@
+module Incline
+  ##
+  # An interface to a global status/lock file.
+  #
+  # The global status/lock file is a simple two line file.
+  # The first line is the global status message.
+  # The second line is the global status progress.
+  #
+  # The real magic comes when we take advantage of exclusive locks.
+  # The process that will be managing the status takes an exclusive lock on the status/lock file.
+  # This prevents any other process from taking an exclusive lock.
+  # It does not prevent other processes from reading from the file.
+  #
+  # So the main process can update the file at any time, until it releases the lock.
+  # The other processes can read the file at any time, and test for the lock state to determine if the main
+  # process is still busy.
+  #
+  #
+  class GlobalStatus
+
+    ##
+    # Creates a new GlobalStatus object.
+    def initialize
+      @handle = nil
+    end
+
+    ##
+    # Gets the path to the global status/lock file.
+    def status_file_path
+      @status_file_path ||= WorkPath.path_for('global_lock')
+    end
+
+    ##
+    # Determines if this instance has a lock on the status/lock file.
+    def have_lock?
+      !!@handle
+    end
+
+    ##
+    # Determines if any process has a lock on the status/lock file.
+    def is_locked?
+      return true if have_lock?
+      begin
+        return true unless acquire_lock
+      ensure
+        release_lock
+      end
+      false
+    end
+
+    ##
+    # Gets the current status message from the status/lock file.
+    def get_message
+      get_status[:message]
+    end
+
+    ##
+    # Gets the current progress from the status/lock file.
+    def get_percentage
+      r = get_status[:percent]
+      r.blank? ? nil : r.to_i
+    end
+
+    ##
+    # Gets the current status from the status/lock file.
+    #
+    # Returns a hash with three elements:
+    #
+    # message::
+    #   The current status message.
+    #
+    # percent::
+    #   The current status progress.
+    #
+    # locked::
+    #   The current lock state of the status/lock file. (true for locked, false for unlocked)
+    #
+    def get_status
+      r = {}
+      if have_lock?
+        @handle.rewind
+        r[:message] = (@handle.eof? ? 'The current process is busy.' : @handle.readline.strip)
+        r[:percent] = (@handle.eof? ? '' : @handle.readline.strip)
+        r[:locked] = true
+      elsif is_locked?
+        if File.exist?(status_file_path)
+          begin
+            File.open(status_file_path, 'r') do |f|
+              r[:message] = (f.eof? ? 'The system is busy.' : f.readline.strip)
+              r[:percent] = (f.eof? ? '' : f.readline.strip)
+            end
+          rescue
+            r[:message] = 'The system appears busy.'
+            r[:percent] = ''
+          end
+        else
+          r[:message] = 'No status file.'
+          r[:percent] = ''
+        end
+        r[:locked] = true
+      else
+        r[:message] = 'The system is no longer busy.'
+        r[:percent] = '-'
+        r[:locked] = false
+      end
+      r
+    end
+
+    ##
+    # Sets the status message if this instance has a lock on the status/lock file.
+    #
+    # Returns true after successfully setting the message.
+    # Returns false if this instance does not currently hold the lock.
+    #
+    def set_message(value)
+      return false unless have_lock?
+      cur = get_status
+      set_status(value, cur[:percent])
+    end
+
+    ##
+    # Sets the status progress if this instance has a lock on the status/lock file.
+    #
+    # Returns true after successfully setting the progress.
+    # Returns false if this instance does not currently hold the lock.
+    #
+    def set_percentage(value)
+      return false unless have_lock?
+      cur = get_status
+      set_status(cur[:message], value)
+    end
+
+    ##
+    # Sets the status message and progress if this instance has a lock on the status/lock file.
+    #
+    # Returns true after successfully setting the status.
+    # Returns false if this instance does not currently hold the lock.
+    #
+    def set_status(message, percentage)
+      return false unless have_lock?
+      @handle.rewind
+      @handle.truncate 0
+      @handle.write(message.to_s.strip + "\n")
+      @handle.write(percentage.to_s.strip + "\n")
+      @handle.flush
+      true
+    end
+
+    ##
+    # Releases the lock on the status/lock file if this instance holds the lock.
+    #
+    # Returns true.
+    #
+    def release_lock
+      return true unless @handle
+      set_message ''
+      @handle.flock(File::LOCK_UN)
+      @handle.close
+      @handle = nil
+      true
+    end
+
+    ##
+    # Acquires the lock on the status/lock file.
+    #
+    # Returns true on success or if this instance already holds the lock.
+    # Returns false if another process holds the lock.
+    #
+    def acquire_lock
+      return true if @handle
+      begin
+        @handle = File.open(status_file_path, File::RDWR | File::CREAT)
+        raise StandardError.new('Already locked') unless @handle.flock(File::LOCK_EX | File::LOCK_NB)
+        @handle.rewind
+        @handle.truncate 0
+      rescue
+        if @handle
+          @handle.flock(File::LOCK_UN)
+          @handle.close
+        end
+        @handle = nil
+      end
+      !!@handle
+    end
+
+    ##
+    # Determines if any process currently holds the lock on the status/lock file.
+    #
+    # Returns true if the file is locked, otherwise returns false.
+    #
+    def self.locked?
+      global_instance.is_locked?
+    end
+
+    ##
+    # Gets the current status from the status/lock file.
+    #
+    # See #get_status for a description of the returned hash.
+    #
+    def self.current
+      global_instance.get_status
+    end
+
+    ##
+    # Runs the provided block with a lock on the status/lock file.
+    #
+    # If a lock can be acquired, a GlobalStatus object is yielded to the block.
+    # The lock will automatically be released when the block exits.
+    #
+    # If a lock cannot be acquire, then false is yielded to the block.
+    # The block needs to test for this case to ensure that the appropriate
+    # error handling is performed.
+    #
+    def self.lock_for(&block)
+      return unless block_given?
+      status = GlobalStatus.new
+      if status.acquire_lock
+        begin
+          yield status
+        ensure
+          status.release_lock
+        end
+      else
+        yield false
+      end
+    end
+
+    private
+
+    def self.global_instance
+      @global_instance ||= GlobalStatus.new
+    end
+
+  end
+end
+

data/lib/incline/helpers/route_hash_formatter.rb

@@ -0,0 +1,46 @@
+module Incline::Helpers
+  ##
+  # A "formatter" that simply collects formatted route data.
+  class RouteHashFormatter
+
+    ##
+    # Creates a new hash formatter for the route inspector.
+    def initialize
+      @buffer = []
+      @engine = ''
+    end
+
+    ##
+    # Gets the resulting hash from the route inspector.
+    def result
+      @buffer
+    end
+
+    ##
+    # Analyzes the section title to get the current engine name.
+    def section_title(title)
+      @engine = title.include?(' ') ? title.rpartition(' ')[2] : title
+    end
+
+    ##
+    # Does nothing for this formatter.
+    def header(routes)
+      # no need for a header
+    end
+
+    ##
+    # Does nothing for this formatter.
+    def no_routes
+      # no need to do anything here either.
+    end
+
+    ##
+    # Adds the specified routes to the resulting hash.
+    def section(routes)
+      routes.each do |r|
+        @buffer << r.symbolize_keys.merge(engine: @engine)
+      end
+    end
+
+  end
+end

data/lib/incline/json_log_formatter.rb

@@ -0,0 +1,96 @@
+require 'logger'
+
+module Incline
+  ##
+  # A log formatter that writes entries in JSON format (each line is a valid JSON object).
+  class JsonLogFormatter < ::Logger::Formatter
+
+    ##
+    # Regular expressions used to auto-classify any matching message as a debug message.
+    AUTO_DEBUG_PATTERNS = [
+        /^rendered\s/i,
+        /started\sget\s"\/assets/i
+    ]
+
+    ##
+    # Overrides the default formatter behavior to log a JSON line.
+    def call(sev, time, _, msg) #:nodoc:
+      level = ({
+          Logger::DEBUG   => 'DEBUG',
+          Logger::INFO    => 'INFO',
+          Logger::WARN    => 'WARN',
+          Logger::ERROR   => 'ERROR',
+          Logger::FATAL   => 'FATAL',
+      }[sev] || sev.to_s).upcase
+
+      if msg.present? && AUTO_DEBUG_PATTERNS.find{|pattern| msg =~ pattern}
+        return '' if debug_skip?
+        level = 'DEBUG'
+      end
+
+      if msg.present?
+        # And we'll expand exceptions so we get as much info as possible.
+        # If you just want the message, make sure you just pass the message.
+        if msg.is_a?(::Exception)
+          msg = "#{msg.message} (#{msg.class})\n#{(msg.backtrace || []).join("\n")}"
+        elsif !msg.is_a?(::String)
+          msg = msg.inspect
+        end
+
+        msg = rm_fmt msg
+
+        {
+            level: level,
+            time: time.strftime('%Y-%m-%d %H:%M:%S'),
+            message: msg,
+            app_name: app_name,
+            app_version: app_version,
+            process_id: Process.pid,
+        }.to_json + "\r\n"
+      else
+        ''
+      end
+    end
+
+    private
+
+    def app_name
+      if Object.const_defined?(:Rails)
+        Rails&.application&.app_name || 'Unknown'
+      else
+        'Unknown'
+      end
+    end
+
+    def app_version
+      if Object.const_defined?(:Rails)
+        Rails&.application&.app_version || '0.0.0'
+      else
+        '0.0.0'
+      end
+    end
+
+    def debug_skip?
+      if Object.const_defined?(:Rails)
+        (Rails&.logger&.level).to_s.to_i > 0
+      else
+        false
+      end
+    end
+
+    def rm_fmt(msg)
+      msg
+          .gsub(/\e\[(\d+;?)*[ABCDEFGHfu]/, "\n")   #   any of the "set cursor position" CSI commands.
+          .gsub(/\e\[=?(\d+;?)*[A-Za-z]/,'')        #   \e[#;#;#A or \e[=#;#;#A  basically all the CSI commands except ...
+          .gsub(/\e\[(\d+;"[^"]+";?)+p/, '')        #   \e[#;"A"p
+          .gsub(/\e[NOc]./,'?')                     #   any of the alternate character set commands.
+          .gsub(/\e[P_\]^X][^\e\a]*(\a|(\e\\))/,'') #   any string command
+          .gsub(/[\x00\x08\x0B\x0C\x0E-\x1F]/, '')  #   any non-printable characters (notice \x0A (LF) and \x0D (CR) are left as is).
+          .gsub("\t", ' ')                          #   turn tabs into spaces.
+          .gsub("\r\n", "\n")                       #   all CRLF to LF
+          .gsub("\r", "\n")                         #   all CR to LF
+          .strip                                    #   remove trailing and leading whitespace
+    end
+
+  end
+end

data/lib/incline/json_logger.rb

@@ -0,0 +1,17 @@
+require 'active_support/logger'
+require 'incline/json_log_formatter'
+
+module Incline
+  ##
+  # Overrides the default formatter for the base logger.
+  class JsonLogger < ::ActiveSupport::Logger
+  
+    ##
+    # Sets the formatter to Incline::JsonLogFormatter.
+    def initialize(*args)
+      super
+      @formatter = ::Incline::JsonLogFormatter.new
+    end
+    
+  end
+end

data/lib/incline/log.rb

@@ -0,0 +1,153 @@
+require 'ansi/code'
+
+module Incline
+  ##
+  # A logging wrapper to tag log messages with location information.
+  class Log
+
+    ##
+    # Logs a debug message.
+    def self.debug(msg = nil, &block)
+      safe_log :debug, msg, &block
+    end
+
+    ##
+    # Logs an info message.
+    def self.info(msg = nil, &block)
+      safe_log :info, msg, &block
+    end
+
+    ##
+    # Logs a warning message.
+    def self.warn(msg = nil, &block)
+      safe_log :warn, msg, &block
+    end
+
+    ##
+    # Logs an error message.
+    def self.error(msg = nil, &block)
+      safe_log :error, msg, &block
+    end
+
+    ##
+    # Gets a list of paths that are considered root paths for logging purposes.
+    def self.root_paths
+      @root_paths ||=
+          begin
+            [
+                Rails.root.to_s,
+                File.expand_path('../../../', __FILE__)
+            ]
+                .map{|v| v[-1] == '/' ? v : "#{v}/"}
+          end
+    end
+
+    ##
+    # Set output to go to a file.
+    #
+    # If a +file+ is specified, it will be used for output.  This will bypass Rails logging.
+    # If +file+ is set to false or nil then the default logging behavior will be used.
+    def self.set_output(file)
+      if file
+        if file.respond_to?(:puts)
+          @output = file
+          @rails = nil
+        elsif file.is_a?(::String)
+          @output = File.open(file, 'wt')
+          @rails = nil
+        else
+          raise ArgumentError, 'The file parameter must be an IO-like object, a string path, or a false value.'
+        end
+      else
+        # reset behavior
+        remove_instance_variable(:@output) if instance_variable_defined?(:@output)
+        remove_instance_variable(:@rails) if instance_variable_defined?(:@rails)
+      end
+    end
+
+    ##
+    # Gets the current logging output.
+    def self.get_output
+      rails&.logger || output
+    end
+
+    private
+
+    def self.output
+      # always returns something.
+      (instance_variable_defined?(:@output) ? instance_variable_get(:@output) : $stderr) || $stderr
+    end
+
+    def self.skip?(level)
+      filt_level = (log_level || 0)
+      if filt_level > 0
+        return true if level == :debug
+        return true if level == :info && filt_level > 1
+        return true if level == :warn && filt_level > 2
+      end
+      false
+    end
+
+    def self.rails
+      unless instance_variable_defined?(:@rails)
+        @rails = Object.const_defined?(:Rails) ? Object.const_get(:Rails) : nil
+      end
+      @rails
+    end
+
+    def self.log_level
+      rails&.logger&.level
+    end
+
+    def self.safe_log(level, msg)
+      return '' if skip?(level)
+
+      # by allowing a block, we can defer message processing and skip it altogether when the level is being silenced.
+      msg = yield if block_given?
+
+      c = caller_locations(2,1)[0]
+      c = "#{relative_path(c.path)}:#{c.lineno}:in `#{c.base_label}`"
+      msg = "[#{c}] #{msg_to_str(msg)}"
+
+      if rails&.logger
+        rails.logger.send level, msg
+      else
+        level = case level
+                  when :error
+                    ANSI.ansi level.to_s.upcase, :bright, :red
+                  when :warn
+                    ANSI.ansi level.to_s.upcase, :yellow
+                  when :info
+                    ANSI.ansi level.to_s.upcase, :bright, :white
+                  else
+                    level.to_s.upcase
+                end
+
+        output.puts "#{level}: #{msg}"
+      end
+
+      msg
+    end
+
+    def self.relative_path(path)
+      path = path.to_s
+      root_paths.each do |rp|
+        if path[rp]
+          return path[rp.length..-1]
+        end
+      end
+      path
+    end
+
+    def self.msg_to_str(msg)
+      if msg.is_a?(::Exception)
+        "#{msg.message} (#{msg.class})\n#{(msg.backtrace || []).join("\n")}"
+      elsif msg.is_a?(::String)
+        msg
+      else
+        msg.inspect
+      end
+    end
+
+  end
+end

data/lib/incline/number_formats.rb

@@ -0,0 +1,17 @@
+module Incline
+  module NumberFormats
+
+    ##
+    # Verifies a number with comma delimiters included.
+    #
+    # 1,234,567.89e0
+    WITH_DELIMITERS = /\A[+-]?(0|[1-9][0-9]{0,2}(,[0-9]{3})*)(\.[0-9]*)?(e\d+)?\z/i
+
+    ##
+    # Verifies a number without comma delimiters included.
+    #
+    # 1234567.89e0
+    WITHOUT_DELIMITERS = /\A[+-]?([0-9]+)(\.[0-9]*)?(e\d+)?\z/i
+
+  end
+end