tdiary 5.4.0 → 5.5.0.beta1

data/vendor/bundle/ruby/3.4.0/gems/logger-1.7.0/README.md

@@ -0,0 +1,104 @@
+# Logger
+
+Logger is a simple but powerful logging utility to output messages in your Ruby program.
+
+Logger has the following features:
+
+ * Print messages to different levels such as `info` and `error`
+ * Auto-rolling of log files
+ * Setting the format of log messages
+ * Specifying a program name in conjunction with the message
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'logger'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install logger
+
+## Usage
+
+### Simple Example
+
+```ruby
+require 'logger'
+
+# Create a Logger that prints to STDOUT
+log = Logger.new(STDOUT)
+log.debug("Created Logger")
+
+log.info("Program finished")
+
+# Create a Logger that prints to STDERR
+error_log = Logger.new(STDERR)
+error_log = error_log.error("fatal error")
+```
+
+## Development
+
+After checking out the repo, run the following to install dependencies.
+
+```
+$ bin/setup
+```
+
+Then, run the tests as:
+
+```
+$ rake test
+```
+
+To install this gem onto your local machine, run
+
+```
+$ rake install
+```
+
+To release a new version, update the version number in `lib/logger/version.rb`, and then run
+
+```
+$ rake release
+```
+
+which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Advanced Development
+
+### Run tests of a specific file
+
+```
+$ ruby test/logger/test_logger.rb
+```
+
+### Run tests filtering test methods by a name
+
+`--name` option is available as:
+
+```
+$ ruby test/logger/test_logger.rb --name test_lshift
+```
+
+### Publish documents to GitHub Pages
+
+```
+$ rake gh-pages
+```
+
+Then, git commit and push the generated HTMLs onto `gh-pages` branch.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/ruby/logger.
+
+## License
+
+The gem is available as open source under the terms of the [BSD-2-Clause](BSDL).

data/vendor/bundle/ruby/3.4.0/gems/logger-1.7.0/lib/logger/errors.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class Logger
+  # not used after 1.2.7. just for compat.
+  class Error < RuntimeError # :nodoc:
+  end
+  class ShiftingError < Error # :nodoc:
+  end
+end

data/vendor/bundle/ruby/3.4.0/gems/logger-1.7.0/lib/logger/formatter.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+class Logger
+  # Default formatter for log messages.
+  class Formatter
+    Format = "%.1s, [%s #%d] %5s -- %s: %s\n"
+    DatetimeFormat = "%Y-%m-%dT%H:%M:%S.%6N"
+
+    attr_accessor :datetime_format
+
+    def initialize
+      @datetime_format = nil
+    end
+
+    def call(severity, time, progname, msg)
+      sprintf(Format, severity, format_datetime(time), Process.pid, severity, progname, msg2str(msg))
+    end
+
+  private
+
+    def format_datetime(time)
+      time.strftime(@datetime_format || DatetimeFormat)
+    end
+
+    def msg2str(msg)
+      case msg
+      when ::String
+        msg
+      when ::Exception
+        "#{ msg.message } (#{ msg.class })\n#{ msg.backtrace.join("\n") if msg.backtrace }"
+      else
+        msg.inspect
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.4.0/gems/logger-1.7.0/lib/logger/log_device.rb

