yodel 0.0.1

data/lib/yodel/public/core/js/yodel_jquery.js

@@ -0,0 +1,238 @@
+var Yodel = {};
+
+// Security
+Yodel.Security = {
+  login: function(credentials, path) {
+    var action = (path ? path : '/login');
+    var form = jQuery('<form action="' + action + '" metod="post"/>');
+    jQuery.each(credentials, function(key, value) { 
+      form.append(jQuery('<input type="hidden" name="' + key + '" value="' + value + '"/>'));
+    });
+    form.submit();
+  },
+  
+  remote_login: function(credentials, fns, path) {
+    path = path ? path : '/login.json';
+    var request = jQuery.post(path, credentials, 'json');
+    request.success(function(data, textStatus, jqXHR) {
+      if(fns.success)
+        fns.success(data);
+    });
+    request.error(function(jqXHR, textStatus, errorThrown) {
+      if(fns.failure) {
+        var json = {};
+        try {
+          json = jQuery.parseJSON(jqXHR.responseText);
+        } catch(err) {}
+        fns.failure(json);
+      }
+    });
+  },
+  
+  Facebook: {
+    Window: {
+      width: 1000,
+      height: 480,
+      title: 'Login'
+    },
+    redirectPath: '/facebook',
+    redirectURI: null,
+    clientID: '',
+    scope: null
+  },
+  
+  facebook_login: function() {
+    var Options = Yodel.Security.Facebook;
+    var url = 'https://www.facebook.com/dialog/oauth?client_id=' + Options.clientID;
+    
+    if(Options.redirectURI) {
+      url += '&redirect_uri=' + Options.redirectURI;
+    } else {
+      url += '&redirect_uri=' + window.location.protocol + '//' + window.location.host + Options.redirectPath;
+    }
+    
+    if(Options.scope) {
+      url += '&scope=' + Options.scope;
+    }
+    
+    var windowOptionsString = 'width=' + Options.Window.width + ',height=' + Options.Window.height;
+    window.open(url, Options.Window.title, windowOptionsString);
+  }
+}
+
+jQuery('*[data-oauth-login=facebook]').live('click', function(event, element) {
+  Yodel.Security.facebook_login();
+  event.preventDefault();
+});
+
+
+// Record interaction
+Yodel.Records = {
+  update: function(path, fields) {
+    if((path.length <= 5) || (path.substr(-5,5) != '.json'))
+      path = path + '.json';
+    jQuery.post(path, {_method: 'put', record: JSON.stringify(fields)});
+  }
+};
+
+jQuery('.yodel-remote-action').live('click', function(event, element) {
+  var action = element.attr('data-action');
+  if(action)
+    eval(action);
+});
+
+
+// Remote form submission
+Yodel.Forms = {
+  clearStatusStates: function(form) {
+    jQuery(form).find('span[data-handles]').each(function(index, statusData) {
+      var status = jQuery(statusData).children().first();
+      if(status) {
+        status.html('');
+        status.removeClass('new');
+        status.removeClass('valid');
+        status.removeClass('invalid');
+      }
+    });
+  },
+  
+  setState: function(fieldName, form, state, message) {
+    // FIXME: assumes all fields have a status element as well
+    // check the form contains a field element for this message
+    var field = jQuery(form).find('*[data-field=' + fieldName + ']').first();
+    if(!field[0]) {
+      console.log("Form does not contain a field for: " + fieldName);
+      return;
+    }
+
+    var statusData = jQuery(form).find('span[data-handles*=' + fieldName + ']').first();
+    var status = statusData.children().first();
+
+    // submission of a form never transitions a field to the new state
+    status.removeClass('new');    
+
+    if(state == 'valid') {
+      if(!status.hasClass('invalid')) {
+        status.removeClass('invalid');
+        status.addClass('valid');
+      }
+      field.removeClass('invalid');
+      field.addClass('valid');
+    } else {
+      status.addClass('invalid');
+      status.removeClass('valid');
+      field.addClass('invalid');
+      field.removeClass('valid');
+    }
+
+    // either use the supplied message, or override it with
+    // a static message provided in the layout
+    var staticMessage = statusData.attr('data-' + state + '-text');
+    if(staticMessage)
+      message = staticMessage;
+    else
+      message = message || '';
+
+    // set data-errors on the field
+    field.attr('data-errors', message);
+
+    // insert or replace the status element's text. Statuses may
+    // correspond to more than one field, hence concatenating msgs.
+    if(message)
+      if(status.html() == '')
+        status.html(message);
+      else
+        status.html(status.html() + ', ' + message);
+  },
+  
+  handleFailure: function(activityElement, form, data) {
+    var failureFunction = Yodel.Forms.callbackFunction(form, 'failure');
+    Yodel.Forms.hideActivityElement(activityElement);
+    if(failureFunction)
+      failureFunction(data);
+  },
+  
+  callbackFunction: function(form, name) {
+    var functionName = form.attr('data-' + name + '-function');
+    if(functionName) {
+      var functionReference = eval(functionName);
+      if(functionReference)
+        return functionReference;
+    }
+    return null;
+  },
+  
+  hideActivityElement: function(activityElement) {
+    if(activityElement)
+      activityElement.css('visibility', 'hidden');
+  },
+  
+  submit: function(event, element) {
+    var form = jQuery(element);
+    
+    // show the activity indicator if present
+    var activityElement = form.find('.yodel-form-activity')
+    activityElement.css('visibility', 'visible');
+    
+    // create an iframe to handle the submission if necessary. iframes
+    // are used instead of ajax calls so file uploads can be supported
+    var iframeID = 'form_' + form.attr('id') + '_iframe';
+    var iframe = jQuery('#' + iframeID);
+    if(iframe.length == 0) {
+      form.after('<iframe id="' + iframeID + '" name="' + iframeID + '" style="display:none"></iframe>');
+      form.attr('target', iframeID);
+      iframe = jQuery('#' + iframeID);
+      
+      // FIXME: handle timeouts, failed requests
+      iframe.load(function() {
+        var iframeBody = iframe.contents().find('body');
+        var jsonText = iframeBody.find(':contains("{")').html();
+				var json = jQuery.parseJSON(jsonText);
+				setTimeout(function () { iframeBody.html(''); }, 1);
+				
+				if(json.success) {
+          Yodel.Forms.hideActivityElement(activityElement);
+          var successFunction = Yodel.Forms.callbackFunction(form, 'success');
+          var record = json.record;
+
+          if(successFunction)
+            successFunction(record);
+
+        } else {
+          Yodel.Forms.hideActivityElement(activityElement);
+          var errorsFunction = Yodel.Forms.callbackFunction(form, 'errors');
+          var errors = json.errors;
+
+          if(errorsFunction) {
+            errorsFunction(errors);
+          } else {
+            Yodel.Forms.clearStatusStates(form);
+            form.find('*[data-field]').each(function(index, element) {
+              var fieldName = jQuery(element).attr('data-field');
+              if(json.errors[fieldName])
+                Yodel.Forms.setState(fieldName, form, 'invalid', json.errors[fieldName]);
+              else
+                Yodel.Forms.setState(fieldName, form, 'valid');
+            });
+          }
+        }
+      });
+    }
+  }
+}
+
+if(jQuery.browser.msie) {
+  jQuery('form').live('focusin', function(focusEvent) {
+    var form = focusEvent.target;
+    if(jQuery(form).attr('data-remote') == 'true' && !form.builtSubmitEvent) {
+      jQuery(form).submit(function(submitEvent) {
+        Yodel.Forms.submit(submitEvent, submitEvent.target);
+      });
+      form.builtSubmitEvent = true;
+    }
+  });
+} else {
+  jQuery('form[data-remote=true]').live('submit', function(event) {
+    Yodel.Forms.submit(event, event.target);
+  });
+}

