xpcomcore-rubygem 0.3.2 → 0.5.0

data/README.markdown

@@ -0,0 +1,14 @@
+xpcomcore-rubygem
+=================
+
+This is the XPCOMCore JS library wrapped up in a RubyGem with a handy executable for doing things like
+launching XPCOMCore based apps installed as RubyGems and generating new applications and extensions that
+take advantage of XPCOMCore. See `xpcomcore help` once you have the gem installed for details on available
+commands.
+
+License
+=================
+
+See LICENSE for details.
+
+Copyright (c) 2009 ggironda. See LICENSE for details.

data/Rakefile

@@ -7,26 +7,28 @@ begin
   
   Jeweler::Tasks.new do |gem|
     gem.name = "xpcomcore-rubygem"
-    gem.executables = %w[xpcomcore-rubygem-install xpcomcore-firefox]
+    gem.executables = %w[xpcomcore]
     gem.summary = %Q{Gem to allow for using XPCOMCore via RubyGems}
     gem.description = %Q{Gem to allow for using XPCOMCore via RubyGems}
     gem.email = "gabriel.gironda@gmail.com"
     gem.homepage = "http://github.com/gabrielg/xpcomcore-rubygem"
     gem.authors = ["ggironda"]
     gem.files = (gem.files + FileList["xpcomcore/**/*"]).uniq
-    gem.post_install_message = <<-EOF;
+    gem.post_install_message = %Q[
 
-#{"".ljust(80).red_on_blue.bold}
-#{"PAY HEED TO THIS ANNOYING MESSAGE".center(80).red_on_blue.bold}
-#{"".ljust(80).red_on_blue.bold}
-
-The XPCOMCore gem has been installed but you still need to complete installation
-by hand. Run the command #{'xpcomcore-rubygem-install'.underline.bold} without options to get
-usage information on using it to install the bootstrapper code for this gem.
-
-EOF
+    STEP 1. OBTAIN A PIG. THIS ONE WILL DO:                         
+ 
+        _____                                                       
+    ^..^     \\9                                                     
+    (oo)_____/                                                      
+       WW  WW    Pig
+   
+].split("\n").collect { |l| l.ljust(80) }.join("\n").red_on_blue.bold
 
     gem.add_dependency "sys-uname"
+    gem.add_dependency "cmdparse"
+    gem.add_dependency "uuidtools", ">=2.0.0"
+    gem.add_dependency "jeweler", "=1.2.1"
     gem.add_development_dependency "colored"
   end
   Jeweler::GemcutterTasks.new

data/VERSION

@@ -1 +1 @@
-0.3.2
+0.5.0

data/bin/xpcomcore

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'xpcomcore-rubygem/commands'
+require 'pathname'
+
+cmd = XPCOMCore::CommandParser.new
+cmd.parse

data/lib/xpcomcore-rubygem.rb

@@ -0,0 +1,9 @@
+require 'pathname'
+
+module XPCOMCore
+  GemRoot = Pathname(__FILE__).parent.parent
+  Version = (GemRoot + "VERSION").read.strip
+  BootstrapperLocation = (GemRoot + "xpcomcore/bootstrapper.js").expand_path
+  BuildProperties = YAML.load_file((GemRoot + "xpcomcore/build_properties.yml").to_s)
+  
+end

data/lib/xpcomcore-rubygem/commands.rb

@@ -0,0 +1,54 @@
+require 'cmdparse'
+require 'xpcomcore-rubygem'
+require 'pathname'
+
+module XPCOMCore
+  class CommandParser
+    class << self
+      attr_accessor :quiet
+    end
+    self.quiet = false
+    
+    @@commands = [CmdParse::HelpCommand, CmdParse::VersionCommand]
+    
+    def initialize
+      @cmd = CmdParse::CommandParser.new(true, # handle exceptions gracefully
+                                         true) # use partial command matching)
+      @cmd.program_version = XPCOMCore::Version
+      @cmd.options = CmdParse::OptionParserWrapper.new do |opt|
+        opt.separator "Global options:"
+        opt.on("-q", "--quiet", "Be quiet about what's happening", self.class.method(:quiet=))
+      end
+      add_commands
+    end
+    
+    def parse
+      @cmd.parse
+    end
+    
+    def self.load_commands
+      (XPCOMCore::GemRoot + "lib/xpcomcore-rubygem/commands").each_entry do |entry|
+        next unless entry.extname == ".rb"
+        require "xpcomcore-rubygem/commands/#{entry.basename}"
+      end
+    end
+    
+    def self.add_command(cmd_class)
+      @@commands.push(cmd_class)
+    end
+
+    def self.log(msg)
+      return nil if quiet
+      puts msg
+    end
+    
+  private
+  
+    def add_commands
+      @@commands.each { |cmd_class| @cmd.add_command(cmd_class.new) }
+    end
+    
+  end # CommandParser
+end   # XPCOMCore
+
+XPCOMCore::CommandParser.load_commands

