tdiary 5.4.0 → 5.5.0.beta1

data/vendor/bundle/ruby/3.4.0/gems/fastimage-2.4.1/lib/fastimage/fastimage.rb

@@ -0,0 +1,471 @@
+require_relative 'fastimage_parsing/image_base'
+require_relative 'fastimage_parsing/stream_util'
+
+require_relative 'fastimage_parsing/avif'
+require_relative 'fastimage_parsing/bmp'
+require_relative 'fastimage_parsing/exif'
+require_relative 'fastimage_parsing/fiber_stream'
+require_relative 'fastimage_parsing/gif'
+require_relative 'fastimage_parsing/heic'
+require_relative 'fastimage_parsing/ico'
+require_relative 'fastimage_parsing/iso_bmff'
+require_relative 'fastimage_parsing/jpeg'
+require_relative 'fastimage_parsing/jxl'
+require_relative 'fastimage_parsing/jxlc'
+require_relative 'fastimage_parsing/png'
+require_relative 'fastimage_parsing/psd'
+require_relative 'fastimage_parsing/svg'
+require_relative 'fastimage_parsing/tiff'
+require_relative 'fastimage_parsing/type_parser'
+require_relative 'fastimage_parsing/webp'
+
+class FastImage
+  include FastImageParsing
+
+  attr_reader :bytes_read
+
+  class FastImageException < StandardError # :nodoc:
+  end
+  class UnknownImageType < FastImageException # :nodoc:
+  end
+  class ImageFetchFailure < FastImageException # :nodoc:
+  end
+  class SizeNotFound < FastImageException # :nodoc:
+  end
+  class CannotParseImage < FastImageException # :nodoc:
+  end
+  class BadImageURI < FastImageException # :nodoc:
+  end
+
+  DefaultTimeout = 2 unless const_defined?(:DefaultTimeout)
+
+  LocalFileChunkSize = 256 unless const_defined?(:LocalFileChunkSize)
+
+  private
+
+  Parsers = {
+    :bmp => Bmp,
+    :gif => Gif,
+    :jpeg => Jpeg,
+    :png => Png,
+    :tiff => Tiff,
+    :psd => Psd,
+    :heic => Heic,
+    :heif => Heic,
+    :webp => Webp,
+    :svg => Svg,
+    :ico => Ico,
+    :cur => Ico,
+    :jxl => Jxl,
+    :avif => Avif
+  }.freeze
+
+  public
+
+  SUPPORTED_IMAGE_TYPES = Parsers.keys.freeze
+  
+  # Returns an array containing the width and height of the image.
+  # It will return nil if the image could not be fetched, or if the image type was not recognised.
+  #
+  # By default there is a timeout of 2 seconds for opening and reading from a remote server.
+  # This can be changed by passing a :timeout => number_of_seconds in the options.
+  #
+  # If you wish FastImage to raise if it cannot size the image for any reason, then pass
+  # :raise_on_failure => true in the options.
+  #
+  # FastImage knows about GIF, JPEG, BMP, TIFF, ICO, CUR, PNG, HEIC/HEIF, AVIF, PSD, SVG, WEBP and JXL files.
+  #
+  # === Example
+  #
+  #   require 'fastimage'
+  #
+  #   FastImage.size("https://switchstep.com/images/ios.gif")
+  #   => [196, 283]
+  #   FastImage.size("http://switchstep.com/images/ss_logo.png")
+  #   => [300, 300]
+  #   FastImage.size("https://upload.wikimedia.org/wikipedia/commons/0/09/Jpeg_thumb_artifacts_test.jpg")
+  #   => [1280, 800]
+  #   FastImage.size("https://eeweb.engineering.nyu.edu/~yao/EL5123/image/lena_gray.bmp")
+  #   => [512, 512]
+  #   FastImage.size("test/fixtures/test.jpg")
+  #   => [882, 470]
+  #   FastImage.size("http://switchstep.com/does_not_exist")
+  #   => nil
+  #   FastImage.size("http://switchstep.com/does_not_exist", :raise_on_failure=>true)
+  #   => raises FastImage::ImageFetchFailure
+  #   FastImage.size("http://switchstep.com/images/favicon.ico", :raise_on_failure=>true)
+  #   => [16, 16]
+  #   FastImage.size("http://switchstep.com/foo.ics", :raise_on_failure=>true)
+  #   => raises FastImage::UnknownImageType
+  #   FastImage.size("http://switchstep.com/images/favicon.ico", :raise_on_failure=>true, :timeout=>0.01)
+  #   => raises FastImage::ImageFetchFailure
+  #   FastImage.size("http://switchstep.com/images/faulty.jpg", :raise_on_failure=>true)
+  #   => raises FastImage::SizeNotFound
+  #
+  # === Supported options
+  # [:timeout]
+  #   Overrides the default timeout of 2 seconds.  Applies both to reading from and opening the http connection.
+  # [:raise_on_failure]
+  #   If set to true causes an exception to be raised if the image size cannot be found for any reason.
+  #
+  def self.size(uri, options={})
+    new(uri, options).size
+  end
+
+  # Returns an symbol indicating the image type fetched from a uri.
+  # It will return nil if the image could not be fetched, or if the image type was not recognised.
+  #
+  # By default there is a timeout of 2 seconds for opening and reading from a remote server.
+  # This can be changed by passing a :timeout => number_of_seconds in the options.
+  #
+  # If you wish FastImage to raise if it cannot find the type of the image for any reason, then pass
+  # :raise_on_failure => true in the options.
+  #
+  # === Example
+  #
+  #   require 'fastimage'
+  #
+  #   FastImage.type("https://switchstep.com/images/ios.gif")
+  #   => :gif
+  #   FastImage.type("http://switchstep.com/images/ss_logo.png")
+  #   => :png
+  #   FastImage.type("https://upload.wikimedia.org/wikipedia/commons/0/09/Jpeg_thumb_artifacts_test.jpg")
+  #   => :jpeg
+  #   FastImage.type("https://eeweb.engineering.nyu.edu/~yao/EL5123/image/lena_gray.bmp")
+  #   => :bmp
+  #   FastImage.type("test/fixtures/test.jpg")
+  #   => :jpeg
+  #   FastImage.type("http://switchstep.com/does_not_exist")
+  #   => nil
+  #   File.open("/some/local/file.gif", "r") {|io| FastImage.type(io)}
+  #   => :gif
+  #   FastImage.type("test/fixtures/test.tiff")
+  #   => :tiff
+  #   FastImage.type("test/fixtures/test.psd")
+  #   => :psd
+  #
+  # === Supported options
+  # [:timeout]
+  #   Overrides the default timeout of 2 seconds.  Applies both to reading from and opening the http connection.
+  # [:raise_on_failure]
+  #   If set to true causes an exception to be raised if the image type cannot be found for any reason.
+  #
+  def self.type(uri, options={})
+    new(uri, options).type
+  end
+
+  # Returns a boolean value indicating the image is animated.
+  # It will return nil if the image could not be fetched, or if the image type was not recognised.
+  #
+  # By default there is a timeout of 2 seconds for opening and reading from a remote server.
+  # This can be changed by passing a :timeout => number_of_seconds in the options.
+  #
+  # If you wish FastImage to raise if it cannot find the type of the image for any reason, then pass
+  # :raise_on_failure => true in the options.
+  #
+  # === Example
+  #
+  #   require 'fastimage'
+  #
+  #   FastImage.animated?("test/fixtures/test.gif")
+  #   => false
+  #   FastImage.animated?("test/fixtures/animated.gif")
+  #   => true
+  #
+  # === Supported options
+  # [:timeout]
+  #   Overrides the default timeout of 2 seconds.  Applies both to reading from and opening the http connection.
+  # [:raise_on_failure]
+  #   If set to true causes an exception to be raised if the image type cannot be found for any reason.
+  #
+  def self.animated?(uri, options={})
+    new(uri, options).animated
+  end
+  
+  def initialize(uri, options={})
+    @uri = uri
+    @options = {
+      :timeout          => DefaultTimeout,
+      :raise_on_failure => false,
+      :proxy            => nil,
+      :http_header      => {}
+    }.merge(options)
+  end
+
+  def type
+    @property = :type
+    fetch unless defined?(@type)
+    @type
+  end
+
+  def size
+    @property = :size
+    begin
+      fetch unless defined?(@size)
+    rescue CannotParseImage
+    end
+
+    raise SizeNotFound if @options[:raise_on_failure] && !@size
+
+    @size
+  end
+
+  def orientation
+    size unless defined?(@size)
+    @orientation ||= 1 if @size
+  end
+
+  def width
+    size && @size[0]
+  end
+
+  def height
+    size && @size[1]
+  end
+
+  def animated
+    @property = :animated
+    fetch unless defined?(@animated)
+    @animated
+  end
+  
+  def content_length
+    @property = :content_length
+    fetch unless defined?(@content_length)
+    @content_length
+  end
+
+  # find an appropriate method to fetch the image according to the passed parameter
+  def fetch
+    raise BadImageURI if @uri.nil?
+
+    if @uri.respond_to?(:read)
+      fetch_using_read(@uri)
+    elsif @uri.start_with?('data:')
+      fetch_using_base64(@uri)
+    else
+      begin
+        @parsed_uri = URI.parse(@uri)
+      rescue URI::InvalidURIError
+        fetch_using_file_open
+      else
+        if @parsed_uri.scheme == "http" || @parsed_uri.scheme == "https"
+          fetch_using_http
+        else
+          fetch_using_file_open
+        end
+      end
+    end
+
+    raise SizeNotFound if @options[:raise_on_failure] && @property == :size && !@size
+
+  rescue Timeout::Error, SocketError, Errno::ECONNREFUSED, Errno::EHOSTUNREACH, Errno::ECONNRESET,
+    Errno::ENETUNREACH, ImageFetchFailure, Net::HTTPBadResponse, EOFError, Errno::ENOENT,
+    OpenSSL::SSL::SSLError
+    raise ImageFetchFailure if @options[:raise_on_failure]
+  rescue UnknownImageType, BadImageURI, CannotParseImage
+    raise if @options[:raise_on_failure]
+  
+  ensure
+    @uri.rewind if @uri.respond_to?(:rewind)
+
+  end
+
+  private
+
+  def fetch_using_http
+    @redirect_count = 0
+
+    fetch_using_http_from_parsed_uri
+  end
+
+  # Some invalid locations need escaping
+  def escaped_location(location)
+    begin
+      URI(location)
+    rescue URI::InvalidURIError
+      ::URI::DEFAULT_PARSER.escape(location)
+    else
+      location
+    end
+  end
+
+  def fetch_using_http_from_parsed_uri
+    raise ImageFetchFailure unless @parsed_uri.is_a?(URI::HTTP)
+
+    http_header = {'Accept-Encoding' => 'identity'}.merge(@options[:http_header])
+
+    setup_http
+    @http.request_get(@parsed_uri.request_uri, http_header) do |res|
+      if res.is_a?(Net::HTTPRedirection) && @redirect_count < 4
+        @redirect_count += 1
+        begin
+          location = res['Location']
+          raise ImageFetchFailure if location.nil? || location.empty?
+
+          @parsed_uri = URI.join(@parsed_uri, escaped_location(location))
+        rescue URI::InvalidURIError
+        else
+          fetch_using_http_from_parsed_uri
+          break
+        end
+      end
+
+      raise ImageFetchFailure unless res.is_a?(Net::HTTPSuccess)
+
+      @content_length = res.content_length
+      break if @property == :content_length
+
+      read_fiber = Fiber.new do
+        res.read_body do |str|
+          Fiber.yield str
+        end
+        nil
+      end
+
+      case res['content-encoding']
+      when 'deflate', 'gzip', 'x-gzip'
+        begin
+          gzip = Zlib::GzipReader.new(FiberStream.new(read_fiber))
+        rescue FiberError, Zlib::GzipFile::Error
+          raise CannotParseImage
+        end
+
+        read_fiber = Fiber.new do
+          while data = gzip.readline
+            Fiber.yield data
+          end
+          nil
+        end
+      end
+
+      parse_packets FiberStream.new(read_fiber)
+
+      break  # needed to actively quit out of the fetch
+    end
+  end
+
+  def protocol_relative_url?(url)
+    url.start_with?("//")
+  end
+
+  def proxy_uri
+    begin
+      if @options[:proxy]
+        proxy = URI.parse(@options[:proxy])
+      else
+        proxy = ENV['http_proxy'] && ENV['http_proxy'] != "" ? URI.parse(ENV['http_proxy']) : nil
+      end
+    rescue URI::InvalidURIError
+      proxy = nil
+    end
+    proxy
+  end
+
+  def setup_http
+    proxy = proxy_uri
+
+    if proxy
+      @http = Net::HTTP::Proxy(proxy.host, proxy.port, proxy.user, proxy.password).new(@parsed_uri.host, @parsed_uri.port)
+    else
+      @http = Net::HTTP.new(@parsed_uri.host, @parsed_uri.port)
+    end
+    @http.use_ssl = (@parsed_uri.scheme == "https")
+    @http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+    @http.open_timeout = @options[:timeout]
+    @http.read_timeout = @options[:timeout]
+  end
+
+  def fetch_using_read(readable)
+    return @content_length = readable.size if @property == :content_length && readable.respond_to?(:size)
+
+    readable.rewind if readable.respond_to?(:rewind)
+    # Pathnames respond to read, but always return the first
+    # chunk of the file unlike an IO (even though the
+    # docuementation for it refers to IO). Need to supply
+    # an offset in this case.
+    if readable.is_a?(Pathname)
+      read_fiber = Fiber.new do
+        offset = 0
+        while str = readable.read(LocalFileChunkSize, offset)
+          Fiber.yield str
+          offset += LocalFileChunkSize
+        end
+        nil
+      end
+    else
+      read_fiber = Fiber.new do
+        while str = readable.read(LocalFileChunkSize)
+          Fiber.yield str
+        end
+        nil
+      end
+    end
+
+    parse_packets FiberStream.new(read_fiber)
+  end
+
+  def fetch_using_file_open
+    return @content_length = File.size?(@uri) if @property == :content_length
+
+    File.open(@uri) do |s|
+      fetch_using_read(s)
+    end
+  end
+
+  def fetch_using_base64(uri)
+    decoded = begin
+      uri.split(',')[1].unpack("m").first
+    rescue
+      raise CannotParseImage
+    end
+
+    fetch_using_read StringIO.new(decoded)
+  end
+  
+  def parse_packets(stream)
+    @stream = stream
+
+    begin
+      @type = TypeParser.new(@stream).type unless defined?(@type)
+
+      result = case @property
+      when :type
+        @type
+      when :size
+        parse_size
+      when :animated
+        parse_animated
+      end
+
+      if result != nil
+        # extract exif orientation if it was found
+        if @property == :size && result.size == 3
+          @orientation = result.pop
+        else
+          @orientation = 1
+        end
+
+        instance_variable_set("@#{@property}", result)
+      else
+        raise CannotParseImage
+      end
+    rescue FiberError
+      raise CannotParseImage
+    end
+  end
+
+  def parser_class
+    klass = Parsers[@type]
+    raise UnknownImageType unless klass
+    klass
+  end
+
+  def parse_size
+    parser_class.new(@stream).dimensions
+  end
+
+  def parse_animated
+    parser_class.new(@stream).animated?
+  end
+end

