dzl 1.0.0.beta0

data/.gitignore

@@ -0,0 +1,6 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+tmp/*
+log/*

data/.rspec

@@ -0,0 +1 @@
+--colour

data/.rvmrc

@@ -0,0 +1 @@
+rvm use 1.9.3-p125

data/Gemfile

@@ -0,0 +1,9 @@
+source "http://rubygems.org"
+
+gemspec
+gem 'pry'
+gem 'rake'
+gem 'rspec'
+gem 'thin'
+gem 'rack-test'
+gem 'ruby-prof'

data/README.md

@@ -0,0 +1,44 @@
+# Dzl
+
+### What is it?
+
+Dzl is a *request routing* and *parameter validation* DSL.  It is designed for rapid development of small API services.  It is easy to use, read, maintain, and extend.  It promotes some useful conventions for application design without Doing Too Much.
+
+It is a Racktivesupport web framework like those to which you are probably accustomed.  We will have proper documentation soon.
+
+#### I hate reading and want to use this right now!
+
+Ok... https://github.com/vitrue/dzl/tree/master/lib/dzl/examples
+
+#### Quick philosophical point
+
+In Dzl, the API flows in the direction that the request would be serviced.  You define first the route, then a set of acceptable parameters for that route, and finally designate a handler.  
+
+#### Request routing
+
+In this regard, Dzl looks a lot like Sinatra.  Writing (and reading) routes and handlers is simple.  There is no need to have multiple open files to figure out what code responds to `GET /foo`.
+
+#### Parameter Validation
+
+Inside of a route's DSL block (or in a named parameter block which can be used later from any route) you define a set of acceptable (required/optional/header) parameters.  You may also define a set of transformations on each parameter, to be run before or after validation.  For invalid requests, information about which parameters failed validation and which validations they failed is returned.  Otherwise, the (optionally transformed) parameters are yielded to the route handler.
+
+-----------
+
+## Contributing
+
+We welcome pull requests.  With specs.
+
+## Open Source
+
+The MIT License (MIT)
+Copyright (c) Vitrue
+
+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.
+
+## Versions
+
+We will stick to Semantic Versioning (http://semver.org/), as closely as Bundler will allow.

data/Rakefile

@@ -0,0 +1,15 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+desc 'Bust out a console'
+task :console do
+  exec 'pry -I lib -r dzl'
+end
+
+desc 'Boot the test app on localhost:3000'
+task :server do
+  exec 'rackup -p 3000'
+end
+
+desc 'Run the specs'
+RSpec::Core::RakeTask.new('spec')

data/config.ru

@@ -0,0 +1,41 @@
+require 'bundler/setup'
+require 'dzl'
+Bundler.require
+
+favicon_app = lambda do |env|
+  [200, {'Content-Type' => 'text/html'}, ['OK']]
+end
+
+map '/favicon.ico' do
+  run favicon_app
+end
+
+# require 'distil/examples/trey'
+# map '/' do
+#   run Dzl::Examples::Trey
+# end
+
+# require 'distil/examples/fun_with_params'
+# map '/' do
+#   run Dzl::Examples::FunWithParams
+# end
+
+# require 'distil/examples/fun_with_requests'
+# map '/' do
+#   run Dzl::Examples::FunWithRequests
+# end
+
+# require 'distil/examples/route_profile'
+# map '/' do
+#   run Dzl::Examples::RouteProfile
+# end
+
+# require 'distil/examples/fun_with_handlers'
+# map '/' do
+#   run Dzl::Examples::FunWithHandlers
+# end
+
+require 'distil/examples/fun_with_hooks'
+map '/' do
+  run Dzl::Examples::FunWithHooks
+end

data/dzl.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require 'dzl/version'
+
+Gem::Specification.new do |s|
+  s.name        = "dzl"
+  s.version     = Dzl::VERSION
+  s.authors     = ["Kyle Brett", "Paul Bergeron"]
+  s.email       = ["kyle@vitrue.com", "pbergeron@vitrue.com"]
+  s.homepage    = "http://github.com/vitrue/dzl"
+  s.summary     = %q{Parameter validation and request routing DSL & framework}
+  s.description = %q{Dzl zones live!}
+
+  s.files         = `git ls-files`.split("\n")
+  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"]
+
+  s.add_runtime_dependency 'rack'
+  s.add_runtime_dependency 'activesupport'
+end

data/lib/dzl/doc/endpoint_doc.rb

@@ -0,0 +1,70 @@
+module Dzl::EndpointDoc
+
+  def to_md
+    endpoint_template = File.read("./lib/dzl/doc/templates/endpoint.erb")
+
+    ERB.new(endpoint_template, nil, "-%").result(binding)
+  end
+
+  def doc_file_name
+    route.titlecase.gsub("/", "")
+  end
+
+  def doc_endpoint_request_methods
+    upcased_array = opts[:request_methods].collect {|method_sym| method_sym.to_s.upcase}
+    upcased_array.collect {|method_str| method_str.gsub('"', '')}.sort.join(', ')
+  end
+
+  private
+  def doc_list(list)
+    # At this point, ranges were converted to arrays, so best guess
+    if list.all?{|e| e.class == Fixnum} && list.first < list.last
+      "#{list.first}..#{list.last}"
+    else
+      "#{list}"
+    end
+  end
+
+  def doc_conditions(conditions)
+    first_condition = conditions.shift
+    # All arrays have a size validiton, but the conditions are optional
+    doc_str = ""
+    if first_condition
+      doc_str = "Must be #{first_condition[0]} #{first_condition[1]}"
+      conditions.each do |condition|
+        doc_str += " and must be #{condition[0]} #{condition[1]}"
+      end
+      doc_str += "."
+    end
+    return doc_str
+  end
+
+  def doc_param_type(type)
+    "Format: #{type}"
+  end
+  
+  def doc_param_size(size)
+    condition_doc = doc_conditions(size.conditions)
+    "Size: #{condition_doc}" unless condition_doc == ""
+  end
+
+  def doc_param_allowed_values(allowed_values)
+    "Allowed values: #{doc_list(allowed_values)}"
+  end
+
+  def doc_param_disallowed_values(disallowed_values)
+    "Disallowed values: #{doc_list(disallowed_values)}"
+  end
+
+  def doc_param_value(value)
+    condition_doc = doc_conditions(value.conditions)
+    "Value: #{condition_doc}" unless condition_doc == ""
+  end
+
+  # Don't doc transforms
+  def doc_param_prevalidate_transform(a);  end
+
+  # Don't doc procs
+  def doc_param_procs(a);  end
+
+end

data/lib/dzl/doc/router_doc.rb

@@ -0,0 +1,26 @@
+module Dzl::RouterDoc
+
+  def to_docs
+    app_name = app.name.split('::').last
+    
+    root = app.root || "."
+
+    `mkdir -p #{root}/dzl_docs/#{app_name}/`
+
+    home = File.new("./dzl_docs/#{app_name}/Home.md", "w")
+    home.write(to_md(app_name, root))
+    home.close
+
+    endpoints.each do |endpoint|
+      endpoint_page = File.new("#{root}/dzl_docs/#{app_name}/#{endpoint.doc_file_name}.md", "w")
+      endpoint_page.write(endpoint.to_md)
+      endpoint_page.close
+    end
+  end
+
+  def to_md(app_name=nil, root=".")
+    home_template = File.read("#{root}/lib/dzl/doc/templates/home.erb")
+
+    ERB.new(home_template, nil, "-%").result(binding)
+  end
+end

data/lib/dzl/doc/task.rb

@@ -0,0 +1,5 @@
+
+desc 'Generate documentation templates'
+task :dzl_doc do
+  ObjectSpace.each_object(Dzl::DSLSubjects::Router) {|obj| obj.to_docs}
+end

data/lib/dzl/doc/templates/endpoint.erb

@@ -0,0 +1,55 @@
+<%= "#" %> <%= route.titlecase.gsub("/", "") %><% unless doc_endpoint_request_methods.empty? %> - (<%= doc_endpoint_request_methods %>)<% end %> - <%= route %>
+
+{Endpoint Description}
+
+% unless pblock.params.empty?
+% if pblock.params.any?{|param_name, param_obj| param_obj.opts[:header]} 
+% if pblock.params.any?{|param_name, param_obj| param_obj.opts[:header] && param_obj.opts[:required]}
+<%= "##" %> Headers:
+
+<%= "###" %> Required:
+% pblock.params.select{|param_name, param_obj| param_obj.opts[:header] && param_obj.opts[:required]}.each do |param_name, param_obj|
+* **<%= param_name %>**<% param_obj.validations.each do |type, args| param_limits = send(:"doc_param_#{type}", args); if param_limits %> - <%= param_limits %><% end; end %>
+% end
+
+% end
+% if pblock.params.any?{|param_name, param_obj| param_obj.opts[:header] && !param_obj.opts[:required]}
+<%= "###" %> Optional:
+% pblock.params.select{|param_name, param_obj| param_obj.opts[:header] && !param_obj.opts[:required]}.each do |param_name, param_obj|
+* **<%= param_name %>**<% param_obj.validations.each do |type, args| param_limits = send(:"doc_param_#{type}", args); if param_limits %> - <%= param_limits %><% end; end %>
+% end
+
+% end
+% end
+% if pblock.params.any?{|param_name, param_obj| !param_obj.opts[:header]} 
+<%= "##" %> Params:
+
+% if pblock.params.any?{|param_name, param_obj| !param_obj.opts[:header] && param_obj.opts[:required]}
+<%= "###" %> Required:
+% pblock.params.select{|param_name, param_obj| !param_obj.opts[:header] && param_obj.opts[:required]}.each do |param_name, param_obj|
+* **<%= param_name %>**<% param_obj.validations.each do |type, args| param_limits = send(:"doc_param_#{type}", args); if param_limits %> - <%= param_limits %><% end; end %>
+% end
+
+% end
+% end
+
+% if pblock.params.any?{|param_name, param_obj| !param_obj.opts[:header] && !param_obj.opts[:required]}
+<%= "###" %> Optional:
+% pblock.params.select{|param_name, param_obj| !param_obj.opts[:header] && !param_obj.opts[:required]}.each do |param_name, param_obj|
+* **<%= param_name %>**<% param_obj.validations.each do |type, args| param_limits = send(:"doc_param_#{type}", args); if param_limits %> - <%= param_limits %><% end; end %>
+% end
+
+% end
+% end
+
+<%= "##" %> Example Usage
+
+{Endpoint Example Description}
+
+```
+{Endpoint Example Request}
+```
+
+```js
+{Endpoint Example Return Data}
+```

data/lib/dzl/doc/templates/home.erb

@@ -0,0 +1,8 @@
+<%= "#" %> <% if app_name %><%= app_name %><% else %>{API Name}<% end %>
+
+{API Description here}
+
+<%= "##" %> Endpoints
+% endpoints.each do |endpoint|
+*[<% unless endpoint.doc_endpoint_request_methods.empty?%>(<%= endpoint.doc_endpoint_request_methods %>) <% end %><%= endpoint.doc_file_name %>](wiki/<%= endpoint.doc_file_name %>)
+% end

data/lib/dzl/doc.rb

@@ -0,0 +1,58 @@
+module Dzl::Doc
+  
+  def to_md
+    index_template = File.read("./template.erb")
+
+    puts ERB.new(index_template, nil, "-%").result(binding)
+  end
+
+  private
+  def doc_list(list)
+    # At this point, ranges were converted to arrays, so best guess
+    if list.all?{|e| e.class == Fixnum} && list.first < list.last
+      "#{list.first}..#{list.last}"
+    else
+      "#{list}"
+    end
+  end
+
+  def doc_conditions(conditions)
+    first_condition = conditions.shift
+    # All arrays have a size validiton, but the conditions are optional
+    doc_str = ""
+    if first_condition
+      doc_str = "Must be #{first_condition[0]} #{first_condition[1]}"
+      conditions.each do |condition|
+        doc_str += " and must be #{condition[0]} #{condition[1]}"
+      end
+      doc_str += "."
+    end
+    return doc_str
+  end
+
+  def doc_param_type(type)
+    "Format: #{type}"
+  end
+  
+  def doc_param_size(size)
+    condition_doc = doc_conditions(size.conditions)
+    "Size: #{condition_doc}" unless condition_doc == ""
+  end
+
+  def doc_param_allowed_values(allowed_values)
+    "Allowed values: #{doc_list(allowed_values)}"
+  end
+
+  def doc_param_disallowed_values(disallowed_values)
+    "Disallowed values: #{doc_list(disallowed_values)}"
+  end
+
+  def doc_param_value(value)
+    condition_doc = doc_conditions(value.conditions)
+    "Value: #{condition_doc}" unless condition_doc == ""
+  end
+
+  # Don't doc transforms
+  def doc_param_prevalidate_transform(a);  end
+
+end

data/lib/dzl/dsl_proxies/defaults.rb

@@ -0,0 +1,10 @@
+class Dzl::DSLProxies::Defaults < Dzl::DSLProxy
+  def method_missing(m, *args, &block)
+    raise ArgumentError if args.size != 1
+    @subject.set_default(m, args[0])
+  end
+
+  def respond_to?(m)
+    true
+  end
+end

data/lib/dzl/dsl_proxies/endpoint.rb

@@ -0,0 +1,30 @@
+class Dzl::DSLProxies::Endpoint < Dzl::DSLProxy
+  # Delegate to our pblock if we don't answer a method
+  alias_method :orig_respond_to?, :respond_to?
+  def respond_to?(m)
+    orig_respond_to?(m) || @subject.pblock.dsl_proxy.respond_to?(m)
+  end
+
+  alias_method :orig_mm, :method_missing
+  def method_missing(m, *args, &block)
+    if @subject.pblock.dsl_proxy.respond_to?(m)
+      @subject.pblock.dsl_proxy.send(m, *args, &block)
+    else
+      orig_mm(m, *args, &block)
+    end
+  end
+
+  def silent
+    @subject.opts[:silent] = true
+  end
+
+  def handle
+    raise ArgumentError unless block_given?
+    @subject.handler = Proc.new
+  end
+
+  def after_validate
+    raise ArgumentError unless block_given?
+    @subject.hooks[:after_validate] << Proc.new
+  end
+end

data/lib/dzl/dsl_proxies/parameter.rb

@@ -0,0 +1,75 @@
+require 'dzl/validator'
+
+class Dzl::DSLProxies::Parameter < Dzl::DSLProxy
+  alias_method :orig_mm, :method_missing
+  attr_reader :default_value
+  def method_missing(m, *args, &block)
+    validator = "Dzl::Validators::#{m.to_s.camelize}".constantize rescue nil
+    if !validator
+      orig_mm(m, *args, &block)
+    else
+      @subject.validations[m] ||= validator.new
+    end
+  end
+
+  alias_method :orig_respond_to?, :respond_to?
+  def respond_to?(m, *args, &block)
+    orig_respond_to?(m, *args, &block) ||
+    ("Dzl::Validators::#{m.to_s.camelize}".constantize rescue nil)
+  end
+
+  # Currently we allow the parameter to match ANY of these,
+  # perhaps we should require it to match them ALL
+  # or make it configurable
+  # TODO
+  def matches(regex)
+    @subject.validations[:matches] ||= []
+    @subject.validations[:matches] << regex
+  end
+
+  def allowed_values(ary)
+    @subject.validations[:allowed_values] ||= []
+    ary = ary.to_a if ary.is_a?(Range) # TODO or whatever
+    (@subject.validations[:allowed_values] += ary).uniq!
+  end
+
+  def disallowed_values(ary)
+    @subject.validations[:disallowed_values] ||= []
+    ary = ary.to_a if ary.is_a?(Range) # TODO or whatever
+    (@subject.validations[:disallowed_values] += ary).uniq!
+  end
+
+  def type(type, type_opts = {})
+    @subject.validations[:type] = type
+    @subject.opts[:type_opts] = type_opts
+  end
+
+  def integer
+    matches(/\d+/)
+  end
+
+  def default(val)
+    @subject.opts[:default_value] = val
+  end
+
+  def validate_with
+    raise ArgumentError unless block_given?
+    @subject.validations[:procs] ||= []
+    @subject.validations[:procs] << Proc.new
+  end
+
+  def prevalidate_transform
+    raise ArgumentError unless block_given?
+    @subject.validations[:prevalidate_transform] ||= []
+    @subject.validations[:prevalidate_transform] << Proc.new
+  end
+
+  # The idea behind this method is to let one
+  # parameter validate against the value of another
+  # obviously there's the circular validation problem
+  # but perhaps we can catch a circular reference
+  # when it's defined and raise DontDoThat
+  def params
+    raise Dzl::NYI
+  end
+end

data/lib/dzl/dsl_proxies/parameter_block.rb

@@ -0,0 +1,61 @@
+class Dzl::DSLProxies::ParameterBlock < Dzl::DSLProxy
+  def parameter(*names)
+    opts = names.last.is_a?(Hash) ? names.pop : {required: false}
+
+    names.each do |name|
+      if @subject.params[name]
+        # Don't clobber params we already know about
+        @subject.params[name].overwrite_opts(opts)
+      else
+        @subject.params[name] = Dzl::DSLSubjects::Parameter.new(name, opts)
+      end
+
+      @subject.router.call_with_subject(Proc.new, @subject.params[name]) if block_given?
+    end
+  end
+  alias_method :param, :parameter
+
+  def required(*names, &block)
+    opts = names.last.is_a?(Hash) ? names.pop : {}
+    parameter(*names, opts.merge(required: true), &block)
+  end
+
+  def optional(*names, &block)
+    opts = names.last.is_a?(Hash) ? names.pop : {}
+    parameter(*names, opts.merge(required: false), &block)
+  end
+
+  def required_header(*names, &block)
+    opts = names.last.is_a?(Hash) ? names.pop : {}
+    required(*names, opts.merge(header: true), &block)
+  end
+
+  def optional_header(*names, &block)
+    opts = names.last.is_a?(Hash) ? names.pop : {}
+    optional(*names, opts.merge(header: true), &block)
+  end
+
+  def forbid(*names)
+    names.each do |name|
+      @subject.params.delete(name)
+    end
+  end
+
+  def protect
+    raise ArgumentError unless block_given?
+    @subject.opts[:protection] ||= []
+    @subject.opts[:protection] << Dzl::DSLSubjects::Protection.new
+
+    @subject.router.call_with_subject(Proc.new, @subject.opts[:protection].last)
+  end
+
+  def import_pblock(*pblocks)
+    pblocks.each do |pblock|
+      next unless @subject.router.pblocks.has_key?(pblock)
+      @subject.router.pblocks[pblock].params.each do |name, param|
+        @subject.params[name] = param.clone
+      end
+    end
+  end
+  alias_method :import_parameters, :import_pblock
+end

data/lib/dzl/dsl_proxies/protection.rb

@@ -0,0 +1,6 @@
+class Dzl::DSLProxies::Protection < Dzl::DSLProxy
+  def http_basic(opts)
+    raise ArgumentError unless [:username, :password].all? {|k| opts[k].present?}
+    @subject.opts[:http_basic] = opts
+  end
+end

data/lib/dzl/dsl_proxies/router.rb

@@ -0,0 +1,62 @@
+class Dzl::DSLProxies::Router < Dzl::DSLProxy
+  REQUEST_METHODS = [:get, :post, :put, :delete, :options]
+
+  def pblock(name, opts = {})
+    raise ArgumentError unless name.is_a?(Symbol) &&
+                               opts.is_a?(Hash)   &&
+                               block_given?
+
+    
+    pb = Dzl::DSLSubjects::ParameterBlock.new(name, opts, @subject)
+    @subject.add_pblock(pb)
+    @subject.call_with_subject(Proc.new, pb)
+  end
+  alias_method :parameters, :pblock
+
+  def endpoint(route, *request_methods)
+    request_methods = [:get] if request_methods.empty?
+    request_methods.uniq!
+
+    raise ArgumentError unless request_methods.all? {|m| REQUEST_METHODS.include?(m)}
+    opts = {
+      request_methods: request_methods
+    }
+
+    ept = Dzl::DSLSubjects::Endpoint.new(route, opts, @subject)
+    @subject.add_endpoint(ept)
+    @subject.call_with_subject(Proc.new, ept) if block_given?
+  end
+
+  def defaults(&block)
+    raise ArgumentError unless block_given?
+
+    @subject.call_with_subject(Proc.new, @subject.defaults_dslsub)
+  end
+
+  REQUEST_METHODS.each do |m|
+    define_method(m) do |route, *request_methods, &block|
+      request_methods << m
+      endpoint(route, *request_methods, &block)
+    end
+  end
+
+  def global_parameters(&block)
+    raise ArgumentError unless block_given?
+    pblock(:__default, &block)
+  end
+  alias_method :global_pblock, :global_parameters
+
+  alias_method :orig_respond_to?, :respond_to?
+  def respond_to?(m)
+    orig_respond_to?(m) || (@subject.subject && 
+                            @subject.subject.dsl_proxy.respond_to?(m))
+  end
+
+  def method_missing(m, *args, &block)
+    if orig_respond_to?(m)
+      super.method_missing(m, *args, &block)
+    else
+      @subject.subject.dsl_proxy.send(m, *args, &block)
+    end
+  end
+end

data/lib/dzl/dsl_proxy.rb

@@ -0,0 +1,8 @@
+class Dzl::DSLProxy
+  def initialize(subject)
+    raise ArgumentError unless subject
+    @subject = subject
+  end
+end
+
+module Dzl::DSLProxies; end

data/lib/dzl/dsl_subject.rb

@@ -0,0 +1,15 @@
+require 'dzl/dsl_proxy'
+
+class Dzl::DSLSubject
+  attr_reader :name, :opts, :router
+
+  def initialize
+    @opts = {}
+  end
+
+  def dsl_proxy
+    @dsl_proxy || raise("You must set @dsl_proxy in your DSLSubject subclass")
+  end
+end
+
+module Dzl::DSLSubjects; end

data/lib/dzl/dsl_subjects/defaults.rb

@@ -0,0 +1,12 @@
+require 'dzl/dsl_proxies/defaults'
+
+class Dzl::DSLSubjects::Defaults < Dzl::DSLSubject
+  def initialize(router)
+    @dsl_proxy = Dzl::DSLProxies::Defaults.new(self)
+    @router = router
+  end
+
+  def set_default(key, val)
+    @router.defaults[key] = val
+  end
+end