imgix 2.1.0 → 4.0.3

data/lib/imgix/client.rb

@@ -1,95 +1,106 @@
 # frozen_string_literal: true
 
-require 'digest'
-require 'addressable/uri'
-require 'zlib'
-require 'net/http'
-require 'uri'
+require "digest"
+require "net/http"
+require "uri"
+require "json"
 
 module Imgix
   class Client
-    DEFAULTS = { use_https: true, shard_strategy: :crc }
+    DEFAULTS = { use_https: true }.freeze
 
     def initialize(options = {})
       options = DEFAULTS.merge(options)
+      @domain = options[:domain]
+
+      validate_domain!
 
-      deprecate_warning!(options[:host],options[:hosts])
-      @hosts = Array(options[:host]) + Array(options[:hosts]) and validate_hosts!
       @secure_url_token = options[:secure_url_token]
       @api_key = options[:api_key]
       @use_https = options[:use_https]
-      @shard_strategy = options[:shard_strategy] and validate_strategy!
       @include_library_param = options.fetch(:include_library_param, true)
       @library = options.fetch(:library_param, "rb")
       @version = options.fetch(:library_version, Imgix::VERSION)
     end
 
     def path(path)
-      p = Path.new(prefix(path), @secure_url_token, path)
+      p = Path.new(prefix, @secure_url_token, path)
       p.ixlib("#{@library}-#{@version}") if @include_library_param
       p
     end
 
     def purge(path)
-      raise "Authentication token required" unless !!(@api_key)
-      url = prefix(path)+path
-      uri = URI.parse('https://api.imgix.com/v2/image/purger')
-      req = Net::HTTP::Post.new(uri.path, {"User-Agent" => "imgix #{@library}-#{@version}"})
-      req.basic_auth @api_key, ''
-      req.set_form_data({'url' => url})
-      sock = Net::HTTP.new(uri.host, uri.port)
-      sock.use_ssl = true
-      res = sock.start {|http| http.request(req) }
-      res
-    end
+      api_key_error = "A valid API key is required to send purge requests"
+      raise api_key_error if @api_key.nil?
 
-    def prefix(path)
-      "#{@use_https ? 'https' : 'http'}://#{get_host(path)}"
-    end
+      endpoint = URI.parse("https://api.imgix.com/api/v1/purge")
+      # Ensure the path has been prefixed with '/'.
+      path = path.start_with?("/") ? path : "/#{path}"
+      url = prefix + path
 
-    def get_host(path)
-      host = host_for_crc(path) if @shard_strategy == :crc
-      host = host_for_cycle if @shard_strategy == :cycle
-      host
-    end
+      req = create_request(endpoint, url, :json_data_from)
 
-    def host_for_crc(path)
-      crc = Zlib.crc32(path)
-      index = crc % @hosts.length - 1
-      @hosts[index]
+      sock = Net::HTTP.new(endpoint.host, endpoint.port)
+      sock.use_ssl = true
+      sock.start { |http| http.request(req) }
     end
 
-    def host_for_cycle
-      if not defined? @hosts_cycle
-        @hosts_cycle = @hosts.cycle
-      end
-      @hosts_cycle.next
+    def prefix
+      "#{@use_https ? 'https' : 'http'}://#{@domain}"
     end
 
     private
 
-    def validate_strategy!
-      unless STRATEGIES.include?(@shard_strategy)
-        raise ArgumentError.new("#{@shard_strategy} is not supported")
+    # Create a request object by specifying it's endpoint, resource, and
+    # an optional data_fmt.
+    #
+    # `endpoint` must be a valid URI object
+    # `resource` must be a valid URL designating the resource to be purged
+    # `data_fmt` must be a valid method or Proc object
+    #
+    # Specify a `data_fmt` method when a resource (URL) requires
+    # additional formatting before being included in the request body.
+    # By default, the data format is specified by the `json_data_from`
+    # method.
+    def create_request(endpoint, resource, data_fmt = :json_data_from)
+      req = Net::HTTP::Post.new(endpoint.path)
+      req["Content-Type"] = "application/vnd.api+json"
+      req["Authorization"] = "Bearer #{@api_key}"
+      req["User-Agent"] = "imgix #{@library}-#{@version}"
+
+      if data_fmt.is_a?(Proc)
+        req.body = data_fmt.call(resource)
+      elsif data_fmt.is_a?(Symbol)
+        req.body = send(data_fmt, resource)
+      else
+        fmt_arg_error = "`fmt' is required to be of class Symbol or " \
+          "Proc but was found to be\n\s\sof class #{data_fmt.class}\n"
+        raise ArgumentError, fmt_arg_error
       end
