jsc 0.1.0

data/.bnsignore

@@ -0,0 +1,18 @@
+# The list of files that should be ignored by Mr Bones.
+# Lines that start with '#' are comments.
+#
+# A .gitignore file can be used instead by setting it as the ignore
+# file in your Rakefile:
+#
+#   Bones {
+#     ignore_file  '.gitignore'
+#   }
+#
+# For a project with a C extension, the following would be a good set of
+# exclude patterns (uncomment them if you want to use them):
+# *.[oa]
+# *~
+announcement.txt
+coverage
+doc
+pkg

data/.gitignore

@@ -0,0 +1,7 @@
+syntax: glob
+*~
+pkg/
+*#
+.#*
+spec/wip_spec.rb
+doc/

data/History.txt

@@ -0,0 +1,3 @@
+== 0.1.0 / 2009-12-12
+
+* First gem release

data/README.rdoc

@@ -0,0 +1,81 @@
+jsc, a Ruby REST API to Google Closure Compiler web service
+    by sub
+    http://github.com/sub/jsc
+
+== DESCRIPTION:
+
+A simple and clear Ruby REST API to {Google Closure Compiler service}[http://code.google.com/closure/compiler/].
+
+== FEATURES:
+
+The package comes with a jsc commands which accepts several options, run 
+
+  jsc --help 
+
+for help.
+
+More in details:
+* Ruby API actually is a single function call (ex: JSCompiler.compile(file_name, "statistics", "SIMPLE_OPTIMIZATIONS") )
+* Handling of JSON responses, parse and print them (same output of the Google web interface!)
+* Handling of Server Errors responses
+* Compile a piece of code, a file or a whole directory
+* <b>Emacs snippet</b> to compile code your code for errors and warnings
+
+Check {Google API Reference}[http://code.google.com/intl/it-IT/closure/compiler/docs/api-ref.html] for more info about accepted parameters.
+
+== SYNOPSIS:
+
+Compile a file:
+
+  ruby bin/jsc -f js/compiled_code.js
+
+Compile a file, check for errors:
+
+  ruby bin/jsc -f js/errors.js -e
+
+Compile a file, check for warnings:
+
+  ruby bin/jsc -f js/warnings.js -w
+
+Compile a file and get compression stats:
+
+  ruby bin/jsc -f js/compiled_code.js -s
+
+Compile a piece of code, check for errors:
+
+  ruby bin/jsc -e "function("
+
+<b>NOTE</b>: the library is a single file, so you can include it and just call the JSCompiler.compile(file_name, operations, compilation_level) function everywhere in your code. Check the plugins dir for samples or snippets.
+<b>UPDATE 20091212</b>: bin file plugins/bin/google_closure_compiler not working at the moment due to changes in project name and structure
+
+== EMACS SNIPPETS
+
+Wants to compile your code right from Emacs?
+
+Copy 
+
+  plugins/jsc.el
+
+to your emacs <em>load-path</em> and restart Emacs.
+
+Now, select the code to compile and run:
+* <em>CcJe</em> to check for errors
+* <em>CcJw</em> to check for warnings.
+
+== REQUIREMENTS:
+
+No requirements
+
+== INSTALL:
+
+Create your gem with:
+
+  rake gem:package
+
+In order to install it, run:
+
+  rake gem:install
+
+== LICENSE:
+
+GNU General Public License (GPLv3)

data/Rakefile

@@ -0,0 +1,37 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+require 'lib/jsc.rb'
+#require 'lib/jsc/tasks'
+
+require 'term/ansicolor'
+
+class Color
+  class << self
+    include Term::ANSIColor
+  end
+end
+
+## Mr.Bones config
+begin
+  require 'bones'
+rescue LoadError
+  abort '### Please install the "bones" gem ###'
+end
+
+ensure_in_path 'lib'
+require 'jsc'
+
+task :default => 'test:run'
+task 'gem:release' => 'test:run'
+
+Bones {
+  name  'jsc'
+  authors  'sub'
+  email  'fitzkarraldo@gmail.com'
+  url  'http://github.com/sub/jsc'
+  version  '0.1.0'
+  summary 'Google Closure Compiler Ruby REST API'
+}
+

data/bin/jsc

@@ -0,0 +1,89 @@
+#!/usr/bin/env ruby
+
+# == Synopsis
+#
+# jsc, JavaScript Compiler.
+# 
+# This command compiles your JavaScript code throught Google
+# Closure Compiler Service.
+# Look at http://github.com/sub/google_closure_compiler for more info
+#
+# == Usage
+# 
+# jsc [OPTION] ... CODE
+#
+# -h, --help:
+#    show help
+#
+# --file x, -f x:
+#    compile file x
+#
+# --level value, -l value:
+#    compile with level value
+#    If this option is not supplied, SIMPLE_OPTIMIZATIONS will be used
+#    Look at Google API for accepted values
+#
+# --errors, -e:
+#    check for errors
+#
+# --warns, -w:
+#    check for warnings
+#
+# --stats, -s:
+#    get statistics for compiled code
+#
+# CODE: The code that will be compiled.
+
+require 'getoptlong'
+require 'rdoc/usage'
+
+require File.expand_path(
+    File.join(File.dirname(__FILE__), %w[.. lib jsc]))
+
+opts = GetoptLong.new(
+                      [ '--help', '-h', GetoptLong::NO_ARGUMENT ],
+                      [ '--file', '-f', GetoptLong::OPTIONAL_ARGUMENT ],
+                      [ '--level','-l',  GetoptLong::REQUIRED_ARGUMENT ],
+                      [ '--errors', '-e', GetoptLong::NO_ARGUMENT ],
+                      [ '--warns', '-w', GetoptLong::NO_ARGUMENT ],
+                      [ '--stats', '-s', GetoptLong::NO_ARGUMENT ]
+                      )
+
+file = false
+output_info, level, file_path = String.new
+
+opts.each do |opt, arg|
+  case opt
+  when '--help'
+    RDoc::usage
+  when '--file'
+    file = true
+    file_path = arg
+  when '--level'
+    if arg == ''
+      level = "SIMPLE_OPTIMIZATIONS"
+    else
+      level = arg
+    end
+  when '--errors'
+    output_info = "errors"
+  when '--warns'
+    output_info = "warnings"
+  when '--stats'
+    output_info = "statistics"
+  end
+end
+
+# -f option or CODE arg requested
+unless ARGV.length > 0 or file
+   puts "Missing any argument (try --help)"
+   exit 0
+end
+
+code = ARGV.shift
+
+if file
+    puts JSCompiler.compile_file(file_path, output_info, level)
+else
+    puts JSCompiler.compile(code, output_info, level)
+end

data/js/compiled_code.js

@@ -0,0 +1,4 @@
+function hello(name) {
+  alert('Hello, ' + name)
+}
+hello('New user');

data/js/errors.js

@@ -0,0 +1,4 @@
+functiont hello(name) {
+  alert('Hello, ' + name)
+}
+hello('New user');

data/js/warnings.js

@@ -0,0 +1,5 @@
+function hello(name) {
+	return;
+  alert('Hello, ' + name)
+}
+hello('New user');

data/lib/jsc/closure_compiler.rb

@@ -0,0 +1,168 @@
+require 'rubygems'  # include RubyGems
+gem 'activesupport' # load ActiveSupport
+require 'activesupport' # include ActiveSupport
+require 'active_support/core_ext/integer/inflections'
+
+require 'json'
+require 'net/http'
+
+module JSCompiler
+
+# CONFIGURE this with the relative path to your javascript
+# folder (typically public/javascripts in a RAILS APP)
+# NO MORE NEEDED
+#JAVASCRIPTS_DIR = "js/"
+
+# Link to Google Closure Compiler service
+GOOGLE_SERVICE_ADDRESS = "http://closure-compiler.appspot.com/compile"
+# Default output_info parameter
+DEFAULT_SERVICE = "compiled_code"
+# Default compilation_level parameter
+DEFAULT_LEVEL = "SIMPLE_OPTIMIZATIONS"
+
+  class << self
+
+    # Creates the <em>JSON</em> hash for the request and returns the hash to send along with the request
+    #
+    # Accepted parameters:
+    # * <b>code</b>: json_code parameter
+    # * <b>level</b>: compilation_level parameter
+    def create_json_request(code)
+      parameters = {
+    	"code" => code,
+	"level" => @level,
+	"format"   => "json",
+	"info"  => @op
+      }
+    end
+
+    # Sends the JSON request <em>data</em> hash to Google service and returns its response
+    #
+    def post_to_cc(data)
+      post_args = { 
+        'js_code' => data["code"],
+        'compilation_level' => data["level"],
+        'output_format' => data["format"],
+        'output_info' => data["info"]
+      }
+      # send the request
+      resp, data = Net::HTTP.post_form(URI.parse(GOOGLE_SERVICE_ADDRESS), post_args)
+    end
+
+    # Reads the <em>file_name</em> file and calls compile method on it
+    #
+    # Accepted parameters:
+    # * <b>file_name</b>: absolute path to file
+    # * <b>op</b>: output_info parameter
+    # * <b>level</b>: compilation_level parameter
+    def compile_file(file_name, op, level)
+      #    javascript_code = read_file(JAVASCRIPTS_DIR + file_name)
+      #    resp, data = post_to_cc(create_json_request(javascript_code, op, level))
+      #    parse_json_output(data, op)
+     
+      javascript_code = read_file(file_name)
+      compile(javascript_code, op, level)
+    end
+
+    # Compiles <em>javascript_code</em> code and returns parsed output
+    #
+    # Accepted parameters:
+    # * <b>javascript_code</b>: the code to compile
+    # * <b>op</b>: output_info parameter
+    # * <b>level</b>: compilation_level parameter
+    def compile(javascript_code, op, level)
+      @op = op.blank? ? DEFAULT_SERVICE : op
+      @level = level.blank? ? DEFAULT_LEVEL : level
+
+      resp, data = post_to_cc(create_json_request(javascript_code))
+      parse_json_output(data)
+    end
+
+    # Calls compile method for every file in <em>dir</em> directory
+    #
+    # Accepted parameters:
+    # * <b>dir</b>: the directory
+    # * <b>op</b>: output_info parameter
+    # * <b>level</b>: compilation_level parameter
+    def compile_dir(dir, op, level)
+      out = String.new
+      Dir.entries(dir).each do |file|
+        if File.extname(file) == ".js"
+          out << "Statistics for file #{file}...\n"
+          out << compile_file(file, op, level) + "\n***************\n"
+        end
+      end
+      return out
+    end
+
+    # Parses and returns JSON server <em>response</em>
+    #
+    # Accepted parameters:
+    # * <b>response</b>: the server response
+    def parse_json_output(response)
+      out = String.new
+      parsed_response = JSON.parse(response, :max_nesting => false)
+      #p response
+
+      if parsed_response.has_key?("serverErrors") 
+        result = parsed_response['serverErrors']
+        return "Server Error: #{result[0]['error']} - Error Code: #{result[0]['code']}"
+      end
+
+      case @op
+      when "compiled_code"
+        out = parsed_response['compiledCode']
+      when "statistics"
+        result = parsed_response['statistics']
+        out = create_statistics_output(result)
+      else "errors"
+        #case for errors or warnings
+        begin
+          result = parsed_response[@op]
+          unless result.nil?
+            result.each do |message|
+              out = "#{message['type']}: " + message[@op.singularize] + " at line #{message['lineno']} character #{message['charno']}\n"
+              out << message['line'] unless message['line'].nil?
+              return out
+            end
+          else
+            return "No #{@op}"
+          end
+        rescue
+          out = "Error parsing JSON output...Check your output"
+        end
+      end
+    end
+
+    # Reads file and returns its content
+    #
+    # Accepted parameters:
+    # * <b>file_name</b>: the absolute path to the file
+    def read_file(file_name)
+      begin
+        #      content = File.open(JAVASCRIPTS_DIR + file_name).read
+        content = File.open(file_name).read
+        return content, true
+      rescue
+        out = "ERROR reading #{file_name} file"
+        return out, false
+      end
+    end
+
+    # Parses and returns the <em>result</em> JSON server response
+    #
+    # Accepted parameters:
+    # * <b>result</b>: the already parsed JSON server response
+    def create_statistics_output(result)
+      size_improvement = result['originalSize'] - result['compressedSize']
+      size_gzip_improvement = result['originalGzipSize'] - result['compressedGzipSize']
+      rate_improvement = (size_improvement * 100)/result['originalSize']
+      rate_gzip_improvement = (size_gzip_improvement * 100)/result['originalGzipSize']
+      out = "Original Size: #{result['originalSize']} bytes (#{result['originalGzipSize']} bytes gzipped) \n"
+      out << "Compiled Size: #{result['compressedSize']} bytes (#{result['compressedGzipSize']} bytes gzipped) \n"
+      out << "\t Saved #{rate_improvement}% off the original size (#{rate_gzip_improvement}% off the gzipped size)"
+    end
+
+  end
+
+end

data/lib/jsc.rb

@@ -0,0 +1,47 @@
+module JSCompiler
+
+  # :stopdoc:
+#  VERSION = '1.0.0'
+#  LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
+#  PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
+  # :startdoc:
+
+  # Returns the version string for the library.
+  #
+  def self.version
+    VERSION
+  end
+
+  # Returns the library path for the module. If any arguments are given,
+  # they will be joined to the end of the libray path using
+  # <tt>File.join</tt>.
+  #
+  def self.libpath( *args )
+    args.empty? ? LIBPATH : ::File.join(LIBPATH, args.flatten)
+  end
+
+  # Returns the lpath for the module. If any arguments are given,
+  # they will be joined to the end of the path using
+  # <tt>File.join</tt>.
+  #
+  def self.path( *args )
+    args.empty? ? PATH : ::File.join(PATH, args.flatten)
+  end
+
+  # Utility method used to require all files ending in .rb that lie in the
+  # directory below this file that has the same name as the filename passed
+  # in. Optionally, a specific _directory_ name can be passed in such that
+  # the _filename_ does not have to be equivalent to the directory.
+  #
+  def self.require_all_libs_relative_to( fname, dir = nil )
+    dir ||= ::File.basename(fname, '.*')
+    search_me = ::File.expand_path(
+        ::File.join(::File.dirname(fname), dir, '**', '*.rb'))
+
+    Dir.glob(search_me).sort.each {|rb| require rb}
+  end
+
+end  # module JSCompiler
+
+JSCompiler.require_all_libs_relative_to(__FILE__)
+

data/plugins/bin/google_closure_compiler

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby
+
+require File.expand_path(
+    File.join(File.dirname(__FILE__), %w[.. .. lib google_closure_compiler]))
+
+# Give me errors!
+puts ClosureCompiler.compile_file("test_errors.js", "errors")
+puts "**************\n"
+
+# Read file and compile it!
+
+# function passing it the relative path of the file
+code_to_compile, result = ClosureCompiler.read_file('test.js')
+if result
+  compiled_code = ClosureCompiler.compile(code_to_compile, "compiled_code")
+  unless compiled_code.nil?
+    puts compiled_code
+  end
+else
+    puts "ERROR reading file\n"
+end
+puts "**************\n"
+
+# Give me statistics!
+code_to_compile = "function hello(a){alert(\"Hello, \"+a)}hello(\"New user\");"
+puts ClosureCompiler.compile(code_to_compile, "statistics")
+puts "**************\n"
+
+# Compile a whole directory
+js_dir = "js" # relative path to js directory
+puts "Compiling a WHOLE directory...\n"
+puts ClosureCompiler.compile_dir(js_dir, "statistics")
+puts "**************\n"
+
+# Execute every check on the file
+puts ClosureCompiler.compile_file("js/compiled_code.js", "compiled_code")
+puts "*******************"
+puts ClosureCompiler.compile_file("js/compiled_code.js", "warnings")
+puts "*******************"
+puts ClosureCompiler.compile_file("js/compiled_code.js", "errors")
+puts "*******************"
+puts ClosureCompiler.compile_file("js/compiled_code.js", "statistics")

data/plugins/jsc.el

@@ -0,0 +1,44 @@
+;; snippet Google Closure Compiler
+(define-key global-map "\C-cJe" 'fitz-jsc-errors-current-selection)
+
+(defun fitz-jsc-errors-current-selection ()
+ "run jsc for errors on current selection"
+ (interactive)
+ (let ((tmp-buffer (get-buffer-create "**fitz-cc**"))
+       (region-str (buffer-substring (region-beginning) (region-end)))
+       (cc-output (shell-command-to-string
+                       (concat "jsc -e \""
+                               (buffer-substring (region-beginning) (region-end)) "\""))))
+   (set-buffer tmp-buffer)
+   (goto-char (point-max))
+   (insert (concat "===== BEGIN =====\n"
+                   "Selected Code:\n\t"
+                   region-str
+                   "\n\n"
+                   "JSCompiler Errors:\n"
+                   cc-output
+                   "===== END =====\n\n")
+   (switch-to-buffer-other-window tmp-buffer)
+   (recenter (point-max)))))
+
+(define-key global-map "\C-cJw" 'fitz-jsc-warnings-current-selection)
+ 
+(defun fitz-jsc-warnings-current-selection ()
+ "run jsc for warnings on current selection"
+ (interactive)
+ (let ((tmp-buffer (get-buffer-create "**fitz-cc**"))
+       (region-str (buffer-substring (region-beginning) (region-end)))
+       (cc-output (shell-command-to-string
+                       (concat "jsc -w \""
+                               (buffer-substring (region-beginning) (region-end)) "\""))))
+   (set-buffer tmp-buffer)
+   (goto-char (point-max))
+   (insert (concat "===== BEGIN =====\n"
+                   "Selected Code:\n\t"
+                   region-str
+                   "\n\n"
+                   "JSCompiler Warnings:\n"
+                   cc-output
+                   "===== END =====\n\n")
+   (switch-to-buffer-other-window tmp-buffer)
+   (recenter (point-max)))))

data/spec/jsc.rb

@@ -0,0 +1,132 @@
+
+require File.join(File.dirname(__FILE__), %w[spec_helper])
+
+describe JSCompiler do
+
+   describe 'Use the web service through API' do
+    
+    describe 'Put all keys in the request' do
+
+      before do
+        code = "function hello(a){alert(\"Hello, \"+a)}hello(\"New user\");"
+        @request = JSCompiler.create_json_request(code)
+        @request['level'] = "SIMPLE_OPTIMIZATIONS"
+        @request['info'] = "compiled_code"
+      end
+
+      it 'should create a request with code key' do
+        @request['code'].should_not be_nil
+      end
+
+      it 'should create a request with level key' do
+        @request['level'].should_not be_nil
+      end
+
+      it 'should create a request with format key' do
+        @request['format'].should_not be_nil
+      end
+
+      it 'should create a request with info key' do
+        @request['info'].should_not be_nil
+      end
+
+      it 'should create a JSON request with all requested keys' do
+        ["code","level","format","info"].each { |key| @request[key.intern].should }
+      end
+    end
+
+    describe 'create a JSON compile-code request (default request)' do
+      before do
+        code = "function hello(a){alert(\"Hello, \"+a)}hello(\"New user\");"
+        @request = JSCompiler.create_json_request(code)
+        @request['level'] = "SIMPLE_OPTIMIZATIONS"
+        @request['info'] = "compiled_code"
+      end
+
+      it 'with the right value for level key' do
+        @request['level'].should == 'SIMPLE_OPTIMIZATIONS'
+      end
+
+      it 'with the right value for format key' do
+        @request['format'].should == 'json'
+      end
+
+      it 'with the right value for info key' do
+        @request['info'].should == 'compiled_code'
+      end
+      
+      it 'with the right param for code key' do
+        @request['code'].should_not be_nil
+      end
+    end
+
+    describe 'compile code and get compiled code' do
+      before do
+        code = "function hello(a){alert(\"Hello, \"+a)}hello(\"New user\");"
+        @resp = JSCompiler.compile(code, "compiled_code", "SIMPLE_OPTIMIZATIONS")
+      end
+ 
+      it 'should receive the compiled code' do
+        @resp.should_not be_nil
+      end
+    end
+    
+    describe 'compile code and find errors' do
+      before do
+        code = "functiont hello(a){alert(\"Hello, \"+a)}hello(\"New user\");"
+        @resp = JSCompiler.compile(code, "errors", "SIMPLE_OPTIMIZATIONS")
+      end
+      
+      it 'should return the result string' do
+        @resp.should match(/at line/)
+      end
+    end
+    
+    describe 'compile code and find warnings' do
+      before do
+        code = "function hello(a){return; alert(\"Hello, \"+a)}hello(\"New user\");"
+        @resp = JSCompiler.compile(code, "warnings", "SIMPLE_OPTIMIZATIONS")
+      end
+      
+      it 'should return the result string' do
+        @resp.should match(/at line/)
+      end  
+    end
+ 
+    describe 'compile code and obtain statistics' do
+      before do
+        code = "function hello(a){alert(\"Hello, \"+a)}hello(\"New user\");"
+        @resp = JSCompiler.compile(code, "statistics", "SIMPLE_OPTIMIZATIONS")
+      end
+  
+      it 'should return the result string' do
+        @resp.should match(/Original Size:/)
+      end
+    end
+  end
+  
+  describe 'read .js file' do
+    before do
+      #test file
+      @file_name = 'js/compiled_code.js'
+    end
+
+    it 'should return the code without errors' do
+      result, value = JSCompiler.read_file(@file_name)
+      value.should be_true
+    end
+  end
+
+  describe 'compile a whole directory' do
+
+    it 'should get statistics for every file' do
+      js_dir = "js"
+      result = JSCompiler.compile_dir(js_dir, "statistics", String.new)
+      # suppose I have 3 files in the dir
+      3.times do 
+        result.should =~ /Original Size:/
+      end
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+
+require File.expand_path(
+    File.join(File.dirname(__FILE__), %w[.. lib jsc]))
+
+Spec::Runner.configure do |config|
+  # == Mock Framework
+  #
+  # RSpec uses it's own mocking framework by default. If you prefer to
+  # use mocha, flexmock or RR, uncomment the appropriate line:
+  #
+  # config.mock_with :mocha
+  # config.mock_with :flexmock
+  # config.mock_with :rr
+end
+

data/spec/wip_spec.rb

@@ -0,0 +1,6 @@
+require File.join(File.dirname(__FILE__), %w[spec_helper])
+
+describe JSCompiler do
+
+  
+end

data/tasks/jsc.rake

@@ -0,0 +1,4 @@
+#desc "Task descriptios"
+#task :my_cc_task do
+#   Task code
+#end

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification 
+name: jsc
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- sub
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-12-12 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: bones
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 3.1.0
+    version: 
+description: A simple and clear Ruby REST API to {Google Closure Compiler service}[http://code.google.com/closure/compiler/].
+email: fitzkarraldo@gmail.com
+executables: 
+- jsc
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- README.rdoc
+- bin/jsc
+files: 
+- .bnsignore
+- .gitignore
+- History.txt
+- README.rdoc
+- Rakefile
+- bin/jsc
+- js/compiled_code.js
+- js/errors.js
+- js/warnings.js
+- lib/jsc.rb
+- lib/jsc/closure_compiler.rb
+- plugins/bin/google_closure_compiler
+- plugins/jsc.el
+- spec/jsc.rb
+- spec/spec_helper.rb
+- spec/wip_spec.rb
+- tasks/jsc.rake
+- test/test_jsc.rb
+has_rdoc: true
+homepage: http://github.com/sub/jsc
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: jsc
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Google Closure Compiler Ruby REST API
+test_files: 
+- test/test_jsc.rb