dzl 1.0.0.beta0

data/lib/dzl.rb

@@ -0,0 +1,96 @@
+require 'active_support/core_ext'
+require 'dzl/version'
+require 'dzl/logger'
+require 'dzl/errors'
+require 'dzl/value_or_error'
+require 'dzl/response_context'
+require 'dzl/rack_interface'
+require 'dzl/doc/router_doc'
+require 'dzl/doc/endpoint_doc'
+
+require 'dzl/dsl_subject'
+
+require 'dzl/dsl_subjects/router'
+require 'dzl/dsl_subjects/parameter'
+require 'dzl/dsl_subjects/protection'
+require 'dzl/dsl_subjects/parameter_block'
+require 'dzl/dsl_subjects/endpoint'
+
+module Dzl
+  class NYI < StandardError; end
+
+  def self.included(base)
+    unless base.respond_to?(:root)
+      raise ArgumentError.new(
+        "Please define #{base}.root to return the path to your app"
+      )
+    end
+
+    base.extend(RackInterface)
+
+    class << base
+      alias_method :orig_mm, :method_missing
+      alias_method :orig_respond_to?, :respond_to?
+
+      def __router
+        @__router ||= Dzl::DSLSubjects::Router.new(self)
+      end
+
+      def __logger
+        @__logger ||= begin
+          if self.orig_respond_to?(:logger) && self.logger.is_a?(ActiveSupport::BufferedLogger)
+            self.logger
+          else
+            Dzl::Logger.new(self.root)
+          end
+        end
+      end
+
+      def respond_to?(m)
+        orig_respond_to?(m) || (__router && __router.dsl_proxy.respond_to?(m))
+      end
+
+      def method_missing(m, *args, &block)
+        if __router.dsl_proxy.respond_to?(m)
+          __router.dsl_proxy.send(m, *args, &block)
+        elsif m == :logger
+          __logger
+        else
+          orig_mm(m, *args, &block)
+        end
+      end
+
+      def to_docs
+        app_name = self.name.split('::').last
+        
+        `mkdir -p ./dzl_docs/#{app_name}/`
+
+        home = File.new("./dzl_docs/#{app_name}/Home.md", "w")
+        home.write(__router.to_md(app_name))
+        home.close
+
+        __router.endpoints.each do |endpoint|
+          endpoint_page = File.new("./dzl_docs/#{app_name}/#{endpoint.doc_file_name}.md", "w")
+          endpoint_page.write(endpoint.to_md)
+          endpoint_page.close
+        end
+      end
+    end
+  end
+
+  def self.env
+    ENV['RACK_ENV']
+  end
+
+  [:development?, :production?, :staging?, :test?].each do |m|
+    define_singleton_method(m) do
+      env == m.to_s[0..-2]
+    end
+  end
+
+  def self.development?
+    true
+  end
+end
+
+Diesel = Dzl

data/spec/dsl_subject_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Dzl::DSLSubject do
+  it 'forwards DSL methods to its DSL proxy' do
+    Dzl::DSLSubject.any_instance.should_not_receive(:required)
+    Dzl::DSLProxies::ParameterBlock.any_instance.should_receive(:required).once
+
+    class DSLTest < Dzl::Examples::Base
+      pblock :foo do
+        required :bar
+      end
+    end
+  end
+end

data/spec/endpoint_doc_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+require 'dzl/examples/fun_with_params'
+require 'rack/test'
+
+def app; Dzl::Examples::FunWithParams; end
+
+describe 'endpoint doc functionality' do
+  it 'should use a template to generate markdown' do
+    File.should_receive(:read).with("./lib/dzl/doc/templates/home.erb").and_return("")
+
+    app.__router.to_md
+  end
+
+  it 'asks endpoints to generate thier docs' do
+    file_mock
+    app.__router.endpoints.each do |endpoint|
+      endpoint.should_receive(:to_md).and_return("")
+    end
+
+    app.__router.should_receive(:to_md).with("FunWithParams", anything).and_return("")
+    app.__router.should_receive(:'`').with(/FunWithParams/).and_return(nil)
+
+    app.__router.to_docs
+  end
+end