+
+      req
     end
 
-    def validate_hosts!
-      unless @hosts.length > 0
-        raise ArgumentError, "The :host or :hosts option must be specified"
-      end
-      @hosts.each do |host|
-        if host.match(DOMAIN_REGEX) == nil
-          raise ArgumentError, "Domains must be passed in as fully-qualified domain names and should not include a protocol or any path element, i.e. \"example.imgix.net\"."
-        end
-      end
+    def json_data_from(url)
+      {
+        data: {
+          attributes: {
+              url: url
+          },
+          type: "purges"
+        }
+      }.to_json
     end
 
-    def deprecate_warning!(host, hosts)
-      has_many_domains = (host.kind_of?(Array) && host.length > 1 ) || (hosts.kind_of?(Array) && hosts.length > 1)
-      if has_many_domains
-        warn "Warning: Domain sharding has been deprecated and will be removed in the next major version."
-      end
+    def validate_domain!
+      domain_error  = "The :domain option must be specified"
+      raise ArgumentError, domain_error if @domain.nil?
+
+      domain_error = "Domains must be passed in as fully-qualified"\
+                     "domain names and should not include a protocol"\
+                     'or any path element, i.e. "example.imgix.net"'\
+
+      raise ArgumentError, domain_error if @domain.match(DOMAIN_REGEX).nil?
     end
   end
 end

data/lib/imgix/path.rb

@@ -1,82 +1,125 @@
 # frozen_string_literal: true
 
-require 'base64'
-require 'cgi/util'
-require 'erb'
-require 'imgix/param_helpers'
+require "base64"
+require "cgi/util"
+require "erb"
 
 module Imgix
   class Path
-    include ParamHelpers
 
-    ALIASES = {
-      width:           :w,
-      height:          :h,
-      rotation:        :rot,
-      noise_reduction: :nr,
-      sharpness:       :sharp,
-      exposure:        :exp,
-      vibrance:        :vib,
-      saturation:      :sat,
-      brightness:      :bri,
-      contrast:        :con,
-      highlight:       :high,
-      shadow:          :shad,
-      gamma:           :gam,
-      pixelate:        :px,
-      halftone:        :htn,
-      watermark:       :mark,
-      text:            :txt,
-      format:          :fm,
-      quality:         :q
-    }
-
-    def initialize(prefix, secure_url_token, path = '/')
+    def initialize(prefix, secure_url_token, path = "/")
       @prefix = prefix
       @secure_url_token = secure_url_token
       @path = path
       @options = {}
-
-      @path = CGI.escape(@path) if /^https?/ =~ @path
-      @path = "/#{@path}" if @path[0] != '/'
     end
 
     def to_url(opts = {})
+      sanitized_path = sanitize_path(@path)
       prev_options = @options.dup
       @options.merge!(opts)
 
-      url = @prefix + path_and_params
+      current_path_and_params = path_and_params(sanitized_path)
+      url = @prefix + current_path_and_params
 
       if @secure_url_token
-        url += (has_query? ? '&' : '?') + "s=#{signature}"
+        url += (has_query? ? "&" : "?") + "s=#{signature(current_path_and_params)}"
       end
 
       @options = prev_options
-      return url
+      url
     end
 
     def defaults
       @options = {}
-      return self
+      self
+    end
+
+    def ixlib(lib_version)
+      @options[:ixlib] = lib_version
     end
 
