imgix 3.3.0

data/Rakefile

@@ -0,0 +1,16 @@
+require 'bundler/gem_tasks'
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+end
+task :default => :test
+
+task :console do
+  require 'irb'
+  require 'irb/completion'
+  require 'imgix'
+  ARGV.clear
+  IRB.start
+end

data/imgix.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'imgix/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'imgix'
+  spec.version       = Imgix::VERSION
+  spec.authors       = ['Kelly Sutton', 'Sam Soffes', 'Ryan LeFevre', 'Antony Denyer', 'Paul Straw', 'Sherwin Heydarbeygi']
+  spec.email         = ['kelly@imgix.com', 'sam@soff.es', 'ryan@layervault.com', 'email@antonydenyer.co.uk', 'paul@imgix.com', 'sherwin@imgix.com']
+  spec.description   = 'Easily create and sign imgix URLs.'
+  spec.summary       = 'Official Ruby Gem for easily creating and signing imgix URLs.'
+  spec.homepage      = 'https://github.com/imgix/imgix-rb'
+  spec.license       = 'MIT'
+
+  spec.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/#{spec.version}",
+    'source_code_uri'   => "https://github.com/imgix/imgix-rb/tree/#{spec.version}"
+  }
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.required_ruby_version = '>= 1.9.0'
+  spec.add_dependency 'addressable'
+  spec.add_development_dependency 'webmock'
+end

data/lib/imgix.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'imgix/version'
+require 'imgix/client'
+require 'imgix/path'
+
+module Imgix
+  # 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
+  }
+
+  # 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/lib/imgix/client.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require 'digest'
+require 'addressable/uri'
+require 'net/http'
+require 'uri'
+
+module Imgix
+  class Client
+    DEFAULTS = { use_https: true }.freeze
+
+    def initialize(options = {})
+      options = DEFAULTS.merge(options)
+      host, domain = options[:host], options[:domain]
+
+      host_deprecated = "Warning: The identifier `host' has been deprecated and " \
+        "will\nappear as `domain' in the next major version, e.g. " \
+        "`@host'\nbecomes `@domain', `options[:host]' becomes " \
+        "`options[:domain]'.\n"
+
+      if host
+        warn host_deprecated
+        @host = host
+      elsif domain
+        @host = domain
+      end
+
+      validate_host!
+
+      @secure_url_token = options[:secure_url_token]
+      @api_key = options[:api_key]
+      @use_https = options[:use_https]
+      @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(new_prefix, @secure_url_token, path)
+      p.ixlib("#{@library}-#{@version}") if @include_library_param
+      p
+    end
+
+    def purge(path)
+      token_error = 'Authentication token required'
+      raise token_error if @api_key.nil?
+
+      url = new_prefix + path
+      uri = URI.parse('https://api.imgix.com/v2/image/purger')
+
+      user_agent = { 'User-Agent' => "imgix #{@library}-#{@version}" }
+
+      req = Net::HTTP::Post.new(uri.path, user_agent)
+      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
+
+    def prefix(path)
+      msg = "Warning: `Client::prefix' will take zero arguments " \
+        "in the next major version.\n"
+      warn msg
+      new_prefix
+    end
+
+    def new_prefix
+      "#{@use_https ? 'https' : 'http'}://#{@host}"
+    end
+
+    private
+
+    def validate_host!
+      host_error = 'The :host option must be specified'
+      raise ArgumentError, host_error if @host.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"'\
+
+      if @host.match(DOMAIN_REGEX).nil?
+        raise ArgumentError, domain_error
+      end
+    end
+  end
+end

data/lib/imgix/param_helpers.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Imgix
+  module ParamHelpers
+    def rect(position)
+      warn "Warning: `ParamHelpers.rect` has been deprecated and will be removed in the next major version.\n"
+      @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

data/lib/imgix/path.rb

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+require 'base64'
+require 'cgi/util'
+require 'erb'
+require 'imgix/param_helpers'
+
+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
+    }.freeze
+
+    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] != '/'
+      @target_widths = TARGET_WIDTHS.call(DEFAULT_WIDTH_TOLERANCE, MIN_WIDTH, MAX_WIDTH)
+    end
+
+    def to_url(opts = {})
+      prev_options = @options.dup
+      @options.merge!(opts)
+
+      url = @prefix + path_and_params
+
+      if @secure_url_token
+        url += (has_query? ? '&' : '?') + "s=#{signature}"
+      end
+
+      @options = prev_options
+      url
+    end
+
+    def defaults
+      @options = {}
+      self
+    end
+
+    def method_missing(method, *args, &block)
+      key = method.to_s.gsub('=', '')
+      if args.length == 0
+        return @options[key]
+      elsif args.first.nil? && @options.has_key?(key)
+        @options.delete(key) and return self
+      end
+
+      @options[key] = args.join(',')
+      self
+    end
+
+    ALIASES.each do |from, to|
+      define_method from do |*args|
+        warn "Warning: `Path.#{from}' has been deprecated and " \
+             "will be removed in the next major version (along " \
+             "with all parameter `ALIASES`).\n"
+        self.send(to, *args)
+      end
+
+      define_method "#{from}=" do |*args|
+        warn "Warning: `Path.#{from}=' has been deprecated and " \
+             "will be removed in the next major version (along " \
+             "with all parameter `ALIASES`).\n"
+        self.send("#{to}=", *args)
+        return self
+      end
+    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 && aspect_ratio)
+                 build_dpr_srcset(options: options, params: @options)
+               else
+                 build_srcset_pairs(options: options, params: @options)
+               end
+
+      @options = prev_options
+      srcset
+    end
+
+    private
+
+    def signature
+      Digest::MD5.hexdigest(@secure_url_token + path_and_params)
+    end
+
+    def path_and_params
+      has_query? ? "#{@path}?#{query}" : @path
+    end
+
+    def query
+      @options.map do |key, val|
+        escaped_key = ERB::Util.url_encode(key.to_s)
+
+        if escaped_key.end_with? '64'
+          escaped_key << "=" << Base64.urlsafe_encode64(val.to_s).delete('=')
+        else
+          escaped_key << "=" << ERB::Util.url_encode(val.to_s)
+        end
+      end.join('&')
+    end
+
+    def has_query?
+      query.length > 0
+    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 = @target_widths
+      end
+
+      for width in srcset_widths do
+        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]
+
+      for ratio in target_ratios do
+        params[:dpr] = ratio
+
+        unless disable_variable_quality
+          params[:q] = quality || DPR_QUALITY[ratio]
+        end
+
+        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'
+
+      if !width_tolerance.is_a?(Numeric) || width_tolerance <= 0
+        raise ArgumentError, width_increment_error
+      end
+    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_srcset, max_srcset)
+      range_numeric_error = 'error: `min_width` and `max_width` must be positive `Numeric` values'
+      unless min_srcset.is_a?(Numeric) && max_srcset.is_a?(Numeric)
+        raise ArgumentError, range_numeric_error
+      end
+
+      unless min_srcset > 0 && max_srcset > 0
+        raise ArgumentError, range_numeric_error
+      end
+    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

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Imgix
+  VERSION = '3.3.0'
+end

data/test/test_helper.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'rubygems'
+require 'bundler'
+Bundler.require :test
+
+require 'minitest/autorun'
+require 'imgix'
+require 'webmock/minitest'
+include WebMock::API
+
+class Imgix::Test < MiniTest::Test
+end