spider_monkey 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d3271d3ed18f2ac7b406b7be42c9536b03863a9b
-  data.tar.gz: 1df01db03334cadf6cc889ba94c45f4dbd58d9f5
+  metadata.gz: ca54d3b1d9e3ae2d36c0baff41cec4bf784e8d76
+  data.tar.gz: 6e72c92b2332feadc22301c34d8979085ecab0d2
 SHA512:
-  metadata.gz: b3db7abb435f9fd6687617f6230f5222706f0e154382f8756863364cf13bba48ac397d1c6e604e51d43a5e269e24ddac8753a4ac9c5a8e26f132583ed48cd4d8
-  data.tar.gz: 5319f39d083eeda46eb49b7f1affe846b710877fb7385276d39125ffcc1d0c3f9356a763de77371961dbadcbe402ba71951a1381c1357b59056bbdd67636dad2
+  metadata.gz: 39f64bccf3aa5bb8e57f471a9dc4a2558b5dfeb17ed2b3fe4a75422060f069c0a62e9e8ec2e1d708b8db01a7840283947c1c5745581f0870cc2db425bf6579c6
+  data.tar.gz: 28ba8f0600e665273eada889d9e6b509c809e77ae50cdbb782703ba81094e0ab1fef9b847404df3cc6bdd7b75eb5dcea6feecf5e760e73da000bfed1a83926e6

data/Rakefile

@@ -0,0 +1,8 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+end
+
+desc "Run tests"
+task :default => :test

data/lib/spider_monkey.rb

@@ -1,4 +1,6 @@
+require 'active_support/all'
 require 'spider_monkey/config'
+require 'spider_monkey/validator'
 require 'spider_monkey/helper'
 
 ActiveSupport.on_load(:action_view) do

data/lib/spider_monkey/config.rb

@@ -5,6 +5,7 @@ module SpiderMonkey
     cloudfront_host:  "",
     user_secret:      "",
     user_key:         "",
+    validation_error_handler: ->(message, recoverable, valid_options, invalid_options){puts(message)}
   }
   
   def self.config

data/lib/spider_monkey/helper.rb

@@ -4,12 +4,19 @@ module SpiderMonkey
       options = options.reverse_merge(
         key: SpiderMonkey.configuration[:user_key]
       )
-      options_string = spider_monkey_string_from_options_hash(options)
-      signature = spider_monkey_signature_from_options_string(options_string)
+      validation = SpiderMonkey::Validator.new(options).validate_options
+      if validation[:passed] || validation[:recoverable]
+        options = validation[:valid_options]
+        
+        options_string = spider_monkey_string_from_options_hash(options)
+        signature = spider_monkey_signature_from_options_string(options_string)
     
-      compressed_string = Base64.urlsafe_encode64(Zlib::Deflate.deflate(options_string))
+        compressed_string = Base64.urlsafe_encode64(Zlib::Deflate.deflate(options_string))
     
-      "#{SpiderMonkey.configuration[:protocol]}://#{SpiderMonkey.configuration[:cloudfront_host]}/c?o=#{compressed_string}&s=#{signature}"
+        "#{SpiderMonkey.configuration[:protocol]}://#{SpiderMonkey.configuration[:cloudfront_host]}/c?o=#{compressed_string}&s=#{signature}"
+      else
+        ""
+      end
     end
   
     private

data/lib/spider_monkey/validator.rb

