dependence 0.0.4 → 0.0.6

data/bin/dependence

@@ -1,46 +1,121 @@
 #!/usr/bin/env ruby
+
+$: << "."
+require 'rubygems'
+require 'coffee-script'
+require 'lib/dependence'
 require 'optparse'
 require  File.join(File.dirname(__FILE__), "..", "lib/dependence.rb")
 
-options = {:output => "compiled.js"}
+class DependenceCompiler 
+  def initialize(config) 
+    @config = config
+    @src_glob = "**/*.#{@config[:type]}"
+    @concatenator = Dependence::Concatenator.new(
+      :load_path => @config[:src_dir], 
+      :source_type => @src_glob
+    )
+  end
+
+  def compile
+    @config[:watch] ? compile_with_watcher : run_compile 
+  end
+
+  private 
+
+  def compile_with_watcher
+    FileWatcher.new(:load_path => @config[:src_dir],  :glob_str => @src_glob) do
+      run_compile
+    end
+  end
+
+  def run_compile 
+    begin
+      @concatenator.concat do |module_name, module_content|
+        stdout_compile_msg(module_name)
+        output = File.join(@config[:output], "#{module_name}.js")
+        compiled = compile_code(module_content)
+        compiled = ModuleInjector.modularize(module_name, compiled) unless @config[:bare]
+        File.open(output, 'w') { |f| f.syswrite compiled }
+
+        stdout_compile_complete_msg(module_name, output)
+        compress_code(output) if @config[:compress]
+      end
+
+    rescue
+      puts Colors.red("exiting")
+      exit 1
+    end
+  end
+
+
+  def stdout_compile_msg(module_name)
+    puts ""
+    puts "================================"
+    puts Colors.green("Detected Module: #{module_name}")
+    puts "================================"
+  end
+
+  def stdout_compile_complete_msg(module_name, output)
+    puts Colors.green("Compiled #{module_name} to #{output}")
+  end
+
+  def compile_code(raw_code)
+    return CoffeeScript.compile(raw_code, :bare => true) if @config[:type] == "coffee"
+    raw_code
+  end 
+
+  def compress_code(source_file)
+    JsCompiler.new(source_file).compile
+  end
+end
+
+
+options = {
+  :output   => ".",
+  :type     => "js",
+  :watch    => false,
+  :bare     => false,
+  :compress => false
+}
+
 OptionParser.new do |opts|
-  opts.banner = "Usage: compile.rb js_source_dir [options]"
+  opts.banner = "Usage: src_dir [options]"
 
-  opts.on("-o", "--output FILE", "Output .js file") do |file|
-    options[:output] = file
+  opts.on("-o", "--output DIR", "Output directory, defaults to '.'") do |dir|
+    options[:output] = dir
   end
 
-  opts.on("-w", "--watch", "Watch src directory for changes and recompile") do |bool|
+  opts.on("-t", "--type TYPE", "Source file extension [js, coffee]") do |type|
+    options[:type] = type
+  end
+
+  opts.on("-w", "--watch", "Watch src_dir for changes and recompile") do |bool|
     options[:watch] = bool
   end
+
+  opts.on("-b", "--bare", "Do not wrap modules in closures with export var") do |bool|
+    options[:bare] = bool
+  end
+
+  opts.on("-c", "--compress", "Compress output with Googles Closure compiler") do |bool|
+    options[:compress] = bool
+  end
+
 end.parse(ARGV)
 
 if ARGV.length < 1
-  puts "You need to inlcude your js src directory"
+  puts "You need a src directory to compile from!"
   exit 1
-elsif !File.directory? ARGV[0] 
-  puts "Can't find your js source directory: #{ARGV[0]}"
+elsif !File.directory? ARGV[0]
+  puts "#{ARGV[0]} is not a directory!"
   exit 1
 end
 
-options[:input] = ARGV[0]
-output_file = options[:output]
-compiler = JsCompiler.new(options[:input])
-
-def recompile(compiler, output_file)
-  File.delete(output_file) if File.exists?(output_file)
-  compiler.compile(output_file)
-end
-
-recompile compiler, output_file
-
-if options[:watch]
-  puts "Watching #{options[:input]} for changes. Your javascript files will be compiled automatically"
-  FileWatcher.new "**/*.js" do
-    recompile compiler, output_file
-  end 
-end
+options[:src_dir] = ARGV[0]
 
 
+compiler = DependenceCompiler.new options
+compiler.compile
 
 

data/lib/dependence/concatenator.rb

@@ -0,0 +1,55 @@
+require 'fileutils'
+require File.join(File.dirname(__FILE__), 'colors')
+
+module Dependence
+  # Take a load path + file glob and concat them into 1 file per directory
+  class Concatenator
+    @@defaults = {
+      :load_path    => ".",
+      :source_type  => "**/*.js"
+    }
+
+    def initialize(opts = {})
+      @options = @@defaults.merge(opts)
+    end
+
+    def concat(&block)
+      get_dirs.each { |dir| concat_module(dir, &block) }
+    end
+
+    private
+
+    def concat_module(dir, &block)
+      module_name = File.basename(dir)
+
+      files = Dir.glob File.join(dir, @options[:source_type])
+      no_files_error if files.empty?
+
+      files_list = get_files_in_dependency_order(dir, files)
+      
+      block.call module_name, concat_files(files_list)
+    end
+
+    def no_files_error 
+      puts Colors.red("No files of the specified type #{File.extname(@options[:source_type])} were found in #{@options[:load_path]}")
+      throw :no_files_to_concatenate 
+    end
+
+    def get_files_in_dependency_order(dir, files)
+      resolver = DependencyResolver.new(files, dir)
+      resolver.sorted_files
+    end
+
+    def concat_files(file_list)
+      content = ""
+      file_list.each { |f| content << File.read(f); content << "\n" }
+      content
+    end
+
+    # Top level dirs only
+    def get_dirs
+      Dir.glob("#{@options[:load_path]}/*/**/")
+    end
+
+  end
+end