data/lib/yodel/request/authentication.rb

@@ -0,0 +1,76 @@
+# some of the basic auth code taken from an inspired by rack/auth/basic
+module Authentication
+  AUTHORIZATION_KEYS = ['HTTP_AUTHORIZATION', 'X-HTTP_AUTHORIZATION', 'X_HTTP_AUTHORIZATION']
+  
+  def logged_in?(auth_type=nil)
+    !current_user(auth_type).nil?
+  end
+  
+  def current_user(auth_type=nil)
+    unless defined?(@current_user)
+      @current_user = nil
+      auth_type ||= mime_type.auth_type
+      
+      if auth_type == :page || session['current_user_id']
+        @current_user = site.users.find(session['current_user_id'])
+        session.delete('current_user_id') if @current_user.nil?
+        
+      elsif auth_type == :basic
+        unless authorization_key.nil? || !basic?
+          user = site.users.first(username: credentials.first)
+          @current_user = user if user.try(:passwords_match?, credentials.last)
+        end
+      end
+    end
+    @current_user
+  end
+  
+  def prompt_login(auth_type=nil)
+    auth_type ||= mime_type.auth_type
+    case auth_type
+    when :page
+      session[:redirect_to_after_login] = self.path
+      response.redirect site.login_pages.first.path
+    when :basic
+      response['Content-Type'] = 'text/plain'
+      response['WWW-Authenticate'] = "Basic realm=\"#{title}\""
+      response.status = 401
+      response.body = []
+    end
+  end
+  
+  def login(credentials)
+    password = credentials.delete('password')
+    user = site.users.first(credentials)
+    if user && user.passwords_match?(password)
+      store_authenticated_user(user)
+    end
+    !@current_user.nil?
+  end
+  
+  def logout
+    session.delete('current_user_id')
+  end
+  
+  def store_authenticated_user(user)
+    session['current_user_id'] = user.id
+    @current_user = user
+  end
+  
+  private
+    def authorization_key
+      @authorization_key ||= AUTHORIZATION_KEYS.find {|key| env.has_key?(key)}
+    end
+    
+    def basic?
+      parts.first.downcase == 'basic'
+    end
+    
+    def credentials
+      @credentials ||= parts.last.unpack("m*").first.split(/:/, 2)
+    end
+    
+    def parts
+      @parts ||= env[authorization_key].split(' ', 2)
+    end 
+end

