sinatra-param2 1.0.0

data/example/Gemfile

@@ -0,0 +1,7 @@
+ruby '2.0.0'
+source "https://rubygems.org"
+
+gem 'sinatra', require: 'sinatra/base'
+gem 'sinatra-param', path: File.join(__FILE__, "../.."), require: 'sinatra/param'
+gem 'json'
+gem 'unicorn'

data/example/Gemfile.lock

@@ -0,0 +1,33 @@
+PATH
+  remote: /Users/mattt/Code/Ruby/sinatra-param
+  specs:
+    sinatra-param (0.1.3)
+      sinatra (~> 1.3)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    json (1.8.1)
+    kgio (2.8.1)
+    rack (1.5.2)
+    rack-protection (1.5.0)
+      rack
+    raindrops (0.12.0)
+    sinatra (1.4.3)
+      rack (~> 1.4)
+      rack-protection (~> 1.4)
+      tilt (~> 1.3, >= 1.3.4)
+    tilt (1.4.1)
+    unicorn (4.6.3)
+      kgio (~> 2.6)
+      rack
+      raindrops (~> 0.7)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  json
+  sinatra
+  sinatra-param!
+  unicorn

data/example/Procfile

@@ -0,0 +1 @@
+web: bundle exec unicorn -p $PORT

data/example/app.rb

@@ -0,0 +1,52 @@
+class App < Sinatra::Base
+  helpers Sinatra::Param
+
+  before do
+    content_type :json
+  end
+
+  # GET /messages
+  # GET /messages?sort=name&order=ASC
+  get '/messages' do
+    param :sort,  String, default: "name"
+    param :order, String, in: ["ASC", "DESC"], transform: :upcase, default: "ASC"
+
+    {
+      sort: params[:sort],
+      order: params[:order]
+    }.to_json
+  end
+
+  # GET /messages/1,2,3,4,5
+  get '/messages/:ids' do
+    param :ids, Array, required: true
+
+    {
+      ids: params[:ids]
+    }.to_json
+  end
+
+  # POST /messages/1/response
+  post '/messages/:id/response' do
+    param :message, String, max: 1024, required: true
+
+    {
+      message: params[:message]
+    }.to_json
+  end
+
+  # GET /choice?a=foo
+  # GET /choice?b=bar
+  # GET /choice?c=baz
+  get '/choice' do
+    param :a, String
+    param :b, String
+    param :c, String
+
+    one_of(:a, :b, :c)
+
+    {
+      message: 'OK'
+    }.to_json
+  end
+end

data/example/config.ru

@@ -0,0 +1,6 @@
+require 'bundler'
+Bundler.require
+
+require './app'
+
+run App

data/lib/sinatra/param.rb