data/lib/xpcomcore-rubygem/commands/generate.rb

@@ -0,0 +1,23 @@
+require 'xpcomcore-rubygem/commands'
+
+module XPCOMCore
+  class CommandParser
+    class GenerateCommand < CmdParse::Command
+      class GenerationError < CmdParse::ParseError
+        reason "An error occured trying to generate your application"
+      end
+
+      def initialize
+        super('generate', true,  # Takes subcommands
+                          true)  # Uses partial command matching
+        self.short_desc = "Generates an XPCOMCore based XUL application or library packaged in a RubyGem."
+        [ApplicationCommand, LibraryCommand].each { |k| add_command(k.new) }
+      end
+
+    end # GenerateCommand
+  end   # CommandParser
+end     # XPCOMCore
+
+XPCOMCore::CommandParser.add_command(XPCOMCore::CommandParser::GenerateCommand)
+require "xpcomcore-rubygem/commands/generate/application"
+require "xpcomcore-rubygem/commands/generate/library"

data/lib/xpcomcore-rubygem/commands/generate/application.rb

@@ -0,0 +1,63 @@
+require "xpcomcore-rubygem/commands/generate/jeweler_builder_command"
+require 'uuidtools'
+
+module XPCOMCore
+  class CommandParser
+    class GenerateCommand
+      
+      class ApplicationCommand < JewelerBuilderCommand
+        
+        def initialize
+          super('application', false) # Doesn't take subcommands
+          self.short_desc = "Generates an application"
+          self.options = CmdParse::OptionParserWrapper.new { |opt_parse| add_jeweler_opts(opt_parse) }
+        end
+  
+      private
+      
+        def setup_project(gem_name, project_path)
+          with_rakefile_in(project_path) do |rakefile|
+            add_jsdoc_toolkit_doc_task(rakefile, :task_name => "doc:app", :doc_dir => "xpcomcore/app/doc", :doc_paths => %w[xpcomcore/app/chrome xpcomcore/app/components])
+            add_xultestrunner_test_task(rakefile, :task_name => "test:app", :test_libs => %w[xpcomcore/app/chrome], :test_pattern => "xpcomcore/app/test/**/*_test.js")
+          end
+          copy_template_application(gem_name, project_path)
+        end
+        
+        def copy_template_application(gem_name, project_path)
+          template_vars = {'application.ini' => default_application_ini_values(gem_name),
+                           'chrome.manifest' => default_chrome_manifest_values(gem_name),
+                           'main_window.xul' => default_main_window_xul_values(gem_name),
+                           'prefs.js'        => default_prefs_js_values(gem_name)}
+                           
+          copy_template_directory("application", project_path + "xpcomcore/app", template_vars)
+        end
+
+        def default_application_ini_values(gem_name)
+          build_properties_version = XPCOMCore::BuildProperties['version']
+          min_xpcomcore_version = build_properties_version.values_at('major', 'minor', 'patch').join('.')
+          {:app_name => gem_name.capitalize,
+           :app_version => "0.0.0",
+           :build_id => UUIDTools::UUID.random_create.to_s,
+           :app_id => "#{gem_name.capitalize}@CHANGEME.example.com",
+           :app_vendor => ENV['USER'],
+           :min_gecko_version => XPCOMCore::BuildProperties['gecko']['min_version'],
+           :min_xpcomcore_version => min_xpcomcore_version}
+        end
+        
+        def default_chrome_manifest_values(gem_name)
+          {:default_chrome_id => gem_name}
+        end
+        
+        def default_prefs_js_values(gem_name)
+          {:default_chrome_id => gem_name}
+        end
+        
+        def default_main_window_xul_values(gem_name)
+          {:app_name => gem_name.capitalize}
+        end
+        
+      end # ApplicationCommand
+      
+    end   # GenerateCommand
+  end     # CommandParser
+end       # XPCOMCore

data/lib/xpcomcore-rubygem/commands/generate/jeweler_builder_command.rb