data/vendor/bundle/ruby/3.4.0/gems/fastimage-2.4.1/lib/fastimage/fastimage_parsing/avif.rb

@@ -0,0 +1,12 @@
+module FastImageParsing
+  class Avif < ImageBase # :nodoc:  
+    def dimensions
+      bmff = IsoBmff.new(@stream)
+      [bmff.width, bmff.height]
+    end
+  
+    def animated?
+      @stream.peek(12)[4..-1] == "ftypavis"
+    end
+  end
+end

data/vendor/bundle/ruby/3.4.0/gems/fastimage-2.4.1/lib/fastimage/fastimage_parsing/bmp.rb

@@ -0,0 +1,17 @@
+module FastImageParsing
+  class Bmp < ImageBase # :nodoc:
+    def dimensions
+      d = @stream.read(32)[14..28]
+      header = d.unpack("C")[0]
+
+      result = if header == 12
+                 d[4..8].unpack('SS')
+               else
+                 d[4..-1].unpack('l<l<')
+               end
+
+      # ImageHeight is expressed in pixels. The absolute value is necessary because ImageHeight can be negative
+      [result.first, result.last.abs]
+    end
+  end
+end

data/vendor/bundle/ruby/3.4.0/gems/fastimage-2.4.1/lib/fastimage/fastimage_parsing/exif.rb

