tidyflash 0.1

data/Manifest

@@ -0,0 +1,40 @@
+Manifest
+README
+Rakefile
+bin/test_project.axml
+bin/tidyflash
+lib/script/bwlimit.rb
+lib/script/generate
+lib/script/server
+lib/script/server.rb
+lib/tasks/assets.rb
+lib/tasks/demo_config.rb
+lib/tasks/deploy.rb
+lib/tidy/axml.rb
+lib/tidy/compile.rb
+lib/tidy/generate.rb
+lib/tidy/template.rb
+lib/tidy/template_binding.rb
+lib/tidy/templates/air.axml.erb
+lib/tidy/templates/demo_config.as.erb
+lib/tidy_project.rb
+templates/project/project.rb
+templates/project/rakefile.rb
+templates/project/script/fcsh/rakefile.rb
+templates/project/src/app/helpers/Colours.as
+templates/project/src/app/helpers/Debug.as
+templates/project/src/app/helpers/Typography.as
+templates/project/src/app/models/App.as
+templates/project/src/app/models/FlashVars.as
+templates/project/src/app/views/MainView.as
+templates/project/src/app/views/PreloaderView.as
+templates/scaffold/bin/xml/__model.xml
+templates/scaffold/scaffold.rb
+templates/scaffold/src/models/__Model.as
+templates/scaffold/src/views/__model/__ModelDetailView.as
+templates/scaffold/src/views/__model/__ModelListItemView.as
+templates/scaffold/src/views/__model/__ModelListView.as
+templates/swfobject/bin/index.html
+templates/swfobject/bin/js/swfobject.js
+templates/swfobject/swfobject.rb
+test/test_tidy_project.rb

data/README

@@ -0,0 +1,4 @@
+Following in the footsteps of Ruby On Rails, Processing, _why's Shoes and Luke Bayes' Sprouts library, here is a Flash framework that funnels the brilliance of all these people into a single set of libraries for developing Flash.
+USAGE:
+
+tidyproject SomeProject

data/Rakefile

@@ -0,0 +1,15 @@
+require 'rubygems'
+require 'rake'
+require 'echoe'
+
+Echoe.new('tidyflash', '0.1') do |p|
+  p.description    = "Tidy Flash - an ActionScript framework for people who love Ruby"
+  p.url            = "http://github.com/michaelforrest/tidy"
+  p.author         = "Michael Forrest"
+  p.email          = "mf@grimaceworks.com"
+  p.ignore_pattern = ["tmp/**/*", "script/*", "tasks/**/*"]
+  p.development_dependencies = []
+end
+
+Dir["#{File.dirname(__FILE__)}/tasks/*.rake"].sort.each { |ext| load ext }
+

data/bin/test_project.axml

@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="UTF-8"?> 
+<application xmlns="http://ns.adobe.com/air/application/1.5"> 
+    <id>testproject</id> 
+    <version>1</version> 
+    <filename>testproject</filename> 
+    <initialWindow> 
+        <content>test_project.swf</content> 
+        <visible>true</visible> 
+        <x>400</x>
+				<y>50</y>
+        <width>1200</width> 
+        <height>923</height> 
+    </initialWindow> 
+    <!--
+		<icon>
+			<image128x128>icons/128x128/fubuntu_logo_128x128.png</image128x128>
+		</icon>
+		-->
+</application>

data/bin/tidyflash

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+#
+require 'rubygems'
+require 'optparse'
+require File.dirname(__FILE__) + '/../lib/tidy_project'
+
+def fail_with(opts, message)
+  puts "[ERROR] #{message}"
+  puts ""
+  puts opts
+  exit
+end
+
+parser = OptionParser.new do |options|
+  options.banner = <<-BANNER
+    Tidy is an ActionScript framework for people who love Ruby
+    
+    Usage: #{File.basename($0)}
+    - adds necessary stuff to project
+  BANNER
+  
+  options.separator ""
+  
+#  options.on("-v", "--verbose", "Show what it's doing") do
+#    OPTIONS[:verbose] = true
+#  end
+  
+  
+end
+
+puts ">> adding stuff to project"
+fail_with ARGV, "Please specify a project name!" if ARGV.length < 1
+TidyProject.new(ARGV[0])

