dzl 1.0.0.beta0

data/lib/dzl/examples/fun_with_requests.rb

@@ -0,0 +1,47 @@
+require 'dzl/examples/base'
+
+class Dzl::Examples::FunWithRequests < Dzl::Examples::Base 
+  endpoint '/foo' do
+    handle do
+      'get'
+    end
+  end
+
+  endpoint '/post_op', :post do
+    handle do
+      'post'
+    end
+  end
+
+  endpoint '/multi_op', :post, :put do
+    handle do
+      request.request_method.downcase
+    end
+  end
+
+  get '/get_only'
+  delete '/delete_only'
+  get '/get_and_post', :post
+
+  get '/validated_header' do
+    required_header :key do
+      validate_with { |k| k == 'hello' }
+    end
+  end
+
+  get '/ambiguous' do
+    required :foo
+
+    handle do
+      params[:foo]
+    end
+  end
+
+  get '/ambiguous' do
+    required :bar
+
+    handle do
+      params[:bar]
+    end
+  end
+end

data/lib/dzl/examples/route_profile.rb

@@ -0,0 +1,158 @@
+require 'dzl/examples/base'
+
+class Dzl::Examples::RouteProfile < Dzl::Examples::base
+  global_pblock do end
+
+  #150 routes
+  endpoint '/Lorem' do end
+  endpoint '/ipsum' do end
+  endpoint '/dolor' do end
+  endpoint '/sit' do end
+  endpoint '/amet' do end
+  endpoint '/consectetur' do end
+  endpoint '/adipiscing' do end
+  endpoint '/elit' do end
+  endpoint '/Aenean' do end
+  endpoint '/pulvinar' do end
+  endpoint '/ante' do end
+  endpoint '/id' do end
+  endpoint '/venenatis' do end
+  endpoint '/eleifend' do end
+  endpoint '/Vivamus' do end
+  endpoint '/mattis' do end
+  endpoint '/tempor' do end
+  endpoint '/bibendum' do end
+  endpoint '/nulla' do end
+  endpoint '/lobortis' do end
+  endpoint '/vitae' do end
+  endpoint '/Vestibulum' do end
+  endpoint '/primis' do end
+  endpoint '/in' do end
+  endpoint '/faucibus' do end
+  endpoint '/orci' do end
+  endpoint '/luctus' do end
+  endpoint '/et' do end
+  endpoint '/ultrices' do end
+  endpoint '/posuere' do end
+  endpoint '/cubilia' do end
+  endpoint '/Curae;' do end
+  endpoint '/Proin' do end
+  endpoint '/nisi' do end
+  endpoint '/malesuada' do end
+  endpoint '/eu' do end
+  endpoint '/scelerisque' do end
+  endpoint '/ut' do end
+  endpoint '/eget' do end
+  endpoint '/augue' do end
+  endpoint '/Aliquam' do end
+  endpoint '/erat' do end
+  endpoint '/volutpat' do end
+  endpoint '/Praesent' do end
+  endpoint '/leo' do end
+  endpoint '/commodo' do end
+  endpoint '/ac' do end
+  endpoint '/suscipit' do end
+  endpoint '/sed' do end
+  endpoint '/magna' do end
+  endpoint '/Fusce' do end
+  endpoint '/lacinia' do end
+  endpoint '/lorem' do end
+  endpoint '/felis' do end
+  endpoint '/fermentum' do end
+  endpoint '/non' do end
+  endpoint '/molestie' do end
+  endpoint '/ligula' do end
+  endpoint '/sollicitudin' do end
+  endpoint '/Cras' do end
+  endpoint '/auctor' do end
+  endpoint '/mi' do end
+  endpoint '/eros' do end
+  endpoint '/quis' do end
+  endpoint '/velit' do end
+  endpoint '/facilisis' do end
+  endpoint '/a' do end
+  endpoint '/metus' do end
+  endpoint '/Ut' do end
+  endpoint '/enim' do end
+  endpoint '/aliquam' do end
+  endpoint '/cursus' do end
+  endpoint '/Etiam' do end
+  endpoint '/imperdiet' do end
+  endpoint '/rhoncus' do end
+  endpoint '/nibh' do end
+  endpoint '/tincidunt' do end
+  endpoint '/ullamcorper' do end
+  endpoint '/Nulla' do end
+  endpoint '/dapibus' do end
+  endpoint '/nunc' do end
+  endpoint '/at' do end
+  endpoint '/vestibulum' do end
+  endpoint '/tortor' do end
+  endpoint '/pharetra' do end
+  endpoint '/vulputate' do end
+  endpoint '/accumsan' do end
+  endpoint '/Pellentesque' do end
+  endpoint '/Nam' do end
+  endpoint '/elementum' do end
+  endpoint '/ultricies' do end
+  endpoint '/Morbi' do end
+  endpoint '/varius' do end
+  endpoint '/lacus' do end
+  endpoint '/mollis' do end
+  endpoint '/Quisque' do end
+  endpoint '/porttitor' do end
+  endpoint '/arcu' do end
+  endpoint '/mauris' do end
+  endpoint '/hendrerit' do end
+  endpoint '/pretium' do end
+  endpoint '/placerat' do end
+  endpoint '/quam' do end
+  endpoint '/feugiat' do end
+  endpoint '/diam' do end
+  endpoint '/aliquet' do end
+  endpoint '/convallis' do end
+  endpoint '/Donec' do end
+  endpoint '/dignissim' do end
+  endpoint '/lectus' do end
+  endpoint '/rutrum' do end
+  endpoint '/nisl' do end
+  endpoint '/ornare' do end
+  endpoint '/tristique' do end
+  endpoint '/sapien' do end
+  endpoint '/euismod' do end
+  endpoint '/vel' do end
+  endpoint '/massa' do end
+  endpoint '/porta' do end
+  endpoint '/nec' do end
+  endpoint '/habitant' do end
+  endpoint '/morbi' do end
+  endpoint '/senectus' do end
+  endpoint '/netus' do end
+  endpoint '/fames' do end
+  endpoint '/turpis' do end
+  endpoint '/egestas' do end
+  endpoint '/Curabitur' do end
+  endpoint '/pellentesque' do end
+  endpoint '/libero' do end
+  endpoint '/Duis' do end
+  endpoint '/congue' do end
+  endpoint '/iaculis' do end
+  endpoint '/In' do end
+  endpoint '/Nunc' do end
+  endpoint '/Sed' do end
+  endpoint '/blandit' do end
+  endpoint '/tempus' do end
+  endpoint '/tellus' do end
+  endpoint '/condimentum' do end
+  endpoint '/interdum' do end
+  endpoint '/fringilla' do end
+  endpoint '/viverra' do end
+  endpoint '/justo' do end
+  endpoint '/consequat' do end
+  endpoint '/gravida' do end
+  endpoint '/risus' do end
+  endpoint '/urna' do end
+  endpoint '/semper' do end
+  endpoint '/dui' do end
+
+end