@@ -0,0 +1,265 @@
+# frozen_string_literal: true
+
+require_relative 'period'
+
+class Logger
+  # Device used for logging messages.
+  class LogDevice
+    include Period
+
+    attr_reader :dev
+    attr_reader :filename
+    include MonitorMixin
+
+    def initialize(
+      log = nil, shift_age: nil, shift_size: nil, shift_period_suffix: nil,
+      binmode: false, reraise_write_errors: [], skip_header: false
+    )
+      @dev = @filename = @shift_age = @shift_size = @shift_period_suffix = nil
+      @binmode = binmode
+      @reraise_write_errors = reraise_write_errors
+      @skip_header = skip_header
+      mon_initialize
+      set_dev(log)
+      set_file(shift_age, shift_size, shift_period_suffix) if @filename
+    end
+
+    def write(message)
+      handle_write_errors("writing") do
+        synchronize do
+          if @shift_age and @dev.respond_to?(:stat)
+            handle_write_errors("shifting") {check_shift_log}
+          end
+          handle_write_errors("writing") {@dev.write(message)}
+        end
+      end
+    end
+
+    def close
+      begin
+        synchronize do
+          @dev.close rescue nil
+        end
+      rescue Exception
+        @dev.close rescue nil
+      end
+    end
+
+    def reopen(log = nil, shift_age: nil, shift_size: nil, shift_period_suffix: nil, binmode: nil)
+      # reopen the same filename if no argument, do nothing for IO
+      log ||= @filename if @filename
+      @binmode = binmode unless binmode.nil?
+      if log
+        synchronize do
+          if @filename and @dev
+            @dev.close rescue nil # close only file opened by Logger
+            @filename = nil
+          end
+          set_dev(log)
+          set_file(shift_age, shift_size, shift_period_suffix) if @filename
+        end
+      end
+      self
+    end
+
+  private
+
+    # :stopdoc:
+
+    MODE = File::WRONLY | File::APPEND
+    # TruffleRuby < 24.2 does not have File::SHARE_DELETE
+    if File.const_defined? :SHARE_DELETE
+      MODE_TO_OPEN = MODE | File::SHARE_DELETE | File::BINARY
+    else
+      MODE_TO_OPEN = MODE | File::BINARY
+    end
+    MODE_TO_CREATE = MODE_TO_OPEN | File::CREAT | File::EXCL
+
+    def set_dev(log)
+      if log.respond_to?(:write) and log.respond_to?(:close)
+        @dev = log
+        if log.respond_to?(:path) and path = log.path
+          if File.exist?(path)
+            @filename = path
+          end
+        end
+      else
+        @dev = open_logfile(log)
+        @filename = log
+      end
+    end
+
+    def set_file(shift_age, shift_size, shift_period_suffix)
+      @shift_age = shift_age || @shift_age || 7
+      @shift_size = shift_size || @shift_size || 1048576
+      @shift_period_suffix = shift_period_suffix || @shift_period_suffix || '%Y%m%d'
+
+      unless @shift_age.is_a?(Integer)
+        base_time = @dev.respond_to?(:stat) ? @dev.stat.mtime : Time.now
+        @next_rotate_time = next_rotate_time(base_time, @shift_age)
+      end
+    end
+
+    if MODE_TO_OPEN == MODE
+      def fixup_mode(dev)
+        dev
+      end
+    else
+      def fixup_mode(dev)
+        return dev if @binmode
+        dev.autoclose = false
+        old_dev = dev
+        dev = File.new(dev.fileno, mode: MODE, path: dev.path)
+        old_dev.close
+        PathAttr.set_path(dev, filename) if defined?(PathAttr)
+        dev
+      end
+    end
+
+    def open_logfile(filename)
+      begin
+        dev = File.open(filename, MODE_TO_OPEN)
+      rescue Errno::ENOENT
+        create_logfile(filename)
+      else
+        dev = fixup_mode(dev)
+        dev.sync = true
+        dev.binmode if @binmode
+        dev
+      end
+    end
+
+    def create_logfile(filename)
+      begin
+        logdev = File.open(filename, MODE_TO_CREATE)
+        logdev.flock(File::LOCK_EX)
+        logdev = fixup_mode(logdev)
+        logdev.sync = true
+        logdev.binmode if @binmode
+        add_log_header(logdev) unless @skip_header
+        logdev.flock(File::LOCK_UN)
+        logdev
+      rescue Errno::EEXIST
+        # file is created by another process
+        open_logfile(filename)
+      end
+    end
+
+    def handle_write_errors(mesg)
+      yield
+    rescue *@reraise_write_errors
+      raise
+    rescue
+      warn("log #{mesg} failed. #{$!}")
+    end
+
+    def add_log_header(file)
+      file.write(
+        "# Logfile created on %s by %s\n" % [Time.now.to_s, Logger::ProgName]
+      ) if file.size == 0
+    end
+
+    def check_shift_log
+      if @shift_age.is_a?(Integer)
+        # Note: always returns false if '0'.
+        if @filename && (@shift_age > 0) && (@dev.stat.size > @shift_size)
+          lock_shift_log { shift_log_age }
+        end
+      else
+        now = Time.now
+        if now >= @next_rotate_time
+          @next_rotate_time = next_rotate_time(now, @shift_age)
+          lock_shift_log { shift_log_period(previous_period_end(now, @shift_age)) }
+        end
+      end
+    end
+
+    def lock_shift_log
+      retry_limit = 8
+      retry_sleep = 0.1
+      begin
+        File.open(@filename, MODE_TO_OPEN) do |lock|
+          lock.flock(File::LOCK_EX) # inter-process locking. will be unlocked at closing file
+          if File.identical?(@filename, lock) and File.identical?(lock, @dev)
+            yield # log shifting
+          else
+            # log shifted by another process (i-node before locking and i-node after locking are different)
+            @dev.close rescue nil
+            @dev = open_logfile(@filename)
+          end
+        end
+        true
+      rescue Errno::ENOENT
+        # @filename file would not exist right after #rename and before #create_logfile
+        if retry_limit <= 0
+          warn("log rotation inter-process lock failed. #{$!}")
+        else
+          sleep retry_sleep
+          retry_limit -= 1
+          retry_sleep *= 2
+          retry
+        end
+      end
+    rescue
+      warn("log rotation inter-process lock failed. #{$!}")
+    end
+
+    def shift_log_age
+      (@shift_age-3).downto(0) do |i|
+        if FileTest.exist?("#{@filename}.#{i}")
+          File.rename("#{@filename}.#{i}", "#{@filename}.#{i+1}")
+        end
+      end
+      shift_log_file("#{@filename}.0")
+    end
+
+    def shift_log_period(period_end)
+      suffix = period_end.strftime(@shift_period_suffix)
+      age_file = "#{@filename}.#{suffix}"
+      if FileTest.exist?(age_file)
+        # try to avoid filename crash caused by Timestamp change.
+        idx = 0
+        # .99 can be overridden; avoid too much file search with 'loop do'
+        while idx < 100
+          idx += 1
+          age_file = "#{@filename}.#{suffix}.#{idx}"
+          break unless FileTest.exist?(age_file)
+        end
+      end
+      shift_log_file(age_file)
+    end
+
+    def shift_log_file(shifted)
+      stat = @dev.stat
+      @dev.close rescue nil
+      File.rename(@filename, shifted)
+      @dev = create_logfile(@filename)
+      mode, uid, gid = stat.mode, stat.uid, stat.gid
+      begin
+        @dev.chmod(mode) if mode
+        mode = nil
+        @dev.chown(uid, gid)
+      rescue Errno::EPERM
+        if mode
+          # failed to chmod, probably nothing can do more.
+        elsif uid
+          uid = nil
+          retry # to change gid only
+        end
+      end
+      return true
+    end
+  end
+end
+
+File.open(__FILE__) do |f|
+  File.new(f.fileno, autoclose: false, path: "").path
+rescue IOError
+  module PathAttr               # :nodoc:
+    attr_reader :path
+
+    def self.set_path(file, path)
+      file.extend(self).instance_variable_set(:@path, path)
+    end
+  end
+end

