dzl 1.0.0.beta0

data/lib/dzl/dsl_subjects/endpoint.rb

@@ -0,0 +1,79 @@
+require 'dzl/dsl_proxies/endpoint'
+
+class Dzl::DSLSubjects::Endpoint < Dzl::DSLSubject
+  attr_reader :pblock, :route_regex, :route, :router, :hooks
+  attr_accessor :handler
+  include Dzl::EndpointDoc
+
+  def initialize(route, opts, router)
+    @route   = route
+    @opts    = opts
+    @router  = router
+    @pblock  = Dzl::DSLSubjects::ParameterBlock.new(:anonymous, {}, @router)
+    @pblock.dsl_proxy.import_pblock(:__default)
+    @dsl_proxy = Dzl::DSLProxies::Endpoint.new(self)
+    @hooks   = {
+      after_validate: []
+    }
+
+    analyze_route
+  end
+
+  def as_json(opts=nil)
+    {
+      opts: @opts,
+      pblock: @pblock
+    }
+  end
+
+  def handle(request)
+    request.silent = true if @opts[:silent]
+    Dzl::ResponseContext.new(self, request, @handler).__respond__
+  end
+
+  def validate(request)
+    unless @opts[:request_methods].include?(request.request_method.downcase.to_sym)
+      return Dzl::ValueOrError.new(e: :request_method_not_supported)
+    end
+
+    route_params = extract_route_parameters(request.path)
+    params = {
+      params: request.params.merge(route_params).symbolize_keys,
+      headers: request.headers.symbolize_keys
+    }
+
+    pblock.validate(params, request)
+  end
+
+  def extract_route_parameters(path)
+    path_splits = path.split('/')
+    path_splits.delete('')
+
+    return nil if path_splits.size != @route_splits.size
+
+    Hash[
+      *@route_splits.collect do |rsplit|
+        psplit = path_splits.shift
+        next unless rsplit.starts_with?(':')
+        [rsplit[1..-1].to_sym, psplit]
+      end.compact.flatten
+    ]
+  end
+
+  private
+  def analyze_route
+    @route = "/#{@route}" if @route.is_a?(Symbol)
+
+    if params = /\/:([^\/]+)/.match(@route)
+      params[1..-1].each {|p| @pblock.dsl_proxy.required(p.to_sym, in_path: true)}
+    end
+
+    @route_splits = @route.split('/').select{|s| not s.empty?}
+
+    route_regex_string = @route_splits.collect do |route_part|
+      route_part.starts_with?(':') ? "/.*?" : "/#{route_part}"
+    end.push('$').join('')
+
+    @route_regex = Regexp.new(route_regex_string)
+  end
+end

data/lib/dzl/dsl_subjects/parameter/allowed_values.rb

@@ -0,0 +1,60 @@
+class Dzl::DSLSubjects::Parameter
+  module AllowedValues
+    def allowed_values(input)
+      unless (@validations[:allowed_values].present? ||
+           @validations[:disallowed_values].present?)
+        return Dzl::ValueOrError.new(v: input)
+      end
+
+      if @validations[:disallowed_values].present?
+        valid = true
+
+        if input.is_a?(Array)
+          valid = input.none? do |value|
+            @validations[:disallowed_values].include?(value)
+          end
+        elsif input.is_a?(String)
+          valid = !@validations[:disallowed_values].include?(input)
+        end
+
+        return Dzl::ValueOrError.new(e: :disallowed_values_failed) unless valid
+      end
+
+      if @validations[:allowed_values].present?
+        valid = true
+
+        if param_type == Array
+          valid = input.all? do |value|
+            @validations[:allowed_values].include?(value)
+          end
+        elsif param_type == String
+          valid = @validations[:allowed_values].include?(input)
+        end
+
+        return Dzl::ValueOrError.new(e: :allowed_values_failed) unless valid
+      end
+
+      Dzl::ValueOrError.new(v: input)
+    end
+
+    def regex_match(input)
+      return Dzl::ValueOrError.new(v: input) unless @validations[:matches].present?
+      
+      error = nil
+
+      if input.is_a?(String)
+        unless @validations[:matches].any? {|re| re.match(input)}
+          error = Dzl::ValueOrError.new(e: :regex_match_fail)
+        end
+      elsif input.is_a?(Array)
+        input.each do |v|
+          unless @validations[:matches].any? {|re| re.match(v)}
+            error = Dzl::ValueOrError.new(e: :regex_match_fail)
+          end
+        end
+      end
+
+      return error ? error : Dzl::ValueOrError.new(v: input)
+    end
+  end
+end

