imglab 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2d52305397eb47d122dcfb0211c013ba7d7d11958bb45854949321a3972c87c7
+  data.tar.gz: 7bf0e1b1325ba9ee9e54be5b3c56cd43de1cc386fa902aba7c9a7468a458fc3f
+SHA512:
+  metadata.gz: eca396e106d905482ea8ed1a8c081b3bc9d9e5d5380b2af576ae4ab3a36f1318e7585f9a10c90fed9f7fa85be8c75d1b3c971a5bf205e7fd212e05dd5d8dc271
+  data.tar.gz: b2255cf65a8887bbdd1dbcff7a52c9bf724b8d05ee4b2127931f0f8ed8b424a2c4df4808d41fc63374f959c3e000c08ee54e165d9e4e7c882d1884f8d332868e

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+Gemfile.lock

data/.yardopts

@@ -0,0 +1 @@
+lib/**/*.rb --readme README.md --files LICENSE

data/Gemfile

@@ -0,0 +1,8 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in imglab.gemspec
+gemspec
+
+gem "rake", "~> 12.0"
+gem "minitest", "~> 5.11.3"
+gem "yard", "~> 0.9.26"

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 imglab
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,290 @@
+# imglab
+
+`imglab` is the official Ruby gem to integrate with imglab services.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "imglab", "~> 0.1.0"
+```
+
+And then execute:
+
+```sh
+$ bundle install
+```
+
+Or install it yourself as:
+
+```sh
+$ gem install imglab
+```
+
+## Ruby compatibility
+
+`imglab` has been successfully tested on the following Ruby versions: `3.0`, `2.7`, `2.6`, `2.5`, `2.4`, `2.3`, `2.2`, `2.1` and `2.0`.
+
+## Generating URLs
+
+You can use `Imglab.url` function to generate imglab compatible URLs for your application.
+
+The easiest way to generate a URL is to specify the `source_name`, `path` and required `parameters`:
+
+```ruby
+Imglab.url("assets", "image.jpeg", width: 500, height: 600)
+"https://cdn.imglab.io/assets/image.jpeg?width=500&height=600"
+
+Imglab.url("avatars", "user-01.jpeg", width: 300, height: 300, mode: :crop, crop: :face, format: :webp)
+"https://cdn.imglab.io/avatars/user-01.jpeg?width=300&height=300&mode=crop&crop=face&format=webp"
+```
+
+If some specific settings are required for the source you can use an instance of `Imglab::Source` class instead of a `string` source name:
+
+```ruby
+Imglab.url(Imglab::Source.new("assets"), "image.jpeg", width: 500, height: 600)
+"https://cdn.imglab.io/assets/image.jpeg?width=500&height=600"
+```
+
+### Using secure image sources
+
+For sources that require signed URLs you can specify `secure_key` and `secure_salt` attributes for the source:
+
+```ruby
+source = Imglab::Source.new(secure_key: "assets-secure-key", secure_salt: "assets-secure-salt")
+
+Imglab.url(source, "image.jpeg", width: 500, height: 600)
+"https://cdn.imglab.io/assets/image.jpeg?width=500&height=600&signature=generated-signature"
+```
+
+`signature` query parameter will be automatically generated and attached to the returned URL.
+
+> Note: `secure_key` and `secure_salt` attributes are secrets that should not be added to a code repository. Please use environment vars or other secure method to use them in your application.
+
+### Using HTTP instead of HTTPS
+
+In the case that HTTP schema is required instead of HTTPS you can set `https` attribute to `false` when creating the source:
+
+```ruby
+Imglab.url(Imglab::Source.new("assets", https: false), "image.jpeg", width: 500, height: 600)
+"http://cdn.imglab.io/assets/image.jpeg?width=500&height=600"
+```
+
+> Note: HTTPS is the default and recommended way to generate URLs with imglab.
+
+### Specifying parameters
+
+Any parameter from the imglab API can be used to generate URLs with `Imglab.url` method. For parameters that required dashes characters like `trim-color` you can use regular underscore Ruby symbols like `:trim_color` those will be normalized in the URL generation to it's correct form:
+
+```ruby
+Imglab.url("assets", "image.jpeg", trim: "color", trim_color: "black")
+"https://cdn.imglab.io/assets/image.jpeg?trim=color&trim-color=black"
+```
+
+It is possible to use strings too:
+
+```ruby
+Imglab.url("assets", "image.jpeg", "trim" => "color", "trim-color" => "black")
+"https://cdn.imglab.io/assets/image.jpeg?trim=color&trim-color=black"
+```
+
+And quoted symbols for Ruby version >= 2.2:
+
+```ruby
+Imglab.url("assets", "image.jpeg", trim: "color", "trim-color": "black")
+"https://cdn.imglab.io/assets/image.jpeg?trim=color&trim-color=black"
+```
+
+### Specifying color parameters
+
+Some imglab parameters can receive a color as value. It is possible to specify these color values as strings:
+
+```ruby
+# Specifying a RGB color as string
+Imglab.url("assets", "image.jpeg", width: 500, height: 600, mode: :contain, background_color: "255,0,0")
+"https://cdn.imglab.io/assets/image.jpeg?width=500&height=600&mode=contain&background-color=255%2C0%2C0"
+
+# Specifying a RGBA color as string
+Imglab.url("assets", "image.jpeg", width: 500, height: 600, mode: :contain, background_color: "255,0,0,128")
+"https://cdn.imglab.io/assets/image.jpeg?width=500&height=600&mode=contain&background-color=255%2C0%2C0%2C128"
+
+# Specifying a named color as string
+Imglab.url("assets", "image.jpeg", width: 500, height: 600, mode: :contain, background_color: "red")
+"https://cdn.imglab.io/assets/image.jpeg?width=500&height=600&mode=contain&background-color=red"
+
+# Specifying a hexadecimal color as string
+Imglab.url("assets", "image.jpeg", width: 500, height: 600, mode: :contain, background_color: "F00")
+"https://cdn.imglab.io/assets/image.jpeg?width=500&height=600&mode=contain&background-color=F00"
+```
+
+You can additionally use `Imglab::Color` helpers to specify these color values:
+
+```ruby
+# Remember to include Imglab::Color module before use these helpers
+include Imglab::Color
+
+# Using color helper for a RGB color
+Imglab.url("assets", "image.jpeg", width: 500, height: 600, mode: "contain", background_color: color(255, 0, 0))
+"https://cdn.imglab.io/assets/image.jpeg?width=500&height=600&mode=contain&background-color=255%2C0%2C0"
+
+# Using color helper for a RGBA color
+Imglab.url("assets", "image.jpeg", width: 500, height: 600, mode: "contain", background_color: color(255, 0, 0, 128))
+"https://cdn.imglab.io/assets/image.jpeg?width=500&height=600&mode=contain&background-color=255%2C0%2C0%2C128"
+
+# Using color helper for a named color
+Imglab.url("assets", "image.jpeg", width: 500, height: 600, mode: "contain", background_color: color("red"))
+"https://cdn.imglab.io/assets/image.jpeg?width=500&height=600&mode=contain&background-color=red"
+```
+
+> Note: specify hexadecimal color values using `Imglab::Color` helpers is not allowed. You can use strings instead.
+
+### Specifying position parameters
+
+Some imglab parameters can receive a position as value. It is possible to specify these values using strings:
+
+```ruby
+# Specifying a horizontal and vertical position as string
+Imglab.url("assets", "image.jpeg", width: 500, height: 500, mode: "crop", crop: "left,top")
+"https://cdn.imglab.io/assets/image.jpeg?width=500&height=500&mode=crop&crop=left%2Ctop"
+
+# Specifying a vertical and horizontal position as string
+Imglab.url("assets", "image.jpeg", width: 500, height: 500, mode: "crop", crop: "top,left")
+"https://cdn.imglab.io/assets/image.jpeg?width=500&height=500&mode=crop&crop=top%2Cleft"
+
+# Specifying a position as string
+Imglab.url("assets", "image.jpeg", width: 500, height: 500, mode: "crop", crop: "left")
+"https://cdn.imglab.io/assets/image.jpeg?width=500&height=500&mode=crop&crop=left"
+```
+
+You can additionally use `Imglab::Position` helpers to specify these position values:
+
+```ruby
+# Remember to include Imglab::Position module before use these helpers
+include Imglab::Position
+
+# Using position helper for a horizontal and vertical position
+Imglab.url("assets", "image.jpeg", width: 500, height: 500, mode: "crop", crop: position("left", "top"))
+"https://cdn.imglab.io/assets/image.jpeg?width=500&height=500&mode=crop&crop=left%2Ctop"
+
+# Using position macro for a vertical and horizontal position
+Imglab.url("assets", "image.jpeg", width: 500, height: 500, mode: "crop", crop: position("top", "left"))
+"https://cdn.imglab.io/assets/image.jpeg?width=500&height=500&mode=crop&crop=top%2Cleft"
+
+# Using position macro for a position
+Imglab.url("assets", "image.jpeg", width: 500, height: 500, mode: "crop", crop: position("left"))
+"https://cdn.imglab.io/assets/image.jpeg?width=500&height=500&mode=crop&crop=left"
+```
+
+### Specifying URL parameters
+
+Some imglab parameters can receive URLs as values. It is possible to specify these parameter values as strings.
+
+```ruby
+Imglab.url("assets", "image.jpeg", width: 500, height: 600, watermark: "logo.svg")
+"https://cdn.imglab.io/assets/image.jpeg?width=500&height=600&watermark=logo.svg"
+```
+
+And even use parameters if required:
+
+```ruby
+Imglab.url("assets", "image.jpeg", width: 500, height: 600, watermark: "logo.svg?width=100&format=png")
+"https://cdn.imglab.io/assets/image.jpeg?width=500&height=600&watermark=logo.svg%3Fwidth%3D100%26format%3Dpng"
+```
+
+Additionally you can use nested `Imglab.url` calls to specify these URL values:
+
+```ruby
+Imglab.url(
+  "assets",
+  "image.jpeg",
+  width: 500,
+  height: 600,
+  watermark: Imglab.url("assets", "logo.svg", width: 100, format: "png")
+)
+"https://cdn.imglab.io/assets/image.jpeg?width=500&height=600&watermark=https%3A%2F%2Fcdn.imglab.io%2Fassets%2Flogo.svg%3Fwidth%3D100%26format%3Dpng"
+```
+
+If the resource is located in a different source we can specify it using `Imglab.url`:
+
+```ruby
+Imglab.url(
+  "assets",
+  "image.jpeg",
+  width: 500,
+  height: 600,
+  watermark: Imglab.url("marketing", "logo.svg", width: 100, format: "png")
+)
+"https://cdn.imglab.io/assets/image.jpeg?width=500&height=600&watermark=https%3A%2F%2Fcdn.imglab.io%2Fmarketing%2Flogo.svg%3Fwidth%3D100%26format%3Dpng"
+```
+
+Using secure sources for URLs parameter values is possible too:
+
+```ruby
+marketing_source = Imglab::Source.new("marketing", secure_key: "marketing-secure-key", secure_salt: "marketing-secure-salt")
+
+Imglab.url(
+  "assets",
+  "image.jpeg",
+  width: 500,
+  height: 600,
+  watermark: Imglab.url(marketing_source, "logo.svg", width: 100, format: "png")
+)
+```
+
+`signature` query parameter will be automatically generated and attached to the nested URL value.
+
+## Generating URLs for on-premises imglab server
+
+For on-premises imglab server is possible to define custom sources pointing to your server location.
+
+* `:https` - a `boolean` value specifying if the source should use https or not (default: `true`)
+* `:host` - a `string` specifying the host where the imglab server is located. (default: `cdn.imglab.io`)
+* `:port` - a `integer` specifying a port where the imglab server is located.
+* `:subdomains` - a `boolean` value specifying if the source should be specified using subdomains instead of using the path. (default: `false`)
+
+If we have our on-premises imglab server at `http://imglab.mycompany.com:8080` with a source named `web-images` we can use the following source settings to access a `logo.png` image:
+
+```ruby
+source = Imglab::Source.new("web-images", https: false, host: "imglab.mycompany.com", port: 8080)
+
+Imglab.url(source, "logo.png", width: 300, height: 300, format: "png")
+"http://imglab.mycompany.com:8080/web-images/logo.png?width=300&height=300&format=png"
+```
+
+It is possible to use secure sources too:
+
+```ruby
+source = Imglab::Source.new(
+  "web-images",
+  https: false,
+  host: "imglab.mycompany.com",
+  port: 8080,
+  secure_key: "web-images-secure-key",
+  secure_salt: "web-images-secure-salt"
+)
+
+Imglab.url(source, "logo.png", width: 300, height: 300, format: "png")
+"http://imglab.mycompany.com:8080/web-images/logo.png?width=300&height=300&format=png&signature=generated-signature"
+```
+
+### Using sudomains sources
+
+In the case that your on-premises imglab server is configured to use source names as subdomains you can set `subdomains` attribute to `true` to generate URLs using subdomains:
+
+```ruby
+source = Imglab::Source.new(
+  "web-images",
+  https: false,
+  host: "imglab.mycompany.com",
+  port: 8080,
+  subdomains: true
+)
+
+Imglab.url(source, "marketing/logo.png", width: 300, height: 300, format: "png")
+"http://web-images.imglab.mycompany.com:8080/marketing/logo.png?width=300&height=300&format=png"
+```
+
+## License
+
+imglab source code is released under [MIT License](LICENSE).

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "imglab"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/imglab.gemspec