@@ -0,0 +1,76 @@
+module FastImageParsing
+  class Exif # :nodoc:
+    attr_reader :width, :height, :orientation
+  
+    def initialize(stream)
+      @stream = stream
+      @width, @height, @orientation = nil
+      parse_exif
+    end
+  
+    def rotated?
+      @orientation >= 5
+    end
+  
+    private
+  
+    def get_exif_byte_order
+      byte_order = @stream.read(2)
+      case byte_order
+      when 'II'
+        @short, @long = 'v', 'V'
+      when 'MM'
+        @short, @long = 'n', 'N'
+      else
+        raise FastImage::CannotParseImage
+      end
+    end
+  
+    def parse_exif_ifd
+      tag_count = @stream.read(2).unpack(@short)[0]
+      tag_count.downto(1) do
+        type = @stream.read(2).unpack(@short)[0]
+        data_type = @stream.read(2).unpack(@short)[0]
+        @stream.read(4)
+
+        if data_type == 4
+          data = @stream.read(4).unpack(@long)[0]
+        else
+          data = @stream.read(2).unpack(@short)[0]
+          @stream.read(2)
+        end
+
+        case type
+        when 0x0100 # image width
+          @width = data
+        when 0x0101 # image height
+          @height = data
+        when 0x0112 # orientation
+          @orientation = data
+        end
+        if @width && @height && @orientation
+          return # no need to parse more
+        end
+      end
+    end
+  
+    def parse_exif
+      @start_byte = @stream.pos
+  
+      get_exif_byte_order
+  
+      @stream.read(2) # 42
+  
+      offset = @stream.read(4).unpack(@long)[0]
+      if @stream.respond_to?(:skip)
+        @stream.skip(offset - 8)
+      else
+        @stream.read(offset - 8)
+      end
+  
+      parse_exif_ifd
+  
+      @orientation ||= 1
+    end
+  end
+end