data/lib/dzl/dsl_subjects/parameter/type_conversion.rb

@@ -0,0 +1,59 @@
+class Dzl::DSLSubjects::Parameter
+  module TypeConversion
+    def convert_type(input)
+      if param_type == String
+        v = Dzl::ValueOrError.new(v: input)
+
+        if v.value.empty? && @opts[:required]
+          v = Dzl::ValueOrError.new(
+            e: :missing_required_param
+          )
+        else
+          v
+        end
+      elsif param_type == Array
+        v = Dzl::ValueOrError.new(
+          v: input.split(
+            (@opts[:type_opts][:separator] rescue nil) || ' '
+          )
+        )
+
+        if v.value.empty? && @opts[:required]
+          Dzl::ValueOrError.new(
+            e: :empty_required_array
+          )
+        else
+          v
+        end
+      elsif param_type == Integer || param_type == Fixnum
+        if (input = input.to_i.to_s) == input
+          Dzl::ValueOrError.new(v: input.to_i)
+        else
+          Dzl::ValueOrError.new(
+            e: :type_conversion_error
+          )
+        end
+      elsif param_type == Date || param_type == Time
+        input = Time.parse(input) rescue nil
+        if input
+          input = input.to_date if param_type == Date
+          Dzl::ValueOrError.new(v: input)
+        else
+          Dzl::ValueOrError.new(
+            e: :type_conversion_error
+          )
+        end
+      end
+    end
+
+    def prevalidate_transform(input)
+      if @validations.has_key?(:prevalidate_transform)
+        @validations[:prevalidate_transform].each do |transform|
+          input = transform.call(input)
+        end
+      end
+
+      Dzl::ValueOrError.new(v: input)
+    end
+  end
+end

data/lib/dzl/dsl_subjects/parameter.rb

@@ -0,0 +1,100 @@
+require 'dzl/dsl_proxies/parameter'
+
+class Dzl::ParameterError < StandardError; end
+
+class Dzl::DSLSubjects::Parameter < Dzl::DSLSubject
+  require 'dzl/dsl_subjects/parameter/type_conversion'
+  require 'dzl/dsl_subjects/parameter/allowed_values'
+  include TypeConversion
+  include AllowedValues
+
+  attr_reader :validations, :opts
+  attr_writer :default
+
+  def initialize(name, opts)
+    @name = name
+    @opts = opts
+    @validations = {
+      type: String
+    }
+    @dsl_proxy = Dzl::DSLProxies::Parameter.new(self)
+  end
+
+  def clone
+    deep_copy = self.dup
+    deep_copy.dup_data
+    deep_copy
+  end
+
+  def dup_data
+    @opts = @opts.clone
+    @validations = @validations.clone
+    @dsl_proxy = Dzl::DSLProxies::Parameter.new(self)
+  end
+
+  def param_type
+    @validations[:type]
+  end
+
+  def overwrite_opts(opts)
+    if @opts[:in_path] && opts[:required] == false
+      raise Dzl::ParameterError.new("Cannot set in-path param #{name} to optional")
+    end
+
+    @opts.merge!(opts)
+  end
+
+  # Returns a symbol describe the error if error,
+  # returns the transformed value if not
+  # TODO symbol values?
+  def validate(input)
+    # Validate type
+    unless input
+      if @opts[:required]
+        return Dzl::ValueOrError.new(
+          e: @opts[:header] ? :missing_required_header : :missing_required_param
+        )
+      else
+        return Dzl::ValueOrError.new(
+          v: @opts.has_key?(:default_value) ? @opts[:default_value] : :__no_value__
+        )
+      end
+    end
+
+    input = convert_type(input)
+    return input if input.error?
+
+    input = prevalidate_transform(input.value)
+    return input if input.error?
+
+    input = allowed_values(input.value)
+    return input if input.error?
+
+    input = regex_match(input.value)
+    return input if input.error?
+
+    # Validator procs
+    if @validations.has_key?(:procs)
+      @validations[:procs].each do |vproc|
+        vproc.call(input.value) or
+          return Dzl::ValueOrError.new(e: :validator_poc_failed)
+      end
+    end
+
+    # Validator classes
+    @validations.select {|k, v| v.kind_of?(Dzl::Validator)}.each do |vary|
+      name, validator = vary
+      input = validator.validate(input.value)
+      return input if input.error?
+    end
+
+    Dzl::ValueOrError.new(v: input.value)
+  end
+
+  def as_json(opts=nil)
+    {
+      opts: @opts,
+      validations: @validations
+    }
+  end
+end

