dao 0.0.0 → 2.0.0

data/sample/rails_app/public/javascripts/rails.js

@@ -0,0 +1,175 @@
+(function() {
+  // Technique from Juriy Zaytsev
+  // http://thinkweb2.com/projects/prototype/detecting-event-support-without-browser-sniffing/
+  function isEventSupported(eventName) {
+    var el = document.createElement('div');
+    eventName = 'on' + eventName;
+    var isSupported = (eventName in el);
+    if (!isSupported) {
+      el.setAttribute(eventName, 'return;');
+      isSupported = typeof el[eventName] == 'function';
+    }
+    el = null;
+    return isSupported;
+  }
+
+  function isForm(element) {
+    return Object.isElement(element) && element.nodeName.toUpperCase() == 'FORM'
+  }
+
+  function isInput(element) {
+    if (Object.isElement(element)) {
+      var name = element.nodeName.toUpperCase()
+      return name == 'INPUT' || name == 'SELECT' || name == 'TEXTAREA'
+    }
+    else return false
+  }
+
+  var submitBubbles = isEventSupported('submit'),
+      changeBubbles = isEventSupported('change')
+
+  if (!submitBubbles || !changeBubbles) {
+    // augment the Event.Handler class to observe custom events when needed
+    Event.Handler.prototype.initialize = Event.Handler.prototype.initialize.wrap(
+      function(init, element, eventName, selector, callback) {
+        init(element, eventName, selector, callback)
+        // is the handler being attached to an element that doesn't support this event?
+        if ( (!submitBubbles && this.eventName == 'submit' && !isForm(this.element)) ||
+             (!changeBubbles && this.eventName == 'change' && !isInput(this.element)) ) {
+          // "submit" => "emulated:submit"
+          this.eventName = 'emulated:' + this.eventName
+        }
+      }
+    )
+  }
+
+  if (!submitBubbles) {
+    // discover forms on the page by observing focus events which always bubble
+    document.on('focusin', 'form', function(focusEvent, form) {
+      // special handler for the real "submit" event (one-time operation)
+      if (!form.retrieve('emulated:submit')) {
+        form.on('submit', function(submitEvent) {
+          var emulated = form.fire('emulated:submit', submitEvent, true)
+          // if custom event received preventDefault, cancel the real one too
+          if (emulated.returnValue === false) submitEvent.preventDefault()
+        })
+        form.store('emulated:submit', true)
+      }
+    })
+  }
+
+  if (!changeBubbles) {
+    // discover form inputs on the page
+    document.on('focusin', 'input, select, texarea', function(focusEvent, input) {
+      // special handler for real "change" events
+      if (!input.retrieve('emulated:change')) {
+        input.on('change', function(changeEvent) {
+          input.fire('emulated:change', changeEvent, true)
+        })
+        input.store('emulated:change', true)
+      }
+    })
+  }
+
+  function handleRemote(element) {
+    var method, url, params;
+
+    var event = element.fire("ajax:before");
+    if (event.stopped) return false;
+
+    if (element.tagName.toLowerCase() === 'form') {
+      method = element.readAttribute('method') || 'post';
+      url    = element.readAttribute('action');
+      params = element.serialize();
+    } else {
+      method = element.readAttribute('data-method') || 'get';
+      url    = element.readAttribute('href');
+      params = {};
+    }
+
+    new Ajax.Request(url, {
+      method: method,
+      parameters: params,
+      evalScripts: true,
+
+      onComplete:    function(request) { element.fire("ajax:complete", request); },
+      onSuccess:     function(request) { element.fire("ajax:success",  request); },
+      onFailure:     function(request) { element.fire("ajax:failure",  request); }
+    });
+
+    element.fire("ajax:after");
+  }
+
+  function handleMethod(element) {
+    var method = element.readAttribute('data-method'),
+        url = element.readAttribute('href'),
+        csrf_param = $$('meta[name=csrf-param]')[0],
+        csrf_token = $$('meta[name=csrf-token]')[0];
+
+    var form = new Element('form', { method: "POST", action: url, style: "display: none;" });
+    element.parentNode.insert(form);
+
+    if (method !== 'post') {
+      var field = new Element('input', { type: 'hidden', name: '_method', value: method });
+      form.insert(field);
+    }
+
+    if (csrf_param) {
+      var param = csrf_param.readAttribute('content'),
+          token = csrf_token.readAttribute('content'),
+          field = new Element('input', { type: 'hidden', name: param, value: token });
+      form.insert(field);
+    }
+
+    form.submit();
+  }
+
+
+  document.on("click", "*[data-confirm]", function(event, element) {
+    var message = element.readAttribute('data-confirm');
+    if (!confirm(message)) event.stop();
+  });
+
+  document.on("click", "a[data-remote]", function(event, element) {
+    if (event.stopped) return;
+    handleRemote(element);
+    event.stop();
+  });
+
+  document.on("click", "a[data-method]", function(event, element) {
+    if (event.stopped) return;
+    handleMethod(element);
+    event.stop();
+  });
+
+  document.on("submit", function(event) {
+    var element = event.findElement(),
+        message = element.readAttribute('data-confirm');
+    if (message && !confirm(message)) {
+      event.stop();
+      return false;
+    }
+
+    var inputs = element.select("input[type=submit][data-disable-with]");
+    inputs.each(function(input) {
+      input.disabled = true;
+      input.writeAttribute('data-original-value', input.value);
+      input.value = input.readAttribute('data-disable-with');
+    });
+
+    var element = event.findElement("form[data-remote]");
+    if (element) {
+      handleRemote(element);
+      event.stop();
+    }
+  });
+
+  document.on("ajax:after", "form", function(event, element) {
+    var inputs = element.select("input[type=submit][disabled=true][data-disable-with]");
+    inputs.each(function(input) {
+      input.value = input.readAttribute('data-original-value');
+      input.removeAttribute('data-original-value');
+      input.disabled = false;
+    });
+  });
+})();

