image_vise 0.2.0 → 0.2.1

data/lib/image_vise/fetchers/fetcher_file.rb

@@ -1,27 +0,0 @@
-class ImageVise::FetcherFile
-  class AccessError < StandardError
-    def http_status; 403; end
-  end
-  def self.fetch_uri_to_tempfile(uri)
-    tf = Tempfile.new 'imagevise-localfs-copy'
-    real_path_on_filesystem = File.expand_path(URI.decode(uri.path))
-    verify_filesystem_access! real_path_on_filesystem
-    # Do the checks
-    File.open(real_path_on_filesystem, 'rb') do |f|
-      IO.copy_stream(f, tf)
-    end
-    tf.rewind; tf
-  rescue Exception => e
-    ImageVise.close_and_unlink(tf)
-    raise e
-  end
-
-  def self.verify_filesystem_access!(path_on_filesystem)
-    patterns = ImageVise.allowed_filesystem_sources
-    matches = patterns.any? { |glob_pattern| File.fnmatch?(glob_pattern, path_on_filesystem) }
-    raise AccessError, "filesystem access is disabled" unless patterns.any?
-    raise AccessError, "#{path_on_filesystem} is not on the path whitelist" unless matches
-  end
-
-  ImageVise.register_fetcher 'file', self
-end

data/lib/image_vise/fetchers/fetcher_http.rb

@@ -1,42 +0,0 @@
-class ImageVise::FetcherHTTP
-  EXTERNAL_IMAGE_FETCH_TIMEOUT_SECONDS = 5
-
-  class AccessError < StandardError; end
-
-  class UpstreamError < StandardError
-    attr_accessor :http_status
-    def initialize(http_status, message)
-      super(message)
-      @http_status = http_status
-    end
-  end
-  
-  def self.fetch_uri_to_tempfile(uri)
-    tf = Tempfile.new 'imagevise-http-download'
-    verify_uri_access!(uri)
-    s = Patron::Session.new
-    s.automatic_content_encoding = true
-    s.timeout = EXTERNAL_IMAGE_FETCH_TIMEOUT_SECONDS
-    s.connect_timeout = EXTERNAL_IMAGE_FETCH_TIMEOUT_SECONDS
-    
-    response = s.get_file(uri.to_s, tf.path)
-    
-    if response.status != 200
-      raise UpstreamError.new(response.status, "Unfortunate upstream response #{response.status} on #{uri}")
-    end
-    
-    tf
-  rescue Exception => e
-    ImageVise.close_and_unlink(tf)
-    raise e
-  end
-  
-  def self.verify_uri_access!(uri)
-    host = uri.host
-    return if ImageVise.allowed_hosts.include?(uri.host)
-    raise AccessError, "#{uri} is not permitted as source"
-  end
-
-  ImageVise.register_fetcher 'http', self
-  ImageVise.register_fetcher 'https', self
-end

data/lib/image_vise/file_response.rb

@@ -1,22 +0,0 @@
-# Wrappers a given Tempfile for a Rack response.
-# Will close _and_ unlink the Tempfile it contains.
-class ImageVise::FileResponse
-  ONE_CHUNK_BYTES = 1024 * 1024 * 2
-  def initialize(file)
-    @file = file
-  end
-
-  def each
-    @file.flush # Make sure all the writes have been synchronized
-    # We can easily open another file descriptor
-    File.open(@file.path, 'rb') do |my_file_descriptor|
-      while data = my_file_descriptor.read(ONE_CHUNK_BYTES)
-        yield(data)
-      end
-    end
-  end
-
-  def close
-    ImageVise.close_and_unlink(@file)
-  end
-end

data/lib/image_vise/image_request.rb