data/lib/dzl/dsl_subjects/parameter_block.rb

@@ -0,0 +1,64 @@
+require 'dzl/dsl_proxies/parameter_block'
+
+class Dzl::DSLSubjects::ParameterBlock < Dzl::DSLSubject
+  attr_accessor :params
+  attr_reader :router
+
+  def initialize(name, opts, router)
+    @name   = name
+    @opts   = opts
+    @router = router
+    @params = {}
+    @dsl_proxy = Dzl::DSLProxies::ParameterBlock.new(self)
+  end
+
+  def validate(parandidates, request)
+    errors = @params.each_with_object({}) do |pary, errors|
+      pname, param = pary
+      parandidate_key = param.opts[:header] ? :headers : :params
+
+      # verror = value or error.
+      verror = @params[pname].validate(parandidates[parandidate_key][pname])
+      if verror.error?
+        errors[pname] = verror.error
+      else
+        parandidates[parandidate_key][pname] = verror.value unless verror.value == :__no_value__
+      end
+    end || {}
+
+    # Check for extra request params we are not expecting
+    parandidates[:params].each do |pname, value|
+      unless @params.keys.include?(pname)
+        parandidates[:params].delete(pname)
+        errors[pname] = :unknown_param
+      end
+    end
+
+    if !errors.empty?
+      Dzl::ValueOrError.new(e: errors)
+    elsif @opts[:protection]
+      protection_errors = @opts[:protection].collect do |protection|
+        protection.allow?(parandidates, request)
+      end.select { |result| result.error? }
+
+      if protection_errors.empty?
+        Dzl::ValueOrError.new(v: parandidates)
+      else
+        protection_errors[0]
+      end
+    else
+      Dzl::ValueOrError.new(v: parandidates)
+    end
+  end
+
+  def to_s
+    "pblock:#{name}"
+  end
+
+  def as_json(opts=nil)
+    {
+      opts: @opts,
+      params: @params
+    }
+  end
+end

data/lib/dzl/dsl_subjects/protection.rb