@@ -0,0 +1,245 @@
+require 'sinatra/base'
+require 'sinatra/param/version'
+require 'date'
+require 'time'
+
+module Sinatra
+  module Param
+    Boolean = :boolean
+
+    class InvalidParameterError < StandardError
+      attr_accessor :param, :options
+    end
+
+    def param(name, type, options = {})
+      name = name.to_s
+      applicable_params = @applicable_params || params
+
+      return unless applicable_params.member?(name) or options.has_key?(:default) or options[:required]
+
+      begin
+        applicable_params[name] = coerce(applicable_params[name], type, options)
+        applicable_params[name] = (options[:default].call if options[:default].respond_to?(:call)) || options[:default] if applicable_params[name].nil? and options.has_key?(:default)
+        applicable_params[name] = options[:transform].to_proc.call(applicable_params[name]) if applicable_params[name] and options[:transform]
+        validate!(applicable_params[name], options)
+
+        if block_given?
+          if type != Hash
+            raise Sinatra::Param::InvalidParameterError.new(
+              'Only the Hash parameter validation can use sub hash validation method')
+          end
+          original_applicable_params = @applicable_params
+          original_parent_key_name = @parent_key_name
+          @applicable_params = applicable_params[name]
+          @parent_key_name = formatted_params(@parent_key_name, name)
+
+          yield
+
+          @applicable_params = original_applicable_params
+          @parent_key_name = original_parent_key_name
+        end
+
+        applicable_params[name]
+      rescue InvalidParameterError => exception
+        exception_name = formatted_params(@parent_key_name, name)
+        if options[:raise] or (settings.raise_sinatra_param_exceptions rescue false)
+          exception.param = exception_name
+          exception.options = options
+          raise exception
+        end
+
+        error = options[:message] || exception.to_s
+
+        if content_type and content_type.match(mime_type(:json))
+          error = {message: error, errors: {exception_name => exception.message}}.to_json
+        end
+
+        halt 400, error
+      end
+    end
+
+    def one_of(*args)
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      names = args.collect(&:to_s)
+      applicable_params = @applicable_params || params
+
+      return unless names.length >= 2
+
+      begin
+        validate_one_of!(applicable_params, names, options)
+      rescue InvalidParameterError => exception
+        if options[:raise] or (settings.raise_sinatra_param_exceptions rescue false)
+          exception.param, exception.options = names, options
+          raise exception
+        end
+
+        error = "Invalid parameters #{formatted_params(@parent_key_name, names)}"
+        if content_type and content_type.match(mime_type(:json))
+          error = {message: error, errors: {names => exception.message}}.to_json
+        end
+
+        halt 400, error
+      end
+    end
+
+    def any_of(*args)
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      names = args.collect(&:to_s)
+      applicable_params = @applicable_params || params
+
+      return unless names.length >= 2
+
+      begin
+        validate_any_of!(applicable_params, names, options)
+      rescue InvalidParameterError => exception
+        if options[:raise] or (settings.raise_sinatra_param_exceptions rescue false)
+          exception.param, exception.options = names, options
+          raise exception
+        end
+
+        formatted_params = formatted_params(@parent_key_name, names)
+        error = "Invalid parameters #{formatted_params}"
+        if content_type and content_type.match(mime_type(:json))
+          error = {message: error, errors: {formatted_params => exception.message}}.to_json
+        end
+
+        halt 400, error
+      end
+    end
+
+    def all_or_none_of(*args)
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      names = args.collect(&:to_s)
+
+     begin
+        validate_all_or_none_of!(params, names, options)
+      rescue InvalidParameterError => exception
+        if options[:raise] or (settings.raise_sinatra_param_exceptions rescue false)
+          exception.param, exception.options = names, options
+          raise exception
+        end
+
+        error = "Invalid parameters [#{names.join(', ')}]"
+        if content_type and content_type.match(mime_type(:json))
+          error = {message: error, errors: {names => exception.message}}.to_json
+        end
+
+        halt 400, error
+      end
+    end
+
+    private
+
+    def coerce(param, type, options = {})
+      begin
+        return nil if param.nil?
+        return param if (param.is_a?(type) rescue false)
+        return Integer(param) if type == Integer
+        return Float(param) if type == Float
+        return String(param) if type == String
+        return Date.parse(param) if type == Date
+        return Time.parse(param) if type == Time
+        return DateTime.parse(param) if type == DateTime
+        return coerce_array(param, options) if type == Array
+        return Hash[param.to_s.split(options[:delimiter] || ",").map{|c| c.split(options[:separator] || ":")}] if type == Hash
+        return (/(false|f|no|n|0)$/i === param.to_s ? false : (/(true|t|yes|y|1)$/i === param.to_s ? true : nil)) if type == TrueClass || type == FalseClass || type == Boolean
+        return nil
+      rescue ArgumentError
+        raise InvalidParameterError, "'#{param}' is not a valid #{type}"
+      end
+    end
+
+    ###
+    # Array is a special case, we should convert from Hash
+    # or convert to string before parsing.
+    def coerce_array(param, options = {})
+      return param if param.is_a? Array
+      return param.to_a if param.is_a? Hash
+      return Array(param.to_s.split(options[:delimiter] || ","))
+    end
+
+    def validate!(param, options)
+      options.each do |key, value|
+        case key
+        when :required
+          raise InvalidParameterError, "Parameter is required" if value && param.nil?
+        when :blank
+          raise InvalidParameterError, "Parameter cannot be blank" if !value && case param
+          when String
+            !(/\S/ === param)
+          when Array, Hash
+            param.empty?
+          else
+            param.nil?
+          end
+        when :format
+          raise InvalidParameterError, "Parameter must be a string if using the format validation" unless param.kind_of?(String)
+          raise InvalidParameterError, "Parameter must match format #{value}" unless param =~ value
+        when :is
+          raise InvalidParameterError, "Parameter must be #{value}" unless param === value
+        when :in, :within, :range
+          raise InvalidParameterError, "Parameter must be within #{value}" unless param.nil? || case value
+          when Range
+            case param
+            when Array
+              param.all? { |element| value.include?(element) }
+            else
+              value.include?(param)
+            end
+          else
+            case param
+            when Array
+              (param - Array(value)).empty?
+            else
+              Array(value).include?(param)
+            end
+          end
+        when :min
+          raise InvalidParameterError, "Parameter cannot be less than #{value}" unless param.nil? || value <= param
+        when :max
+          raise InvalidParameterError, "Parameter cannot be greater than #{value}" unless param.nil? || value >= param
+        when :min_length
+          raise InvalidParameterError, "Parameter cannot have length less than #{value}" unless param.nil? || value <= param.length
+        when :max_length
+          raise InvalidParameterError, "Parameter cannot have length greater than #{value}" unless param.nil? || value >= param.length
+        end
+      end
+    end
+
+    def validate_one_of!(params, names, options)
+      if names.count{|name| present?(params[name])} > 1
+        raise InvalidParameterError, "Only one of #{formatted_params(@parent_key_name, names)} is allowed"
+      end
+    end
+
+    def validate_any_of!(params, names, options)
+      if names.count{|name| present?(params[name])} < 1
+        raise InvalidParameterError, "One of parameters #{formatted_params(@parent_key_name, names)} is required"
+      end
+    end
+
+    def validate_all_or_none_of!(params, names, options)
+      present_count = names.count{|name| present?(params[name])}
+      raise InvalidParameterError, "All or none of parameters [#{names.join(', ')}] are required" if present_count > 0 and present_count != names.length
+    end
+
+    # ActiveSupport #present? and #blank? without patching Object
+    def present?(object)
+      !blank?(object)
+    end
+
+    def blank?(object)
+      object.respond_to?(:empty?) ? object.empty? : !object
+    end
+
+    def formatted_params(parent_key, name)
+      if name.is_a?(Array)
+        name = "[#{name.join(', ')}]"
+      end
+
+      return parent_key ? "#{parent_key}[#{name}]" : name
+    end
+  end
+
+  helpers Param
+end