data/vendor/bundle/ruby/3.4.0/gems/logger-1.7.0/lib/logger/period.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+class Logger
+  module Period
+    module_function
+
+    SiD = 24 * 60 * 60
+
+    def next_rotate_time(now, shift_age)
+      case shift_age
+      when 'daily', :daily
+        t = Time.mktime(now.year, now.month, now.mday) + SiD
+      when 'weekly', :weekly
+        t = Time.mktime(now.year, now.month, now.mday) + SiD * (7 - now.wday)
+      when 'monthly', :monthly
+        t = Time.mktime(now.year, now.month, 1) + SiD * 32
+        return Time.mktime(t.year, t.month, 1)
+      when 'now', 'everytime', :now, :everytime
+        return now
+      else
+        raise ArgumentError, "invalid :shift_age #{shift_age.inspect}, should be daily, weekly, monthly, or everytime"
+      end
+      if t.hour.nonzero? or t.min.nonzero? or t.sec.nonzero?
+        hour = t.hour
+        t = Time.mktime(t.year, t.month, t.mday)
+        t += SiD if hour > 12
+      end
+      t
+    end
+
+    def previous_period_end(now, shift_age)
+      case shift_age
+      when 'daily', :daily
+        t = Time.mktime(now.year, now.month, now.mday) - SiD / 2
+      when 'weekly', :weekly
+        t = Time.mktime(now.year, now.month, now.mday) - (SiD * now.wday + SiD / 2)
+      when 'monthly', :monthly
+        t = Time.mktime(now.year, now.month, 1) - SiD / 2
+      when 'now', 'everytime', :now, :everytime
+        return now
+      else
+        raise ArgumentError, "invalid :shift_age #{shift_age.inspect}, should be daily, weekly, monthly, or everytime"
+      end
+      Time.mktime(t.year, t.month, t.mday, 23, 59, 59)
+    end
+  end
+end

data/vendor/bundle/ruby/3.4.0/gems/logger-1.7.0/lib/logger/severity.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+class Logger
+  # Logging severity.
+  module Severity
+    # Low-level information, mostly for developers.
+    DEBUG = 0
+    # Generic (useful) information about system operation.
+    INFO = 1
+    # A warning.
+    WARN = 2
+    # A handleable error condition.
+    ERROR = 3
+    # An unhandleable error that results in a program crash.
+    FATAL = 4
+    # An unknown message that should always be logged.
+    UNKNOWN = 5
+
+    LEVELS = {
+      "debug" => DEBUG,
+      "info" => INFO,
+      "warn" => WARN,
+      "error" => ERROR,
+      "fatal" => FATAL,
+      "unknown" => UNKNOWN,
+    }
+    private_constant :LEVELS
+
+    def self.coerce(severity)
+      if severity.is_a?(Integer)
+        severity
+      else
+        key = severity.to_s.downcase
+        LEVELS[key] || raise(ArgumentError, "invalid log level: #{severity}")
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.4.0/gems/logger-1.7.0/lib/logger/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class Logger
+  VERSION = "1.7.0"
+end