@@ -1,70 +0,0 @@
-require 'openssl'
-
-class ImageVise::ImageRequest < Ks.strict(:src_url, :pipeline)
-  class InvalidRequest < ArgumentError; end
-  class SignatureError < InvalidRequest; end
-  class URLError < InvalidRequest; end
-  class MissingParameter < InvalidRequest; end
-  
-  # Initializes a new ParamsChecker from given HTTP server framework
-  # params. The params can be symbol- or string-keyed, does not matter.
-  def self.from_params(qs_params:, secrets:)
-    base64_encoded_params = qs_params.fetch(:q) rescue qs_params.fetch('q')
-    given_signature = qs_params.fetch(:sig) rescue qs_params.fetch('sig')
-
-    # Unmask slashes and equals signs (if they are present)
-    base64_encoded_params = base64_encoded_params.tr('-', '/').tr('_', '+')
-
-    # Check the signature before decoding JSON (since we will be creating symbols)
-    unless valid_signature?(base64_encoded_params, given_signature, secrets)
-      raise SignatureError, "Invalid or missing signature"
-    end
-
-    # Decode the JSON
-    # (only AFTER the signature has been validated, so we can use symbol keys)
-    decoded_json = Base64.decode64(base64_encoded_params)
-    params = JSON.parse(decoded_json, symbolize_names: true)
-
-    # Pick up the URL and validate it
-    source_url_str = params.fetch(:src_url).to_s
-    raise URLError, "the :src_url parameter must be non-empty" if source_url_str.empty?
-    pipeline_definition = params.fetch(:pipeline)
-    new(src_url: URI(source_url_str), pipeline: ImageVise::Pipeline.from_param(pipeline_definition))
-  rescue KeyError => e
-    raise InvalidRequest.new(e.message)
-  end
-
-  def to_path_params(signed_with_secret)
-    qs = to_query_string_params(signed_with_secret)
-    q_masked = qs.fetch(:q).tr('/', '-').tr('+', '_')
-    '/%s/%s' % [q_masked, qs[:sig]]
-  end
-
-  def to_query_string_params(signed_with_secret)
-    payload = JSON.dump(to_h)
-    base64_enc = Base64.strict_encode64(payload).gsub(/\=+$/, '')
-    {q: base64_enc, sig: OpenSSL::HMAC.hexdigest(OpenSSL::Digest::SHA256.new, signed_with_secret, base64_enc)}
-  end
-
-  def to_h
-    {pipeline: pipeline.to_params, src_url: src_url.to_s}
-  end
-  
-  def cache_etag
-    Digest::SHA1.hexdigest(JSON.dump(to_h))
-  end
-
-  private
-
-  def self.valid_signature?(for_payload, given_signature, secrets)
-    # Check the signature against every key that we have,
-    # since different apps might be using different keys
-    seen_valid_signature = false
-    secrets.each do | stored_secret |
-      expected_signature = OpenSSL::HMAC.hexdigest(OpenSSL::Digest::SHA256.new, stored_secret, for_payload)
-      result_for_this_key = Rack::Utils.secure_compare(expected_signature, given_signature)
-      seen_valid_signature ||= result_for_this_key
-    end
-    seen_valid_signature
-  end
-end

data/lib/image_vise/operators/auto_orient.rb

@@ -1,10 +0,0 @@
-# Applies ImageMagick auto_orient to the image, so that i.e. mobile photos
-# can be oriented correctly. The operation is applied destructively (changes actual pixel data)
-#
-# The corresponding Pipeline method is `auto_orient`.
-class ImageVise::AutoOrient
-  def apply!(magick_image)
-    magick_image.auto_orient!
-  end
-  ImageVise.add_operator 'auto_orient', self
-end

data/lib/image_vise/operators/background_fill.rb

@@ -1,18 +0,0 @@
-# Applies a background fill color.
-# Can handle most 'word' colors and hex color codes but not RGB values.
-#
-# The corresponding Pipeline method is `background_fill`.
-class ImageVise::BackgroundFill < Ks.strict(:color)
-  def initialize(*)
-    super
-    self.color = color.to_s
-    raise ArgumentError, "the :color parameter must be present and not empty" if self.color.empty?
-  end
-
-  def apply!(image)
-    image.border!(0, 0, color)
-    image.alpha(Magick::DeactivateAlphaChannel)
-  end
-
-  ImageVise.add_operator 'background_fill', self
-end