data/lib/dzl/examples/trey.rb

@@ -0,0 +1,97 @@
+require 'dzl/examples/base'
+
+class Dzl::Examples::Trey < Dzl::Examples::Base
+  METRIC_NAMES_OR_WHATEVER ||= %w{m1 m2 m3 m4 m5 m6}
+
+  # this could be handy
+  # defaults do
+  #   type Array do
+  #     unique
+  #     separator ' '
+  #   end
+  # end
+
+  # global parameter block applies to all routes
+  # each route gets it's own copy, so, they can 
+  # mess with the predefined parameters as much as
+  # they'd like
+  global_pblock do
+    # required_header :api_key do
+    #   validate_with { |key| key == 'open sesame' }
+    # end
+
+    param :page_ids do
+      type Array
+      size <= 5
+    end
+
+    param :post_ids do
+      type Array
+      size <= 100
+    end
+
+    param :metrics do
+      type Array
+      allowed_values METRIC_NAMES_OR_WHATEVER
+    end
+
+    param :since, :until do
+      type Date
+    end
+
+    param :interval do
+      allowed_values %w{day week month}
+      default 'day'
+    end
+
+    param :limit do
+      type Fixnum
+      allowed_values 1..250
+      default 250
+    end
+
+    param :sort do
+      default 'created_time'
+    end
+
+    param :order do
+      prevalidate_transform do |input|
+        input.downcase
+      end
+      allowed_values ['asc', 'desc', 'ascending', 'descending']
+      default :desc
+    end
+  end
+
+  endpoint '/page_insights' do
+    required :page_ids, :metrics, :since, :until
+    optional :interval
+    forbid :post_ids, :limit, :sort, :order
+  end
+
+  endpoint '/post_insights' do
+    required :post_ids, :metrics
+    forbid :page_ids, :since, :until, :interval, :limit, :sort, :order
+  end
+
+  # endpoint '/post_insights' do
+  #   required :page_ids do
+  #     size <= 5
+  #   end
+
+  #   required :metrics, :since, :until
+  #   forbid :post_ids, :interval, :limit, :sort, :order
+  # end
+
+  endpoint '/posts' do
+    required :page_ids, :metrics
+    optional :since, :until, :limit, :sort, :order
+    forbid :post_ids
+  end
+
+  # endpoint '/posts' do
+  #   required :post_ids, :metrics
+  #   optional :since, :until, :limit, :sort, :order
+  #   forbid :page_ids
+  # end
+end