data/lib/dependence/file_watcher.rb

@@ -1,6 +1,10 @@
 class FileWatcher
-  def initialize(glob_str, &block)
-    @dir = glob_str 
+  @@defaults = {
+    :load_path => ".",
+    :glob_str  => "**/*.js"
+  }
+  def initialize(opts, &block)
+    @options = @@defaults.merge(opts)
     recreate_timetable
     poll(&block)
   end
@@ -32,7 +36,7 @@ class FileWatcher
   end
 
   def get_files
-    Dir.glob @dir
+    Dir.glob File.join(@options[:load_path], @options[:glob_str]) 
   end
 
   def recreate_timetable

data/lib/dependence/js_compiler.rb

@@ -2,36 +2,24 @@ require File.join(File.dirname(__FILE__),'dependency_resolver')
 require File.join(File.dirname(__FILE__),'colors')
 
 class JsCompiler
-  def initialize(source_path) 
-    @source_path = source_path
+  def initialize(source_file, output_file = nil) 
+    output_file = source_file.gsub(".js", ".min.js") unless output_file
+    @source = source_file
+    @output = output_file
   end
 
-  def compile(output_file)
+  def compile
     @cmd = cmd_prefix
-    @source_files = get_source_files 
-    dep_resolver = DependencyResolver.new(@source_files,@source_path)
-    file_order = dep_resolver.sorted_files
-    puts "#{Colors.green('Source Files')}: #{file_order.to_s}"
-    puts ""
-    puts Colors.red "Compiler Output:"
-    file_order.each {|source_file| add_file source_file }
-    execute_compile(output_file)
+    puts Colors.green("Compressing: #{@source}")
+    puts Colors.red "Compressor Output:"
+    execute_compile
   end
 
   private
-  def	add_file(filename)
-    @cmd += " --js=#{filename}"
-  end
-
-  def get_source_files
-    Dir.glob File.join(@source_path,"/**/*.js")
-  end
-
-  def execute_compile(output_file)
-    @cmd += " --js_output_file #{output_file}"
+  def execute_compile
+    @cmd += " --js #{@source} --js_output_file #{@output}"
     `#{@cmd}`
-    puts Colors.green("compilted #{@source_files.size} javascript files into #{output_file}")
-    puts "------------------------------------------------------"
+    puts Colors.green("compressed #{@source} to #{@output}")
   end
 
   def cmd_prefix

data/lib/dependence/module_injector.rb

@@ -0,0 +1,28 @@
+# Wraps code in a closure that provides an exports object to attach properties to the global namespace
+module ModuleInjector
+  extend self
+
+  @@module_code = <<MODULE_FUNC
+var global = (global != undefined)? global : window 
+
+if (global.module == undefined) {
+  global.module = function(name, body) {
+    var exports = global[name]
+    if (exports == undefined) {
+      global[name] = {}
+    }
+    body(exports)
+  }
+}
+MODULE_FUNC
+
+  def modularize(name, content)
+    module_code = <<-JS
+    #{@@module_code}
+
+    module('#{name.capitalize}', function(exports) {
+      #{content}
+    })
+    JS
+  end
+end

data/lib/dependence.rb

@@ -1,2 +1,8 @@
+require File.join(File.dirname(__FILE__), "dependence", "dependency_resolver.rb")
+require File.join(File.dirname(__FILE__), "dependence", "module_injector.rb")
 require File.join(File.dirname(__FILE__), 'dependence', 'js_compiler.rb')
 require File.join(File.dirname(__FILE__), "dependence", "file_watcher.rb")
+require File.join(File.dirname(__FILE__), "dependence", "concatenator.rb")
+
+module Dependence
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: dependence
 version: !ruby/object:Gem::Version 
-  hash: 23
-  prerelease: false
+  hash: 19
+  prerelease: 
   segments: 
   - 0
   - 0
-  - 4
-  version: 0.0.4
+  - 6
+  version: 0.0.6
 platform: ruby
 authors: 
 - Joshua Carver
@@ -15,8 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-07-11 00:00:00 -07:00
-default_executable: 
+date: 2011-08-22 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rgl
@@ -44,11 +43,12 @@ files:
 - bin/dependence
 - compiler/compiler.jar
 - lib/dependence/colors.rb
+- lib/dependence/concatenator.rb
 - lib/dependence/dependency_resolver.rb
 - lib/dependence/file_watcher.rb
 - lib/dependence/js_compiler.rb
+- lib/dependence/module_injector.rb
 - lib/dependence.rb
-has_rdoc: true
 homepage: 
 licenses: []
 
@@ -79,7 +79,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 1.8.7
 signing_key: 
 specification_version: 3
 summary: An easy way to handle your client side javascript dependencies