virgo-gadgeteer 0.2.2

data/LICENSE

@@ -0,0 +1 @@
+Copyright (c) 2009 Virgo Systems Kft., released under the MIT license

data/README.rdoc

@@ -0,0 +1,49 @@
+Gadgeteer simplifies OpenSocial Gadget development by giving you helpers you can use in your Rails application to verify Signed Requests and access OpenSocial data.
+
+= Requirements
+
+Gadgeteer requires the {oauth gem}[http://github.com/pelle/oauth/tree/master] (0.2.7+).
+
+*Note*: the current version of the oauth gem doesn't comply completely with the OAuth standard, and also doesn't work with Rails 2.3</tt>. You can use {lackac's fork}[http://github.com/lackac/oauth/tree/master], until the fixes are merged in.
+
+= Usage
+
+You can configure the secrets and public keys used by your application two ways.
+
+For consumer secrets you can put your consumer key/secret pairs into <tt>config/oauth_secrets.yml</tt>:
+
+  key: secret
+
+or you could setup those in your ApplicationController:
+
+  class ApplicationController < ActionController::Base
+  
+    oauth_secrets['key'] = 'secret'
+  
+  end
+
+For public keys you can put the certificates into <tt>config/certs</tt> with <tt>.cert</tt> extension, or you could setup the public keys in your ApplicationController by creating a <tt>OpenSSL::PKey::RSA</tt> object and adding it to the <tt>public_keys</tt> hash:
+
+  class ApplicationController < ActionController::Base
+  
+    public_keys['example.com'] = OpenSSL::PKey::RSA.new(OpenSSL::X509::Certificate.new(CERT).public_key)
+  
+  end
+
+You can use the <tt>verify_signature</tt> method as a before_filter in your controllers to make sure the signed requests are correct:
+
+  class SecretNotesController < ActionController::Base
+  
+    before_filter :verify_signature
+  
+  end
+
+The correct secret or public key will be used for verification based on the current request. If the <tt>xoauth_signature_publickey</tt> parameter is set, the corresponding public key will be used. Otherwise the consumer secret connected to the key found in the <tt>oauth_consumer_key</tt> parameter will be used. The singature will be verified based on this key/secret pair and the singature method set in the parameters.
+
+If there are OpenSocial related request parameters, you can access them with the <tt>open_social</tt> method:
+
+  def index
+    @secret_notes = SecretNote.find_by_profile_id(open_social[:viewer_id])
+  end
+
+Copyright (c) 2009 Virgo Systems Kft., released under the MIT license

data/Rakefile

@@ -0,0 +1,42 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rcov/rcovtask'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name = "gadgeteer"
+    s.summary = %Q{Making it easy to develop OpenSocial gadgets with Rails or Sinatra.}
+    s.email = "bacsi.laszlo@virgo.hu"
+    s.homepage = "http://github.com/virgo/gadgeteer"
+    s.description = "Making it easy to develop OpenSocial gadgets with Rails or Sinatra."
+    s.authors = ["Laszlo Bacsi"]
+    s.executables = ["gadgeteer"]
+    s.files = FileList['lib/**/*.rb', 'bin/*', '[A-Z]*', 'test/**/*', 'templates/*', 'javascripts/*.js', 'rails/*'].to_a
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+Rake::TestTask.new do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'gadgeteer'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+Rcov::RcovTask.new do |t|
+  t.libs << 'test'
+  t.test_files = FileList['test/**/*_test.rb']
+  t.verbose = true
+end
+
+task :default => :rcov

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:patch: 2
+:major: 0
+:minor: 2

data/bin/gadgeteer

@@ -0,0 +1,224 @@
+#!/usr/bin/env ruby 
+
+$usage = <<USAGE
+== Synopsis 
+  This script generates some files for you to start coding your gadget with.
+
+== Examples
+  For a Rails project:
+    gadgeteer --rails Gadget
+
+  For a Sinatra project:
+    gadgeteer --sinatra Gadget
+
+== Usage 
+  gadgeteer <--rails|--sinatra> [options] ModelName
+
+  For help use: gadgeteer -h
+
+== Options
+  -h, --help          Displays help message
+  -V, --version       Display the version, then exit
+  -q, --quiet         Output as little as possible, overrides verbose
+  -v, --verbose       Verbose output
+  -r, --rails         Generates files for a Rails app
+  -s, --sinatra       Generates files for a Sinatra app
+  -f, --force         Overwrite existing files
+  -a, --author me     Name of the author (for gadget.xml)
+  -e, --email i@me.us Email address of the author (for gadget.xml)
+
+== Author
+  László Bácsi
+
+== Copyright
+  Copyright (c) 2009 Virgo Systems Kft. Licensed under the MIT License:
+  http://www.opensource.org/licenses/mit-license.php
+USAGE
+
+require 'optparse' 
+require 'rdoc/usage'
+require 'ostruct'
+require 'date'
+
+require 'erb'
+require 'yaml'
+require 'activesupport'
+
+module Gadgeteer
+  class App
+    VERSION_HASH = YAML.load_file(File.join(File.dirname(__FILE__), '..', 'VERSION.yml'))
+    VERSION = "#{VERSION_HASH[:major]}.#{VERSION_HASH[:minor]}.#{VERSION_HASH[:patch]}"
+
+    MAPPING = {
+      :rails => {
+        :files => {
+          "gadget.yml" => "config/:singular.yml",
+          "gadget.rb" => "app/models/:singular.rb",
+          "gadget.haml" => "app/views/:plural/show.xml.haml",
+          "canvas.haml" => "app/views/:plural/_canvas.html.haml",
+          "gadget.js" => "public/javascripts/:singular.js",
+          "gadgets_controller.rb" => "app/controllers/:plural_controller.rb"
+        },
+        :help => <<-HELP
+    Add this to your Rails application routes:
+
+      map.resource ::singular
+        HELP
+      },
+      :sinatra => {
+        :files => {
+          "gadget.yml" => "config/:singular.yml",
+          "gadget.rb" => ":singular.rb",
+          "gadget.haml" => "views/:singular.haml",
+          "canvas.haml" => "views/canvas.haml",
+          "gadget.js" => "public/javascripts/:singular.js"
+        },
+        :help => <<-HELP
+    Add this to your Sinatra application:
+
+      require 'sinatra/gadgeteer'
+      require ':singular'
+
+      get '/:singular.xml' do
+        haml ::singular
+      end
+        HELP
+      }
+    }
+
+    attr_reader :options
+
+    def initialize(arguments, stdin)
+      @arguments = arguments
+      @stdin = stdin
+
+      # Set defaults
+      @options = OpenStruct.new
+      @options.verbose = true
+      @options.quiet = false
+      @options.author = "Calvin"
+      @options.email = "calvin@example.com"
+    end
+
+    # Parse options, check arguments, then process the command
+    def run
+      if parsed_options? && arguments_valid?
+        process_arguments            
+        process_command
+      else
+        output_usage
+      end
+    end
+
+    protected
+
+      def parsed_options?
+        # Specify options
+        opts = OptionParser.new 
+        opts.on('-V', '--version')    { output_version ; exit 0 }
+        opts.on('-h', '--help')       { output_help }
+        opts.on('-v', '--verbose')    { @options.verbose = true }  
+        opts.on('-q', '--quiet')      { @options.quiet = true }
+        opts.on('-r', '--rails')      { @options.rails = true }
+        opts.on('-s', '--sinatra')    { @options.sinatra = true }
+        opts.on('-f', '--force')      { @options.force = true }
+        opts.on('-a', '--author AUTHOR')  { |x| @options.author = x }
+        opts.on('-e', '--email EMAIL')    { |x| @options.email = x }
+
+        opts.parse!(@arguments) rescue return false
+
+        process_options
+      end
+
+      # Performs post-parse processing on options
+      def process_options
+        @options.verbose = false if @options.quiet
+        @options.rails ^ @options.sinatra
+      end
+
+      # True if required arguments were provided
+      def arguments_valid?
+        true if @arguments.length == 1 
+      end
+
+      # Setup the arguments
+      def process_arguments
+        @options.model    = @arguments.first.classify
+        @options.title    = @options.model.underscore.humanize
+        @options.singular = @options.model.underscore
+        @options.plural   = @options.model.tableize
+      end
+
+      def output_help
+        output_version
+        usage_and_exit! #exits app
+      end
+
+      def output_usage
+        usage_and_exit! # gets usage from comments above
+      end
+
+      # Shamefully stolen from RDoc#usage. We cannot use RDoc::usage because
+      # RubyGems will call this from a wrapper, and #usage is hardcoded to look
+      # at the top-level file instead of the current one. I have changed this
+      # code to instead just parse a string.
+      def usage_and_exit!
+        markup = SM::SimpleMarkup.new
+        flow_convertor = SM::ToFlow.new
+
+        flow = markup.convert($usage, flow_convertor)
+
+        options = RI::Options.instance
+        formatter = options.formatter.new(options, "")
+        formatter.display_flow(flow)
+
+        exit(0)
+      end
+
+      def output_version
+        puts "#{$0} version #{VERSION}"
+      end
+
+      def process_command
+        key = @options.rails ? :rails : :sinatra
+        file_mapping = MAPPING[key][:files]
+        help = MAPPING[key][:help]
+
+        # Templates
+        file_mapping.each do |filename, target|
+          template = File.join(File.dirname(__FILE__), '..', 'templates', filename)
+          target = target.gsub(':singular', @options.singular).gsub(':plural', @options.plural)
+          if File.exists?(target) and not @options.force
+            puts "Skipping existing file #{target}" if @options.verbose
+          else
+            puts "Writing file #{target}" if @options.verbose
+            FileUtils.mkdir_p(File.dirname(target))
+            File.open(target, "w") do |f|
+              f.write(ERB.new(File.read(template), nil, "<>").result(binding))
+            end
+          end
+        end
+
+        # Javascript files
+        Dir[File.join(File.dirname(__FILE__), '..', 'javascripts', '*.js')].each do |jsfile|
+          filename = File.basename(jsfile)
+          target = "public/javascripts/#{filename}"
+          if File.exists?(target) and not @options.force
+            puts "Skipping existing file #{target}" if @options.verbose
+          else
+            puts "Writing file #{target}" if @options.verbose
+            FileUtils.mkdir_p(File.dirname(target))
+            FileUtils.cp jsfile, target
+          end
+        end
+
+        # Help
+        puts
+        puts(help.gsub(':singular', @options.singular).gsub(':plural', @options.plural))
+      end
+  end
+end
+
+# Create and run the application
+app = Gadgeteer::App.new(ARGV, STDIN)
+app.run

data/javascripts/jquery.gadgeteer.js

@@ -0,0 +1,230 @@
+/*! Copyright (c) 2009 Virgo Systems Kft. (http://virgo.hu)
+ * Licensed under the MIT (http://www.opensource.org/licenses/mit-license.php)
+ *
+ * Version: 1.0.2
+ * Requires opensocial-jQuery 0.5+
+ */
+
+(function($) {
+
+$.gadgeteer = function(callback, options) {
+  // If called with callback, notify it if we're ready
+  if ($.isFunction(callback)) {
+    if ($.gadgeteer.options) {
+      return false;
+    } else {
+      $.gadgeteer.options = options = options || {};
+    }
+    $.gadgeteer.defaultTarget = options.defaultTarget || '#page';
+    $.gadgeteer.host = options.host || '';
+
+    // Setup link behaviours
+    $.gadgeteer.linkBehaviours = options.linkBehaviours || {};
+    if (!options.noAjaxLinks) {
+      $('a').livequery('click', function(e) {
+        $.gadgeteer.handleLinkBehaviour.call($(this), e);
+      }).removeAttr('onclick');
+    }
+
+    if (!options.noAjaxForms) {
+      // All forms will submit through an ajax call
+      $('form').livequery('submit', function(e) {
+        e.preventDefault();
+        var form = $(this);
+        var action = form.attr('action');
+        var target = form.hasClass('silent') ? null : $.gadgeteer.defaultTarget;
+        $.ajax({
+          url: action.charAt(0) == '/' ? $.gadgeteer.host + action : action,
+          type: form.attr('method') || 'GET',
+          data: [$.param(form.formToArray()), $.param($.gadgeteer.viewer.osParams()), $.param($.gadgeteer.owner.osParams())].join("&"),
+          dataType: 'html',
+          auth: 'SIGNED',
+          target: target
+        });
+      });
+    }
+
+    // Setup ajax event callbacks
+    $(document).ajaxSend(function(e, request, settings) {
+      if (settings.target) {
+        // TODO: make this customizable by `loading` callback in options
+        $(settings.target).append($.gadgeteer.loadingElem());
+      }
+    }).ajaxSuccess(function(e, request, settings) {
+      $.gadgeteer.currentUrl = request.url;
+      if (settings.target) {
+        var html = request.responseText;
+        $(settings.target).html(html);
+      }
+      // !iframe
+      $(window).adjustHeight();
+      // Do another adjustHeight in 250ms just to be sure
+      setTimeout(function() {$(window).adjustHeight();}, 250);
+    }).ajaxError(function(e, request, settings, exception) {
+      console.log(request, settings, exception);
+      if (settings.target) {
+        var html = request.responseText;
+        $(settings.target).html(html);
+      }
+      // !iframe
+      $(window).adjustHeight();
+      // Do another adjustHeight in 250ms just to be sure
+      setTimeout(function() {$(window).adjustHeight();}, 250);
+    }).ajaxComplete(function(e, request, settings) {
+      if (request.status.toString().charAt(0) == '3') {
+        var href = request.getResponseHeader('Location') || request.getResponseHeader('location');
+        // hackish way to determine if we have an array (depends on the fact that the real href must be longer than 1 char)
+        if (!href.charAt) href = href[0];
+        $.ajax({
+          url: href.charAt(0) == '/' ? $.gadgeteer.host + href : href,
+          type: 'GET',
+          data: $.param($.gadgeteer.viewer.osParams()) + '&' + $.param($.gadgeteer.owner.osParams()),
+          dataType: 'html',
+          auth: settings.auth,
+          target: settings.target
+        });
+      }
+    });
+
+    // Wait for everything to load then call the callback
+    setTimeout(function() {
+      if ($.gadgeteer.viewer && $.gadgeteer.owner) {
+        // Navigate away if params tell so
+        var params = gadgets.views.getParams();
+        var navTo = params.navigateTo;
+        if (navTo) {
+          $.gadgeteer.simpleRequest(navTo, params.signedNavigate);
+        } else {
+          callback();
+        }
+      } else {
+        setTimeout(arguments.callee, 50);
+      }
+    }, 50);
+
+  } else { // if called with no arguments it means we're initializing
+    // Get information about the viewer and owner
+    $.getData('/people/@viewer/@self', function(data, status) {
+      $.gadgeteer.viewer = data[0];
+      $.gadgeteer.viewer.osParams = function() {return $.gadgeteer._osParams.call($.gadgeteer.viewer, 'viewer')};
+    });
+    $.getData('/people/@owner/@self', function(data, status) {
+      $.gadgeteer.owner = data[0];
+      $.gadgeteer.owner.osParams = function() {return $.gadgeteer._osParams.call($.gadgeteer.owner, 'owner')};
+    });
+  }
+}
+
+$.extend($.gadgeteer, {
+  _osParams: function(name) {
+    var params = {};
+    for (var attr in this) {
+      if (!$.isFunction(this[attr])) {
+        var underscore = attr.replace(/([A-Z])/, '_$1').toLowerCase();
+        params['os_'+name+'_'+underscore] = this[attr];
+      }
+    }
+    return params;
+  },
+
+  loadingElem: function() {
+    if ($.gadgeteer.LOADING_ELEM) return $.gadgeteer.LOADING_ELEM;
+
+    // TODO: make this customizable
+    var loading = $('#loading');
+    if (loading.length < 1) {
+      loading = $('<div id="loading">Az oldal tölt <span class="ellipses">…</span></div>');
+    }
+    return $.gadgeteer.LOADING_ELEM = loading;
+  },
+
+  simpleRequest: function(href, signed) {
+    var params = {}
+    if (href.indexOf('os_viewer_id') == -1) params.os_viewer_id = $.gadgeteer.viewer.id;
+    if (href.indexOf('os_owner_id') == -1) params.os_owner_id = $.gadgeteer.owner.id;
+    if (signed) {
+      params = $.extend(false, params, $.gadgeteer.viewer.osParams(), $.gadgeteer.owner.osParams());
+    }
+    $.ajax({
+      type: 'GET',
+      data: $.param(params),
+      url: href.charAt(0) == '/' ? $.gadgeteer.host + href : href,
+      dataType: 'html',
+      auth: signed && 'SIGNED',
+      target: $($.gadgeteer.defaultTarget)
+    });
+  },
+
+  regularRequest: function(e) {
+    // regular request (i.e. normal anchor click through) is a no-op
+  },
+
+  ajaxRequest: function(e) {
+    e.preventDefault();
+    var host = document.location.host;
+    var link = $(this);
+    var href = link.attr('href');
+    var _href = link[0].getAttribute('href');
+
+    //hack for IE href attr bug
+    if (_href.match(host)) {
+      var l = _href.search(host)+host.length;
+      href = _href.substring(l);
+    }
+
+    if (href.charAt(0) == '/') href = $.gadgeteer.host + href;
+
+    var params = {};
+    var method = link.hasClass('post') ? 'post' : link.hasClass('put') ? 'put' : link.hasClass('delete') ? 'delete' : 'get';
+    if (method != 'get') params._method = method;
+    if (link.hasClass('signed'))
+      params = $.extend(false, params, $.gadgeteer.viewer.osParams(), $.gadgeteer.owner.osParams());
+    else
+      params = $.extend(false, params, {os_viewer_id: $.gadgeteer.viewer.id, os_owner_id: $.gadgeteer.owner.id});
+
+    var target = link.hasClass('silent') ? null : $.gadgeteer.defaultTarget;
+    $.ajax({
+      type: method == 'get' ? 'GET' : 'POST',
+      url: href,
+      data: params,
+      dataType: target ? 'html' : null,
+      auth: link.hasClass('signed') ? 'SIGNED' : null,
+      target: target
+    });
+  },
+
+  navigateRequest: function(view, params, ownerId, e) {
+    e.preventDefault();
+    view = gadgets.views.getSupportedViews()[view];
+    gadgets.views.requestNavigateTo(view, params, ownerId); 
+  },
+
+  handleLinkBehaviour: function(e) {
+    var link = $(this);
+    var matched = false;
+    $.each($.gadgeteer.linkBehaviours, function(behaviour, callback) {
+      var match;
+      if ($.isFunction(callback) && (match = callback.call(link, e))) {
+        var params = match === true ? [] : ($.isFunction(match.push) ? match : Array(match));
+        params.push(e);
+        //console.log('calling ', behaviour, ' link behaviour for ', link, ' with ', params);
+        var handler = behaviour+'Request';
+        handler = $.gadgeteer.linkBehaviours.handlers && $.gadgeteer.linkBehaviours.handlers[handler] || $.gadgeteer[handler];
+        handler.apply(link, params);
+        matched = true;
+        return false;
+      }
+    });
+    if (!matched) {
+     var def = $.gadgeteer.linkBehaviours.defaultBehavior || 'ajax';
+     //console.log('calling DEFAULT ', def, ' link behaviour for ', link, ' with ', e);
+     $.gadgeteer[def+'Request'].call(link, e);
+    }
+  }
+
+});
+
+// Initialize gadgeteer
+$($.gadgeteer);
+
+})(jQuery);