@@ -0,0 +1,26 @@
+require_relative "lib/imglab/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "imglab"
+  spec.version       = Imglab::VERSION
+  spec.authors       = ["imglab"]
+  spec.email         = ["support@imglab.io"]
+
+  spec.summary       = %q{Official imglab Ruby library.}
+  spec.description   = %q{Official Ruby library to integrate with imglab services.}
+  spec.homepage      = "https://github.com/imglab-io/imglab-rb"
+  spec.license       = "MIT"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.0.0")
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/imglab-io/imglab-rb"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path("..", __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features|.github)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+end

data/lib/imglab/color.rb

@@ -0,0 +1,195 @@
+module Imglab::Color
+  extend self
+
+  COLORS = %w[
+    aliceblue
+    antiquewhite
+    aqua
+    aquamarine
+    azure
+    beige
+    bisque
+    black
+    blanchedalmond
+    blue
+    blueviolet
+    brown
+    burlywood
+    cadetblue
+    chartreuse
+    chocolate
+    coral
+    cornflowerblue
+    cornsilk
+    crimson
+    cyan
+    darkblue
+    darkcyan
+    darkgoldenrod
+    darkgray
+    darkgreen
+    darkgrey
+    darkkhaki
+    darkmagenta
+    darkolivegreen
+    darkorange
+    darkorchid
+    darkred
+    darksalmon
+    darkseagreen
+    darkslateblue
+    darkslategray
+    darkslategrey
+    darkturquoise
+    darkviolet
+    deeppink
+    deepskyblue
+    dimgray
+    dimgrey
+    dodgerblue
+    firebrick
+    floralwhite
+    forestgreen
+    fuchsia
+    gainsboro
+    ghostwhite
+    gold
+    goldenrod
+    gray
+    green
+    greenyellow
+    grey
+    honeydew
+    hotpink
+    indianred
+    indigo
+    ivory
+    khaki
+    lavender
+    lavenderblush
+    lawngreen
+    lemonchiffon
+    lightblue
+    lightcoral
+    lightcyan
+    lightgoldenrodyellow
+    lightgray
+    lightgreen
+    lightgrey
+    lightpink
+    lightsalmon
+    lightseagreen
+    lightskyblue
+    lightslategray
+    lightslategrey
+    lightsteelblue
+    lightyellow
+    lime
+    limegreen
+    linen
+    magenta
+    maroon
+    mediumaquamarine
+    mediumblue
+    mediumorchid
+    mediumpurple
+    mediumseagreen
+    mediumslateblue
+    mediumspringgreen
+    mediumturquoise
+    mediumvioletred
+    midnightblue
+    mintcream
+    mistyrose
+    moccasin
+    navajowhite
+    navy
+    oldlace
+    olive
+    olivedrab
+    orange
+    orangered
+    orchid
+    palegoldenrod
+    palegreen
+    paleturquoise
+    palevioletred
+    papayawhip
+    peachpuff
+    peru
+    pink
+    plum
+    powderblue
+    purple
+    rebeccapurple
+    red
+    rosybrown
+    royalblue
+    saddlebrown
+    salmon
+    sandybrown
+    seagreen
+    seashell
+    sienna
+    silver
+    skyblue
+    slateblue
+    slategray
+    slategrey
+    snow
+    springgreen
+    steelblue
+    tan
+    teal
+    thistle
+    tomato
+    turquoise
+    violet
+    wheat
+    white
+    whitesmoke
+    yellow
+    yellowgreen
+  ]
+
+  # Returns a formatted color value as string.
+  #
+  # @param args [Array<Integer>, String] the RGB, RGBA components as integers or a string with a named color.
+  # @return [String] the formatted color with the specified arguments.
+  # @raise [ArgumentError] when the specified arguments are not a valid color.
+  #
+  # @example Specify a RGB color
+  #   Imglab::Color.color(255, 128, 128) #=> "255,128,128"
+  # @example Specify a RGBA color
+  #   Imglab::Color.color(255, 128, 128, 64) #=> "255,128,128,64"
+  # @example Specify a named color
+  #   Imglab::Color.color("white") #=> "white"
+  # @example Specify an invalid RGB color (raising ArgumentError exception)
+  #   Imglab::Color.color(256, 255, 255) #=> ArgumentError: Invalid color
+  # @example Specify an invalid RGBA color (raising ArgumentError exception)
+  #   Imglab::Color.color(255, 255, 255, 256) #=> ArgumentError: Invalid color
+  # @example Specify an invalid named color (raising ArgumentError exception)
+  #   Imglab::Color.color("blues") #=> ArgumentError: Invalid color
+  def color(*args)
+    case
+    when args.size == 1 && COLORS.include?(args[0])
+      args[0]
+    when args.size == 3 && valid_components?(*args)
+      args.join(",")
+    when args.size == 4 && valid_components?(*args)
+      args.join(",")
+    else
+      raise ArgumentError.new("Invalid color")
+    end
+  end
+
+  private
+
+  def valid_components?(*components)
+    components.all? { |component| valid_component?(component) }
+  end
+
+  def valid_component?(component)
+    component.is_a?(Integer) && component >= 0 && component <= 255
+  end
+end