data/vendor/bundle/ruby/3.4.0/gems/fastimage-2.4.1/lib/fastimage/fastimage_parsing/fiber_stream.rb

@@ -0,0 +1,58 @@
+module FastImageParsing
+  class FiberStream # :nodoc:
+    include StreamUtil
+    attr_reader :pos
+  
+    # read_fiber should return nil if it no longer has anything to return when resumed
+    # so the result of the whole Fiber block should be set to be nil in case yield is no
+    # longer called
+    def initialize(read_fiber)
+      @read_fiber = read_fiber
+      @pos = 0
+      @strpos = 0
+      @str = ''
+    end
+  
+    # Peeking beyond the end of the input will raise
+    def peek(n)
+      while @strpos + n > @str.size
+        unused_str = @str[@strpos..-1]
+  
+        new_string = @read_fiber.resume
+        raise FastImage::CannotParseImage if !new_string
+        # we are dealing with bytes here, so force the encoding
+        new_string.force_encoding("ASCII-8BIT") if new_string.respond_to? :force_encoding
+  
+        @str = unused_str + new_string
+        @strpos = 0
+      end
+  
+      @str[@strpos, n]
+    end
+  
+    def read(n)
+      result = peek(n)
+      @strpos += n
+      @pos += n
+      result
+    end
+  
+    def skip(n)
+      discarded = 0
+      fetched = @str[@strpos..-1].size
+      while n > fetched
+        discarded += @str[@strpos..-1].size
+        new_string = @read_fiber.resume
+        raise FastImage::CannotParseImage if !new_string
+  
+        new_string.force_encoding("ASCII-8BIT") if new_string.respond_to? :force_encoding
+  
+        fetched += new_string.size
+        @str = new_string
+        @strpos = 0
+      end
+      @strpos = @strpos + n - discarded
+      @pos += n
+    end
+  end
+end

