jsus 0.3.4 → 0.3.5

data/lib/jsus/container.rb

@@ -128,26 +128,33 @@ module Jsus
           end
         end
       end
-      result = []
-      if Jsus.look_for_cycles?
-        cycles = graph.cycles
-        error_msg = []
-        unless cycles.empty?
-          error_msg << "Jsus has discovered you have circular dependencies in your code."
-          error_msg << "Please resolve them immediately!"
-          error_msg << "List of circular dependencies:"
-          cycles.each do |cycle|
-            error_msg << "-" * 30
-            error_msg << (cycle + [cycle.first]).map {|sf| sf.filename}.join(" => ")
-          end
-          error_msg = error_msg.join("\n")
-          Jsus.logger.fatal(error_msg)
-        end
+
+      begin
+        graph.topsorted_vertices
+      rescue RGL::TopsortedGraphHasCycles => e
+        output_cycles(graph)
+        raise e # fail fast
       end
-      graph.topsort_iterator.each { |item| result << item }
-      result
     end
 
+    # @api private
+    def output_cycles(graph)
+      cycles = graph.cycles
+      error_msg = []
+      unless cycles.empty?
+        error_msg << "Jsus has discovered you have circular dependencies in your code."
+        error_msg << "Please resolve them immediately!"
+        error_msg << "List of circular dependencies:"
+        cycles.each do |cycle|
+          error_msg << "-" * 30
+          error_msg << (cycle + [cycle.first]).map {|sf| sf.filename}.join(" => ")
+        end
+        error_msg << "-" * 30
+        error_msg = error_msg.join("\n")
+        Jsus.logger.fatal(error_msg)
+      end
+    end # output_cycles
+
     # Cached map of dependencies pointing to source files.
     # @return [Hash]
     # @api private

data/lib/jsus/middleware.rb

@@ -36,14 +36,15 @@ module Jsus
     class << self
       # Default settings for Middleware
       DEFAULT_SETTINGS = {
-        :packages_dir     => ".",
-        :cache            => false,
-        :cache_path       => nil,
-        :prefix           => "jsus",
-        :cache_pool       => true,
-        :includes_root    => ".",
-        :log_method       => nil, # [:alert, :html, :console]
-        :postproc         => []   # ["mooltie8", "moocompat12"]
+        :packages_dir       => ".",
+        :cache              => false,
+        :cache_path         => nil,
+        :prefix             => "jsus",
+        :cache_pool         => true,
+        :includes_root      => ".",
+        :compression_method => :yui, # :yui, :frontcompiler, :uglifier, :closure
+        :log_method         => nil,  # [:alert, :html, :console]
+        :postproc           => []    # ["mooltie8", "moocompat12"]
       }.freeze
 
       # @return [Hash] Middleware current settings
@@ -175,7 +176,7 @@ module Jsus
       files = path_string_to_files(path_string)
       if !files.empty?
         response = Container.new(*files).map {|f| f.content }.join("\n")
-        response = Jsus::Util::Compressor.new(response).result if request_options[:compress]
+        response = Jsus::Util::Compressor.compress(response, :method => self.class.settings[:compression_method]) if request_options[:compress]
         respond_with(response)
       else
         not_found!

data/lib/jsus/package.rb

@@ -27,7 +27,7 @@ module Jsus
       elsif File.exists?(File.join(directory, 'package.json'))
         self.header           = JSON.load(File.open(File.join(directory, 'package.json'), 'r:utf-8') {|f| f.read })
       else
-        Jsus::Middleware.errors << "Directory #{directory} does not contain a valid package.yml / package.json file!"
+        Jsus.logger.fatal "Directory #{directory} does not contain a valid package.yml / package.json file!"
         raise "Directory #{directory} does not contain a valid package.yml / package.json file!"
       end
       Dir.chdir(directory) do

data/lib/jsus/util.rb

@@ -9,5 +9,25 @@ module Jsus
     autoload :FileCache,     'jsus/util/file_cache'
     autoload :CodeGenerator, 'jsus/util/code_generator'
     autoload :Logger,        'jsus/util/logger'