data/lib/imglab/position.rb

@@ -0,0 +1,55 @@
+module Imglab::Position
+  extend self
+
+  HORIZONTAL = %w[left center right]
+  VERTICAL = %w[top middle bottom]
+
+  # Returns a formatted position value as string.
+  #
+  # @param args [Array<String>, String] the position with two directions or one single direction as strings.
+  # @return [String] the formatted position with the specified arguments.
+  # @raise [ArgumentError] when the specified arguments are not a valid position.
+  #
+  # @example Specify a double direction position (horizontal, vertical order)
+  #   Imglab::Position.position("left", "bottom") #=> "left,bottom"
+  # @example Specify a double direction position (vertical, horizontal order)
+  #   Imglab::Position.position("bottom", "left") #=> "bottom,left"
+  # @example Specify a single direction position
+  #   Imglab::Position.position("left") #=> "left"
+  # @example Specify an invalid double direction position (raising ArgumentError exception)
+  #   Imglab::Position.position("left", "center") #=> ArgumentError: Invalid position
+  # @example Specify an invalid single direction position (raising ArgumentError exception)
+  #   Imglab::Position.position("lefts") #=> ArgumentError: Invalid position
+  def position(*args)
+    case
+    when args.size == 1 && valid_position?(args[0])
+      args[0]
+    when args.size == 2 && valid_position?(*args)
+      args.join(",")
+    else
+      raise ArgumentError.new("Invalid position")
+    end
+  end
+
+  private
+
+  def valid_position?(*args)
+    case
+    when args.size == 1 && valid_direction?(args[0])
+      true
+    when args.size == 2 && valid_directions?(args[0], args[1])
+      true
+    else
+      false
+    end
+  end
+
+  def valid_direction?(direction)
+    HORIZONTAL.include?(direction) || VERTICAL.include?(direction)
+  end
+
+  def valid_directions?(direction_a, direction_b)
+    (HORIZONTAL.include?(direction_a) && VERTICAL.include?(direction_b)) ||
+    (HORIZONTAL.include?(direction_b) && VERTICAL.include?(direction_a))
+  end
+end