data/lib/dzl/logger.rb

@@ -0,0 +1,65 @@
+class ActiveSupport::BufferedLogger
+  def self.timestamp
+    DateTime.now.strftime("[%Y-%m-%d %H:%M:%S] - ")
+  end
+
+  alias_method :orig_add, :add
+  def add(severity, message = nil, progname = nil, &block)
+    message = "#{ActiveSupport::BufferedLogger.timestamp}#{message}"
+    orig_add(severity, message, progname, &block)
+  end
+end
+
+module Dzl
+  class Logger
+    LOG_METHODS = [:debug, :info, :warn, :error, :fatal]
+    def initialize(app_root)
+      @app_root = app_root
+      @loggers = {
+        default: create_logger # log/[environment].log
+      }
+    end
+
+    # Get the standard logger methods defined
+    LOG_METHODS.each do |severity|
+      define_method(severity) do |msg|
+        log(severity, msg)
+      end
+    end
+
+    ############
+    # Receives all the default log methods on AppClass.logger
+    # and forwards to the default logger
+    ############
+    def log(severity, msg)
+      @loggers[:default].send(severity, msg)
+    end
+
+    ############
+    # The idea here is that you can call
+    # AppClass.logger.tidy.debug("Something")
+    # and we'll write your log message to tidy.environment.log
+    ############
+    def method_missing(m, *args, &block)
+      if @loggers[:default].respond_to?(m)
+        # Don't create things like flush.development.log (-:
+        @loggers[:default].send(m, *args, &block)
+      else
+        @loggers[m] ||= create_logger(m.to_s)
+      end
+    end
+
+    private
+    def create_logger(name = nil)
+      logfile = name ? "#{name}.#{Dzl.env}.log" : "#{Dzl.env}.log"
+      ActiveSupport::BufferedLogger.new(
+        File.join(@app_root, 'log', logfile),
+        %w{ staging production }.include?(Dzl.env) ? ::Logger::INFO : ::Logger::DEBUG
+      )
+    end
+  end
+
+  def self.logger
+    @@logger ||= Logger.new
+  end
+end

data/lib/dzl/rack_interface.rb