@@ -0,0 +1,108 @@
+require "xpcomcore-rubygem/commands/generate/template_helpers"
+require "english"
+require "shell"
+require "stringio"
+
+module XPCOMCore
+  class CommandParser
+    class GenerateCommand
+
+      class JewelerBuilderCommand < CmdParse::Command
+        include TemplateHelpers
+        
+        JewelerSuccess = /Jeweler has prepared your gem in (.*)/
+        DefaultJewelerOpts = %w[--testunit]
+        ApplicableJewelerOpts = {
+          "--create-repo"               => "create the repository on GitHub",
+          "--gemcutter"                 => "setup project for gemcutter",
+          "--summary [SUMMARY]"         => "specify the summary of the project",
+          "--description [DESCRIPTION]" => "specify a description of the project",
+          "--directory [DIRECTORY]"     => "specify the directory to generate into"
+        }
+        DefaultGemDependencies = {'xpcomcore-rubygem' => ">=#{XPCOMCore::Version}",
+                                  'riot-js'           => ">0.0.0"}
+        RakefileGemDepFormat = "    gem.add_dependency %s, %s"
+        RakefileGemSpecLine = /# gem is a Gem::Specification/
+        
+        def initialize(*args)
+          super(*args)
+          @jeweler_opts = {}
+        end
+                  
+        def execute(args)
+          gem_name = args.shift || raise(CmdParse::InvalidArgumentError, "A name must be given")
+          project_path = Pathname(Dir.pwd) + make_jeweler_project(gem_name)
+          with_rakefile_in(project_path) { |rakefile| add_gem_dependencies(rakefile) }
+          rewrite_stub_ruby_file(gem_name, project_path)
+          setup_project(gem_name, project_path)
+        end
+        
+      private
+      
+        def setup_project(gem_name, project_path)
+          raise NotImplementedError
+        end
+        
+        def rewrite_stub_ruby_file(gem_name, project_path)
+          (project_path + "lib" + "#{gem_name}.rb").open('w') do |f|
+            f << "warn('This is a stub file generated by xpcomcore-rubygem. There may in fact be no Ruby code to speak of in this gem.')"
+          end
+        end
+        
+        def add_gem_dependencies(rakefile)
+          new_rakefile = rakefile.readlines.inject([]) do |new_rake,line|
+            if line =~ RakefileGemSpecLine
+              new_rake.concat(DefaultGemDependencies.collect { |dep,ver| RakefileGemDepFormat % [dep.inspect, ver.inspect] })
+            end
+            new_rake << line.chomp
+          end
+          rakefile.rewind && rakefile.write(new_rakefile.join($RS))
+        end
+        
+        def with_rakefile_in(project_path)
+          (project_path + "Rakefile").open("r+") { |f| yield(f) }
+        end
+
+        def make_jeweler_project(gem_name)
+          # FIXME - ugh. jeweler doesn't return non-zero exit on failure.
+          captured, sh, jeweler_args = StringIO.new, Shell.new, make_jeweler_args
+          sh.out(captured) { sh.system("jeweler", gem_name, *jeweler_args) }
+          captured = captured.rewind && captured.read
+          (captured =~ JewelerSuccess) ? (return($1)) : raise(GenerationError, "Failed to generate your project using Jeweler.")
+        ensure
+          puts captured
+        end
+
+        def add_jeweler_opts(opt_parse)
+          ApplicableJewelerOpts.each do |switch,desc|
+            switch_name = switch.split(" ", 2)[0]
+            opt_parse.on(switch, desc) {|val| @jeweler_opts[switch_name] = val }
+          end
+        end
+        
+        def make_jeweler_args
+          @jeweler_opts.inject(DefaultJewelerOpts.dup) do |args,(opt_switch,opt_val)|
+            opt_val == true ? args.push(opt_switch) : args.push(opt_switch, opt_val)
+          end
+        end
+      
+        def add_jsdoc_toolkit_doc_task(rakefile, options)
+          append_to(rakefile, eval_template("shared/jsdoc_doc_task.erb", options))
+        end
+
+        def add_xultestrunner_test_task(rakefile, options)
+          append_to(rakefile, eval_template("shared/xultestrunner_test_task.erb", options))
+        end
+        
+        def append_to(io, str, add_newlines = true)
+          io.seek(0, IO::SEEK_END)
+          io << $RS * 2 if add_newlines
+          io << str
+        end
+        
+      end # JewelerBuilderCommand
+      
+    end   # GenerateCommand
+  end     # CommandParser
+end       # XPCOMCore
+      