data/lib/script/bwlimit.rb

@@ -0,0 +1,305 @@
+#!/usr/bin/env ruby
+
+
+require 'socket'
+require 'fcntl'
+require 'thread'
+
+
+# Limits the amount of data sent/recv.
+# It acts as a authorisation-to-sent/recv-data dispenser
+# Whoever wants to send/recv data must call the #dispense method
+# to know how many it should send/recv at that time
+class BwLimiter
+  def initialize(rate, ticks)
+    @bytes_per_tick = 1.0*rate/ticks
+    @hz = 1.0/ticks
+    if @bytes_per_tick < 1 
+      raise "rate too low or ticks too high"
+    end
+    @bytes_per_tick = @bytes_per_tick.round
+    if @bytes_per_tick * ticks != rate
+      puts "Adjusting rate to #{@bytes_per_tick * ticks}"
+    end
+    @last_tick = Time.now
+  end
+  def dispense
+    curr = Time.now
+    delta = curr - @last_tick
+    if delta < @hz
+      sleep(@hz - delta)
+    end
+    #puts "Releasing #{@bytes_per_tick}. Speed = #{@bytes_per_tick / (Time.now - curr)}"
+    @last_tick = curr
+    @bytes_per_tick
+  end
+end
+
+class ConstantBwLimiter < BwLimiter
+  def initialize
+  end
+  def dispense
+    8192
+  end
+end
+
+
+
+class BwLimiterProxy
+  def self.create_producer_thread(name, socket, socket_mutex, 
+				  queue, queue_mutex, queue_added_cond,
+				  read_limiter, kill_thread_proc)
+    Thread.new {
+      read_s = nil
+      while (1)
+	result = select([socket], nil, [socket], nil)
+	if result[0].length > 0
+	  n_read = read_limiter.dispense
+	  #puts "#{name} need to read #{n_read}"
+	  socket_mutex.synchronize {
+	    read_s = socket.recv(n_read)
+	  }
+	  if (read_s.length == 0)
+	    #puts "#{name} closed"
+	    kill_thread_proc.call
+	    break # or Thread.stop
+	  else
+	    queue_mutex.synchronize {
+	      read_s.split(//).each {|i| queue << i}
+	      #puts "#{name}: read #{read_s.length}"
+	      queue_added_cond.signal
+	    }
+	  end
+	elsif result[2].length > 0
+	  raise "#{name} read error"
+	end
+      end
+    }
+  end
+
+
+
+  def self.create_consumer_thread(name, socket, socket_mutex, 
+				  queue, queue_mutex, queue_added_cond,
+				  write_limiter)
+    my_queue = nil
+    Thread.new{
+      while (1)
+	queue_mutex.synchronize {
+	  queue_added_cond.wait(queue_mutex)
+	  my_queue = queue.clone
+	  queue.clear
+	}
+	while (my_queue && my_queue.length > 0)
+	  result = select(nil, [socket], [socket], nil)
+	  if result[1].length > 0
+	    n_write = write_limiter.dispense
+	    socket_mutex.synchronize {
+	      n_write = socket.send(my_queue[0..n_write].join, 0)
+	    }
+	    my_queue.slice!(0..n_write);
+	    #puts "REMOTE: written #{n_write}"
+	  elsif result[2].length > 0
+	    raise "#{name} send error"
+	  end
+	end
+      end
+    }
+  end
+  
+
+
+  def self.make_nonblocking(io)
+    io.fcntl(Fcntl::F_SETFD, io.fcntl(Fcntl::F_GETFD) | Fcntl::O_NONBLOCK)
+  end
+
+
+  def self.make_proc_kill_thread(t_parent)
+    proc{t_parent[:thread_list].each {|t| 
+	t.kill if Thread.current != t
+	#puts "Killed: #{t.inspect}"; 
+      }
+    }
+  end
+
+    
+  attr_reader :is_global_limit
+  attr_reader :input_rate
+  attr_reader :output_rate
+  attr_reader :ticks
+  attr_reader :input_limiter
+  attr_reader :output_limiter
+  
+  def session(l_socket, r_socket)
+    [l_socket, r_socket].each {|io|
+      BwLimiterProxy.make_nonblocking io
+    }
+    
+    proc_kill_thread =  BwLimiterProxy.make_proc_kill_thread(Thread.current)
+    
+    if @is_global_limit
+      input_limiter = @input_limiter
+      output_limiter = @output_limiter
+    else
+      t_current = Thread.current;
+      input_limiter = BwLimiter.new(@input_rate, @ticks)
+      output_limiter = BwLimiter.new(@output_rate, @ticks)
+    end
+    local_input_limiter = ConstantBwLimiter.new
+    local_output_limiter = ConstantBwLimiter.new
+
+    outgoing_queue = [] #from l->r
+    outgoing_mutex = Mutex.new
+    outgoing_produced = ConditionVariable.new
+
+    incoming_queue = [] #from r->l
+    incoming_mutex = Mutex.new
+    incoming_produced = ConditionVariable.new
+    
+    l_socket_mutex = Mutex.new
+    r_socket_mutex = Mutex.new
+
+    t_outgoing_producer = 
+      BwLimiterProxy.create_producer_thread("LOCAL", l_socket, l_socket_mutex,
+					    outgoing_queue, outgoing_mutex, 
+					    outgoing_produced,
+					    local_output_limiter, 
+					    proc_kill_thread)
+    t_incoming_producer = 
+      BwLimiterProxy.create_producer_thread("REMOTE", r_socket, r_socket_mutex,
+					    incoming_queue, incoming_mutex, 
+					    incoming_produced,
+					    input_limiter, 
+					    proc_kill_thread)
+    t_outgoing_consumer = 
+      BwLimiterProxy.create_consumer_thread("REMOTE", r_socket, r_socket_mutex,
+					    outgoing_queue, outgoing_mutex, 
+					    outgoing_produced,
+					    output_limiter)
+    t_incoming_consumer =
+      BwLimiterProxy.create_consumer_thread("LOCAL", l_socket, l_socket_mutex,
+					     incoming_queue, incoming_mutex, 
+					     incoming_produced,
+					     local_input_limiter)
+    
+    t_current = Thread.current
+    t_current[:thread_list] = [t_outgoing_producer, t_incoming_producer, 
+      t_outgoing_consumer, t_incoming_consumer]
+    #t_current[:thread_list].each{|t| puts "Threads: #{t.inspect}"}
+
+    t_current[:thread_list].each {|t| 
+      t.join; 
+      #puts "Joined: #{t.inspect}"; 
+    }
+    l_socket.close
+    r_socket.close
+    #puts "Exiting cleanly"
+  end
+
+
+  def initialize(input_rate, output_rate, is_global_limit, ticks)
+    @input_rate = input_rate
+    @output_rate = output_rate
+    @ticks = ticks
+    if @is_global_limit = is_global_limit
+      @input_limiter = BwLimiter.new(@input_rate, @ticks)
+      @output_limiter = BwLimiter.new(@output_rate, @ticks)
+    end
+  end
+end
+
+
+def print_help
+  puts <<-EOF
+  # #{$0} [options] rhost rport
+  #
+  # --lhost x           listen to the interface x (def: localhost)
+  # --lport x           listen to port x (def: 8119)
+  # --outgoing-rate x
+  # -o x                output at x KBps (def: 5)
+  # --incoming-rate x
+  # -i x                accepts input at xKBps (def: 5)
+  # --global-limit
+  # -g                  if set, the rate is for total rate (def: the rate is per connection)
+  # --ticks
+  # -t                  ticks per second, higher more accurate but consumes more cpu (def: 100)
+  # --help
+  # -h                  this page
+  # rhost               host to connect to
+  # rport               port to connect to
+  EOF
+end							    
+
+
+
+if $0 == __FILE__
+  require 'getoptlong'
+
+  if ARGV.length < 2
+    print_help
+    exit
+  end
+  opts = GetoptLong.new(["--lhost", GetoptLong::REQUIRED_ARGUMENT ],
+			["--lport", GetoptLong::REQUIRED_ARGUMENT ],
+			["--outgoing-rate", "-o", GetoptLong::REQUIRED_ARGUMENT ],
+			["--incoming-rate", "-i", GetoptLong::REQUIRED_ARGUMENT ],
+			["--outgoing-rate-byte", "--orb",  GetoptLong::REQUIRED_ARGUMENT ],
+			["--incoming-rate-byte", "--irb", GetoptLong::REQUIRED_ARGUMENT ],
+			["--global-limit", "-g", GetoptLong::NO_ARGUMENT],
+			["--ticks", "-t", GetoptLong::REQUIRED_ARGUMENT],
+			["--help", "-h", GetoptLong::NO_ARGUMENT])
+  hopts = {}
+  opts.each {|opt, arg|
+    hopts[opt] = arg
+  }
+  if ARGV.length != 2
+    print_help
+  end
+
+  
+  LPORT = (hopts["--lport"] || 8119).to_i
+  LHOST = hopts["--lhost"] || "localhost"
+  OUTGOING_RATE = (hopts["--outgoing-rate"] || 5).to_i * 1024
+  INCOMING_RATE = (hopts["--incoming-rate"] || 5).to_i * 1024
+  IS_GLOBAL_LIMIT = if hopts["--global-limit"] then true else false end
+  TICKS = (hopts["--ticks"] || 100).to_i
+  RHOST = ARGV[0]
+  RPORT = ARGV[1].to_i
+  
+  if hopts["--outgoing-rate-byte"]
+    OUTGOING_RATE = hopts["--outgoing-rate-byte"].to_i
+  end
+  if hopts["--incoming-rate-byte"]
+    INCOMING_RATE = hopts["--incoming-rate-byte"].to_i
+  end
+
+  puts "LPORT=#{LPORT}"
+  puts "LHOST=#{LHOST}"
+  puts "OUTGOING_RATE=#{OUTGOING_RATE}"
+  puts "INCOMING_RATE=#{INCOMING_RATE}"
+  puts "TICKS=#{TICKS}"
+  puts "IS_GLOBAL_LIMIT=#{IS_GLOBAL_LIMIT.to_s}"
+  puts "RHOST=#{RHOST}"
+  puts "RPORT=#{RPORT}"
+
+  threads = []
+  threads_mutex = Mutex.new
+  proxy = BwLimiterProxy.new(INCOMING_RATE, OUTGOING_RATE, IS_GLOBAL_LIMIT, TICKS)
+  server = TCPServer.new(LHOST, LPORT)
+  #server.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEADDR, 1)
+  puts "Ready"
+  while (local_socket = server.accept)
+    begin
+      remote_socket = TCPSocket.new(RHOST, RPORT)
+      t = Thread.new { 
+	proxy.session(local_socket, remote_socket)
+	threads_mutex.synchronize { threads.delete_if{|t| Thread.current == t}}
+	puts "Now serving #{threads.size} connections"
+      }
+      threads_mutex.synchronize { threads << t }
+      puts "Now serving #{threads.size} connections"
+    rescue => e
+      p e
+    end
+  end
+end

data/lib/script/generate

@@ -0,0 +1,124 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'activesupport'
+LANGUAGE = 'as3' #TODO: un-hard-code
+SCRIPT_PATH = File.join("script", LANGUAGE)
+def available_templates
+  Dir.entries(SCRIPT_PATH).collect{|e| e unless e[0]==46}.compact
+end
+
+module LBi
+  require 'erb'
+  require 'fileutils'
+  class Template
+    attr_reader :args
+    def initialize(params)
+      @template_id = params[:template_id]
+      @force = params[:force]
+      @args = params[:args].collect{|arg| arg unless arg.match("--")}
+      
+      create_template_binding
+      copy_files if @template_binding.valid?
+    end
+    def create_template_binding
+      require template_class
+      # the get_template_binding method is placed
+      # in the included template class
+      @template_binding = get_template_binding(self)
+      @template_binding.init!
+    end
+
+    def template_path
+      File.join(SCRIPT_PATH,@template_id)
+    end
+    
+    def template_class
+      File.join(template_path,"#{@template_id}.rb")
+    end
+    
+    def copy_files
+      pattern = File.join(template_path,"**/*")
+      files = Dir.glob(pattern)
+      files.each do |filename|
+        copy_file(filename) unless filename == template_class
+      end
+    end
+    
+    def copy_file(filename)
+      if File.directory?(filename)
+        
+        make_dirs(get_destination filename)
+        return
+      end
+      contents = IO.read(filename)
+      destination = get_destination(filename)
+      make_dirs(File.split(destination)[0])
+      
+      result = File.extname(filename) == ".erb" ? contents : ERB.new(contents,0,"%").result(@template_binding.get_binding)
+      force = @force unless @force.nil?
+      if File.exists?(destination) 
+        if(force.nil?) 
+          puts "overwrite #{destination}? (yN)"
+          force = $stdin.gets.chomp.downcase == "y"
+        end
+        unless force
+          puts "skipping #{destination}"
+        else
+          File.delete(destination)
+          write_result(result,destination)
+        end
+      else
+        write_result(result,destination)
+      end
+    end
+    
+    def write_result result,destination
+      File.open(destination,'a') do |file|
+        file << result
+      end
+      puts("created " + destination)
+    end
+    
+    def make_dirs(dir)
+      FileUtils.mkdir_p(dir) unless File.exists? dir
+    end
+    
+    def get_destination(file)
+      @template_binding.get_destination file.gsub(template_path,".")
+    end
+  end
+  class TemplateBinding
+    def initialize(template)
+      @template = template
+      @is_valid = true
+    end
+    def init!
+      #override this method to do extra curricular template activities
+    end
+    def valid?
+      @is_valid
+    end
+    def get_binding
+      return binding
+    end
+    def get_destination path
+      path
+    end
+    #COMMON stuff for templates
+    def credit
+      "Generated with Tidy Flash"
+    end
+  end
+end
+params = {:force=>ARGV.find{|a| a=="--force"}!=nil, :template_id=>ARGV.shift, :args=>ARGV}
+
+unless params[:template_id].nil?
+  LBi::Template.new(params)
+else
+  puts <<-MSG
+  Please provide a template name, e.g.
+  $ ruby script/lbi/generate carousel
+  Available templates: #{available_templates.join(",")} 
+  MSG
+end
+

data/lib/script/server

@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+./script/server.rb &
+./script/bwlimit.rb --lhost localhost --lport 2001 -i 99 -o 99 localhost 2000 &
+open http://localhost:2001

data/lib/script/server.rb

@@ -0,0 +1,20 @@
+#!/usr/local/bin/ruby
+require 'webrick'
+include WEBrick
+
+s = HTTPServer.new(
+  :Port            => 2000,
+  :DocumentRoot    => File.join(File.dirname(__FILE__), "..", "bin"),
+  :MimeTypes => {:js=>"text/javascript"}
+)
+
+## mount subdirectories
+#s.mount("/ipr", HTTPServlet::FileHandler, "/proj/ipr/public_html")
+#s.mount("/~gotoyuzo",
+#        HTTPServlet::FileHandler, "/home/gotoyuzo/public_html",
+#        true)  #<= allow to show directory index.
+#system_mime_table = Utils::load_mime_types('/etc/mime.types') 
+
+
+trap("INT"){ s.shutdown }
+s.start()

data/lib/tasks/assets.rb

@@ -0,0 +1,133 @@
+require 'activesupport'
+namespace :assets do
+  desc "Build list of desktop images"
+  task :desktop do
+    catalog_file "bin/system/desktop_backgrounds", "DesktopCatalog"
+  end
+
+  desc "App-related assets"
+  task :apps do
+    Dir.chdir("src/plugins/apps/firefox/") do
+      asset_file ".", "FirefoxLibrary", :package=>'plugins.apps.firefox.assets'
+    end
+  end
+  
+  desc "Create boot classes"
+  task :boot do
+    asset_file "boot", "BootLibrary"
+    asset_file "boot/avatars", "Avatars"
+    asset_file "boot/icons", "BootIcons"
+  end
+  
+  desc "mouse cursors"
+  task :cursors do
+    asset_file "cursors", "CursorLibrary"
+  end
+  
+  desc "Create menu icon classes"
+  task :menu do
+    Dir.chdir("common/plugins/menus") do
+      asset_file '.', 'MessagingServicesLibrary', :package=>'plugins.menus.assets'
+    end
+  end
+
+  desc "Create menu panel icon classes"
+  task :panels do
+    asset_file "panels", "PanelLibrary"
+  end
+
+  desc "Create UI library"
+  task :ui do
+    asset_file "ui", "UILibrary"
+    asset_file "ui/scrollbar", "OverlayScrollbarLibrary"
+  end
+  
+  desc "testing assets"
+  task :testing do
+    asset_file "testing", "TestingLibrary"
+  end
+  
+  desc 'launcher assets'
+  task :launcher do
+    Dir.chdir("common/plugins/launcher") do
+      asset_file '.', 'LauncherLibrary', :package=>'plugins.launcher.assets'
+    end
+  end
+
+  desc 'dash-related assets'
+  task :dash do
+    Dir.chdir("common/plugins/dash") do
+      asset_file '.', 'DashLibrary', :package=>'plugins.dash.assets'
+      asset_file './categories', 'DashCategoriesLibrary', :package=>'plugins.dash.assets.categories'
+      asset_file './groupicons', 'DashGroupIconsLibrary', :package=>'plugins.dash.assets.groupicons'
+      asset_file './menuicons', 'DashMenuIconsLibrary', :package=>'plugins.dash.assets.menuicons'
+
+    end
+  end
+  
+  desc 'hud-related assets'
+  task :hud do
+    asset_file 'hud', 'HUDLibrary'
+  end
+  
+  desc 'unr-related assets'
+  task :unr do
+    asset_file 'unr', "UNRLibrary"
+  end
+  
+  desc "window assets"
+  task :theme do
+   Dir.entries("common/themes/").each do |entry|
+      
+      if File.directory?("common/themes/#{entry}") && (entry =~ /^\./).nil? && entry != "fonts"
+        puts "updating theme library for #{entry} to #{entry.classify}"
+        Dir.chdir("common/themes/#{entry}") do
+          asset_file ".", "#{entry.classify}Library", :package=>"themes.#{entry}.assets"
+        end
+      end
+    end
+  end
+  
+  def asset_file dir, class_name, options={}
+    Dir.chdir("assets/#{dir}") do
+      File.open("#{class_name}.as","w") do |file|
+        file << <<-END
+        package #{options[:package] || dir.gsub("/",".")}{
+          public class #{class_name}{
+        END
+        %w[.png .jpg .swf].each do |suffix|
+          add_entries file, suffix
+        end
+        file << "}}"
+      end
+    end
+    
+  end
+  def add_entries file, suffix
+    Dir.entries(".").select{ |f| f.match(suffix) }.each do |icon|
+      file << "[Embed(source='#{icon}')] "
+      file << "public static var #{icon.gsub(suffix,"").gsub("-","_")}: Class;\n"
+      puts icon
+    end
+  end
+   
+   def catalog_file dir, class_name
+     File.open("assets/catalogs/#{class_name}.as","w") do |file|
+      file << <<-END
+      package catalogs {
+      	// this file is automatically generated with rake assets:desktop
+      	public class DesktopCatalog {
+      		public static var BACKGROUNDS : Array = [
+        END
+      
+      file << Dir.entries(dir).map{|f| "'#{f}'" unless f =~ /^\./ }.compact.join(",")
+        
+      file << <<-END
+      		];
+      	}
+      }
+      END
+    end
+   end
+   
+end