riojs 0.0.0

data/lib/rio/rio_proxy_controller.rb

@@ -0,0 +1,60 @@
+class RioProxyController < ApplicationController
+  ssl_allowed :javascripts, :sounds, :stylesheets, :stylesheet_concat if defined? SslRequirement
+  
+  def javascripts
+    if m = params[:path].last.match(/(.*)_concat\.jst/)
+      app = m[1]
+      render :text => RioCompressor.concat_templates_for_app(app, params[:path])
+    elsif m = params[:path].last.match(/(.*)_concat\.js/)
+      app = m[1]
+      if app == "rio"
+        render :text => RioCompressor.concat_scripts_for_rio
+      elsif app == "rio_development"
+        render :text => RioCompressor.concat_scripts_for_rio_development
+      elsif app == "prototype"
+        render :text => RioCompressor.concat_scripts_for_prototype
+      else
+        render :text => RioCompressor.concat_script_functions_for_app(app, params[:path])
+      end
+    else
+      file_to_render = File.join(Rio::ROOT, "public", "javascripts", File.join(params[:path])) 
+      extension = params[:path].last.split('.').last || 'js'
+      render :file => file_to_render, :content_type => Mime::Type.lookup_by_extension(extension).to_s
+    end
+  end
+  
+  def sounds
+    file_to_render = File.join(Rio::ROOT, "public", "sounds", File.join(params[:path])) 
+    extension = params[:path].last.split('.').last || 'js'
+    render :file => file_to_render, :content_type => Mime::Type.lookup_by_extension(extension).to_s
+  end
+  
+  def images
+    file_to_render = File.join(Rio::ROOT, "public", "images", File.join(params[:path])) 
+    extension = params[:path].last.split('.').last || 'png'
+    render :file => file_to_render, :content_type => Mime::Type.lookup_by_extension(extension).to_s
+  end
+  
+  def stylesheets
+    if m = params[:path].last.match(/(.*)_concat\.css/)
+      app = m[1]
+      render :text => RioCompressor.concat_stylesheets_for_app(app, params[:path][0..-2] + ["apps"] + [params[:path][-1]]), :content_type => Mime::Type.lookup_by_extension("css").to_s
+    else
+      file_to_render = File.join(Rio::ROOT, "public", "stylesheets", File.join(params[:path]))
+      if (file_to_render.match(/\.css$/))
+        render :file => file_to_render, :content_type => Mime::Type.lookup_by_extension("css").to_s
+      else
+        render :text => "Not a css file"
+      end
+    end
+  end
+  
+  def stylesheet_concat
+    content = params[:files].map do |f|
+      app_path = File.join(RAILS_ROOT, "public", "stylesheets", f + ".css")
+      rio_path = File.join(Rio::ROOT, "public", "stylesheets", f + ".css")
+      File.open(File.exists?(app_path) ? app_path : rio_path).read
+    end
+    render :text => content.join("\n\n"), :content_type => Mime::Type.lookup_by_extension("css").to_s
+  end
+end

data/lib/rio/rio_push_controller.rb

@@ -0,0 +1,48 @@
+class RioPushController < ApplicationController
+  session :cookie_only => false, :only => :subscribe
+
+  def subscribe
+    client_id = params[:client_id].to_i
+    channels = params[:channels] || []
+    if(client_id == 0)
+      # client 0 is the server
+      render :text => "AUTHORIZED"
+    elsif(channels.length != 1)
+      render :text => "FAILED", :status => 500
+    else
+      channel = channels.first
+      model = channel.split(".")[0].constantize
+      id = channel.split(".")[1].to_i
+      
+      if (model.authorize_broadcast(id, client_id))
+        render :text => "AUTHORIZED"
+      else
+        render :text => "UNAUTHORIZED", :status => 401
+      end
+    end
+  end
+  
+  def broadcast
+    channel = params[:channel]
+    model_name = channel.split(".")[0]
+    model = model_name.constantize
+    id = channel.split(".")[1].to_i
+    user_id = current_user.id
+
+    if (model.authorize_broadcast(id, user_id))
+
+      message_json = ActiveSupport::JSON.decode(params[:message])
+      message = "rio.models." + model_name + ".receiveBroadcast(" + message_json.to_json + ")"
+
+      Rio::Push.send_to_channel(message, channel)
+      
+      render :text => "PASSED", :status => 200
+    else
+      render :text => "UNAUTHORIZED", :status => 500
+    end
+  end
+  
+  def test_connection
+    render :text => Rio::Push.show_connected_clients.detect {|c| c["session_id"] == session.session_id} ? "CONNECTED" : "NOT_CONNECTED"
+  end
+end