data/spec/fun_with_handlers_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+require 'rack/test'
+require 'dzl/examples/fun_with_handlers'
+
+describe 'handlers' do
+  include Rack::Test::Methods
+  def app; Dzl::Examples::FunWithHandlers; end
+
+  it 'have access to parameters and headers' do
+    get '/say_bar?baz=no&bam=nope&bar=Hello%2C%20world' do |response|
+      response.status.should == 200
+      response.body.should == 'Hello, world'
+    end
+
+    get('/say_bar_and_api_key', {bar: 'Hello, world'}, {'HTTP_ApI-keY' => 'open sesame'}) do |response|
+      response.status.should == 200
+      response['Content-Type'].should == 'application/json'
+      JSON.parse(response.body).should == {
+        'bar' => 'Hello, world',
+        'api_key' => 'open sesame'
+      }
+    end
+
+    get('/say_bar_and_api_key', {bar: 'whatever'}) do |response|
+      response.status.should == 404
+      JSON.parse(response.body)['errors']['/say_bar_and_api_key'].should == {
+        'api_key' => 'missing_required_header'
+      }
+    end
+  end
+
+  it 'can raise exceptions without exploding everything' do
+    get '/raise' do |response|
+      response.status.should == 500
+    end
+  end
+end

data/spec/fun_with_hooks_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+require 'rack/test'
+require 'dzl/examples/fun_with_hooks'
+
+describe 'FunWithHooks' do
+  include Rack::Test::Methods
+  def app; Dzl::Examples::FunWithHooks; end
+
+  describe '/pre' do
+    it 'only transforms :foo == 1' do
+      get('/pre', {foo: 2}) do |response|
+        response.status.should == 404
+        JSON.parse(response.body)['errors']['/pre']['foo'].should == 'value_validation_failed'
+      end
+
+      get('/pre', {foo: 6}) do |response|
+        response.status.should == 200
+      end
+
+      get('/pre', {foo: 1}) do |response|
+        response.status.should == 200
+        JSON.parse(response.body)['params']['foo'].should == 4
+      end
+    end
+  end
+
+  describe '/post' do
+    it 'can operate on parameters' do
+      get('/post?foo=4') do |response|
+        JSON.parse(response.body)['params']['foo'].should == 8
+      end
+    end
+  end
+
+  describe '/multiply' do
+    it 'can be used to fudge new parameters' do
+      get('/multiply?x=3&y=7') do |response|
+        JSON.parse(response.body)['params']['z'].should == 21
+      end
+    end
+
+    it 'runs multiple after_validate hooks in order' do
+      get('/omg_math?x=2&y=4&z=8&prefix=hello') do |response|
+        response.status.should == 200
+        params = JSON.parse(response.body)['params']
+        params['multiply_then_add'].should == 16
+        params['speak'].should == 'hello 16'
+        [params['x'], params['y'], params['z']].should == [2, 4, 8]
+      end
+    end
+  end
+
+  describe 'after validate hooks' do
+    it 'are good places to raise Dzl::BadRequest' do
+      get('/vomit') do |response|
+        response.status.should == 400
+        JSON.parse(response.body)['errors'].should == "This isn't quite what I was expecting"
+      end
+    end
+  end
+end

data/spec/fun_with_params_spec.rb