data/lib/image_vise/operators/crop.rb

@@ -1,32 +0,0 @@
-# Crops the image to the given dimensions with a given gravity. Gravities are shorthand versions
-# of ImageMagick gravity parameters (see GRAVITY_PARAMS)
-#
-# The corresponding Pipeline method is `crop`.
-class ImageVise::Crop < Ks.strict(:width, :height, :gravity)
-  GRAVITY_PARAMS = {
-    'nw' => Magick::NorthWestGravity,
-    'n' => Magick::NorthGravity,
-    'ne' => Magick::NorthEastGravity,
-    'w' => Magick::WestGravity,
-    'c' => Magick::CenterGravity,
-    'e' => Magick::EastGravity,
-    'sw' => Magick::SouthWestGravity,
-    's' => Magick::SouthGravity,
-    'se' => Magick::SouthEastGravity,
-  }
-  
-  def initialize(*)
-    super
-    self.width = width.to_i
-    self.height = height.to_i
-    raise ArgumentError, ":width must positive" unless width > 0
-    raise ArgumentError, ":height must positive" unless height > 0
-    raise ArgumentError, ":gravity must be within the permitted values" unless GRAVITY_PARAMS.key? gravity
-  end
-  
-  def apply!(image)
-    image.crop!(GRAVITY_PARAMS.fetch(gravity), width, height, remove_padding_data_outside_window = true)
-  end
-
-  ImageVise.add_operator 'crop', self
-end

data/lib/image_vise/operators/ellipse_stencil.rb

@@ -1,70 +0,0 @@
-# Applies an elliptic stencil around the entire image. The stencil will fit inside the image boundaries,
-# with about 1 pixel cushion on each side to provide smooth anti-aliased edges. If the input image to be
-# provessed is square, the ellipse will turn into a neat circle.
-#
-# This adds an alpha channel to the image being processed (and premultiplies the RGB channels by it). This
-# will force the RenderEngine to return the processed image as a PNG in all cases, instead of keeping it
-# in the original format.
-#
-# The corresponding Pipeline method is `ellipse_stencil`.
-class ImageVise::EllipseStencil
-  C_black = 'black'.freeze
-  C_white = 'white'.freeze
-  private_constant :C_white, :C_black
-
-  def apply!(magick_image)
-    width, height = magick_image.columns, magick_image.rows
-    
-    # This is a bit involved. We need to do a manual composite. Here is what it entails.
-    #
-    # Given a premultiplied RGB image B, and a grayscale mask A, we need to do the following
-    # operation:
-    #
-    #    BrBgBb / Ba * (Ba * A)
-    #
-    # Since ImageMagick works with unpremultiplied alphas, it is doable - but special care
-    # must be taken not to overmult or overdivide.
-    #
-    # To begin,generate a black and white image for the stencil
-    mask = Magick::Image.new(width, height)
-    draw_circle(mask, width, height)
-    
-    # At this stage the mask contains a B/W image of the circle, black outside, white inside.
-    # Retain the alpha of the original in a separate image
-    only_alpha = magick_image.copy
-    only_alpha.alpha(Magick::ExtractAlphaChannel)
-    mask.composite!(only_alpha, Magick::CenterGravity, Magick::MultiplyCompositeOp)
-    
-    # With this composite op, enabling alpha on the destination image is
-    # not required - it will be enabled automatically.
-    # The CopyOpacityCompositeOp implies that we copy the grayscale version
-    # of the RGB channels as the alpha channel, so for some weird reason we need
-    # to disable the alpha on our mask image
-    mask.alpha(Magick::DeactivateAlphaChannel)
-    # And perform the operation (set gray(RGB) of mask as the A of magick_image)
-    magick_image.composite!(mask, Magick::CenterGravity, Magick::CopyOpacityCompositeOp)
-  ensure
-    [mask, only_alpha].each do |maybe_image|
-      ImageVise.destroy(maybe_image)
-    end
-  end
-  
-  def draw_circle(into_image, width, height)
-    center_x = (width / 2.0)
-    center_y = (height / 2.0)
-    # Make sure all the edges are anti-aliased
-    radius_width = center_x - 1.5
-    radius_height = center_y - 1.5
-
-    gc = Magick::Draw.new
-    gc.fill C_black
-    gc.rectangle(0, 0, width, height)
-    gc.fill C_white
-    gc.ellipse(center_x, center_y, radius_width, radius_height, deg_start=0, deg_end=360)
-    gc.draw(into_image)
-  ensure
-    ImageVise.destroy(gc)
-  end
-  
-  ImageVise.add_operator 'ellipse_stencil', self
-end