data/lib/imglab/signature.rb

@@ -0,0 +1,22 @@
+require "base64"
+require "openssl"
+
+class Imglab::Signature
+  # Returns a generated signature for a source, path and encoded parameters.
+  #
+  # @param source [Imglab::Source] the source used to generate the signature.
+  # @param path [String] the path of the resource.
+  # @param encoded_params [String] encoded query params of the URL to generate the signature.
+  # @return [String]
+  def self.generate(source, path, encoded_params = nil)
+    decoded_secure_key = Base64.decode64(source.secure_key)
+    decoded_secure_salt = Base64.decode64(source.secure_salt)
+
+    data = "#{decoded_secure_salt}/#{path}"
+    data = encoded_params ? "#{data}?#{encoded_params}" : data
+
+    hmac = OpenSSL::HMAC.digest(OpenSSL::Digest.new("sha256"), decoded_secure_key, data)
+
+    Base64.urlsafe_encode64(hmac).tr("=", "")
+  end
+end

data/lib/imglab/source.rb

@@ -0,0 +1,63 @@
+class Imglab::Source
+  DEFAULT_HTTPS = true
+  DEFAULT_HOST = "cdn.imglab.io"
+  DEFAULT_SUBDOMAINS = false
+
+  attr_reader :name, :https, :port, :secure_key, :secure_salt, :subdomains
+
+  # Returns a Imglab::Source instance with the specified options for the source.
+  #
+  # @param name [String] the name of the source.
+  # @param host [String] the host where the imglab server is located, only for imglab on-premises.
+  # @param https [Boolean] specify if the source should use https or not.
+  # @param port [Integer] the port where the imglab server is located, only for imglab on-premises.
+  # @param secure_key [String] the source secure key.
+  # @param secure_salt [String] the source secure salt.
+  # @param subdomains [Boolean] specify if the source should use subdomains to build the host name, only for imglab on-premises.
+  # @return [Imglab::Source] with the specified options.
+  def initialize(name, host: DEFAULT_HOST, https: DEFAULT_HTTPS, port: nil, secure_key: nil, secure_salt: nil, subdomains: DEFAULT_SUBDOMAINS)
+    @name = name
+    @host = host
+    @https = https
+    @port = port
+    @secure_key = secure_key
+    @secure_salt = secure_salt
+    @subdomains = subdomains
+  end
+
+  # Returns the URI scheme to be used with the source ("http" or "https").
+  #
+  # @return [String]
+  def scheme
+    @https ? "https" : "http"
+  end
+
+  # Returns the host to be used with the source.
+  #
+  # @return [String]
+  def host
+    @subdomains ? "#{@name}.#{@host}" : @host
+  end
+
+  # Returns a the path to be used with the source.
+  #
+  # @param path [String]
+  # @return [String]
+  def path(path)
+    @subdomains ? path : File.join(@name, path)
+  end
+
+  # Returns if the source is secure or not.
+  #
+  # @return [Boolean]
+  def secure?
+    @secure_key && @secure_salt
+  end
+
+  # Overrided inspect method to don't show sensitive attributes like secure_key and secure_salt.
+  #
+  # @return [String]
+  def inspect
+    "#<#{self.class.name}:#{object_id} @name=#{@name.inspect}, @host=#{@host.inspect}, @https=#{@https.inspect}, @port=#{@port.inspect}, @subdomains=#{@subdomains.inspect}>"
+  end
+end