@@ -0,0 +1,197 @@
+require 'spec_helper'
+require 'rack/test'
+require 'dzl/examples/fun_with_params'
+
+describe Dzl::Examples::FunWithParams do
+  include Rack::Test::Methods
+
+  def app; Dzl::Examples::FunWithParams; end
+
+  describe '/foo' do
+    describe "understands disallowed values" do
+      it "for arrays" do
+        all_good = ['ok', 'sweet', 'awesome'].join(' ')
+        one_bad = ['zip'].join(' ')
+        all_bad = ['zip', 'zilch', 'nada'].join(' ')
+        mixed = ['ok', 'sweet', 'nada', 'nice'].join(' ')
+
+        get('/foo', {foo: all_good}) do |response|
+          response.status.should == 200
+        end
+
+        get('/foo', {foo: one_bad}) do |response|
+          response.status.should == 404
+          JSON.parse(response.body)['errors']['/foo'].should == {
+            'foo' => 'disallowed_values_failed'
+          }
+        end
+
+        get('/foo', {foo: all_bad}) do |response|
+          response.status.should == 404
+          JSON.parse(response.body)['errors']['/foo'].should == {
+            'foo' => 'disallowed_values_failed'
+          }
+        end
+
+        get('/foo', {foo: mixed}) do |response|
+          response.status.should == 404
+          JSON.parse(response.body)['errors']['/foo'].should == {
+            'foo' => 'disallowed_values_failed'
+          }
+        end
+      end
+    end
+
+    describe "required parameters" do
+      it "arrays cannot be empty" do
+        get('/foo', {foo: ''}) do |response|
+          response.status.should == 404
+          JSON.parse(response.body)['errors']['/foo'].should == {
+            'foo' => 'empty_required_array'
+          }
+        end
+      end
+
+      it "strings cannot be empty" do
+        get('/bar', {foo: ''}) do |response|
+          response.status.should == 404
+          JSON.parse(response.body)['errors']['/bar'].should == {
+            'foo' => 'missing_required_param'
+          }
+        end
+      end
+    end
+
+    describe "arbitrary array separator" do
+      it "can split arrays on +" do
+        ary = %w{one two three}
+        bad = ary.join(' ')
+        good = ary.join('+')
+
+        get('/bar', {foo: bad}) do |response|
+          response.status.should == 200
+          JSON.parse(response.body)['params']['foo'].should == ['one two three']
+        end
+
+        get('/bar', {foo: good}) do |response|
+          response.status.should == 200
+          JSON.parse(response.body)['params']['foo'].should == ary
+        end
+      end
+    end
+
+    it "can split arrays on ," do
+      ary = %w{one two three}
+      bad = ary.join(' ')
+      good = ary.join(',')
+
+      get('/baz', {foo: bad}) do |response|
+        response.status.should == 200
+        JSON.parse(response.body)['params']['foo'].should == ['one two three']
+      end
+
+      get('/baz', {foo: good}) do |response|
+        response.status.should == 200
+        JSON.parse(response.body)['params']['foo'].should == ary
+      end
+    end
+  end
+
+  describe '/foo/:bar (:bar as string)' do
+    it 'finds :bar properly' do
+      get '/foo/omg' do |response|
+        response.status.should == 200
+        JSON.parse(response.body)['params']['bar'].should == 'omg'
+      end
+    end
+  end
+
+  describe '/foo/:bar (:bar as time)' do
+    it 'converts :bar to time' do
+      get '/foo/2012-01-01' do |response|
+        response.status.should == 200
+        JSON.parse(response.body)['params']['bar'].should == '2012-01-01T00:00:00-05:00'
+      end
+    end
+  end
+
+  describe '/protected' do
+    it 'should present http basic challenge with no credentials' do
+      get '/protected' do |response|
+        response.status.should == 401
+      end
+    end
+
+    it 'should present the http basic challenge with invalid credentials' do
+      authorize('wrong', 'values')
+      get '/protected' do |response|
+        response.status.should == 401
+      end
+    end
+
+    it 'should process normally if credentials are correct' do
+      authorize('no', 'way')
+      get '/protected' do |response|
+        response.status.should == 200
+      end
+    end
+  end
+
+  describe '/arithmetic' do
+    it 'should not allow :int < 5' do
+      get('/arithmetic', {int: 4}) do |response|
+        response.status.should == 404
+        JSON.parse(response.body)['errors']['/arithmetic'].should == {
+          'int' => 'value_validation_failed'
+        }
+      end
+
+      get('/arithmetic', {int: 5}) do |response|
+        response.status.should == 200
+      end
+    end
+
+    it "is called arithmetic but works on strings" do
+      get('/arithmetic', {str: 'goodbye'}) do |response|
+        response.status.should == 404
+      end
+
+      get('/arithmetic', {str: 'hello'}) do |response|
+        response.status.should == 200
+      end
+    end
+
+    it "also works on dates" do
+      get('/arithmetic', {date: '2011-12-25'}) do |response|
+        response.status.should == 404
+      end
+
+      get('/arithmetic', {date: '2012-01-02'}) do |response|
+        response.status.should == 200
+      end
+    end
+  end
+
+  describe '/defaults' do
+    it "handles default parameter values correctly" do
+      get('/defaults') do |response|
+        response.status.should == 200
+        JSON.parse(response.body)['params'].should == {
+          'foo' => 'hello',
+          'baz' => 'world',
+          'nil' => nil
+        }
+      end
+
+      get('/defaults', {foo: 'world', baz: 'hello', bar: 'not nil', nil: 'not nil'}) do |response|
+        response.status.should == 200
+        JSON.parse(response.body)['params'].should == {
+          'foo' => 'world',
+          'baz' => 'hello',
+          'bar' => 'not nil',
+          'nil' => 'not nil'
+        }
+      end
+    end
+  end
+end

data/spec/fun_with_requests_spec.rb