@@ -0,0 +1,288 @@
+module SpiderMonkey
+  class Validator
+    def initialize(options = {})
+      @options = options
+    end
+    
+    def validate_options
+      @passed = true
+      @recoverable = true
+      @valid_options = {}
+      @invalid_options = {}
+      @messages = []
+      
+      @options.each do |key, value|
+        # First, lets loop through them all and remove any invalid keys
+        if !is_allowed_root_key?(key)
+          @invalid_options[key] = value
+          @options.delete(key)
+          @messages << "Extra Key present: #{key}"
+        end
+      end
+      
+      
+      if is_source?(@options, "source")
+        @valid_options[:source_url] = @options[:source_url] if @options[:source_url]
+        @valid_options[:source_key] = @options[:source_key] if @options[:source_key]
+        @valid_options[:source_bucket] = @options[:source_bucket] if @options[:source_bucket]
+      else
+        @messages << "Invalid Source."
+        @recoverable = false
+        @invalid_options[:source_url] = @options[:source_url] if @options[:source_url]
+        @invalid_options[:source_key] = @options[:source_key] if @options[:source_key]
+        @invalid_options[:source_bucket] = @options[:source_bucket] if @options[:source_bucket]
+      end
+      
+      @options.delete(:source_url)
+      @options.delete(:source_key)
+      @options.delete(:source_bucket)
+      
+      
+      validate_option(:colorspace, :read_colorspace)
+      validate_option(:integer_like, :read_density)
+      validate_option(:integer_like, :quality)
+      validate_option(:integer_like, :width, true)
+      validate_option(:integer_like, :height, true)
+      validate_option(:resize_method, :resize_method)
+      validate_option(:gravity, :resize_gravity)
+      validate_option(:boolean, :thumbnail)
+      validate_option(:integer_like, :density)
+      validate_option(:string, :key, true)
+      validate_option(:colorspace, :colorspace)
+      validate_option(:color, :background_color)
+
+      #:annotate,
+      @valid_options[:annotate] = @options[:annotate] if @options[:annotate]
+      #:composite
+      @valid_options[:composite] = @options[:composite] if @options[:composite]
+      
+      #:annotate
+        # array, or single element
+          # :gravity
+          # :weight integer
+          # :pointsize interger
+          # :color "blue", "#123456", "rgb(1,1,1)", "rgba(12,12,12)"
+          # :translate_x integer
+          # :translate_y integer
+          # :text (required) string
+      
+      # :composite
+      #   :url / :key && :bucket
+      #   width  numeric or percentage
+      #   height
+      #   :resize_gravity
+      #   :disolve_percent optional - integer 0-100
+
+
+      if @messages.size > 0
+        @passed = false
+      end
+      
+      SpiderMonkey.configuration[:validation_error_handler].call(@messages, @recoverable, @valid_options, @invalid_options) unless @passed
+      return {
+        passed: @passed,
+        recoverable: @recoverable,
+        valid_options: @valid_options
+      }
+    end
+    
+    def validate_option(validation_type, key, required = false)
+      if @options[key].present?
+        if send("is_#{validation_type}?".to_sym, @options[key])
+          @valid_options[key] = @options[key]
+        else
+          @recoverable = false
+          @messages << "Invalid parameter: #{key}."
+          @invalid_options[key] = @options[key]
+        end
+      elsif required
+        @recoverable = false
+        @messages << "Missing parameter: #{key}"
+      end
+      @options.delete(key)
+    end
+    
+    
+    def is_integer_like?(input)
+      is_integer?(input) || /\A[-+]?\d+\z/ === input
+    end
+    
+    def is_integer?(input)
+      input.kind_of? Integer
+    end
+    
+    def is_string?(input)
+      input.kind_of?(String) && !input.blank?
+    end
+    
+    def is_symbol?(input)
+      input.kind_of? Symbol
+    end
+    
+    def is_boolean?(input)
+      input.kind_of?(TrueClass) || input.kind_of?(FalseClass)
+    end
+    
+    def is_color?(input)
+      # This is really just a semi-validator.
+      return false unless is_string?(input) || is_symbol?(input)
+      
+      input = input.to_s
+      
+      if input.starts_with?("#")
+        # We have a hash color
+        # All Valid:
+        # #00F
+        # #0000FF
+        # #0000FFFF (w/ alpha)
+        return false unless [4, 7, 9].include?(input.length)
+        hex_input = input[1..(input.length)] # everything except the first character
+        return !hex_input[/\H/]
+      elsif input.starts_with?("rgba")
+        # 1 of each parentheses and 3 commas
+        return input.scan("(").count == 1 && input.scan(")").count == 1 && input.scan(",").count == 3
+      elsif input.starts_with?("rgb")
+        # 1 of each parentheses and 2 commas
+        return input.scan("(").count == 1 && input.scan(")").count == 1 && input.scan(",").count == 2
+      else
+        # Some other string. We're going to just assume it's a color. In an
+        # ideal world we would check it against the valid list, but that's way
+        # too detailed.
+        return true
+      end
+    end
+    
+    def is_gravity?(input)
+      %w(
+        northwest
+        north
+        northeast
+        west
+        center
+        east
+        southwest
+        south
+        southeast
+      ).include?(input.to_s.downcase)
+    end
+    
+    def is_colorspace?(input)
+      %w(
+        CIELab
+        CMY
+        CMYK
+        Gray
+        HCL
+        HCLp
+        HSB
+        HSI
+        HSL
+        HSV
+        HWB
+        Lab
+        LCH
+        LCHab
+        LCHuv
+        LMS
+        Log
+        Luv
+        OHTA
+        Rec601Luma
+        Rec601YCbCr
+        Rec709Luma
+        Rec709YCbCr
+        RGB
+        scRGB
+        sRGB
+        Transparent
+        XYZ
+        xyY
+        YCbCr
+        YDbDr
+        YCC
+        YIQ
+        YPbPr
+        YUV
+      ).include?(input.to_s)
+    end
+    
+    def is_percent?(input)
+      # String, with a percent sign, and an integer
+      input.kind_of?(String) && input.include?('%') && is_integer_like?(input.gsub('%', ''))
+    end
+    
+    def is_url?(input)
+      # Super lame test
+      is_string?(input) && ( input.starts_with?("http://") || input.starts_with?("https://") ) && input.length > 10
+    end
+    
+    def is_resize_method?(input)
+      return false unless is_string?(input) || is_symbol?(input)
+      ["crop", "fit"].include? input.to_s.downcase
+    end
+    
+    def is_source?(input, prefix = nil)
+      return false unless input.kind_of? Hash 
+      
+      if prefix.present?
+        prefix = prefix + "_"
+      end
+      
+      if input.has_key?("#{prefix}url".to_sym)
+        return false unless !input.has_key?("#{prefix}bucket".to_sym) && !input.has_key?("#{prefix}key".to_sym)
+        return is_url?(input["#{prefix}url".to_sym])
+      elsif (input.has_key?("#{prefix}bucket".to_sym) && input.has_key?("#{prefix}key".to_sym))
+        return false unless !input.has_key?("#{prefix}url".to_sym)
+        return (is_string?(input["#{prefix}bucket".to_sym]) && is_string?(input["#{prefix}key".to_sym]))
+      else
+        return false
+      end
+    end
+    
+    def is_allowed_root_key?(symbol)
+      [
+        :key,
+        :source_url,
+        :source_key,
+        :source_bucket,
+        :read_density,
+        :read_colorspace,
+        :quality,
+        :width,
+        :height,
+        :resize_method,
+        :resize_gravity,
+        :thumbnail,
+        :density,
+        :colorspace,
+        :annotate,
+        :composite,
+        :background_color
+      ].include?(symbol)
+    end
+    
+    def is_allowed_annotate_key?(symbol)
+      [
+        :gravity,
+        :weight,
+        :pointsize,
+        :color,
+        :translate_x,
+        :translate_y,
+        :text
+      ].include?(symbol)
+    end
+    
+    def is_allowed_composite_key?(symbol)
+      [
+        :url,
+        :key,
+        :bucket,
+        :width,
+        :height,
+        :resize_gravity,
+        :disolve_percent
+      ].include?(symbol)
+    end
+  end
+end