data/lib/image_vise/operators/fit_crop.rb

@@ -1,33 +0,0 @@
-# Fits the image based on the smaller-side fit. This means that the image is going to be fit
-# into the requested rectangle so that all of the pixels of the rectangle are filled. The
-# gravity parameter defines the crop gravity (on corners, sides, or in the middle).
-#
-# The corresponding Pipeline method is `fit_crop`.
-class ImageVise::FitCrop < Ks.strict(:width, :height, :gravity)
-  GRAVITY_PARAMS = {
-    'nw' => Magick::NorthWestGravity,
-    'n' => Magick::NorthGravity,
-    'ne' => Magick::NorthEastGravity,
-    'w' => Magick::WestGravity,
-    'c' => Magick::CenterGravity,
-    'e' => Magick::EastGravity,
-    'sw' => Magick::SouthWestGravity,
-    's' => Magick::SouthGravity,
-    'se' => Magick::SouthEastGravity,
-  }
-
-  def initialize(*)
-    super
-    self.width = width.to_i
-    self.height = height.to_i
-    raise ArgumentError, ":width must positive" unless width > 0
-    raise ArgumentError, ":height must positive" unless height > 0
-    raise ArgumentError, ":gravity must be within the permitted values" unless GRAVITY_PARAMS.key? gravity
-  end
-
-  def apply!(magick_image)
-    magick_image.resize_to_fill! width, height, GRAVITY_PARAMS.fetch(gravity)
-  end
-  
-  ImageVise.add_operator 'fit_crop', self
-end

data/lib/image_vise/operators/force_jpg_out.rb

@@ -1,17 +0,0 @@
-# Forces the output format to be JPEG and specifies the quality factor to use when saving
-#
-# The corresponding Pipeline method is `force_jpg_out`.
-class ImageVise::ForceJPGOut < Ks.strict(:quality)
-  def initialize(quality:)
-    unless (0..100).cover?(quality)
-      raise ArgumentError, "the :quality setting must be within 0..100, but was %d" % quality
-    end
-    self.quality = quality
-  end
-
-  def apply!(_, metadata)
-    metadata[:writer] = ImageVise::JPGWriter.new(quality: quality)
-  end
-
-  ImageVise.add_operator 'force_jpg_out', self
-end

data/lib/image_vise/operators/geom.rb

@@ -1,16 +0,0 @@
-# Applies a transformation using an ImageMagick geometry string
-#
-# The corresponding Pipeline method is `geom`.
-class ImageVise::Geom < Ks.strict(:geometry_string)
-  def initialize(*)
-    super
-    self.geometry_string = geometry_string.to_s
-    raise ArgumentError, "the :geom parameter must be present and not empty" if self.geometry_string.empty?
-  end
-
-  def apply!(image)
-    image.change_geometry(geometry_string) { |cols, rows, _| image.resize!(cols,rows) }
-  end
-
-  ImageVise.add_operator 'geom', self
-end

data/lib/image_vise/operators/sharpen.rb

@@ -1,21 +0,0 @@
-# Applies a sharpening filter to the image.
-#
-# The corresponding Pipeline method is `sharpen`.
-class ImageVise::Sharpen < Ks.strict(:radius, :sigma)
-  def initialize(*)
-    super
-    self.radius = radius.to_f
-    self.sigma = sigma.to_f
-    raise ArgumentError, ":radius must positive" unless sigma > 0
-    raise ArgumentError, ":sigma must positive" unless sigma > 0
-  end
-  
-  def apply!(magick_image)
-    sharpened_image = magick_image.sharpen(radius, sigma)
-    magick_image.composite!(sharpened_image, Magick::CenterGravity, Magick::CopyCompositeOp)
-  ensure
-    ImageVise.destroy(sharpened_image)
-  end
-end
-
-ImageVise.add_operator 'sharpen', ImageVise::Sharpen