@@ -0,0 +1,95 @@
+require 'rack'
+require 'dzl/request'
+
+module Dzl::RackInterface
+  PROFILE_REQUESTS = false
+
+  def call(env)
+    response = nil
+    request = nil
+    start_time = Time.now
+    start_profile if PROFILE_REQUESTS
+    response = begin
+      request = Dzl::Request.new(env)
+      __router.handle_request(request)
+    rescue Dzl::RespondWithHTTPBasicChallenge
+      respond_with_http_basic_challenge
+    rescue Dzl::Error => e
+      respond_with_dzl_error_handler(e)
+    rescue StandardError => e
+      respond_with_standard_error_handler(e)
+    end
+
+    if response[0] < 100
+      response = respond_with_standard_error_handler(StandardError.new('Application did not respond'))
+    end
+
+    stop_profiling_and_print if PROFILE_REQUESTS
+    log_request(request, response, (Time.now - start_time)) unless request.silent?
+
+    if Dzl.production? || Dzl.staging?
+      (response[0] < 500) ? response : [response[0], [], [response[0].to_s]]
+    else
+      response
+    end
+  end
+
+  def respond_with_http_basic_challenge
+    response = Rack::Response.new
+    response['WWW-Authenticate'] = %(Basic realm="Dzl HTTP Basic")
+    response.status = 401
+    response.headers['Content-Type'] = 'text/html'
+    response.write("Not Authorized\n")
+    response.finish
+  end
+
+  def respond_with_standard_error_handler(e)
+    response = Rack::Response.new
+    response.headers['Content-Type'] = 'application/json'
+    response.status = 500
+
+    response.write({
+      status: 500,
+      error_class: e.class.to_s,
+      errors: e.to_s,
+      trace: e.backtrace
+    }.to_json)
+
+    response.finish
+  end
+
+  def respond_with_dzl_error_handler(e)
+    response = Rack::Response.new
+    response.headers['Content-Type'] = 'application/json'
+
+    if e.is_a?(Dzl::RequestError)
+      response.status = e.status
+      response.write(e.to_json)
+    else
+      response.status = e.status
+      response.write(e.to_json)
+    end
+
+    response.finish
+  end
+
+  def start_profile
+    require 'ruby-prof'
+    RubyProf.start
+  end
+
+  def stop_profiling_and_print
+    result = RubyProf.stop
+    printer = RubyProf::GraphHtmlPrinter.new(result)
+    printer.print(
+      File.open('/Projects/dzl/profile.html', 'w'),
+      min_percent: 5
+    )
+  end
+
+  def log_request(request, response, seconds)
+    logger.info "#{request.request_method} #{request.path}"
+    logger.info "PARAMS: #{request.params}"
+    logger.info "#{response[0]} in #{seconds * 1000}ms"
+  end
+end

data/lib/dzl/request.rb

@@ -0,0 +1,54 @@
+class Dzl::Request < Rack::Request
+  attr_accessor :silent
+
+  def initialize(env)
+    super(env)
+
+    @endpoints = Hash.new({})
+  end
+
+  def headers
+    @headers ||= begin
+      env.each_with_object({}) do |env_pair, headers|
+        k, v = env_pair
+        if header = (/HTTP_(.+)/.match(k.upcase.gsub('-', '_'))[1]) rescue nil
+          headers[header.downcase] = v
+        end
+      end
+    end
+  end
+
+  def params
+    @params ||= super
+  end
+
+  def overwrite_headers(new_headers)
+    @headers = new_headers
+  end
+
+  def overwrite_params(new_params)
+    @params = new_params
+  end
+
+  def handle_with_endpoint(endpoint)
+    overwrite_params(@endpoints[endpoint][:params])
+    overwrite_headers(@endpoints[endpoint][:headers])
+    endpoint.handle(self).finish
+  end
+
+  def params_and_headers_for_endpoint(endpoint, params_and_headers = nil)
+    if params_and_headers
+      raise ArgumentError unless params_and_headers.is_a?(Hash) &&
+                                 params_and_headers.has_key?(:params) &&
+                                 params_and_headers.has_key?(:headers)
+
+      @endpoints[endpoint].merge!(params_and_headers)
+    else
+      @endpoints[endpoint].slice(:params, :headers)
+    end
+  end
+
+  def silent?
+    @silent == true
+  end
+end

data/lib/dzl/response_context/request_helpers.rb

@@ -0,0 +1,11 @@
+class Dzl::ResponseContext
+  module RequestHelpers
+    def params
+      request.params
+    end
+
+    def headers
+      request.headers
+    end
+  end
+end

data/lib/dzl/response_context.rb