+    def ixlib=(lib_version)
+      @options[:ixlib] = lib_version
+    end
+
+    def to_srcset(options: {}, **params)
+      prev_options = @options.dup
+      @options.merge!(params)
+
+      width = @options[:w]
+      height = @options[:h]
+      aspect_ratio = @options[:ar]
+
+      srcset = if width || height
+          build_dpr_srcset(options: options, params: @options)
+        else
+          build_srcset_pairs(options: options, params: @options)
+        end
+
+      @options = prev_options
+      srcset
+    end
+
+    ALIASES = {
+      width:           :w,
+      height:          :h,
+      rotation:        :rot,
+      noise_reduction: :nr,
+      sharpness:       :sharp,
+      exposure:        :exp,
+      vibrance:        :vib,
+      saturation:      :sat,
+      brightness:      :bri,
+      contrast:        :con,
+      highlight:       :high,
+      shadow:          :shad,
+      gamma:           :gam,
+      pixelate:        :px,
+      halftone:        :htn,
+      watermark:       :mark,
+      text:            :txt,
+      format:          :fm,
+      quality:         :q,
+      fill_color:      :fillcolor
+    }.freeze
+
+    # Define query parameters on a Path (via method_missing).
+    # Normally, when overriding method_missing, it is a best practice
+    # to fall back to super, but this method works differently.
+    #
+    # method_missing intercepts messages sent to objects of this class
+    # and acts as a getter, setter, and deleter. If there are no args,
+    # e.g. `path.width`, then this method acts like a getter.
+    #
+    # Likewise, if the first argument is nil and the method name exists
+    # as a key in @options, e.g. `path.param_name = nil`, then this
+    # method acts like a deleter and the `param_name` is removed from
+    # the list of @options.
+    #
+    # Finally, in _all_ other cases, the `method` name is used as the
+    # `key` and the `*args` are used as the value.
     def method_missing(method, *args, &block)
       key = method.to_s.gsub('=', '')
-      if args.length == 0
+
+      if args.length == 0 # Get, or
         return @options[key]
-      elsif args.first.nil? && @options.has_key?(key)
+      elsif args.first.nil? && @options.has_key?(key) # Delete, or
         @options.delete(key) and return self
       end
 
-      @options[key] = args.join(',')
-      return self
+      @options[key] = args.join(',') # Set the option.
+      self
     end
 
+    # Use ALIASES to define setters for a subset of imgix parameters.
+    # E.g. `path.width(100)` would result in `send(:w, [100])`.
     ALIASES.each do |from, to|
       define_method from do |*args|
         self.send(to, *args)
       end
 
+      # E.g. `path.width = 100` would result in `send(":w=", [100])`.
       define_method "#{from}=" do |*args|
         self.send("#{to}=", *args)
         return self
@@ -85,12 +128,46 @@ module Imgix
 
     private
 
-    def signature
-      Digest::MD5.hexdigest(@secure_url_token + path_and_params)
+    # Escape and encode any characters in path that are reserved and not utf8 encoded.
+    # This includes " +?:#" characters. If a path is being used as a proxy, utf8
+    # encode everything. If it is not being used as proxy, leave certain chars, like
+    # "/", alone. Method assumes path is not already encoded.
+    def sanitize_path(path)
+      # remove the leading "/", we'll add it back after encoding
+      path = path.slice(1, path.length) if Regexp.new('^/') =~ path
+      # if path is being used as a proxy, encode the entire thing
+      if /^https?/ =~ path
+        return encode_URI_Component(path)
+      else
+        # otherwise, encode only specific characters
+        return encode_URI(path)
+      end
     end
 
-    def path_and_params
-      has_query? ? "#{@path}?#{query}" : @path
+    # URL encode the entire path
+    def encode_URI_Component(path)
+      return "/" + ERB::Util.url_encode(path)
+    end
+
+    # URL encode every character in the path, including
+    # " +?:#" characters.
+    def encode_URI(path)
+      # For each component in the path, URL encode it and add it
+      # to the array path component.
+      path_components = []
+      path.split("/").each do |str|
+        path_components << ERB::Util.url_encode(str)
+      end
+      # Prefix and join the encoded path components.
+      "/#{path_components.join('/')}"
+    end
+
+    def signature(rest)
+      Digest::MD5.hexdigest(@secure_url_token + rest)
+    end
+
+    def path_and_params(path)
+      has_query? ? "#{path}?#{query}" : path
     end
 
     def query
@@ -102,11 +179,86 @@ module Imgix
         else
           escaped_key << "=" << ERB::Util.url_encode(val.to_s)
         end
-      end.join('&')
+      end.join("&")
     end
 
     def has_query?