data/lib/rio/rio_routes.rb

@@ -0,0 +1,24 @@
+module ActionController
+  module Routing #:nodoc:
+    class RouteSet #:nodoc:
+      alias_method :draw_without_rio_routes, :draw
+      def draw
+        draw_without_rio_routes do |map|
+          map.connect 'rio/fixtures', :controller => 'rio_spec', :action => 'fixtures' unless RAILS_ENV == "production"
+          map.connect 'rio/specs', :controller => 'rio_spec', :action => 'specs' unless RAILS_ENV == "production"
+          map.connect 'rio/file', :controller => 'rio_file', :action => 'write' if RAILS_ENV == "development"
+          map.connect 'rio/stylesheets', :controller => 'rio_proxy', :action => 'stylesheet_concat'
+          yield map
+          map.connect 'javascripts/*path', :controller => 'rio_proxy', :action => 'javascripts' if RAILS_ENV == "development" or RAILS_ENV == "test"
+          map.connect 'sounds/*path', :controller => 'rio_proxy', :action => 'sounds' if RAILS_ENV == "development"
+          map.connect 'images/*path', :controller => 'rio_proxy', :action => 'images'
+          map.connect 'stylesheets/*path', :controller => 'rio_proxy', :action => 'stylesheets'
+          map.connect 'push/subscribe', :controller => 'rio_push', :action => 'subscribe'
+          map.connect 'push/broadcast', :controller => 'rio_push', :action => 'broadcast'
+          map.connect 'push/test_connection', :controller => 'rio_push', :action => 'test_connection'
+        end
+      end
+    end
+  end
+end
+

data/lib/rio/rio_spec_controller.rb