data/lib/xpcomcore-rubygem/commands/generate/library.rb

@@ -0,0 +1,25 @@
+require "xpcomcore-rubygem/commands/generate/jeweler_builder_command"
+
+module XPCOMCore
+  class CommandParser
+    class GenerateCommand
+
+      class LibraryCommand < JewelerBuilderCommand
+  
+        def initialize
+          super('library', false) # Doesn't take subcommands
+          self.short_desc = "Generates a library"
+          self.options = CmdParse::OptionParserWrapper.new { |opt_parse| add_jeweler_opts(opt_parse) }
+        end
+      
+      private
+      
+        def setup_project(gem_name, project_path)
+        
+        end
+        
+      end # LibraryCommand
+
+    end   # GenerateCommand
+  end     # CommandParser
+end       # XPCOMCore

data/lib/xpcomcore-rubygem/commands/generate/template_helpers.rb

@@ -0,0 +1,78 @@
+require 'erb'
+require 'fileutils'
+
+# FIXME - clean this ugly guy up
+module XPCOMCore
+  class CommandParser
+    class GenerateCommand
+
+      module TemplateHelpers
+        TemplateDir = XPCOMCore::GemRoot + "templates"
+        class EvalContext
+          def initialize(ivars)
+            ivars.each {|k,v| instance_variable_set("@#{k}", v)}
+          end
+          
+          def get_binding
+            binding
+          end
+        end # EvalContext
+        
+        def eval_template(path, vars)
+          context = EvalContext.new(vars)
+          template = ERB.new((TemplateDir + path).read)
+          template.result(context.get_binding)
+        end
+        
+        def copy_template_directory(dir_name, dest, template_vars)
+          template_dir = (TemplateDir + dir_name).expand_path
+          dest.mkpath
+          Pathname.glob("#{template_dir}/**/*").each do |dir_entry|
+            handle_entry_creation(template_dir, dir_entry, dest, template_vars)
+          end
+        end
+        
+        def handle_entry_creation(template_dir, dir_entry, dest_dir, template_vars)
+          relative_path = dir_entry.relative_path_from(template_dir)
+          if dir_entry.directory?
+            mkpath(dest_dir + relative_path)
+          else
+            handle_file(dir_entry, (dest_dir + relative_path), template_vars)
+          end
+        end
+        
+        def handle_file(entry, dest, template_vars)
+          if entry.extname == ".erb"
+            copy_template(entry, dest, template_vars)
+          else
+            copy_file(entry, dest)
+          end
+        end
+        
+        def mkpath(path)
+          puts "Creating #{path}"
+          path.mkpath
+        end
+        
+        def copy_template(entry, dest, template_vars)
+          real_dest = Pathname(dest.expand_path.to_s.sub(/#{dest.extname}$/, ""))
+          puts "Creating #{real_dest}"
+          vars = determine_template_vars(real_dest, template_vars)
+          real_dest.open('w') { |f| f << eval_template(entry, vars) }
+        end
+        
+        def copy_file(entry, dest)
+          puts "Creating #{dest.expand_path}"
+          FileUtils.cp(entry.expand_path.to_s, dest.expand_path.to_s)
+        end
+        
+        def determine_template_vars(dest, template_vars)
+          template_vars.detect do |path,values|
+            dest.to_s =~ /#{Regexp.escape(path)}$/
+          end.last
+        end
+      end # TemplateHelpers
+      
+    end   # GenerateCommand
+  end     # CommandParser
+end       # XPCOMCore

data/lib/xpcomcore-rubygem/commands/launch.rb

@@ -0,0 +1,129 @@
+require 'rubygems'
+require 'xpcomcore-rubygem/commands'
+require 'sys/uname'
+require 'pathname'
+
+module XPCOMCore
+  class CommandParser
+    class LaunchCommand < CmdParse::Command
+      attr_accessor :use_xulrunner
+
+      class ApplicationNotFoundError < CmdParse::InvalidArgumentError
+        reason 'Application not found'
+      end
+      
+      class XULRunnerNotFoundError < CmdParse::ParseError
+        reason 'XULRunner not found'
+      end
+      
+      GemAppRelativePath = "xpcomcore/app/application.ini"
+      CurrentPlatform = Sys::Uname.sysname.downcase.to_sym
+      
+      # FIXME - clean up this xulrunnerlocator crap that takes up like half the class
+      XULRunnerLocators = {:firefox => {}, :xulrunner => {}}
+      XULRunnerLocators[:firefox][:unix] = [lambda { `which firefox-bin`}, lambda { `which firefox`}]
+      XULRunnerLocators[:xulrunner][:unix] = [lambda { `which xulrunner-bin`}, lambda { `which xulrunner`}]
+      
+      # Linux uses the default UNIX locators
+      XULRunnerLocators[:firefox][:linux] = XULRunnerLocators[:firefox][:unix]
+      XULRunnerLocators[:xulrunner][:linux] = XULRunnerLocators[:xulrunner][:unix]
+      
+      # Darwin does some extra magic
+      XULRunnerLocators[:firefox][:darwin] = XULRunnerLocators[:firefox][:unix] + [
+        lambda do 
+          applications = `osascript -e 'POSIX path of (path to applications folder)'`.strip
+          firefox_bin = Pathname(applications) + "Firefox.app/Contents/MacOS/firefox-bin"
+          firefox_bin.exist? ? firefox_bin.expand_path.to_s : ''
+        end
+      ]
+      
+      XULRunnerLocators[:xulrunner][:darwin] = XULRunnerLocators[:xulrunner][:unix] + [
+        lambda do 
+          library = `osascript -e 'POSIX path of (path to library folder)'`.strip
+          xulrunner_bin = Pathname(library) + "Frameworks/XUL.framework/xulrunner-bin"
+          xulrunner_bin.exist? ? xulrunner_bin.expand_path.to_s : ''
+        end
+      ]
+
+      
+      def initialize
+        super('launch', false, # Doesn't take subcommands
+                        true)  # Uses partial command matching
+        self.short_desc = "Launches an XPCOMCore based XUL application either from RubyGems or a given path"
+        self.options = CmdParse::OptionParserWrapper.new do |opt|
+          opt.on('-x', '--use-xulrunner', 'Tries to use XULRunner to launch the given application rather than the default of Firefox', method(:use_xulrunner=))
+        end
+      end
+      
+      def execute(args)
+        app_name_or_path = args.shift || '.'
+        application = find_app(app_name_or_path)
+        unless application
+          raise(ApplicationNotFoundError, "The application '#{app_name_or_path}' could not be found in the given path or in your RubyGems install")
+        end
+        launch_app(application, args)
+      end
+      
+      def use_xulrunner?
+        !!use_xulrunner
+      end
+      
+      def runner_type
+        use_xulrunner ? :xulrunner : :firefox
+      end
+      
+    private
+    
+      def launch_app(application_ini_path, args)
+        xulrunner_path = find_xulrunner
+        if xulrunner_path
+          XPCOMCore::CommandParser.log("Launching XUL application using '#{xulrunner_path}' from '#{application_ini_path}'")
+          set_env_and_launch(xulrunner_path, application_ini_path, args)
+        else
+          raise(XULRunnerNotFoundError, "A valid XULRunner executable could not be found.")
+        end
+      end
+      
+      def set_env_and_launch(xulrunner_bin, application_ini, args)
+        ENV['XPCOMCORE'] = ENV['XPCOMCORE'] || XPCOMCore::BootstrapperLocation.to_s
+        XPCOMCore::CommandParser.log("Using XPCOMCore bootstrapper at '#{ENV['XPCOMCORE']}'")
+        exec(xulrunner_bin, *["-app", application_ini, *args])
+      end
+      
+      def find_xulrunner
+        XULRunnerLocators[runner_type][CurrentPlatform].any? do |locator|
+          location = locator.call.strip
+          location.empty? ? nil : (break(location))
+        end
+      end
+      
+      def find_app(app_path)
+        fs_path = Pathname(Dir.pwd) + app_path + "application.ini"
+        if fs_path.exist?
+          return fs_path
+        else
+          return search_gems(app_path)
+        end
+      end
+      
+      def search_gems(app_name)
+        gems = Gem.source_index.find_name(app_name)
+        return nil if gems.empty?
+        latest_gem_spec = gems.last
+        get_application_path_from_gem_spec(latest_gem_spec)
+      end
+
+      def get_application_path_from_gem_spec(gem_spec)
+        ini_path = Pathname(gem_spec.full_gem_path) + GemAppRelativePath
+        if ini_path.exist?
+          return ini_path
+        else
+          return nil
+        end
+      end
+      
+    end # LaunchCommand
+  end   # CommandParser
+end     # XPCOMCore
+
+XPCOMCore::CommandParser.add_command(XPCOMCore::CommandParser::LaunchCommand)