data/sample/rails_app/public/robots.txt

@@ -0,0 +1,5 @@
+# See http://www.robotstxt.org/wc/norobots.html for documentation on how to use the robots.txt file
+#
+# To ban all spiders from the entire site uncomment the next two lines:
+# User-Agent: *
+# Disallow: /

data/sample/rails_app/script/rails

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# This command will automatically be run when you run "rails" with Rails 3 gems installed from the root of your application.
+
+APP_PATH = File.expand_path('../../config/application',  __FILE__)
+require File.expand_path('../../config/boot',  __FILE__)
+require 'rails/commands'

data/sample/rails_app/test/performance/browsing_test.rb

@@ -0,0 +1,9 @@
+require 'test_helper'
+require 'rails/performance_test_help'
+
+# Profiling results for each test method are written to tmp/performance.
+class BrowsingTest < ActionDispatch::PerformanceTest
+  def test_homepage
+    get '/'
+  end
+end

data/sample/rails_app/test/test_helper.rb

@@ -0,0 +1,13 @@
+ENV["RAILS_ENV"] = "test"
+require File.expand_path('../../config/environment', __FILE__)
+require 'rails/test_help'
+
+class ActiveSupport::TestCase
+  # Setup all fixtures in test/fixtures/*.(yml|csv) for all tests in alphabetical order.
+  #
+  # Note: You'll currently still have to declare fixtures explicitly in integration tests
+  # -- they do not yet inherit this setting
+  fixtures :all
+
+  # Add more helper methods to be used by all tests here...
+end

data/test/dao_test.rb