-      query.length > 0
+      !query.empty?
+    end
+
+    def build_srcset_pairs(options:, params:)
+      srcset = ""
+
+      widths = options[:widths] || []
+      width_tolerance = options[:width_tolerance] || DEFAULT_WIDTH_TOLERANCE
+      min_width = options[:min_width] || MIN_WIDTH
+      max_width = options[:max_width] || MAX_WIDTH
+
+      if !widths.empty?
+        validate_widths!(widths)
+        srcset_widths = widths
+      elsif width_tolerance != DEFAULT_WIDTH_TOLERANCE || min_width != MIN_WIDTH || max_width != MAX_WIDTH
+        validate_range!(min_width, max_width)
+        validate_width_tolerance!(width_tolerance)
+        srcset_widths = TARGET_WIDTHS.call(width_tolerance, min_width, max_width)
+      else
+        srcset_widths = DEFAULT_TARGET_WIDTHS
+      end
+
+      srcset_widths.each do |width|
+        params[:w] = width
+        srcset += "#{to_url(params)} #{width}w,\n"
+      end
+
+      srcset[0..-3]
+    end
+
+    def build_dpr_srcset(options:, params:)
+      srcset = ""
+
+      disable_variable_quality = options[:disable_variable_quality] || false
+      validate_variable_qualities!(disable_variable_quality)
+
+      target_ratios = [1, 2, 3, 4, 5]
+      quality = params[:q]
+
+      target_ratios.each do |ratio|
+        params[:dpr] = ratio
+
+        params[:q] = quality || DPR_QUALITY[ratio] unless disable_variable_quality
+
+        srcset += "#{to_url(params)} #{ratio}x,\n"
+      end
+
+      srcset[0..-3]
+    end
+
+    def validate_width_tolerance!(width_tolerance)
+      width_increment_error = "error: `width_tolerance` must be a positive `Numeric` value"
+
+      raise ArgumentError, width_increment_error if !width_tolerance.is_a?(Numeric) || width_tolerance <= 0
+    end
+
+    def validate_widths!(widths)
+      widths_error = "error: `widths` must be an array of positive `Numeric` values"
+      raise ArgumentError, widths_error unless widths.is_a?(Array)
+
+      all_positive_integers = widths.all? { |i| i.is_a?(Integer) && i > 0 }
+      raise ArgumentError, widths_error unless all_positive_integers
+    end
+
+    def validate_range!(min_width, max_width)
+      range_numeric_error = "error: `min_width` and `max_width` must be positive `Numeric` values"
+      raise ArgumentError, range_numeric_error unless min_width.is_a?(Numeric) && max_width.is_a?(Numeric)
+
+      raise ArgumentError, range_numeric_error unless min_width > 0 && max_width > 0
+    end
+
+    def validate_variable_qualities!(disable_quality)
+      disable_quality_error = "error: `disable_quality` must be a Boolean value"
+      unless disable_quality.is_a?(TrueClass) || disable_quality.is_a?(FalseClass)
+        raise ArgumentError, disable_quality_error
+      end
     end
   end
 end

data/lib/imgix/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Imgix
-  VERSION = '2.1.0'
+  VERSION = "4.0.3"
 end

data/lib/imgix.rb

@@ -1,10 +1,52 @@
 # frozen_string_literal: true
 
-require 'imgix/version'
-require 'imgix/client'
-require 'imgix/path'
+require "imgix/version"
+require "imgix/client"
+require "imgix/path"
 
 module Imgix
-  STRATEGIES = [:crc, :cycle]
-  DOMAIN_REGEX = /^(?:[a-z\d\-_]{1,62}\.){0,125}(?:[a-z\d](?:\-(?=\-*[a-z\d])|[a-z]|\d){0,62}\.)[a-z\d]{1,63}$/i
+  # regex pattern used to determine if a domain is valid
+  DOMAIN_REGEX = /^(?:[a-z\d\-_]{1,62}\.){0,125}(?:[a-z\d](?:\-(?=\-*[a-z\d])|[a-z]|\d){0,62}\.)[a-z\d]{1,63}$/i.freeze
+
+  # determines the growth rate when building out srcset pair widths
+  DEFAULT_WIDTH_TOLERANCE = 0.08
+
+  # the default minimum srcset width
+  MIN_WIDTH = 100
+
+  # the default maximum srcset width, also the max width supported by imgix
+  MAX_WIDTH = 8192
+
+  # returns an array of width values used during scrset generation
+  TARGET_WIDTHS = lambda { |tolerance, min, max|
+    increment_percentage = tolerance || DEFAULT_WIDTH_TOLERANCE
+
+    unless increment_percentage.is_a?(Numeric) && increment_percentage > 0
+      width_increment_error = "error: `width_tolerance` must be a positive `Numeric` value"
+      raise ArgumentError, width_increment_error
+    end
+
+    max_size = max || MAX_WIDTH
+    resolutions = []
+    prev = min || MIN_WIDTH
+
+    while prev < max_size
+      # ensures that each width is even
+      resolutions.push(prev.round)
+      prev *= 1 + (increment_percentage * 2)
+    end
+
+    resolutions.push(max_size)
+    return resolutions
+  }
+  DEFAULT_TARGET_WIDTHS = TARGET_WIDTHS.call(DEFAULT_WIDTH_TOLERANCE, MIN_WIDTH, MAX_WIDTH).freeze
+
+  # hash of default quality parameter values mapped  by each dpr srcset entry
+  DPR_QUALITY = {
+    1 => 75,
+    2 => 50,
+    3 => 35,
+    4 => 23,
+    5 => 20
+  }.freeze
 end