data/lib/yodel/request/flash.rb

@@ -0,0 +1,28 @@
+class Flash
+  def initialize(session)
+    @session = session
+    @last_request = @session['flash'] || {}
+    @this_request = {}
+  end
+  
+  def finalize
+    @session['flash'] = @this_request
+  end
+  
+  def [](key)
+    @this_request[key] || @last_request[key]
+  end
+  
+  def now(key, value)
+    @last_request[key] = value
+  end
+  
+  def []=(key, value)
+    @this_request[key] = value
+  end
+  
+  def delete(key)
+    @this_request.delete(key)
+    @last_request.delete(key)
+  end
+end

data/lib/yodel/request/request.rb

@@ -0,0 +1,4 @@
+Dir.chdir(File.dirname(__FILE__)) do
+  require './authentication'
+  require './flash'
+end

data/lib/yodel/requires.rb

@@ -0,0 +1,47 @@
+require 'logger'
+require 'forwardable'
+require 'bigdecimal'
+require 'date'
+require 'ostruct'
+require 'net/http'
+require 'open-uri'
+require 'fileutils'
+require 'uri'
+
+# load bundled gems
+require 'rubygems'
+require 'bundler'
+require 'rack'
+require 'plucky' # requires mongo
+require 'ember'
+require 'mail'
+require 'hpricot'
+require 'json'
+require 'rack/contrib'
+require 'rubydns'
+require 'git'
+require 'highline'
+require 'mini_magick'
+require 'linguistics'
+
+# manually load active support extensions
+require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/object/try'
+require 'active_support/inflector'
+require 'active_support/core_ext/hash/keys'
+require 'active_support/core_ext/array/conversions'
+require 'active_support/core_ext/time/calculations'
+
+# for consistency, default to syck for YAML dumps/loads
+# psych and syck have incompatible nil representations
+YAML::ENGINE.yamler = 'syck'
+
+# config and environment are loaded separately
+# from yodel, so a configuration can be created
+# before loading the server or console
+require File.join(File.dirname(__FILE__), 'config', 'config')
+if $settings
+  require $settings
+else
+  require '/usr/local/etc/yodel/settings.rb'
+end

data/lib/yodel/task_queue/queue_daemon.rb

@@ -0,0 +1,33 @@
+module QueueDaemon
+  IMMEDIATE_WORKERS = 1
+  DELAYED_WORKERS = 1
+  
+  def self.run
+    immediate_queue = TaskQueue.new(true)
+    delayed_queue = TaskQueue.new(false)
+
+    immediate_workers = []
+    delayed_workers = []
+    
+    puts "Starting Workers..."
+    stats_thread = StatsThread.new
+    IMMEDIATE_WORKERS.times do
+      immediate_workers << QueueWorker.new(immediate_queue, stats_thread)
+    end
+
+    DELAYED_WORKERS.times do
+      delayed_workers << QueueWorker.new(delayed_queue, stats_thread)
+    end
+    
+    Signal.trap('INT') do
+      puts("Shutting down...")
+      stats_thread.stop
+      immediate_workers.each(&:stop)
+      delayed_workers.each(&:stop)
+    end
+
+    immediate_workers.each {|worker| worker.join}
+    delayed_workers.each {|worker| worker.join}
+    puts "Shutdown complete"
+  end
+end

data/lib/yodel/task_queue/queue_worker.rb

@@ -0,0 +1,32 @@
+class QueueWorker
+  PAUSE_DURATION = 1
+  def initialize(queue, stats_thread)
+    @stats_thread = stats_thread
+    @queue = queue
+    run
+  end
+  
+  def run
+    @running = true
+    @thread = Thread.new do
+      while @running
+        task = @queue.pop
+        sleep(PAUSE_DURATION) and next if task.nil?
+        task.execute
+        @stats_thread.processed_task
+      end
+    end
+  end
+  
+  def stop
+    @running = false
+  end
+  
+  def kill
+    @thread.kill
+  end
+  
+  def join
+    @thread.join
+  end
+end