@@ -0,0 +1,70 @@
+class RioSpecController < ApplicationController
+  def initialize
+    @file_utils = FileDependencies.new(File.join(RAILS_ROOT, 'public', 'javascripts', 'specs'))
+    @rio_file_utils = FileDependencies.new(File.join(Rio::ROOT, "public", "javascripts", "specs"))
+  end
+
+  def specs
+    render :text => ("{" + (spec_entries(@file_utils) + spec_entries(@rio_file_utils)).join(",") + "}")
+  end
+
+  def fixtures
+    render :json => "{ #{(dir(@file_utils, 'fixtures') + dir(@rio_file_utils, 'fixtures')).join(",")} }"
+  end
+  
+  def spec_entries utils
+    utils.entries.reject do |entry|
+      entry == 'fixtures' or entry.starts_with?('.')
+    end.map do |entry|
+      dir(utils, entry)
+    end.flatten
+  end
+  
+  def dir utils, dir_path
+    utils.entries(dir_path).reject do |entry|
+      # REQ: Skip anything that start with '.'
+      entry.starts_with?('.')
+    end.reject do |entry|
+      # REQ: Skip files that don't end with '.js'
+      utils.file?(entry) and not entry.ends_with?('.js')
+    end.map do |entry|
+      child_path = File.join(dir_path, entry)
+      if(utils.directory?(child_path))
+        dir(utils, child_path)
+      else
+        file(utils, child_path)
+      end
+    end.flatten
+  end
+  
+  def file(utils, file_path)
+    "\"#{strip_ex file_path}\": function(){ return \"#{escape_special_characters(utils.read(file_path).gsub("\n", ""))}\" }"
+  end
+  
+  def escape_special_characters s
+      s.gsub(/["]/, '\\\"').gsub(/\\n/, '\\\\\\n').gsub(/\\t/, '\\\\\\t')
+  end
+  
+  def strip_ex s
+    s[0..(s.rindex('.')-1)]
+  end
+end
+
+class FileDependencies
+  def initialize root_directory
+    @root_directory = root_directory
+  end
+  
+  def entries *path
+    Dir.entries(File.join(@root_directory, *path))
+  end
+  def directory? path
+    File.directory?(File.join(@root_directory, path))
+  end
+  def file? path
+    not self.directory?(path)
+  end
+  def read path
+    File.read(File.join(@root_directory, path))
+  end
+end

data/lib/riojs.rb

@@ -0,0 +1,14 @@
+require "rio/rio_compressor"
+require "rio/rio_file_controller"
+require "rio/rio_on_rails"
+require "rio/path"
+require "rio/rio_proxy_controller"
+require "rio/rio_push_controller"
+require "rio/rio_routes"
+require "rio/rio_spec_controller"
+require "rio/juggernaut"
+
+ActionView::Base.send(:include, Rio::Helpers)
+ActionController::Base.send(:extend, Rio::ActionControllerExtensions)
+ActionController::Base.send(:include, Rio::ApplicationControllerExtensions)
+ActiveRecord::Base.send(:include, Rio::ActiveRecordExtensions)

data/lib/tasks/rio.rb

@@ -0,0 +1,63 @@
+require "packr"
+require "rio/path"
+require "rio/autospec"
+require "rio/rio_compressor"
+
+ROOT = RAILS_ROOT
+RIO_ROOT = Rio::ROOT
+
+JS_ROOT = File.join(ROOT, "public", "javascripts")
+RIO_JS_ROOT = File.join(RIO_ROOT, "public", "javascripts")
+
+
+namespace :js do
+  
+  desc "Minify javascripts and templates for production environment"
+  task :min => :environment do
+    RioCompressor.minify_boot
+    RioCompressor.apps.each do |app|
+      RioCompressor.minify_scripts(RioCompressor.scripts_for_app(app, ["apps", app + ".js"]), File.join(JS_ROOT, "apps", "compressed", app + ".js"))
+
+      RioCompressor.minify_stylesheets(app, ["apps", app + ".build"], File.join(ROOT, "public", "stylesheets", "compressed", app + ".css"))
+
+      RioCompressor.minify_templates(app, ["apps", app + ".build"], File.join(JS_ROOT, "apps", "compressed", app + ".jst"))
+    end
+  end
+  
+  def entries_to_delete(directory, save = [])
+    return [] unless File.exist?(File.join(JS_ROOT, directory))
+    Dir.entries(File.join(JS_ROOT, directory)).reject do |entry|
+      entry.match /\.build$/ or entry.match /\.jst$/ or entry.match /^\./ or entry == "compressed" or save.include?(entry)
+    end.map { |entry| File.join(directory, entry) }
+  end
+  
+  desc "[ONLY USE IN PRODUCTION] Prepares for JS deployment, by minifying then removing all non-minified and non-prototype javascript files."
+  task :deploy => :min do
+    FileUtils.cp(File.join(RIO_JS_ROOT, "lib", "boot.js"), File.join(JS_ROOT, "lib"))
+    FileUtils.cp(File.join(RIO_JS_ROOT, "lib", "event.simulate.js"), File.join(JS_ROOT, "lib"))
+    FileUtils.cp_r(File.join(RIO_JS_ROOT, "prototype"), File.join(JS_ROOT))
+    
+    to_remove = (
+      ["models"] + 
+      entries_to_delete("components") +
+      entries_to_delete("pages") + 
+      entries_to_delete("apps") + 
+      entries_to_delete("lib", ["boot.js", "environment.js", "ZeroClipboard.swf", "swfupload.swf", "juggernaut.swf", "selenium_extensions.js", "event.simulate.js", "expressinstall.swf"])
+    ).map do |entry|
+      File.join(JS_ROOT, entry)
+    end
+    FileUtils.rm_rf(to_remove)
+  end
+  
+  desc "Start the rio javascript autospec server"
+  task :autospec do
+    AutoSpec.run
+  end
+end
+
+desc "Start the juggernaut server"
+task :juggernaut do
+  `juggernaut -c config/juggernaut.yml`
+end
+
+

data/public/javascripts/components/accordion.js

@@ -0,0 +1,144 @@
+rio.Application.require("components/box");
+
+rio.components.Accordion = rio.Component.create(rio.components.Box, "Accordion", {
+	requireCss: "accordion",
+	attrReaders: ["panes", "accordionPanes"],
+	attrAccessors: [["selectedPaneIndex", 0]],
+	methods: {
+		initialize: function() {
+			if (!this.getAccordionPanes()) {
+				this._accordionPanes = this.getPanes().map(function(pane) {
+					var accordionPane = new rio.components.AccordionPane({
+						header: pane.header,
+						body: pane.body,
+						onSelect: pane.onSelect
+					});
+			
+			
+					return accordionPane;
+				}.bind(this));
+			} else if (!Object.isArray(this.getAccordionPanes())) {
+				this._accordionPanes = [this.getAccordionPanes()];
+			}
+			
+			this.getAccordionPanes().each(function(accordionPane) {
+				accordionPane.bind("selected", function(selected) {
+					if (selected) {
+						this.setSelectedPaneIndex(this.getAccordionPanes().indexOf(accordionPane));
+					}
+				}.bind(this));
+			}.bind(this));
+		
+			this.resize.bind(this).defer();
+		},
+
+		buildHtml: function() {
+			var accordionHtml = this.boxHtml();
+			this.getAccordionPanes().each(function(ap) { return accordionHtml.insert(ap.html()); });
+			accordionHtml.addClassName("accordion");
+		
+			this.bind("selectedPaneIndex", function(index) {
+				var toShow = this.getAccordionPanes()[index];
+				var toHide = this.getAccordionPanes().detect(function(ap) { return ap.getSelected() && ap != toShow; });
+			
+				if (!toHide) { 
+					toShow.bodyHtml().show();
+					toShow.setSelected(true);
+					return;
+				}
+
+				this.getAccordionPanes().each(function(ap) { ap.setSelected(false); });
+			
+				toShow.setSelected(true);
+				toShow.bodyHtml().show();
+				toHide.bodyHtml().hide();
+			
+				// (function() {
+				// 	var effects = [new Effect.BlindDown(toShow.bodyHtml(), {
+				// 		duration: 0.5,
+				// 		sync: true,
+				// 		// transition: Effect.Transitions.sinoidal
+				// 	})];
+				// 	if (toHide) {
+				// 		effects.push(new Effect.BlindUp(toHide.bodyHtml(), {
+				// 			duration: 0.5,
+				// 			sync: true,
+				// 			// transition: Effect.Transitions.sinoidal
+				// 		}));
+				// 	}
+				// 	new Effect.Parallel(effects, {
+				// 		duration: 0.5, 
+				// 		queue: {
+				// 			position: 'end', 
+				// 			scope: 'accordionAnimation'
+				// 		},
+				// 		afterUpdate: function() {
+				// 		}.bind(this),
+				// 		afterFinish: function() {
+				// 			toShow.setSelected(true);
+				// 			toHide.setSelected(false);
+				// 			this.resize();
+				// 		}.bind(this)
+				// 	});
+				// 
+				// }).bind(this).defer();
+			}.bind(this));
+
+			Element.observe(window, "resize", this.resize.bind(this));
+
+			return accordionHtml;
+		},
+	
+		resize: function() {
+			this.getAccordionPanes().each(function(pane) {
+				pane.setBodyHeight(this.bodyHeight());
+			}.bind(this));
+		},
+	
+		bodyHeight: function() {
+			var bodyHeight = this.html().getHeight();
+			var headersHeight = this.getAccordionPanes().inject(0, function(acc, pane) {
+				return acc + pane.getHeaderHeight();
+			}.bind(this));
+			return bodyHeight - headersHeight;
+		}
+	}
+});
+
+rio.components.AccordionPane = rio.Component.create(rio.components.Base, "AccordionPane", {
+	attrReaders: ["header", "body", ["onSelect", Prototype.emptyFunction]],
+	attrAccessors: [["selected", false]],
+	attrHtmls: ["header", "body"],
+	methods: {
+		buildHtml: function() {
+			return rio.Tag.div([this.headerHtml(), this.bodyHtml()], { className: "pane" });
+		},
+
+		buildHeaderHtml: function() {
+			var headerHtml = rio.Tag.h1(this.getHeader(), { className: "paneHeader" });
+			this.bind("selected", function(selected) {
+				headerHtml[(selected ? "addClassName" : "removeClassName")]("selected");
+				if (selected) {
+					this.getOnSelect()();
+				}
+			}.bind(this));
+			headerHtml.observe("click", function() { this.setSelected(true); }.bind(this));
+			return headerHtml;
+		},
+
+		buildBodyHtml: function() {
+			var bodyHtml = rio.Tag.div(this.getBody(), { className: "paneBody" });
+			if (this.getSelected()) { bodyHtml.show(); } else { bodyHtml.hide(); }
+			return bodyHtml;
+		},
+
+		getHeaderHeight: function() {
+			return this.headerHtml().totalHeight();
+		},
+
+		setBodyHeight: function(height) {
+			this.bodyHtml().style.height = height;
+		}
+	}
+});
+