+    autoload :Watcher,       'jsus/util/watcher'
+
+    class <<self
+      # Tries to load given gem.
+      # @param [String] gemname gem name
+      # @param [String, nil] lib path to load. When set to nil, uses gemname
+      #    param
+      # @return [Boolean] true if that lib could be required, false otherwise
+      # @api semipublic
+      def try_load(gemname, lib = nil)
+        required_file = lib || gemname
+        begin
+          require(required_file)
+          true
+        rescue LoadError
+          Jsus.logger.error %{ERROR: missing file #{required_file}}
+          false
+        end
+      end
+    end # class <<self
   end # Util
 end # Jsus

data/lib/jsus/util/compressor.rb

@@ -1,21 +1,72 @@
 module Jsus
   module Util
-    class Compressor
-      attr_reader :result
-      def initialize(source, options = {}) # todo - non-java compressor
-        @result = compress_with_yui(source)
-      end # initialize
+    module Compressor
+      class <<self
+        # Compresses the javascript source with given compressor and returns
+        # the result.
+        #
+        # @param [String] source javascript source code
+        # @param [Hash] options
+        # @option [Symbol] (:yui) method compressor to use.
+        #   Available methods: :uglifier, :frontcompiler, :closure, :yui
+        # @return [String] compressed js code
+        # @api public
+        def compress(source, options = {})
+          method = options.fetch(:method, :yui)
+          @result = case method.to_s
+            when "uglifier" then compress_with_uglifier(source)
+            when "frontcompiler" then compress_with_frontcompiler(source)
+            when "closure" then compress_with_closure(source)
+            when "yui" then compress_with_yui(source)
+            else
+              Jsus.logger.error "tried to use unavailable method #{method.inspect}"
+              source
+          end
+        end # compress
 
-      def compress_with_yui(source)
-        begin
-          require 'yui/compressor'
-          compressor = YUI::JavaScriptCompressor.new(:munge => true)
-          compressed_content = compressor.compress(source)
-        rescue LoadError
-          Jsus.logger.fatal 'ERROR: You need "yui-compressor" gem in order to use --compress option'
-        end
-        compressed_content
-      end # compress_with_yui
-    end # class Compressor
+        private
+
+        # @api private
+        def compress_with_yui(source)
+          try_compress(source, "yuicompressor") do
+            YUICompressor.compress_js(source, :munge => true)
+          end
+        end # compress_with_yui
+
+        # @api private
+        def compress_with_uglifier(source)
+          try_compress(source, "uglifier") do
+            Uglifier.compile(source, :squeeze => true, :copyright => false)
+          end
+        end # compress_with_uglifier
+
+        # @api private
+        def compress_with_frontcompiler(source)
+          try_compress(source, 'front-compiler') do
+            FrontCompiler.new.compact_js(source)
+          end
+        end # compress_with_frontcompiler
+
+        # @api private
+        def compress_with_closure(source)
+          try_compress(source, 'closure-compiler') do
+            Closure::Compiler.new.compile(source)
+          end
+        end # compress_with_closure
+
+        # @api private
+        def try_compress(source, library, libname = nil)
+          if Jsus::Util.try_load(library, libname) then
+            yield
+          else
+            source
+          end
+        rescue Exception => e
+          Jsus.logger.error "#{library} could not compress the file, exception raised #{e}\n" <<
+                            "Returning initial source"
+          source
+        end # try_compress
+      end # class <<self
+    end # module Compressor
   end # module Util
 end # module Jsus

data/lib/jsus/util/watcher.rb

@@ -0,0 +1,79 @@
+class Jsus::Util::Watcher
+  class << self
+    # Watches input directories and their subdirectories for changes in
+    # js source files and package metadata files.
+    # @param [String, Array] input_dirs directory or directories to watch
+    # @yield [filename] Callback to trigger on creation / update / removal of
+    #        any file in given directories
+    # @yieldparam [String] filename Updated filename full path
+    # @return [FSSM::Monitor] fssm monitor instance
+    # @api public
+    def watch(input_dirs, &callback)
+      new(input_dirs, &callback)
+    end
+  end
+
+  # Instantiates a FSSM monitor and starts watching. Consider using class method
+  # Jsus::Util::Watcher.watch instead.
+  # @see .watch
+  # @api semipublic
+  def initialize(input_dirs, &callback)
+    require 'fssm'
+    @callback = callback
+    input_dirs = Array(input_dirs).compact
+    @semaphore = Mutex.new
+    watcher = self
+    FSSM.monitor do
+      input_dirs.each do |dir|
+        dir = File.expand_path(dir)
+        path(dir) do
+          glob ["**/*.js", "**/package.yml", "**/package.json"]
+          create &watcher.method(:watch_callback)
+          update &watcher.method(:watch_callback)
+          delete &watcher.method(:watch_callback)
+        end
+      end
+    end
+
+  rescue LoadError => e
+    Jsus.logger.error "You need to install fssm gem for --watch option."
+    Jsus.logger.error "You may also want to install rb-fsevent for OS X" if RUBY_PLATFORM =~ /darwin/
+    raise e
+  end
+
+  # Default callback for the FSSM watcher.
+  # @note Defers the processing to a separate thread and ignores all the incoming
+  #       events received during the processing.
+  # @param [String] base base part of filename
+  # @param [String] match matched part of filename
+  # @api semipublic
+  def watch_callback(base, match)
+    Thread.new do
+      run do
+        full_path = File.join(base, match)
+        @callback.call(full_path)
+      end
+    end
+  end # watch_callback
+
+  # @api semipublic
+  def run
+    if @semaphore.try_lock
+      begin
+        yield
+      rescue Exception => e
+        Jsus.logger.error "Exception happened during watching: #{e}, #{e.inspect}"
+        Jsus.logger.error "\t#{e.backtrace.join("\n\t")}" if Jsus.verbose?
+        Jsus.logger.error "Compilation FAILED."
+      ensure
+        @semaphore.unlock
+      end
+    end
+  end # run
+
+  # @return [Boolean]
+  # @api public
+  def running?
+    @semaphore.locked?
+  end # running?
+end

data/spec/benchmarks/topsort.rb

@@ -0,0 +1,29 @@
+require 'benchmark'
+require 'rubygems'
+require 'rgl/adjacency'
+require 'rgl/topsort'
+$:.unshift(File.expand_path("../../../lib/", __FILE__))
+require 'extensions/rgl'
+
+edges = [[
+  1,3,  1,4,
+  2,3,
+  3,7,
+  4,7,
+  5,6,
+  6,7,
+  7,8
+]] * 10
+
+edges.each_with_index do |v_list, i|
+  v_list.each {|v| v += i * 100 }
+end
+
+edges.flatten!
+
+n = 5_000
+graph = RGL::DirectedAdjacencyGraph[*edges]
+Benchmark.bmbm do |x|
+  x.report("default") { n.times { graph.topsort_iterator.to_a ; graph.cycles.to_a  } }
+  x.report("custom") { n.times { graph.topsorted_vertices }  }
+end

data/spec/data/ComplexDependencies/Mootools/Source/Core.js

@@ -15,6 +15,8 @@ provides: [Core]
 ...
 */
 
+var Core = {};
+
 //<ltIE8>
 var IE7 = true;
 //</ltIE8>

data/spec/extensions/rgl_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe "RGL extensions" do
+  describe "DirectedAdjacencyGraph#topsorted_vertices" do
+    let(:edges) do
+      [
+        1,3,  1,4,
+        2,3,
+        3,7,
+        4,7,
+        5,6,
+        6,7,
+        7,8
+      ]
+    end
+    subject { RGL::DirectedAdjacencyGraph[*edges] }
+    it "should return list of topologically sorted vertices" do
+      result = subject.topsorted_vertices
+      result.index(1).should < result.index(3)
+      result.index(2).should < result.index(3)
+      result.index(1).should < result.index(4)
+      result.index(1).should < result.index(7)
+      result.index(5).should < result.index(6)
+      result.index(5).should < result.index(7)
+      result.index(6).should < result.index(7)
+      result.index(7).should < result.index(8)
+    end
+
+    it "should throw an exception if graph contains cycles" do
+      subject.add_edge(7,2)
+      lambda { subject.topsorted_vertices }.should raise_error(RGL::TopsortedGraphHasCycles)
+    end
+  end
+end

data/spec/jsus/middleware_spec.rb

@@ -281,7 +281,7 @@ describe Jsus::Middleware do
   describe "post processing" do
     let(:packages_dir) { File.expand_path("spec/data/ComplexDependencies") }
     before(:each) { Jsus::Middleware.settings = {:packages_dir => packages_dir} }
-    let("path") { "/javascripts/jsus/require/Package.js" }
+    let(:path) { "/javascripts/jsus/require/Package.js" }
     it "should not do anything if postprocs setting is empty" do
       Jsus::Middleware.settings = {:postproc => []}
       get(path).body.should include("//<ltIE8>")
@@ -305,6 +305,28 @@ describe Jsus::Middleware do
     end
   end # describe "post processing"
 
+  describe "compression" do
+    let(:packages_dir) { File.expand_path("spec/data/ComplexDependencies") }
+    before(:each) { described_class.settings = {:packages_dir => packages_dir} }
+    let(:path) { "/javascripts/jsus/compressed/Package.js" }
+
+    it "should be successful" do
+      get(path).should be_successful
+    end
+
+    it "should respond with type text/javascript" do
+      get(path).content_type.should == "text/javascript"
+    end
+
+    it "should respond with generated content" do
+      get(path).body.should =~ /var.*Core/
+    end
+
+    it "should compress the code" do
+      get(path).body.should_not include("/*")
+    end
+  end # describe "compression"
+
   describe "errors logging" do
     let(:packages_dir) { File.expand_path("spec/data/MissingDependencies") }
     before(:each) { Jsus::Middleware.settings = {:packages_dir => packages_dir} }

data/spec/jsus/util/compressor_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe Jsus::Util::Compressor do
+  let(:source) { File.read("spec/data/test_source_one.js") }
+  describe ".compress" do
+    it "should take source and compress it with some default params" do
+      result = described_class.compress(source)
+      result.should include("var TestSourceOne")
+    end
+
+    # To test actual compression, we check for removal of comments which is
+    # not the only criterion, but the easiest one to check
+
+    it "should accept :yui for method" do
+      result = described_class.compress(source, :method => :yui)
+      result.should include("var TestSourceOne")
+      result.should_not include("/*")
+    end
+
+    it "should accept :uglifier for method" do
+      result = described_class.compress(source, :method => :uglifier)
+      result.should include("var TestSourceOne")
+      result.should_not include("/*")
+    end
+
+    it "should accept :frontcompiler for method" do
+      result = described_class.compress(source, :method => :frontcompiler)
+      result.should include("var TestSourceOne")
+      result.should_not include("/*")
+    end
+
+    it "should accept :closure for method" do
+      result = described_class.compress(source, :method => :closure)
+      result.should include("var TestSourceOne")
+      result.should_not include("/*")
+    end
+
+    it "should accept strings for methods" do
+      result = described_class.compress(source, :method => "yui")
+      result.should include("var TestSourceOne")
+      result.should_not include("/*")
+    end
+  end
+end