@@ -0,0 +1,47 @@
+require 'dzl/response_context/request_helpers'
+
+class Dzl::ResponseContext
+  include RequestHelpers
+  attr_reader :request, :response, :endpoint
+
+  @@default_handler = Proc.new do
+    response['Content-Type'] = 'application/json'
+    {
+      headers: headers,
+      params: params
+    }.to_json
+  end
+
+  def initialize(endpoint, request, handler = nil)
+    @request  = request
+    @endpoint = endpoint
+    @handler  = handler
+    __build_response_with_defaults__
+  end
+
+  def logger
+    @logger ||= @endpoint.router.app.logger
+  end
+
+  def __respond__
+    @endpoint.hooks[:after_validate].each do |proc|
+      self.instance_exec(&proc)
+    end
+
+    value = @handler ? self.instance_exec(&@handler) : self.instance_exec(&@@default_handler)
+
+    unless @response.body.present?
+      @response.write(value)
+    end
+
+    @response
+  end
+
+  def __build_response_with_defaults__
+    @response = Rack::Response.new
+
+    if ct = @endpoint.router.defaults[:content_type]
+      @response['Content-Type'] = ct
+    end
+  end
+end

data/lib/dzl/validator.rb

@@ -0,0 +1,10 @@
+class Dzl::Validator
+  def validate(input)
+    raise "You must implement #validate in your Dzl::Validator subclass"
+  end
+end
+
+module Dzl::Validators; end
+
+require 'dzl/validators/size'
+require 'dzl/validators/value'

data/lib/dzl/validators/size.rb

@@ -0,0 +1,32 @@
+module Dzl::Validators
+  class Size < Dzl::Validator
+    attr_reader :conditions
+    def initialize
+      @conditions = []
+    end
+
+    def validate(input)
+      unless input.respond_to?(:size)
+        return Dzl::ValueOrError.new(
+          e: :cannot_validate_size
+        )
+      end
+
+      valid = @conditions.all? do |op, n|
+        input.size.send(op, n)
+      end
+
+      if valid
+        Dzl::ValueOrError.new(v: input)
+      else
+        Dzl::ValueOrError.new(e: :size_validation_failed)
+      end
+    end
+
+    [:==, :<=, :>=, :<, :>].each do |op|
+      define_method(op) do |n|
+        @conditions << [op, n]
+      end
+    end
+  end
+end

data/lib/dzl/validators/value.rb

@@ -0,0 +1,30 @@
+module Dzl::Validators
+  class Value < Dzl::Validator
+    attr_reader :conditions
+    def initialize
+      @conditions = []
+    end
+
+    def validate(input)
+      valid = @conditions.all? do |op, n|
+        return Dzl::ValueOrError.new(
+          e: :value_validation_failed
+        ) unless input.respond_to?(op)
+        
+        input.send(op, n)
+      end
+
+      if valid
+        Dzl::ValueOrError.new(v: input)
+      else
+        Dzl::ValueOrError.new(e: :value_validation_failed)
+      end
+    end
+
+    [:==, :<=, :>=, :<, :>].each do |op|
+      define_method(op) do |n|
+        @conditions << [op, n]
+      end
+    end
+  end
+end

data/lib/dzl/value_or_error.rb

@@ -0,0 +1,32 @@
+class Dzl::ValueOrError
+  attr_reader :error, :value
+
+  def initialize(opts = {})
+    @error = opts[:error] || opts[:e]
+    @value = opts[:value] || opts[:v]
+
+    if @error && @value
+      raise ArgumentError, "it's ValueOrError, not ValueAndError"
+    end
+
+    unless @error || opts.has_key?(:v) || opts.has_key?(:value)
+      raise ArgumentError, "Must provide :value key, even if nil"
+    end
+  end
+
+  def error?
+    @error.present?
+  end
+
+  def value?
+    !error?
+  end
+
+  def to_s
+    if error?
+      "e: #{@error.inspect}"
+    else
+      "v: #{@value.inspect}"
+    end
+  end
+end

data/lib/dzl/version.rb

@@ -0,0 +1,3 @@
+module Dzl
+  VERSION = "1.0.0.beta0"
+end