@@ -0,0 +1,31 @@
+require 'dzl/dsl_proxies/protection'
+
+class Dzl::RespondWithHTTPBasicChallenge < StandardError; end
+
+class Dzl::DSLSubjects::Protection < Dzl::DSLSubject
+  def initialize
+    super
+    @dsl_proxy = Dzl::DSLProxies::Protection.new(self)
+  end
+
+  def allow?(parandidates, request)
+    params = parandidates[:params]
+    headers = parandidates[:headers]
+
+    if @opts[:http_basic].present?
+      @auth = Rack::Auth::Basic::Request.new(request.env)
+      if @auth.provided? && @auth.basic? && @auth.credentials
+        unless @auth.credentials[0] == @opts[:http_basic][:username] &&
+               @auth.credentials[1] == @opts[:http_basic][:password]
+          Dzl::ValueOrError.new(e: :invalid_http_basic_credentials)
+        else
+          Dzl::ValueOrError.new(v: nil)
+        end
+      else
+        Dzl::ValueOrError.new(e: :no_http_basic_credentials)
+      end
+    else
+      Dzl::ValueOrError.new(v: nil)
+    end
+  end
+end

data/lib/dzl/dsl_subjects/router.rb

@@ -0,0 +1,87 @@
+require 'dzl/dsl_proxies/router'
+require 'dzl/dsl_subjects/defaults'
+
+class Dzl::DSLSubjects::Router < Dzl::DSLSubject
+  include Dzl::RouterDoc
+  attr_reader :pblocks, :defaults_dslsub, :defaults, :app
+
+  def initialize(app)
+    @pblocks = {}
+    @endpoints_by_route = {}
+    @stack = []
+    @defaults = {}
+    @defaults_dslsub = Dzl::DSLSubjects::Defaults.new(self)
+    @dsl_proxy = Dzl::DSLProxies::Router.new(self)
+    @app = app
+  end
+
+  def call_with_subject(proc, subject)
+    @stack.push(subject)
+    proc.call
+    @stack.pop
+  end
+
+  def subject
+    @stack.last
+  end
+
+  def routes
+    @endpoints_by_route.keys
+  end
+
+  def endpoints
+    @endpoints = @endpoints_by_route.values.flatten
+  end
+
+  def add_endpoint(ept)
+    @endpoints_by_route[ept.route] ||= []
+    @endpoints_by_route[ept.route] << ept
+  end
+
+  def pblocks
+    @pblocks
+  end
+
+  def add_pblock(pb)
+    @pblocks[pb.name] = pb
+  end
+
+  def as_json(opts=nil)
+    @endpoints
+  end
+
+  def handle_request(request)
+    endpoint = find_endpoint(request)
+    response = request.handle_with_endpoint(endpoint)
+  end
+
+  def find_endpoint(request)
+    errors = {}
+    raise Dzl::NotFound if routes.empty?
+
+    endpoint = endpoints.find do |endpoint|
+      if request.path.match(endpoint.route_regex)
+        validation = endpoint.validate(request)
+        if validation.value?
+          # use our validated/transformed/params
+          request.params_and_headers_for_endpoint(
+            endpoint,
+            validation.value
+          )
+          true
+        else
+          errors[endpoint.route] = validation.error
+          false
+        end
+      end
+    end
+
+    if !errors.empty? &&
+        errors.values.any? {|v| v == :no_http_basic_credentials || v == :invalid_http_basic_credentials}
+      raise Dzl::RespondWithHTTPBasicChallenge
+    end
+
+    endpoint || raise(Dzl::NotFound.new(errors))
+  end
+  
+end

data/lib/dzl/errors.rb

@@ -0,0 +1,33 @@
+class Dzl::Error < StandardError
+  attr_reader :data, :status
+
+  def initialize(data = {})
+    @data = data
+    @status = 500
+  end
+
+  def to_json
+    {
+      status: @status,
+      error_class: self.class.to_s,
+      errors: @data,
+      trace: self.backtrace
+    }.to_json
+  end
+end
+
+class Dzl::RequestError < Dzl::Error; end
+
+class Dzl::NotFound < Dzl::RequestError
+  def initialize(data = {})
+    super(data)
+    @status = 404
+  end
+end
+
+class Dzl::BadRequest < Dzl::RequestError
+  def initialize(data = {})
+    super(data)
+    @status = 400
+  end
+end

data/lib/dzl/examples/base.rb