data/spider_monkey.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = "spider_monkey"
-  s.version     = "0.0.3"
+  s.version     = "0.0.4"
   s.platform    = Gem::Platform::RUBY
 
   s.authors = ["Ben McFadden"]
@@ -9,10 +9,13 @@ Gem::Specification.new do |s|
   s.email = "ben@forgeapps.com"
   s.files        = `git ls-files`.split("\n")
 
-  #s.homepage = "http://github.com/ForgeApps/anaconda"
+  #s.homepage = ""
   s.licenses = ["MIT"]
   s.require_paths = ["lib"]
   s.rubygems_version = "2.0.3"
   s.summary = "usespidermonkey.com integration"
+  
+  s.add_dependency "activesupport"
+  s.add_development_dependency "minitest-reporters"
 
 end

data/test/test_helper.rb

@@ -0,0 +1,2 @@
+require "minitest/reporters"
+Minitest::Reporters.use! Minitest::Reporters::SpecReporter.new

data/test/test_validator.rb

@@ -0,0 +1,256 @@
+require 'minitest/autorun'
+require 'spider_monkey'
+
+class SpiderMonkeyValidatorTest < Minitest::Test
+  def test_validate_options
+    url = "http://example.com/image.jpg"
+    
+    options = {width: 150, height: 85, resize_method: :crop, resize_gravity: "Center", density: 300, quality: 90, thumbnail: true, source_url: url, key: "asdf"}
+    validator = SpiderMonkey::Validator.new(options)
+    response = validator.validate_options
+    assert response[:passed]
+    assert response[:recoverable]
+
+    options = {extra_params: "foobar", width: 150, height: 85, resize_method: :crop, resize_gravity: "Center", density: 300, quality: 90, thumbnail: true, source_url: url, key: "asdf"}
+    validator = SpiderMonkey::Validator.new(options)
+    response = validator.validate_options
+    refute response[:passed]
+    assert response[:recoverable]
+    
+    
+    options = {width: nil, height: 85, resize_method: :crop, resize_gravity: "Center", density: 300, quality: 90, thumbnail: true, source_url: url, key: "asdf"}
+    validator = SpiderMonkey::Validator.new(options)
+    response = validator.validate_options
+    refute response[:passed]
+    refute response[:recoverable]
+    
+    options = {height: 85, resize_method: :crop, resize_gravity: "Center", density: 300, quality: 90, thumbnail: true, source_url: url, key: "asdf"}
+    validator = SpiderMonkey::Validator.new(options)
+    response = validator.validate_options
+    refute response[:passed]
+    refute response[:recoverable]
+    
+    options = {width: "foo", height: 85, resize_method: :crop, resize_gravity: "Center", density: 300, quality: 90, thumbnail: true, source_url: url, key: "asdf"}
+    validator = SpiderMonkey::Validator.new(options)
+    response = validator.validate_options
+    refute response[:passed]
+    refute response[:recoverable]
+    
+    options = {}
+    validator = SpiderMonkey::Validator.new(options)
+    response = validator.validate_options
+    refute response[:passed]
+    refute response[:recoverable]
+    
+    options = {width: 150, height: 85, source_url: url, key: "asdf"}
+    validator = SpiderMonkey::Validator.new(options)
+    response = validator.validate_options
+    assert response[:passed]
+    assert response[:recoverable]
+  end
+  
+  def test_is_integer?
+    validator = SpiderMonkey::Validator.new
+    assert validator.is_integer?(3)
+    
+    refute validator.is_integer?("300")
+    refute validator.is_integer?("3")
+    refute validator.is_integer?(3.0)
+    refute validator.is_integer?("3.0")
+    refute validator.is_integer?("3oo")
+    refute validator.is_integer?("")
+    refute validator.is_integer?(nil)
+    refute validator.is_integer?("thirty")
+  end
+  
+  def test_is_integer_like?
+    validator = SpiderMonkey::Validator.new
+    assert validator.is_integer_like?(3)
+    assert validator.is_integer_like?("300")
+    assert validator.is_integer_like?("3")
+    
+    refute validator.is_integer_like?(3.0)
+    refute validator.is_integer_like?("3.0")
+    refute validator.is_integer_like?("3oo")
+    refute validator.is_integer_like?("")
+    refute validator.is_integer_like?(nil)
+    refute validator.is_integer_like?("thirty")
+  end
+  
+  def test_is_string?
+    validator = SpiderMonkey::Validator.new
+    assert validator.is_string?("asdf")
+    assert validator.is_string?("14")
+    
+    refute validator.is_string?(14)
+  end
+  
+  def test_is_boolean?
+    validator = SpiderMonkey::Validator.new
+    assert validator.is_boolean?(true)
+    assert validator.is_boolean?(false)
+    
+    refute validator.is_boolean?("false")
+    refute validator.is_boolean?("true")
+    refute validator.is_boolean?("asdf")
+    refute validator.is_boolean?(0)
+    refute validator.is_boolean?(1)
+  end
+  
+  def test_is_color?
+    validator = SpiderMonkey::Validator.new
+    
+    assert validator.is_color?("blue")
+    assert validator.is_color?(:blue)
+    assert validator.is_color?("#0000FF")
+    assert validator.is_color?("#0000FF00")
+    assert validator.is_color?("rgb(0,0,255)")
+    assert validator.is_color?("rgba(0,0,255, 0.5)")
+    
+    refute validator.is_color?("#asdf")
+    refute validator.is_color?("#1234567")
+    refute validator.is_color?("#123456HH")
+    refute validator.is_color?("rgba(0,0,255)") #said rgba but didn't include alpha
+    refute validator.is_color?("rgb(0,0,255, 0.5)")
+    refute validator.is_color?("rgb(0)")
+    refute validator.is_color?("rgb(blue)")
+  end
+  
+  def test_is_gravity?
+    validator = SpiderMonkey::Validator.new
+    gravities = %w(
+      northwest
+      north
+      northeast
+      west
+      center
+      east
+      southwest
+      south
+      southeast
+    )
+    
+    gravities.each do |g|
+      assert validator.is_gravity?(g)
+    end
+    
+    assert validator.is_gravity?(:center)
+    assert validator.is_gravity?("Center")
+    
+    assert validator.is_gravity?("NorthWest")
+    assert validator.is_gravity?("Northwest")
+    
+    refute validator.is_gravity?("Middle")
+    refute validator.is_gravity?("Purple")
+    refute validator.is_gravity?("foobar")
+  end
+  
+  def test_is_colorspace?
+    validator = SpiderMonkey::Validator.new
+    colorspaces = %w(
+      CIELab
+      CMY
+      CMYK
+      Gray
+      HCL
+      HCLp
+      HSB
+      HSI
+      HSL
+      HSV
+      HWB
+      Lab
+      LCH
+      LCHab
+      LCHuv
+      LMS
+      Log
+      Luv
+      OHTA
+      Rec601Luma
+      Rec601YCbCr
+      Rec709Luma
+      Rec709YCbCr
+      RGB
+      scRGB
+      sRGB
+      Transparent
+      XYZ
+      xyY
+      YCbCr
+      YDbDr
+      YCC
+      YIQ
+      YPbPr
+      YUV
+    )
+    
+    colorspaces.each do |g|
+      assert validator.is_colorspace?(g)
+    end
+    
+    refute validator.is_colorspace?("srgb")
+    refute validator.is_colorspace?("Weee")
+    refute validator.is_colorspace?("")
+    refute validator.is_colorspace?("cmyk")
+  end
+  
+  def test_is_percent?
+    validator = SpiderMonkey::Validator.new
+    # String, with a percent sign, and an integer
+    
+    assert validator.is_percent? "4%"
+    assert validator.is_percent? "40%"
+    assert validator.is_percent? "14%"
+    assert validator.is_percent? "154%"
+    
+    refute validator.is_percent? "154"
+    refute validator.is_percent? "%"
+    refute validator.is_percent? 14
+  end
+  
+  def test_is_url?
+    validator = SpiderMonkey::Validator.new
+    
+    assert validator.is_url?("http://asdf.com/asdf")
+    assert validator.is_url?("https://asdf.com/asdf")
+    
+    refute validator.is_url?("asdf")
+    refute validator.is_url?("asdfasdfasdf")
+    refute validator.is_url?("https://")
+  end
+  
+  def test_is_resize_method?
+    validator = SpiderMonkey::Validator.new
+    assert validator.is_resize_method? :crop
+    assert validator.is_resize_method? :fit
+    assert validator.is_resize_method? "crop"
+    
+    refute validator.is_resize_method? :magic
+    refute validator.is_resize_method? "magic"
+  end
+  
+  def test_is_source?
+    validator = SpiderMonkey::Validator.new
+    assert validator.is_source?({key: "foo", bucket: "bar"})
+    assert validator.is_source?({url: "http://fizbam.com"})
+    
+    assert validator.is_source?({source_key: "foo", source_bucket: "bar"}, "source")
+    assert validator.is_source?({source_url: "http://fizbam.com"}, "source")
+    
+    refute validator.is_source?({key: "foo", bucket: "bar"}, "source")
+    refute validator.is_source?({url: "http://fizbam.com"}, "source")
+    
+    
+    refute validator.is_source?({url: "fizbam"})
+    refute validator.is_source?({url: "fizbam", key: "asdf"})
+    refute validator.is_source?({url: "fizbam", bucket: "fsda"})
+    refute validator.is_source?({key: "fizbam", bucket: ""})
+    refute validator.is_source?({key: "", bucket: "fsda"})
+    refute validator.is_source?({key: "asdf"})
+    refute validator.is_source?({bucket: "asdf"})
+    refute validator.is_source?({key: "asdf", bucket: nil})
+    refute validator.is_source?({key: nil, bucket: "asdf"})
+    refute validator.is_source?({})
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: spider_monkey
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Ben McFadden
@@ -9,17 +9,49 @@ autorequire:
 bindir: bin
 cert_chain: []
 date: 2015-11-19 00:00:00.000000000 Z
-dependencies: []
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  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: minitest-reporters
+  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'
 description: A gem to simplify generating image URLs for usespidermonkey.com
 email: ben@forgeapps.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- Rakefile
 - lib/spider_monkey.rb
 - lib/spider_monkey/config.rb
 - lib/spider_monkey/helper.rb
+- lib/spider_monkey/validator.rb
 - spider_monkey.gemspec
+- test/test_helper.rb
+- test/test_validator.rb
 homepage: 
 licenses:
 - MIT