riojs 0.0.0

data/generators/rio_page/templates/spec.js

@@ -0,0 +1,6 @@
+describe(rio.pages.<%= class_name %>Page, {
+	beforeEach: function() {
+
+	}
+
+});

data/generators/rio_resource/USAGE

@@ -0,0 +1,20 @@
+Description:
+    Generates a "rio-ready" rails resource and the corresponding rio model.
+
+Examples:
+
+    ./script/generate rio_resource post
+
+    This will create a standard rails resource with the line:
+
+		rio_resource
+		
+	in the PostController
+		
+		
+    ./script/generate rio_model post title:string body:text published:boolean
+
+    creates an end-to-end model with the corresponding attributes
+
+
+

data/generators/rio_resource/rio_resource_generator.rb

@@ -0,0 +1,10 @@
+class RioResourceGenerator < Rails::Generator::NamedBase
+  def manifest
+    record do |m|
+      m.dependency "resource", [name] + @args
+      m.dependency "rio_model", [name] + @args
+      
+      m.template "controller.rb", "app/controllers/#{file_name}s_controller.rb", :collision => :force
+    end
+  end
+end

data/generators/rio_resource/templates/controller.rb

@@ -0,0 +1,3 @@
+class <%= class_name %>sController < ApplicationController
+  rio_resource
+end

data/init.rb

@@ -0,0 +1,4 @@
+# Placeholder to satisfy Rails and allow it to use generators.
+#
+# Do NOT add any require statements to this file. Doing
+# so will cause Rails to load this plugin all of the time.

data/install/config/juggernaut_hosts.yml

@@ -0,0 +1,18 @@
+# You should list any juggernaut hosts here.
+# You need only specify the secret key if you're using that type of authentication (see juggernaut.yml)
+# 
+# Name:                       Mapping:
+# :port                       internal push server's port
+# :host                       internal push server's host/ip
+# :public_host                public push server's host/ip (accessible from external clients)
+# :public_port                public push server's port
+# :secret_key (optional)      shared secret (should map to the key specified in the push server's config)
+# :environment (optional)     limit host to a particular RAILS_ENV
+
+:hosts:
+  - :port: 5001
+    :host: 127.0.0.1
+    :public_host: 127.0.0.1
+    :public_port: 5001
+    # :secret_key: your_secret_key
+    # :environment: :development

data/install/lib/tasks/rio.rake

@@ -0,0 +1 @@
+require "tasks/rio"

data/install/script/rio_server

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require "rio/path"
+require "rio/autospec"
+
+JUGGERNAUT_PID_FILE = "tmp/pids/juggernaut.pid"
+
+def kill_juggernaut
+  return unless File.exist?(JUGGERNAUT_PID_FILE)
+  system("kill #{File.read(JUGGERNAUT_PID_FILE).strip}")
+  system("rm #{JUGGERNAUT_PID_FILE}")
+end
+
+def start_juggernaut
+  kill_juggernaut
+  system("juggernaut -d -P #{JUGGERNAUT_PID_FILE} -c config/juggernaut.yml -l log/juggernaut.log")
+end
+
+def start_autospec
+  fork do
+    require "rio/autospec"
+
+    AutoSpec.run
+  end
+end
+
+def start_server
+  system("script/server #{ARGV}")
+end
+
+start_juggernaut
+start_autospec
+start_server
+
+kill_juggernaut
+

data/lib/rio/autospec.rb