@@ -0,0 +1,9 @@
+module Dzl::Examples
+  class Base
+    def self.root
+      @@root ||= File.expand_path('../../../../', __FILE__)
+    end
+
+    include Dzl
+  end
+end

data/lib/dzl/examples/fun_with_handlers.rb

@@ -0,0 +1,33 @@
+require 'dzl/examples/base'
+
+class Dzl::Examples::FunWithHandlers < Dzl::Examples::Base
+  defaults do
+    content_type 'application/json'
+  end
+
+  endpoint '/say_bar' do
+    optional :foo, :bar, :baz, :bam
+
+    handle do
+      params[:bar]
+    end
+  end
+
+  endpoint '/say_bar_and_api_key' do
+    required :bar
+    required_header :api_key
+
+    handle do
+      {
+        bar: params[:bar],
+        api_key: headers[:api_key]
+      }.to_json
+    end
+  end
+
+  get '/raise' do
+    handle do
+      raise 'omg'
+    end
+  end
+end

data/lib/dzl/examples/fun_with_hooks.rb

@@ -0,0 +1,65 @@
+require 'dzl/examples/base'
+
+class Dzl::Examples::FunWithHooks < Dzl::Examples::Base
+  defaults do
+    content_type 'application/json'
+  end
+
+  endpoint '/pre' do
+    required :foo do
+      type Fixnum
+      value >= 4
+      prevalidate_transform do |input|
+        input == 1 ? 4 : input
+      end
+    end
+  end
+
+  endpoint '/post' do
+    required :foo do
+      type Fixnum
+      value >= 4
+    end
+
+    after_validate do
+      params[:foo] *= 2
+    end
+  end
+
+  endpoint '/multiply' do
+    required :x, :y do
+      type Fixnum
+    end
+
+    after_validate do
+      params[:z] = params[:x] * params[:y]
+    end
+  end
+
+  endpoint '/omg_math' do
+    optional :x, :y, :z do
+      type Fixnum
+    end
+
+    optional :prefix
+
+    # NEVER DO THIS IN YOUR APP IT IS SO UGLY
+    after_validate do
+      params[:multiply_then_add] = params[:x] * params[:y]
+    end
+
+    after_validate do
+      params[:multiply_then_add] += params[:z]
+    end
+
+    after_validate do
+      params[:speak] = "#{params[:prefix]} #{params[:multiply_then_add]}"
+    end
+  end
+
+  endpoint '/vomit' do
+    after_validate do
+      raise Dzl::BadRequest.new("This isn't quite what I was expecting")
+    end
+  end
+end

data/lib/dzl/examples/fun_with_params.rb

@@ -0,0 +1,71 @@
+require 'dzl/examples/base'
+
+class Dzl::Examples::FunWithParams < Dzl::Examples::Base
+  endpoint '/foo' do
+    required :foo do
+      type Array
+      disallowed_values %w{zilch zip nada}
+    end
+  end
+
+  endpoint '/bar' do
+    required :foo do
+      type Array, separator: '+'
+    end
+  end
+
+  endpoint '/baz' do
+    required :foo do
+      type Array, separator: ','
+    end
+  end
+
+  endpoint '/bar' do
+    required :foo
+  end
+
+  endpoint '/foo/:bar' do
+    required :bar do
+      type Time
+    end
+  end
+
+  endpoint '/protected' do
+    protect do
+      http_basic username: 'no', password: 'way'
+    end
+  end
+
+  endpoint '/arithmetic' do
+    optional :int do
+      type Fixnum
+      value >= 5
+    end
+
+    optional :str do
+      value == 'hello'
+    end
+
+    optional :date do
+      type Date
+      value > Date.parse('2012-01-01')
+    end
+  end
+
+  endpoint '/defaults' do
+    optional :foo do
+      default 'hello'
+    end
+
+    optional :bar
+    optional :baz do
+      default 'world'
+    end
+
+    optional :nil do
+      default nil
+    end
+  end
+
+  endpoint '/foo/:bar'
+end