coyote 1.1.0 → 1.2.0.rc1

data/lib/coyote/assets/coffeescript.rb

@@ -1,22 +1,16 @@
-module Coyote
-  class CoffeeScript < Asset
+module Coyote::Assets
+  class CoffeeScript < Base
+    require_pattern Regexp.new(/#=\s*require\s(.*)$/i)
+
     def update!
       super
       compile!
     end
-
-    protected
-
-    # Defines the regex pattern for scanning the contents of the
-    # file to look for require directives
-    def require_pattern
-      Regexp.new(/#=\s*require\s(.*)$/i)  # '#= require a/b/c.coffee' => 'a/b/c.coffee'
-    end
-
-    private
-
+    
     def compile!
-      @contents = `cat #{@absolute_path} | coffee -sc`
+      @contents = `cat #{@path} | coffee -sc`
+      self
     end
-  end
-end
+    
+  end    
+end

data/lib/coyote/assets/javascript.rb

@@ -1,4 +1,4 @@
-module Coyote
-  class JavaScript < Asset
-  end
-end
+module Coyote::Assets
+  class JavaScript < Base
+  end    
+end

data/lib/coyote/assets/less.rb

@@ -1,22 +1,27 @@
-module Coyote
-  class Less < Asset
-    def update!
-      super
-      compile!
-    end
+module Coyote::Assets
+  class Less < Base
+    require_pattern Regexp.new(/@import\s*['|"](.*)['|"]\s*;$/i)
+
 
-    protected
-    
-    # Defines the regex pattern for scanning the contents of the
-    # file to look for require directives
-    def require_pattern
-      Regexp.new(/\/\/=\s*require\s(.*)$/i)  # '//= require a/b/c.less' => 'a/b/c.less'
+    def find_dependencies
+      super
+      @dependencies.map! do |file|
+        path = File.expand_path(File.join(File.dirname(@relative_path), file))
+        if File.exists? path
+          file
+        elsif File.exists?(path + ".less")
+          file + ".less"
+        else
+          nil
+        end
+      end.compact!
     end
 
-    private
 
     def compile!
-      @contents = `lessc #{@absolute_path}`
+      @contents = `lessc #{@path}`
+      self
     end
-  end
-end
+
+  end    
+end

data/lib/coyote/bundles.rb

@@ -0,0 +1,22 @@
+require 'coyote/bundles/base'
+require 'coyote/bundles/javascript'
+require 'coyote/bundles/css'
+
+module Coyote
+  
+  module Bundle
+    def self.new(path)
+      Coyote::Bundles.choose(path)
+    end
+  end
+  
+  module Bundles
+    def self.choose(path)
+      case File.extname(path)
+      when /\.js/i      ; JavaScript.new(path)
+      when /\.css/i     ; CSS.new(path)
+      else              ; Base.new(path)
+      end
+    end
+  end
+end

data/lib/coyote/bundles/base.rb

@@ -0,0 +1,112 @@
+require 'coyote/assets'
+
+module Coyote::Bundles
+  class Base
+
+    class << self
+      def filetypes(*args)
+        @filetypes ||= args.map { |arg| arg.to_s.gsub('.','') } || []
+      end
+    end
+    
+    filetypes :js, :coffee, :css, :less
+
+    attr_accessor :contents
+    attr_reader :assets, :target
+    
+    def initialize(target)
+      @target = target
+      empty!
+    end
+
+    def add(input)
+      path = File.expand_path(input)
+      if File.directory? path
+        add_directory path
+      elsif File.exists? path
+        add_file path
+      else
+        notify "Could not find #{path}", :failure
+      end
+    end
+    
+    
+    def add_file(path)
+      return false unless path_is_directory_or_kosher_file?(path)
+      asset = Coyote::Asset.new(path)
+      @files.delete(path) 
+      @files << path
+      @assets[path] = asset
+      add_dependencies(asset)
+    end
+
+
+    def add_directory(dir_path)
+      Dir.foreach(dir_path) do |path|
+        next if path == '.' or path == '..'
+        path = "#{dir_path}/#{path}"
+        add path if path_is_directory_or_kosher_file?(path)
+      end
+    end
+
+
+    def add_dependencies(asset)
+      asset.dependencies.each do |dependency_path|
+        relative_directory = File.dirname asset.relative_path
+        add File.join relative_directory, dependency_path
+      end
+    end
+    
+
+    def path_is_directory_or_kosher_file?(path)
+      return true if File.directory?(path)        
+      self.class.filetypes.include? File.extname(path).gsub('.','')
+    end
+
+
+    def empty!
+      @assets = {}
+      @files = []
+    end
+
+  
+    def files
+      @files ||= []
+    end
+
+
+    def contents
+      @contents ||= files.reverse.map { |path| assets[path].contents }.join
+    end
+  
+  
+    def update!(changed_files=[])
+      reset!
+      changed_files.each { |path| assets[path].update! }
+    end
+  
+  
+    def manifest
+      files.reverse.map { |path| "+ #{path}" }.join("\n")
+    end
+  
+  
+    def reset!
+      @contents = nil      
+    end
+    
+    
+    def save!
+      File.open target, 'w+' do |file|
+        file.write contents
+      end      
+    end
+    
+
+    def compress!
+      self
+    end
+    
+
+  end
+end

data/lib/coyote/bundles/css.rb

@@ -0,0 +1,19 @@
+module Coyote::Bundles
+  class CSS < Base
+    filetypes :css, :less
+
+    def compress!
+      notify "Compressing bundle...", :warning, :timestamp
+      tmp = "#{@target}.#{Time.now.to_i}.less"
+      File.open(tmp, 'w+') { |f| f.write contents }
+      self.contents = `lessc #{tmp} -x`
+      File.delete tmp
+    end
+
+    def contents
+      @contents ||= @assets[files.first].compile!.contents
+    end
+
+  end
+end
+

data/lib/coyote/bundles/javascript.rb

@@ -0,0 +1,21 @@
+require 'coyote/closure_compiler'
+
+module Coyote::Bundles
+  class JavaScript < Base
+    filetypes :js, :coffee
+
+    def compress!
+      notify "Compressing bundle...", :warning, :timestamp
+      compiler = Coyote::ClosureCompiler.new.compile(self.contents)
+      if compiler.success?
+        self.contents = compiler.compiled_code
+      elsif compiler.file_too_big?
+        notify "Input code too big for API, creating uncompressed file\n", :failure
+      elsif compiler.errors
+        notify "Google closure API failed to compile, creating uncompressed file\n", :failure
+        notify "Errors:", :failure
+        notify "#{compiler.errors.to_s}", :failure
+      end      
+    end
+  end    
+end

data/lib/coyote/cli.rb

@@ -1,18 +1,17 @@
-require 'coyote'
 require 'optparse'
 
 options = {}
 OptionParser.new do |opts|
-  Coyote::options.each do |name|
+  ['compress', 'watch', 'quiet', 'version'].each do |name|
     opts.on("-#{name[0]}", "--#{name}", "#{name.capitalize}") { |o| options[name.to_sym] = o }
   end
 end.parse!
 
 if options[:version]
-  puts "coyote #{Coyote::VERSION}"
+  notify "Coyote #{Coyote::VERSION}"
   exit 0
 end
 
-input, output = ARGV[0].split(':', 2)
+input, output = ARGV.fetch(0, "").split(':', 2)
 
-Coyote::run(input, output, options)
+Coyote.compile(input, output, options)

data/lib/coyote/compiler.rb

@@ -0,0 +1,46 @@
+require 'coyote/bundles'
+require 'coyote/fs_listeners'
+
+module Coyote
+  class Compiler
+    attr_reader :bundle
+
+    def initialize(input, output, options={})
+      @options = options || {}
+      @output = output
+      @bundle = Coyote::Bundle.new(output)
+      @bundle.add(input)
+    end
+   
+    def compile!
+      save!
+      watch if @options.fetch(:watch, false)
+    end
+
+   
+    def save!
+      notify "\n" + @bundle.manifest unless @options.fetch(:quiet, false)
+      @bundle.compress! if @options.fetch(:compress, false)
+      @bundle.save!
+      notify "Saved bundle to #{@output}   [#{@bundle.files.length} files]", :timestamp, :success
+    end
+    
+    
+    def watch
+      listener = Coyote::FSListener.new
+
+      listener.on_change do |changed_files|
+        changed_files = @bundle.files & changed_files.map {|file| File.expand_path file }
+
+        if changed_files.length > 0
+          notify "Detected change, recompiling...", :warning, :timestamp
+          @bundle.update! changed_files
+          save!
+        end
+      end
+
+      notify "Watching for changes to your bundle. ctrl+c to stop.", :timestamp
+      listener.start
+    end
+  end
+end

data/lib/coyote/dsl.rb

@@ -0,0 +1,29 @@
+require 'coyote'
+
+module Coyote
+  class DSL
+    attr_accessor :input, :output, :options
+    
+    def initialize(&block)
+      config = Struct.new(:input, :output, :options).new
+      config.options = {}
+      yield config if block_given?
+      instance_eval(&block)
+      @input = config.input
+      @output = config.output
+      @options = config.options
+    end
+    
+    def run
+      Coyote.compile(@input, @output, @options)            
+    end
+  end
+end
+
+
+def coyote(*args, &block)
+  runner = Coyote::DSL.new(&block)
+  runner.run
+end
+
+

data/lib/coyote/fs_listeners.rb

@@ -0,0 +1,42 @@
+require 'coyote/fs_listeners/base'
+require 'coyote/fs_listeners/darwin'
+require 'coyote/fs_listeners/linux'
+require 'coyote/fs_listeners/windows'
+require 'coyote/fs_listeners/polling'
+
+
+module Coyote
+
+  module FSListener
+    def self.new
+      Coyote::FSListeners.choose
+    end
+  end
+
+  module FSListeners
+    def self.choose
+      if mac? && Darwin.usable?
+        Darwin.new
+      elsif linux? && Linux.usable?
+        Linux.new
+      elsif windows? && Windows.usable?
+        Windows.new
+      else
+        notify "Using polling (Please help us to support your system better than that.)", :failure
+        Polling.new
+      end
+    end
+  
+    def self.mac?
+      Config::CONFIG['target_os'] =~ /darwin/i
+    end
+  
+    def self.linux?
+      Config::CONFIG['target_os'] =~ /linux/i
+    end
+  
+    def self.windows?
+      Config::CONFIG['target_os'] =~ /mswin|mingw/i
+    end
+  end
+end

data/lib/coyote/fs_listeners/base.rb

@@ -0,0 +1,46 @@
+require 'digest'
+
+module Coyote::FSListeners
+  class Base
+    attr_reader :last_event, :sha1_checksums_hash
+
+    def initialize
+      @sha1_checksums_hash = {}
+      update_last_event
+    end
+
+    def update_last_event
+      @last_event = Time.now
+    end
+
+    def modified_files(dirs, options = {})
+      files = potentially_modified_files(dirs, options).select { |path| File.file?(path) && file_modified?(path) && file_content_modified?(path) }
+      files.map! { |file| file.gsub("#{Dir.pwd}/", '') }
+    end
+
+    private
+
+    def potentially_modified_files(dirs, options = {})
+      match = options[:all] ? "**/*" : "*"
+      Dir.glob(dirs.map { |dir| "#{dir}#{match}" })
+    end
+
+    def file_modified?(path)
+      # Depending on the filesystem, mtime is probably only precise to the second, so round
+      # both values down to the second for the comparison.
+      File.mtime(path).to_i >= last_event.to_i
+    rescue
+      false
+    end
+
+    def file_content_modified?(path)
+      sha1_checksum = Digest::SHA1.file(path).to_s
+      if @sha1_checksums_hash[path] != sha1_checksum
+        @sha1_checksums_hash[path] = sha1_checksum
+        true
+      else
+        false
+      end
+    end
+  end
+end