@@ -0,0 +1,86 @@
+ENV['RAILS_ENV'] = "development"
+
+require 'find'
+require 'rio/juggernaut'
+require 'rio/path'
+require 'active_support'
+
+class AutoSpec
+  def self.run
+    self.new.run
+  end
+
+  attr_accessor :directories, :last_mtime
+
+  def initialize
+    rio_root = Rio::ROOT
+    js_root = File.join("public", "javascripts")
+    rio_js_root = File.join(rio_root, "public", "javascripts")
+    css_root = File.join("public", "stylesheets")
+    rio_css_root = File.join(rio_root, "public", "stylesheets")
+
+    self.directories = [js_root, rio_js_root, css_root, rio_css_root]
+    self.last_mtime = Time.now
+  end
+  
+  def run
+    if (!Juggernaut)
+      puts "Juggernaut needs to be running for autospec to work"
+      return
+    end
+    begin
+      loop do
+        wait_for_changes
+        files = find_files_to_broadcast
+        self.last_mtime = files.values.map {|d| d[:mtime] }.max
+        broadcast_changes(files)
+      end
+    rescue Interrupt
+      puts
+      # Quit with ^C
+    end
+  end
+  
+  def broadcast_changes(files)
+    puts "\n\nBroadcasting updates for: \n"
+    puts files.values.map{|d| d[:rio_name]}.join(", ")
+
+    Juggernaut.send_to_all("rio.console.touch([#{ files.values.map{|d| "'" + d[:rio_name] + "'"}.join(", ") }])")
+  end
+  
+  def wait_for_changes
+    Kernel.sleep 1 until !find_files_to_broadcast.empty?
+  end
+  
+  def find_files_to_broadcast
+    files = find_files
+    files.each do |filename, data|
+      files.delete(filename) unless self.last_mtime < data[:mtime]
+    end
+    files
+  end
+  
+  def find_files
+    result = {}
+    targets = self.directories
+
+    # from ZenTest
+    targets.each do |target|
+      Find.find(target) do |f|
+
+        next if test ?d, f
+        next if f =~ /(swp|~|rej|orig)$/ # temporary/patch files
+        next if f =~ /(\.svn)/           # svn files
+        next if f =~ /\/\.?#/            # Emacs autosave/cvs merge files
+        next if f =~ /\.DS_Store/        # OSX metadata
+
+        filename = f.sub(/^\.\//, '')
+        
+        rio_name = Regexp.new("^#{Regexp.escape(target)}(.*)").match(filename)[1]
+        result[filename] = { :mtime => File.stat(filename).mtime, :rio_name => rio_name } rescue next
+      end
+    end
+
+    return result
+  end
+end

data/lib/rio/install.rb

@@ -0,0 +1,90 @@
+require 'fileutils'
+
+module Rio
+  class Install
+    ROOT = File.join(File.dirname(__FILE__), "..", "..", "install")
+
+    def self.install!
+      self.print_banner
+      self.create_public_directories!
+      self.install_dependencies!
+      self.add_gem_require_to_environment!
+      self.add_juggernaut_config!
+      self.print_readme
+    end
+    
+    private
+    
+    def self.print_banner
+      puts ""
+      puts "Installing rio dependencies"
+      puts ""
+    end
+    
+    def self.print_readme
+      puts ""
+      puts IO.read(File.join(ROOT, "..", 'README.rdoc'))
+      puts ""
+    end
+    
+    def self.create_public_directories!
+      ["apps", "components", "lib", "models", "pages", "specs"].each do |path|
+        self.mkdir!(File.join("public", "javascripts", path))
+      end
+      self.mkdir!("public/stylesheets/components")
+      self.mkdir!("public/stylesheets/pages")
+    end
+    
+    def self.install_dependencies!
+      install_items! File.join('..', 'public', 'javascripts', 'lib', 'expressinstall.swf'), File.join('public', 'javascripts', 'lib')
+      install_items! File.join('..', 'public', 'javascripts', 'lib', 'juggernaut.swf'), File.join('public', 'javascripts', 'lib')
+      install_items! File.join('..', 'public', 'javascripts', 'lib', 'environment.js'), File.join('public', 'javascripts', 'lib')
+      install_items! File.join('config')
+      install_items! File.join('lib')
+      install_items! File.join('script')
+    end
+    
+    def self.add_gem_require_to_environment!
+      sentinel = 'Rails::Initializer.run do |config|'
+      gsub_file 'config/environment.rb', /(#{Regexp.escape(sentinel)})/mi do |match|
+        "#{match}\n  config.gem \"riojs\"\n"
+      end
+    end
+    
+    def self.add_juggernaut_config!
+      system('juggernaut -g config/juggernaut.yml')
+    end
+    
+    def self.mkdir!(path)
+      puts "\tcreate   #{path}" unless File.exist?(path)
+
+      FileUtils.mkdir_p(path)
+    end
+    
+    def self.install_items!(from, to = from)
+
+      src = File.join(ROOT, from)
+      if File.directory?(src)
+        self.mkdir!(to)
+        Dir.entries(src).reject do |entry|
+          entry.match(/^\..*/)
+        end.each do |entry|
+          install_items! File.join(from, entry), File.join(to, entry)
+        end
+      else
+        dest_dirname = File.dirname(to)
+        FileUtils.mkdir_p(dest_dirname) unless File.exists?(dest_dirname)
+        FileUtils.cp(src, to)
+
+        installed_path = to.match(/#{File.basename(src)}$/) ? to : "#{to}/#{File.basename(src)}"
+        puts "\tinstall  #{installed_path}"
+      end
+    end
+
+    def self.gsub_file(path, regexp, *args, &block)
+      content = File.read(path).gsub(regexp, *args, &block)
+      File.open(path, 'wb') { |file| file.write(content) }
+    end
+  end
+end
+

data/lib/rio/juggernaut.rb

@@ -0,0 +1,212 @@
+require "yaml"
+require "socket"
+require "erb"
+
+module Juggernaut
+  CONFIG = YAML::load(ERB.new(IO.read("config/juggernaut_hosts.yml")).result).freeze
+  CR = "\0"
+  
+  class << self
+    
+    def send_to_all(data)
+      fc = {
+        :command   => :broadcast,
+        :body      => data, 
+        :type      => :to_channels,
+        :client_id => 0,
+        :channels  => []
+      }
+      send_data(fc)
+    end
+    
+    def send_to_channels(data, channels)
+      fc = {
+        :command   => :broadcast,
+        :body      => data, 
+        :type      => :to_channels,
+        :client_id => 0,
+        :channels  => channels
+      }
+      send_data(fc)
+    end
+    alias send_to_channel send_to_channels
+    
+    def send_to_clients(data, client_ids)
+      fc = {
+        :command    => :broadcast,
+        :body       => data, 
+        :type       => :to_clients,
+        :client_id => 0,
+        :client_ids => client_ids
+      }
+      send_data(fc)
+    end
+    alias send_to_client send_to_clients
+    
+    def send_to_clients_on_channels(data, client_ids, channels)
+      fc = {
+        :command    => :broadcast,
+        :body       => data, 
+        :type       => :to_clients,
+        :client_id => 0,
+        :client_ids => client_ids,
+        :channels   => channels
+      }
+      send_data(fc)
+    end
+    alias send_to_client_on_channel send_to_clients_on_channels
+    alias send_to_client_on_channel send_to_clients_on_channels
+    
+    def remove_channels_from_clients(client_ids, channels)
+      fc = {
+        :command    => :query,
+        :type       => :remove_channels_from_client,
+        :client_ids => client_ids,
+        :channels   => channels
+      }
+      send_data(fc)
+    end
+    alias remove_channel_from_client remove_channels_from_clients
+    alias remove_channels_from_client remove_channels_from_clients
+    
+    def remove_all_channels(channels)
+      fc = {
+        :command    => :query,
+        :type       => :remove_all_channels,
+        :channels   => channels
+      }
+      send_data(fc)
+    end
+    
+    def show_clients
+      fc = {
+        :command  => :query,
+        :client_id => 0,
+        :type     => :show_clients
+      }
+      send_data(fc, true).flatten
+    end
+
+    def show_connected_clients
+      show_clients
+    end
+    
+    def show_client(client_id)
+      fc = {
+        :command    => :query,
+        :type       => :show_client,
+        :client_id  => client_id
+      }
+      send_data(fc, true).flatten[0]
+    end
+    
+    def show_clients_for_channels(channels)
+      fc = {
+        :command    => :query,
+        :type       => :show_clients_for_channels,
+        :channels   => channels
+      }
+      send_data(fc, true).flatten
+    end
+    alias show_clients_for_channel show_clients_for_channels
+
+    def send_data(hash, response = false)
+      hash[:channels]   = hash[:channels].to_a   if hash[:channels]
+      hash[:client_ids] = hash[:client_ids].to_a if hash[:client_ids]
+      
+      res = []
+      hosts.each do |address|
+        begin
+          hash[:secret_key] = address[:secret_key] if address[:secret_key]
+          @socket = TCPSocket.new(address[:host], address[:port])
+          # the \0 is to mirror flash
+          @socket.print(hash.to_json + CR)
+          @socket.flush
+          res << @socket.readline(CR) if response
+        ensure
+          @socket.close if @socket and !@socket.closed?
+        end
+      end
+      res.collect {|r| ActiveSupport::JSON.decode(r.chomp!(CR)) } if response
+    end
+    
+  private
+    
+    def hosts
+      CONFIG[:hosts].select {|h| 
+        !h[:environment] or h[:environment].to_s == ENV['RAILS_ENV']
+      }
+    end
+    
+  end
+  
+  module RenderExtension
+    def self.included(base)
+      base.send :include, InstanceMethods
+    end
+    
+    module InstanceMethods
+      # We can't protect these as ActionMailer complains
+      # protected
+
+        def render_with_juggernaut(options = nil, old_local_assigns={}, &block)
+          if options == :juggernaut or (options.is_a?(Hash) and options[:juggernaut])
+            add_variables_to_assigns
+            @template.send! :evaluate_assigns
+
+            generator = ActionView::Helpers::PrototypeHelper::JavaScriptGenerator.new(@template, &block)
+            render_for_juggernaut(generator.to_s, options.is_a?(Hash) ? options[:juggernaut] : nil)
+          else
+            render_without_juggernaut(options, old_local_assigns, &block)
+          end
+        end
+
+        def render_juggernaut(*args)
+          juggernaut_options = args.last.is_a?(Hash) ? args.pop : {}
+          render_for_juggernaut(render_to_string(*args), juggernaut_options)
+        end
+
+        def render_for_juggernaut(data, options = {})
+          if !options or !options.is_a?(Hash)
+            return Juggernaut.send_to_all(data)
+          end
+          
+          case options[:type]
+            when :send_to_all
+              Juggernaut.send_to_all(data)
+            when :send_to_channels:
+              juggernaut_needs options, :channels
+              Juggernaut.send_to_channels(data, options[:channels])
+            when :send_to_channel:
+              juggernaut_needs options, :channel
+              Juggernaut.send_to_channel(data, options[:channel])
+            when :send_to_client:
+              juggernaut_needs options, :client_id
+              Juggernaut.send_to_client(data, options[:client_id])
+            when :send_to_clients:
+              juggernaut_needs options, :client_ids
+              Juggernaut.send_to_clients(data, options[:client_ids])
+            when :send_to_client_on_channel:
+              juggernaut_needs options, :client_id, :channels
+              Juggernaut.send_to_clients_on_channel(data, options[:client_id], options[:channels])
+            when :send_to_clients_on_channel:
+              juggernaut_needs options, :client_ids, :channel
+              Juggernaut.send_to_clients_on_channel(data, options[:client_ids], options[:channel])
+            when :send_to_client_on_channels:
+              juggernaut_needs options, :client_ids, :channel
+              Juggernaut.send_to_clients_on_channel(data, options[:client_id], options[:channels])
+            when :send_to_clients_on_channels:
+              juggernaut_needs options, :client_ids, :channel
+              Juggernaut.send_to_clients_on_channel(data, options[:client_ids], options[:channels])
+          end
+        end
+
+        def juggernaut_needs(options, *args)
+          args.each do |a|
+            raise "You must specify #{a}" unless options[a]
+          end
+        end
+        
+    end
+  end
+end