data/lib/imglab/utils.rb

@@ -0,0 +1,29 @@
+class Imglab::Utils
+  NORMALIZE_PATH_PREFIX_REGEXP = Regexp.compile(/\/*$/)
+  NORMALIZE_PATH_SUFFIX_REGEXP = Regexp.compile(/\A\/*/)
+
+  # Returns a normalized path where suffix and prefix slashes are removed.
+  #
+  # @param path [String]
+  # @return [String]
+  def self.normalize_path(path)
+    path.gsub(NORMALIZE_PATH_PREFIX_REGEXP, "").gsub(NORMALIZE_PATH_SUFFIX_REGEXP, "")
+  end
+
+  # Returns normalized params, transforming keys with undercores to hyphens.
+  #
+  # @param params [Hash]
+  # @return [Hash]
+  def self.normalize_params(params)
+    params.inject({}) do |normalized_params, value|
+      normalized_params[dasherize(value[0])] = value[1]
+      normalized_params
+    end
+  end
+
+  private
+
+  def self.dasherize(value)
+    value.to_s.gsub("_", "-")
+  end
+end

data/lib/imglab/version.rb

@@ -0,0 +1,3 @@
+module Imglab
+  VERSION = "0.1.0"
+end

data/lib/imglab.rb

@@ -0,0 +1,72 @@
+require "imglab/version"
+require "imglab/source"
+require "imglab/signature"
+require "imglab/color"
+require "imglab/position"
+require "imglab/utils"
+
+module Imglab
+  # Returns a formatted URL `string` with the specified arguments.
+  #
+  # @param source_name_or_source [String, Imglab::Source] the source name or source object
+  # @param path [String] the path where the resource is located
+  # @param params [Hash] the query parameters that we want to use
+  # @return [String] the formatted URL with the specified arguments
+  # @raise [ArgumentError] when the source name or source parameter has a not expected type.
+  #
+  # @example Creating a URL specifying source name as string
+  #   Imglab.url("assets", "example.jpeg", width: 500, height: 600) #=> "https://cdn.imglab.io/assets/example.jpeg?width=500&height=600"
+  # @example Creating a URL specifying a Imglab::Source
+  #   Imglab.url(Imglab::Source.new("assets"), "example.jpeg", width: 500, height: 600) #=> "https://cdn.imglab.io/assets/example.jpeg?width=500&height=600"
+  def self.url(source_name_or_source, path, params = {})
+    case source_name_or_source
+    when String
+      url_for_source(Source.new(source_name_or_source), path, params)
+    when Source
+      url_for_source(source_name_or_source, path, params)
+    else
+      raise ArgumentError.new("Invalid source name or source. A string or #{Imglab::Source.name} is expected.")
+    end
+  end
+
+  private
+
+  def self.url_for_source(source, path, params)
+    normalized_path = Utils.normalize_path(path)
+    normalized_params = Utils.normalize_params(params)
+
+    URI::Generic.new(
+      source.scheme,
+      nil,
+      source.host,
+      source.port,
+      nil,
+      File.join("/", source.path(normalized_path)),
+      nil,
+      encode_params(source, normalized_path, normalized_params),
+      nil
+    ).to_s
+  end
+
+  def self.encode_params(source, path, params)
+    return encode_empty_params(source, path) if params.empty?
+
+    if source.secure?
+      signature = Signature.generate(source, path, URI.encode_www_form(params))
+
+      URI.encode_www_form(params.merge(signature: signature))
+    else
+      URI.encode_www_form(params)
+    end
+  end
+
+  def self.encode_empty_params(source, path)
+    if source.secure?
+      signature = Signature.generate(source, path)
+
+      URI.encode_www_form(signature: signature)
+    else
+      nil
+    end
+  end
+end

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification
+name: imglab
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- imglab
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2021-11-24 00:00:00.000000000 Z
+dependencies: []
+description: Official Ruby library to integrate with imglab services.
+email:
+- support@imglab.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".yardopts"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- imglab.gemspec
+- lib/imglab.rb
+- lib/imglab/color.rb
+- lib/imglab/position.rb
+- lib/imglab/signature.rb
+- lib/imglab/source.rb
+- lib/imglab/utils.rb
+- lib/imglab/version.rb
+homepage: https://github.com/imglab-io/imglab-rb
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/imglab-io/imglab-rb
+  source_code_uri: https://github.com/imglab-io/imglab-rb
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Official imglab Ruby library.
+test_files: []