data/script/bench_path.rb

@@ -0,0 +1,11 @@
+$LOAD_PATH << 'lib'
+require 'imgix'
+require 'benchmark/ips'
+
+client = Imgix::Client.new(domain: 'domain.com', secure_url_token: 'token')
+
+Benchmark.ips do |x|
+  x.report('Imgix::Path#initialize') do
+    client.path("/img.jpg")
+  end
+end

data/script/bench_to_url.rb

@@ -0,0 +1,12 @@
+$LOAD_PATH << 'lib'
+require 'imgix'
+require 'benchmark/ips'
+
+client = Imgix::Client.new(domain: 'domain.com', secure_url_token: 'token')
+path = client.path("/img.jpg")
+
+Benchmark.ips do |x|
+  x.report('Imgix::Path#to_url') do
+    path.to_url({ auto: 'compress,format', fit: 'crop', crop: 'top', w: 590, h: 332 })
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: imgix
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 4.0.3
 platform: ruby
 authors:
 - Kelly Sutton
@@ -10,39 +10,11 @@ authors:
 - Antony Denyer
 - Paul Straw
 - Sherwin Heydarbeygi
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-05-08 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: addressable
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: webmock
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
+date: 2021-05-05 00:00:00.000000000 Z
+dependencies: []
 description: Easily create and sign imgix URLs.
 email:
 - kelly@imgix.com
@@ -56,7 +28,9 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".rubocop.yml"
 - ".travis.yml"
+- ".vscode/tasks.json"
 - CHANGELOG.md
 - Contributing.markdown
 - Gemfile
@@ -66,19 +40,19 @@ files:
 - imgix.gemspec
 - lib/imgix.rb
 - lib/imgix/client.rb
-- lib/imgix/param_helpers.rb
 - lib/imgix/path.rb
 - lib/imgix/version.rb
-- test/test_helper.rb
-- test/units/domains_test.rb
-- test/units/path_test.rb
-- test/units/purge_test.rb
-- test/units/url_test.rb
+- script/bench_path.rb
+- script/bench_to_url.rb
 homepage: https://github.com/imgix/imgix-rb
 licenses:
 - MIT
-metadata: {}
-post_install_message: 
+metadata:
+  bug_tracker_uri: https://github.com/imgix/imgix-rb/issues
+  changelog_uri: https://github.com/imgix/imgix-rb/blob/main/CHANGELOG.md
+  documentation_uri: https://www.rubydoc.info/gems/imgix/4.0.3
+  source_code_uri: https://github.com/imgix/imgix-rb/tree/4.0.3
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -93,14 +67,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.13
-signing_key: 
+rubygems_version: 3.1.4
+signing_key:
 specification_version: 4
 summary: Official Ruby Gem for easily creating and signing imgix URLs.
-test_files:
-- test/test_helper.rb
-- test/units/domains_test.rb
-- test/units/path_test.rb
-- test/units/purge_test.rb
-- test/units/url_test.rb
+test_files: []

data/lib/imgix/param_helpers.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module Imgix
-  module ParamHelpers
-    def rect(position)
-      @options[:rect] = position and return self if position.is_a?(String)
-
-      @options[:rect] = [
-        position[:x] || position[:left],
-        position[:y] || position[:top],
-        position[:width] || (position[:right] - position[:left]),
-        position[:height] || (position[:bottom] - position[:top])
-      ].join(',')
-
-      return self
-    end
-  end
-end