@@ -0,0 +1,101 @@
+require 'spec_helper'
+require 'rack/test'
+require 'dzl/examples/fun_with_requests'
+
+describe 'endpoint request method' do
+  include Rack::Test::Methods
+  def app; Dzl::Examples::FunWithRequests; end
+
+  it 'defaults to GET' do
+    get('/foo') do |response|
+      response.status.should == 200
+      response.body.should == 'get'
+    end
+  end
+
+  it 'allows specification through endpoint options' do
+    post('/post_op') do |response|
+      response.status.should == 200
+      response.body.should == 'post'
+    end
+
+    get('/post_op') do |response|
+      response.status.should == 404
+      JSON.parse(response.body)['errors']['/post_op'].should == 'request_method_not_supported'
+    end
+  end
+
+  it 'allows specification of multiple request methods' do
+    post('/multi_op') do |response|
+      response.status.should == 200
+      response.body.should == 'post'
+    end
+
+    put('/multi_op') do |response|
+      response.status.should == 200
+      response.body.should == 'put'
+    end
+
+    get('/multi_op') do |response|
+      response.status.should == 404
+    end
+  end
+
+  describe 'aliases' do
+    it 'work as expected' do
+      get('/get_only') do |response|
+        response.status.should == 200
+      end
+
+      post('/get_only') do |response|
+        response.status.should == 404
+      end
+
+      delete('/delete_only') do |response|
+        response.status.should == 200
+      end
+    end
+
+    it 'allow multiple methods the regular way' do
+      get('/get_and_post') do |response|
+        response.status.should == 200
+      end
+
+      post('/get_and_post') do |response|
+        response.status.should == 200
+      end
+    end
+  end
+
+  describe 'validating headers' do
+    it 'rejects invalid values' do
+      get('/validated_header', {}, {'HTTP_KEY' => 'hell'}) do |response|
+        response.status.should == 404
+      end
+    end
+
+    it 'accepts valid values' do
+      get('/validated_header', {}, {'HTTP_KEY' => 'hello'}) do |response|
+        response.status.should == 200
+      end
+    end
+  end
+
+  describe 'ambiguous routes' do
+    it 'should respond with the right endpoint' do
+      get('/ambiguous', {foo: 'foo'}) do |response|
+        response.status.should == 200
+        response.body.should == 'foo'
+      end
+
+      get('/ambiguous', {bar: 'bar'}) do |response|
+        response.status.should == 200
+        response.body.should == 'bar'
+      end
+
+      get('/ambiguous', {baz: 'baz'}) do |response|
+        response.status.should == 404
+      end
+    end
+  end
+end

data/spec/logger_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+require 'dzl/examples/base'
+require 'rack/test'
+
+class LogTestApp < Dzl::Examples::Base
+  get '/log_me' do
+    required :msg
+
+    handle do
+      logger.success.debug "message is #{params[:msg]}"
+    end
+  end
+end
+
+describe 'Modules including Dzl' do
+  it 'should have a logger object provided by Dzl' do
+    l = Dzl::Examples::Base.__logger.class.should == Dzl::Logger
+  end
+
+  it 'should use their own logger if it is provided' do
+    app = Class.new do
+      def self.root
+        '/'
+      end
+
+      def self.logger
+        @l ||= ActiveSupport::BufferedLogger.new('/dev/null', ::Logger::DEBUG)
+      end
+
+      include Dzl
+    end
+
+    app.__logger.class.should == ActiveSupport::BufferedLogger
+  end
+end
+
+describe 'LogTestApp' do
+  include Rack::Test::Methods
+
+  def app; LogTestApp; end
+
+  it 'drops logs' do
+    get('/log_me?msg=success')
+    last_response.status.should == 200
+
+    `tail -n 1 #{LogTestApp.root}/log/success.test.log`.match('success').should_not == nil
+  end
+end

data/spec/route_params_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe 'route parameters' do
+  it 'cannot be set to optional' do
+    expect {
+      class TestApp1 < Dzl::Examples::Base
+        endpoint '/foo/:bar' do
+          optional :bar
+        end
+      end
+    }.to raise_error(Dzl::ParameterError)
+  end
+end

data/spec/router_doc_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+require 'dzl/examples/base'
+require 'rack/test'
+
+def app; Dzl::Examples::FunWithParams; end
+
+def file_mock
+  mock_file = mock "File"
+  mock_file.stub!(:write).with(anything).and_return(true)
+  mock_file.stub!(:close).and_return(true)
+  File.stub!(:new).and_return(mock_file)
+end
+
+describe 'router doc functionality' do
+  it 'should use a template to generate markdown' do
+    File.should_receive(:read).with("./lib/dzl/doc/templates/home.erb").and_return("")
+
+    app.__router.to_md
+  end
+
+  it 'asks endpoints to generate thier docs' do
+    file_mock
+    app.__router.endpoints.each do |endpoint|
+      endpoint.should_receive(:to_md).and_return("")
+    end
+
+    app.__router.should_receive(:to_md).with("FunWithParams", anything).and_return("")
+    app.__router.should_receive(:'`').with(/FunWithParams/).and_return(nil)
+
+    app.__router.to_docs
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+require 'bundler/setup'
+require 'dzl'
+
+ENV['RACK_ENV'] ||= 'test'
+
+RSpec.configure do |config|
+  config.mock_with :rspec
+end