data/vendor/bundle/ruby/3.4.0/gems/fastimage-2.4.1/lib/fastimage/fastimage_parsing/gif.rb

@@ -0,0 +1,63 @@
+module FastImageParsing
+  class Gif < ImageBase # :nodoc:  
+    def dimensions
+      @stream.read(11)[6..10].unpack('SS')
+    end
+  
+    # Checks for multiple frames
+    def animated?
+      frames = 0
+  
+      # "GIF" + version (3) + width (2) + height (2)
+      @stream.skip(10)
+  
+      # fields (1) + bg color (1) + pixel ratio (1)
+      fields = @stream.read(3).unpack("CCC")[0]
+      if fields & 0x80 != 0 # Global Color Table
+        # 2 * (depth + 1) colors, each occupying 3 bytes (RGB)
+        @stream.skip(3 * 2 ** ((fields & 0x7) + 1))
+      end
+  
+      loop do
+        block_type = @stream.read(1).unpack("C")[0]
+  
+        if block_type == 0x21 # Graphic Control Extension
+          # extension type (1) + size (1)
+          size = @stream.read(2).unpack("CC")[1]
+          @stream.skip(size)
+          skip_sub_blocks
+        elsif block_type == 0x2C # Image Descriptor
+          frames += 1
+          return true if frames > 1
+  
+          # left position (2) + top position (2) + width (2) + height (2) + fields (1)
+          fields = @stream.read(9).unpack("SSSSC")[4]
+          if fields & 0x80 != 0 # Local Color Table
+            # 2 * (depth + 1) colors, each occupying 3 bytes (RGB)
+            @stream.skip(3 * 2 ** ((fields & 0x7) + 1))
+          end
+  
+          @stream.skip(1) # LZW min code size (1)
+          skip_sub_blocks
+        else
+          break # unrecognized block
+        end
+      end
+  
+      false
+    end
+  
+    private
+  
+    def skip_sub_blocks
+      loop do
+        size = @stream.read(1).unpack("C")[0]
+        if size == 0
+          break
+        else
+          @stream.skip(size)
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.4.0/gems/fastimage-2.4.1/lib/fastimage/fastimage_parsing/heic.rb

@@ -0,0 +1,8 @@
+module FastImageParsing
+  class Heic < ImageBase # :nodoc:
+    def dimensions
+      bmff = IsoBmff.new(@stream)
+      [bmff.width, bmff.height]
+    end
+  end
+end