@@ -0,0 +1,271 @@
+testdir = File.dirname(File.expand_path(__FILE__))
+rootdir = File.dirname(testdir)
+libdir = File.join(rootdir, 'lib')
+
+require File.join(libdir, 'dao')
+require File.join(testdir, 'testing')
+require File.join(testdir, 'helper')
+
+
+Testing Dao do
+# api
+#
+  testing 'that an api class for your application can be built using a simple dsl' do
+    assert{
+      api_class =
+        Dao.api do
+          ### dsl
+        end
+    }
+  end
+
+  testing 'that apis can have callable endpoints added to them which accept params and return results' do
+    captured = []
+
+    api_class =
+      assert{
+        Dao.api do
+          endpoint(:foo) do |params, result|
+            captured.push(params, result)
+          end
+        end
+      }
+    api = assert{ api_class.new }
+    result = assert{ api.call(:foo, {}) }
+    assert{ result.is_a?(Hash) }
+  end
+
+  testing 'that endpoints are automatically called according to arity' do
+    api = assert{ Class.new(Dao.api) }
+    assert{ api.class_eval{ endpoint(:zero){|| result.update :args => [] } } }
+    assert{ api.class_eval{ endpoint(:one){|a| result.update :args => [a]} } }
+    assert{ api.class_eval{ endpoint(:two){|a,b| result.update :args => [a,b]} } }
+
+    assert{ api.new.call(:zero).args.size == 0 }
+    assert{ api.new.call(:one).args.size == 1 }
+    assert{ api.new.call(:two).args.size == 2 }
+  end
+
+  testing 'that endpoints have an auto-vivifying params/result' do
+    api = assert{ Class.new(Dao.api) }
+    assert{ api.class_eval{ endpoint(:foo){ params; result; } } }
+    result = assert{ api.new.call(:foo) }
+    assert{ result.path.to_s =~ /foo/ }
+  end
+
+# results
+#
+  testing 'that results can be created' do
+    result = assert{ Dao::Result.new }
+    assert{ result.path }
+    assert{ result.status }
+    assert{ result.data }
+    assert{ result.errors }
+    assert{ result.validations }
+  end
+
+  testing 'that results can be created with a path' do
+    result = assert{ Dao::Result.new('/api/foo/bar') }
+    assert{ result.path == '/api/foo/bar' }
+  end
+
+## paths
+#
+  testing 'that simple paths can be contstructed/compiled' do
+    path = assert{ Dao::Path.for('./api/../foo/bar')  }
+    assert{ path =~ %r|^/| }
+    assert{ path !~ %r|[.]| }
+    assert{ path.params.is_a?(Hash) }
+    assert{ path.keys.is_a?(Array) }
+    assert{ path.pattern.is_a?(Regexp) }
+  end
+
+# status
+#
+  testing 'Status.for' do
+    assert{ Dao::Status.for(:unauthorized).code == 401 }
+    assert{ Dao::Status.for(:UNAUTHORIZED).code == 401 }
+    assert{ Dao::Status.for('unauthorized').code == 401 }
+    assert{ Dao::Status.for('UNAUTHORIZED').code == 401 }
+    assert{ Dao::Status.for('Unauthorized').code == 401 }
+    assert{ Dao::Status.for(:Unauthorized).code == 401 }
+    assert{ Dao::Status.for(:No_Content).code == 204 }
+    assert{ Dao::Status.for(:no_content).code == 204 }
+  end
+
+  testing 'status equality operator' do
+    s = Dao::Status.for(401)
+    assert{ s == :unauthorized }
+    assert{ s == 401 }
+    assert{ s != Array.new }
+  end
+
+# parser
+#
+  testing 'parsing a simple hash by key' do
+    params = {
+      'key(a)' => 40,
+      'key(b)' => 2
+    }
+    parsed = Dao.parse(:key, params)
+    expected = {'a' => 40, 'b' => 2}
+    assert{ parsed =~ expected }
+  end
+
+  testing 'parsing a nested hash by key' do
+    params = {
+      'key(a,x)' => 40,
+      'key(a,y)' => 2
+    }
+    parsed = Dao.parse(:key, params)
+    expected = {'a' => {'x' => 40, 'y' => 2}} 
+    assert{ parsed =~ expected }
+  end
+
+  testing 'parsing a deeply nested hash by key' do
+    params = {
+      'key(a,b,x)' => 40,
+      'key(a,b,y)' => 2
+    }
+    parsed = Dao.parse(:key, params)
+    expected = {'a' => {'b' => {'x' => 40, 'y' => 2}}} 
+    assert{ parsed =~ expected }
+  end
+
+  testing 'that params are auto-parsed if the api detects that they need to be ' do
+    assert{
+      api_class =
+        Dao.api do
+          endpoint('/foobar'){
+            data.update(params)
+          }
+        end
+      api = api_class.new
+
+      result = assert{ api.call('/foobar', 'key' => 'val') }
+      assert{ result.data =~ {'key' => 'val'} }
+
+      result = assert{ api.call('/foobar', '/foobar(key)' => 'val', '/foobar(a,0)' => 42, '/foobar(a,1)' => 42.0) }
+      assert{ result.data =~ {'key' => 'val', 'a' => [42, 42.0]} }
+    }
+  end
+
+# errors.rb
+#
+  testing 'that clear does not drop sticky errors' do
+    errors = Dao::Errors.new
+    errors.add! 'sticky', 'error'
+    errors.add 'not-sticky', 'error'
+    errors.clear
+    assert{ errors['sticky'].first == 'error' }
+    assert{ errors['not-sticky'].nil? }
+  end
+
+  testing 'that clear! ***does*** drop sticky errors' do
+    errors = Dao::Errors.new
+    errors.add! 'sticky', 'error'
+    errors.add 'not-sticky', 'error'
+    errors.clear!
+    assert{ errors['sticky'].nil? }
+    assert{ errors['not-sticky'].nil? }
+  end
+
+  testing 'that global errors are sticky' do
+    errors = Dao::Errors.new
+    global = Dao::Errors::Global
+    errors.add! 'global-error'
+    errors.clear
+    assert{ errors[global].first == 'global-error' }
+    errors.clear!
+    assert{ errors[global].nil? }
+  end
+
+# validations
+#
+  testing 'that simple validations work' do
+    result = Dao::Result.new
+    assert{ result.validates(:password){|password| password=='haxor'} }
+    result.params.set(:password, 'haxor')
+    assert{ result.valid? }
+  end
+
+  testing 'that validations have some syntax sugar' do
+    assert{
+      api_class =
+        Dao.api do
+          endpoint('/foobar'){
+            result.validates(:a)
+            params.validate(:b)
+            validates(:c)
+          }
+        end
+      api = api_class.new
+
+      result = assert{ api.call('/foobar', 'a' => true, 'b' => true, 'c' => true) }
+    }
+  end
+
+# validating
+#
+  testing 'that validations can be cleared and do not clobber manually added errors' do
+    result = Dao::Result.new
+    params = result.params
+    params = result.params
+    errors = result.errors
+
+    assert{ result.validates(:email){|email| email.to_s.split(/@/).size == 2} }
+    assert{ result.validates(:password){|password| password == 'haxor'} }
+
+    params.set(:email => 'ara@dojo4.com', :password => 'fubar')
+    assert{ not result.valid? }
+
+    params.set(:password => 'haxor')
+    assert{ result.valid? }
+
+    errors.add(:name, 'ara')
+    assert{ not result.valid? }
+  end
+
+# doc
+#
+  testing 'that apis can be documented via the api' do
+    api_class =
+      assert {
+        Dao.api {
+          description 'foobar'
+          doc 'signature' => {'read' => '...', 'write' => '...'} 
+          endpoint('/barfoo'){}
+        }
+      }
+    api_class_index = assert{ api_class.index.is_a?(Hash) }
+    api = assert{ api_class.new }
+    api_index = assert{ api.index.is_a?(Hash) }
+    assert{ api_class_index==api_index }
+  end
+
+=begin
+
+# cloning
+#
+  testing 'simple cloning' do
+    data = Dao.data(:foo)
+    clone = assert{ data.clone }
+    assert{ data.path == clone.path }
+    assert{ data.errors == clone.errors }
+    assert{ data.errors.object_id != clone.errors.object_id }
+    assert{ data.validations == clone.validations }
+    assert{ data.validations.object_id != clone.validations.object_id }
+    assert{ data.form != clone.form }
+    assert{ data.form.object_id != clone.form.object_id }
+    assert{ data.status == clone.status }
+    assert{ data.status.object_id != clone.status.object_id }
+    assert{ data == clone }
+  end
+
+=end
+
+    def hash_equal(a, b)
+      array = lambda{|h| h.to_a.map{|k,v| [k.to_s, v]}.sort}
+      array[a] == array[b]
+    end
+end