data/lib/sinatra/param/version.rb

@@ -0,0 +1,5 @@
+module Sinatra
+  module Param
+    VERSION = '1.0.0'
+  end
+end

data/sinatra-param2.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/sinatra/param/version', __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "sinatra-param2"
+  s.license     = "MIT"
+  s.authors     = ["Mattt Thompson", "Adrian Bravo"]
+  s.email       = "adrianbn@gmail.com"
+  s.homepage    = "https://github.com/adrianbn/sinatra-param2"
+  s.version     = Sinatra::Param::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.summary     = "Parameter Validation & Type Coercion for Sinatra 2."
+  s.description = "sinatra-param2 allows you to declare, validate, and transform endpoint parameters as you would in frameworks like ActiveModel or DataMapper."
+
+  s.add_dependency "sinatra", "~> 2.0"
+
+  s.add_development_dependency "rake"
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "rack-test"
+  s.add_development_dependency "simplecov"
+  s.add_development_dependency "simplecov-cobertura"
+
+  s.files         = Dir["./**/*"].reject { |file| file =~ /\.\/(bin|log|pkg|script|spec|test|vendor)/ }
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/spec/dummy/app.rb

@@ -0,0 +1,346 @@
+require 'sinatra/base'
+require 'sinatra/param'
+require 'date'
+require 'time'
+require 'json'
+
+class App < Sinatra::Base
+  helpers Sinatra::Param
+
+  set :show_exceptions, false
+  set :raise_errors, true
+
+  before do
+    content_type :json
+  end
+
+  get '/' do
+    param :a, String
+    param :b, String, required: true
+    param :c, String, default: 'test'
+    param :d, String
+
+    params.to_json
+  end
+
+  get '/keys/stringify' do
+    param :q, String, transform: :upcase
+
+    params['q']
+  end
+
+  get '/coerce/string' do
+    params['arg'] = params['arg'].to_i
+    param :arg, String
+    params.to_json
+  end
+
+  get '/coerce/integer' do
+    param :arg, Integer
+    params.to_json
+  end
+
+  get '/coerce/float' do
+    param :arg, Float
+    params.to_json
+  end
+
+  get '/coerce/time' do
+    param :arg, Time
+    params.to_json
+  end
+
+  get '/coerce/date' do
+    param :arg, Date
+    params.to_json
+  end
+
+  get '/coerce/datetime' do
+    param :arg, DateTime
+    params.to_json
+  end
+
+  get '/coerce/array' do
+    param :arg, Array
+    params.to_json
+  end
+
+  get '/coerce/hash' do
+    param :arg, Hash
+    params.to_json
+  end
+
+  get '/coerce/boolean' do
+    param :arg, Boolean
+    params.to_json
+  end
+
+  get '/default' do
+    param :sort, String, default: "title"
+    params.to_json
+  end
+
+  get '/default/hash' do
+    param :attributes, Hash, default: {}
+    params.to_json
+  end
+
+  get '/default/proc' do
+    param :year, Integer, default: proc { 2014 }
+    params.to_json
+  end
+
+  get '/default/boolean/true' do
+    param :arg, Boolean, default: true
+    params.to_json
+  end
+
+  get '/default/boolean/false' do
+    param :arg, Boolean, default: false
+    params.to_json
+  end
+
+  get '/transform' do
+    param :order, String, transform: :upcase
+    params.to_json
+  end
+
+  get '/transform/required' do
+    param :order, String, required: true, transform: :upcase
+    params.to_json
+  end
+
+  get '/validation/required' do
+    param :arg, String, required: true
+    params.to_json
+  end
+
+  get '/validation/blank/string' do
+    param :arg, String, blank: false
+  end
+
+  get '/validation/blank/array' do
+    param :arg, Array, blank: false
+  end
+
+  get '/validation/blank/hash' do
+    param :arg, Hash, blank: false
+  end
+
+  get '/validation/blank/other' do
+    param :arg, Class, blank: false
+  end
+
+  get '/validation/nonblank/string' do
+    param :arg, String, blank: true
+  end
+
+  get '/validation/format/9000' do
+    param :arg, Integer, format: /9000/
+    params.to_json
+  end
+
+  get '/validation/format/hello' do
+    param :arg, String, format: /hello/
+    params.to_json
+  end
+
+  get '/validation/is' do
+    param :arg, String, is: 'foo'
+    params.to_json
+  end
+
+  get '/validation/in' do
+    param :arg, String, in: ['ASC', 'DESC']
+    params.to_json
+  end
+
+  get '/validation/in/array' do
+    param :arg, Array, in: ['ASC', 'DESC']
+    params.to_json
+  end
+
+  get '/validation/within' do
+    param :arg, Integer, within: 1..10
+    params.to_json
+  end
+
+  get '/validation/within/array' do
+    param :arg, Array, within: 1..10, transform: ->(a) { a.map(&:to_i) }
+    params.to_json
+  end
+
+  get '/validation/range' do
+    param :arg, Integer, range: 1..10
+    params.to_json
+  end
+
+  get '/validation/range/array' do
+    param :arg, Array, range: 1..10, transform: ->(a) { a.map(&:to_i) }
+    params.to_json
+  end
+
+  get '/validation/min' do
+    param :arg, Integer, min: 12
+    params.to_json
+  end
+
+  get '/validation/max' do
+    param :arg, Integer, max: 20
+    params.to_json
+  end
+
+  get '/validation/min_length' do
+    param :arg, String, min_length: 5
+    params.to_json
+  end
+
+  get '/validation/max_length' do
+    param :arg, String, max_length: 10
+    params.to_json
+  end
+
+  get '/one_of/1' do
+    param :a, String
+    param :b, String
+    param :c, String
+
+    one_of :a
+
+    {
+      message: 'OK'
+    }.to_json
+  end
+
+  get '/one_of/2' do
+    param :a, String
+    param :b, String
+    param :c, String
+
+    one_of :a, :b
+
+    {
+      message: 'OK'
+    }.to_json
+  end
+
+  get '/one_of/3' do
+    param :a, String
+    param :b, String
+    param :c, String
+
+    one_of :a, :b, :c
+
+    {
+      message: 'OK'
+    }.to_json
+  end
+
+  get '/any_of' do
+    param :a, String
+    param :b, String
+    param :c, String
+
+    any_of :a, :b, :c
+
+    {
+      message: 'OK'
+    }.to_json
+  end
+
+  get '/raise/validation/required' do
+    param :arg, String, required: true, raise: true
+    params.to_json
+  end
+
+  get '/raise/one_of/3' do
+    param :a, String
+    param :b, String
+    param :c, String
+
+    one_of :a, :b, :c, raise: true
+
+    {
+      message: 'OK'
+    }.to_json
+  end
+
+  get '/raise/any_of' do
+    param :a, String
+    param :b, String
+    param :c, String
+
+    any_of :a, :b, :c, raise: true
+
+    {
+      message: 'OK'
+    }.to_json
+  end
+
+  get '/validation/hash/nested_values' do
+    param :parent, Hash do
+      param :required_child, Integer, :required => true
+      param :optional_child, String
+      param :nested_child, Hash do
+        param :required_sub_child, String, :required => true
+        param :optional_sub_child, Integer
+      end
+      param :default_child,  Boolean, :default => true
+    end
+
+    {
+      message: 'OK'
+    }.to_json
+  end
+
+  get '/validation/hash/bad_nested_values' do
+    param :parent, String do
+      param :child, String
+    end
+  end
+
+  get '/one_of/nested' do
+    param :parent, Hash do
+      param :a, String
+      param :b, String
+      param :c, String
+
+      one_of :a, :b, :c
+    end
+
+    {
+      message: 'OK'
+    }.to_json
+  end
+
+  get '/any_of/nested' do
+    param :parent, Hash do
+      param :a, String
+      param :b, String
+      param :c, String
+
+      any_of :a, :b, :c
+    end
+
+    {
+      message: 'OK'
+    }.to_json
+  end
+
+  get '/all_or_none_of' do
+    param :a, String
+    param :b, String
+    param :c, String
+
+    all_or_none_of :a, :b, :c
+
+    {
+      message: 'OK'
+    }.to_json
+  end
+
+  get '/custommessage' do
+    param :a, Integer, within: 1..10, required: true,
+      message: "'a' must be less than 10"
+  end
+end