data/lib/image_vise/operators/srgb.rb

@@ -1,30 +0,0 @@
-# Applies the sRGB profile to the image.
-# For this to work, your ImageMagick must be built
-# witl LCMS support. On OSX, you need to use the brew install
-# command with the following options:
-#
-#    $brew install imagemagick --with-little-cms --with-little-cms2
-#
-# You can verify if you do have LittleCMS support by checking the
-# delegates list that `$convert --version` outputs:
-#
-# For instance, if you do not have it, the list will look like this:
-#
-#    $ convert --version
-#    ...
-#    Delegates (built-in): bzlib freetype jng jpeg ltdl lzma png tiff xml zlib
-#
-# whereas if you do, the list will include the "lcms" delegate:
-#
-#    $ convert --version
-#    ...
-#    Delegates (built-in): bzlib freetype jng jpeg lcms ltdl lzma png tiff xml zlib
-#
-# The corresponding Pipeline method is `srgb`.
-class ImageVise::SRGB
-  PROFILE_PATH = File.expand_path(__dir__ + '/sRGB_v4_ICC_preference_displayclass.icc')
-  def apply!(magick_image)
-    magick_image.add_profile(PROFILE_PATH)
-  end
-  ImageVise.add_operator 'srgb', self
-end

data/lib/image_vise/operators/strip_metadata.rb

@@ -1,10 +0,0 @@
-# Strips metadata from the image (EXIF, IPTC etc.) using the
-# RMagick `strip!` method
-#
-# The corresponding Pipeline method is `strip_metadata`.
-class ImageVise::StripMetadata
-  def apply!(magick_image)
-    magick_image.strip!
-  end
-  ImageVise.add_operator 'strip_metadata', self
-end

data/lib/image_vise/pipeline.rb

@@ -1,64 +0,0 @@
-class ImageVise::Pipeline
-  def self.operator_by_name(name)
-    operator = ImageVise.operator_from(name)  or raise "Unknown operator #{name}"
-  end
-
-  def self.from_param(array_of_operator_names_to_operator_params)
-    operators = array_of_operator_names_to_operator_params.map do |(operator_name, operator_params)|
-      operator_class = operator_by_name(operator_name)
-      if operator_params && operator_params.any? && operator_class.method(:new).arity.nonzero?
-        operator_class.new(**operator_params)
-      else
-        operator_class.new
-      end
-    end
-    new(operators)
-  end
-
-  def initialize(operators = [])
-    @ops = operators.to_a
-  end
-
-  def <<(image_operator)
-    @ops << image_operator; self
-  end
-
-  def empty?
-    @ops.empty?
-  end
-
-  def method_missing(method_name, *a, &blk)
-    operator_builder = ImageVise.operator_from(method_name)
-    self << operator_builder.new(*a)
-  end
-  
-  def respond_to_missing?(method_name, *a)
-    ImageVise.defined_operators.include?(method_name.to_s)
-  end
-
-  def to_params
-    @ops.map do |operator|
-      operator_name = ImageVise.operator_name_for(operator)
-      operator_params = operator.respond_to?(:to_h) ? operator.to_h : {}
-      [operator_name, operator_params]
-    end
-  end
-
-  def apply!(magick_image, image_metadata)
-    @ops.each do |operator|
-      apply_operator_passing_metadata(magick_image, operator, image_metadata)
-    end
-  end
-
-  def apply_operator_passing_metadata(magick_image, operator, image_metadata)
-    if operator.method(:apply!).arity == 1
-      operator.apply!(magick_image)
-    else
-      operator.apply!(magick_image, image_metadata)
-    end
-  end
-
-  def each(&b)
-    @ops.each(&b)
-  end
-end