guard-templates 0.0.1

data/lib/guard/compilers.rb

@@ -0,0 +1,13 @@
+require 'execjs'
+
+module Guard
+  class Templates < Guard
+    module Compilers
+      def self.compile_jade(str)
+        jade = File.read(File.join(Pathname.new(__FILE__).dirname.to_s, '../engines/jade.js'))
+        ExecJS.compile("window = {}; #{jade}").eval("window.jade.compile(#{str.dump}, {client:true, compileDebug:false}).toString()")
+        
+      end
+    end
+  end
+end

data/lib/guard/templates/templates/Guardfile

@@ -0,0 +1,11 @@
+# Example guardfile for guard-templates
+#
+# by default, output to a single .js file in public/javascript/templates.js
+# if you'd like to compile each template to an individual .js file,
+# change :output to a directory path instead
+#
+# see https://github.com/thegreatape/guard-templates for more options
+guard 'templates', :output => 'public/javascript/templates.js', :namespace => 'MyApp' do
+  # change this regex to match your source files
+  watch(/app\/javascripts\/templates\/(.*)\.jade$/)
+end

data/lib/guard/templates.rb

@@ -0,0 +1,115 @@
+require "guard"
+require "guard/guard"
+require 'guard/compilers'
+
+module Guard
+  class Templates < Guard
+
+    DEFAULTS = { 
+      :namespace => 'this'
+    }
+
+    # Initialize a Guard.
+    # @param [Array<Guard::Watcher>] watchers the Guard file watchers
+    # @param [Hash] options the custom Guard options
+    def initialize(watchers = [], options = {})
+      @watchers = watchers
+      @options = DEFAULTS.clone.merge(options)
+      @single_file_mode = @options[:output].match(/\.js$/)
+      super(watchers, @options)
+    end
+
+    # Call once when Guard starts. Please override initialize method to init stuff.
+    # @raise [:task_has_failed] when start has failed
+    def start
+      run_all
+    end
+
+    # Called when `stop|quit|exit|s|q|e + enter` is pressed (when Guard quits).
+    # @raise [:task_has_failed] when stop has failed
+    def stop
+    end
+
+    # Called when `reload|r|z + enter` is pressed.
+    # This method should be mainly used for "reload" (really!) actions like reloading passenger/spork/bundler/...
+    # @raise [:task_has_failed] when reload has failed
+    def reload
+    end
+
+    # Called when just `enter` is pressed
+    # This method should be principally used for long action like running all specs/tests/...
+    # @raise [:task_has_failed] when run_all has failed
+    def run_all
+      run_on_change(Watcher.match_files(self, Dir.glob('**/*')))
+    end
+
+    # Called on file(s) modifications that the Guard watches.
+    # @param [Array<String>] paths the changes files or paths
+    # @raise [:task_has_failed] when run_on_change has failed
+    def run_on_change(paths)
+      templates = {}
+      paths.each do |path|
+        @watchers.each do |watcher|
+          if target = get_target(path, watcher)
+            contents = File.read(path)
+            if @single_file_mode
+              templates[target] = contents
+            else
+              dir = Pathname.new(target[:path]).dirname.to_s
+              FileUtils.mkdir_p(dir) if !File.exist?(dir)
+              File.open(target[:path], 'w') do |f|
+                f.write("#{@options[:namespace]}['#{target[:name]}'] = #{compile(contents, target[:type])}") 
+              end
+            end
+          end
+        end
+      end
+      if @single_file_mode
+        File.open(@options[:output], 'w') do |f|
+          js = templates.map{|target,content| "#{target[:name].dump}: #{compile(content, target[:type])}" }.join(",\n")
+          f.write "#{@options[:namespace]}.templates = {#{js}}"
+        end
+      end
+    end
+
+    # Called on file(s) deletions that the Guard watches.
+    # @param [Array<String>] paths the deleted files or paths
+    # @raise [:task_has_failed] when run_on_change has failed
+    def run_on_deletion(paths)
+      matched = false
+      paths.each do |path|
+        @watchers.each do |watcher|
+          if target = get_target(path, watcher) 
+            matched = true
+            FileUtils.rm target[:path] unless @single_file_mode 
+          end
+        end
+      end
+
+      # this is slow, but works. would be better to do a eval + series of deletes, 
+      # but how to re-serialize the js object?
+      run_all if @single_file_mode && matched
+    end
+
+    private
+    def get_target(path, watcher)
+      if match = path.match(watcher.pattern)
+        subpath = match[1]
+        jspath = File.join(@options[:output], "#{subpath}.js")
+
+        {:name => subpath, 
+         :type => File.extname(path).gsub(/^\./,''),
+         :path => jspath} 
+      end
+    end
+
+    def compile(str, type)
+      if Compilers.methods.include?("compile_#{type}")
+        Compilers.send("compile_#{type}", str)
+      else
+        str.dump
+      end
+    end
+    
+  end
+end

data/spec/guard-templates-spec.rb

@@ -0,0 +1,202 @@
+require "rubygems"
+require "bundler/setup"
+require 'execjs'
+require 'fakefs/safe'
+
+require 'guard/templates'
+require 'guard/watcher'
+
+# ExecJS needs real filesystem access to find the js engine
+def eval_js(str, context='')
+  FakeFS.deactivate!
+  result = ExecJS.compile(context).eval(str)
+  FakeFS.activate!
+  result
+end
+
+module ExecJS
+  class << self
+    alias :old_compile :compile
+    def compile(source, *args)
+      FakeFS.deactivate!
+      result = self.old_compile(source, *args)
+      FakeFS.activate!
+      result
+    end
+  end
+end
+
+ExecJS.runtime.class.const_get('Context').class_eval do
+  alias :old_eval :eval
+  def eval(source, options={})
+    FakeFS.deactivate!
+    result = old_eval(source, options)
+    FakeFS.activate!
+    result
+  end
+end
+
+
+describe Guard::Templates do 
+  before(:each) do
+    # have to write js libs to FakeFS post-fake-activation
+    js_src = File.join(Pathname.new(__FILE__).dirname.to_s, '../lib/engines/')
+    libs = Dir.glob(File.join(js_src, "*.js")).map do |path|
+      [File.basename(path), File.read(path)]
+    end
+    FakeFS.activate!
+    FileUtils.mkdir_p 'lib/engines'
+    FileUtils.mkdir_p 'javascripts/templates'
+    FileUtils.mkdir_p 'public/templates'
+    libs.each do |name, content|
+      File.open("lib/engines/#{name}", 'w') {|f| f.write(content)}
+    end
+  end
+
+  after(:each) do
+    FileUtils.rm_rf 'javascripts'
+    FileUtils.rm_rf 'public'
+    FakeFS.deactivate!
+  end
+
+  describe "#run_on_change" do
+    before(:each) do
+      @content = "<div>\n  {{foo}}\n</div>"
+      @template = 'javascripts/templates/home.handlebars'
+      File.open(@template, 'w') {|f| f.write(@content)}
+    end
+
+    it "should create a new file with the stringifed template" do
+      @guard_templates = Guard::Templates.new([Guard::Watcher.new(/javascripts\/templates\/(.*)\.handlebars/)],
+                                              :output => 'public/templates')
+      @guard_templates.run_on_change [@template]
+      File.exists?('public/templates/home.js').should == true
+      File.read('public/templates/home.js').should == "this['home'] = #{@content.dump}"
+    end
+
+    it "should write the template with a namespace" do
+      @guard_templates = Guard::Templates.new([Guard::Watcher.new(/javascripts\/templates\/(.*)\.handlebars/)],
+                                              :output => 'public/templates',
+                                              :namespace => 'App.Jawesome')
+      @guard_templates.run_on_change [@template]
+      File.read('public/templates/home.js').should == "App.Jawesome['home'] = #{@content.dump}"
+    end
+
+    it "should write the templates to a single file when output has a .js extension" do
+      wombat_template = 'javascripts/templates/wombat.handlebars'
+      wombat_content = '<span>{{wombat}}</span>'
+      File.open(wombat_template, 'w') {|f| f.write(wombat_content)}
+      @guard_templates = Guard::Templates.new([Guard::Watcher.new(/javascripts\/templates\/(.*)\.handlebars/)],
+                                              :output => 'public/templates/templates.js')
+      @guard_templates.run_on_change [@template, wombat_template]
+      File.exists?('public/templates/home.js').should == false
+      File.exists?('public/templates/wombat.js').should == false
+      File.exists?('public/templates/templates.js').should == true
+      templates = eval_js File.read('public/templates/templates.js')
+      templates.keys.should =~ ['home', 'wombat']
+      templates['wombat'].should == wombat_content 
+      templates['home'].should == @content
+    end
+
+    it "should compile jade to native functions" do
+      jade_template = 'javascripts/templates/jade-test.jade'
+      jade_content = '.greetings O HAI'
+      File.open(jade_template, 'w') {|f| f.write(jade_content)}
+      @guard_templates = Guard::Templates.new([Guard::Watcher.new(/javascripts\/templates\/(.*)\.jade/)],
+                                              :namespace => 'app',
+                                              :output => 'public/templates')
+      @guard_templates.run_on_change [jade_template]
+      File.exists?('public/templates/jade-test.js').should == true
+      compiled = File.read('public/templates/jade-test.js')
+      jade = File.read('lib/engines/jade-runtime.js')
+      context = %{var window = {}, app = {};
+                  #{jade}
+                  #{compiled} }
+      fn = "app['jade-test']()"
+      eval_js(fn, context).should == '<div class="greetings">O HAI</div>'
+    end
+
+    it "should compile jade to native functions in single-file mode" do
+      jade_template = 'javascripts/templates/jade-test.jade'
+      jade_content = '.greetings O HAI'
+      File.open(jade_template, 'w') {|f| f.write(jade_content)}
+      @guard_templates = Guard::Templates.new([Guard::Watcher.new(/javascripts\/templates\/(.*)\.jade/)],
+                                              :namespace => 'app',
+                                              :output => 'public/templates/all.js')
+      @guard_templates.run_on_change [jade_template]
+      File.exists?('public/templates/all.js').should == true
+      File.exists?('public/templates/jade-test.js').should == false
+      compiled = File.read('public/templates/all.js')
+      jade = File.read('lib/engines/jade-runtime.js')
+      context = %{var window = {}, app = {};
+                  #{jade}
+                  #{compiled} }
+      fn = "app.templates['jade-test']()"
+      eval_js(fn, context).should == '<div class="greetings">O HAI</div>'
+    end
+  end
+
+  describe "#run_on_deletion" do
+    it "should delete output files with source files are deleted" do
+      src_path = 'javascripts/templates/home.handlebars'
+      dst_path = 'public/templates/home.js'
+      File.open(src_path, 'w') {|f| f.write('<div>{foo}</div>')}
+      File.open(dst_path, 'w') {|f| f.write('var home = "<div>{foo}</div>"')}
+      @guard_templates = Guard::Templates.new([Guard::Watcher.new(/javascripts\/templates\/(.*)\.handlebars/)],
+                                              :output => 'public/templates')
+      FileUtils.rm(src_path)
+      @guard_templates.run_on_deletion(src_path)
+      File.exists?(dst_path).should == false
+    end
+
+    it "should delete multiple files correctly" do
+      srcs = ['foo', 'bar', 'goats']
+      srcs.each do |s| 
+        File.open("javascripts/templates/#{s}.handlebars", 'w') {|f| f.write('<div>{foo}</div>')}
+        File.open("public/templates/#{s}.js", 'w') {|f| f.write("this['#{s}'] = '<div>{foo}</div>'")}
+      end
+      File.open("javascripts/templates/dont_delete_me_bro.handlebars", 'w') {|f| f.write('<div>{foo}</div>')}
+      @guard_templates = Guard::Templates.new([Guard::Watcher.new(/javascripts\/templates\/(.*)\.handlebars/)],
+                                              :output => 'public/templates')
+
+      srcs.each{|s| FileUtils.rm "javascripts/templates/#{s}.handlebars"}
+      @guard_templates.run_on_deletion(srcs.map{|s| "javascripts/templates/#{s}.handlebars"})
+      srcs.each{|s| File.exists?("public/templates/#{s}.js").should == false}
+    end
+
+    it "should delete entries in single file mode" do
+      src_path = 'javascripts/templates/home.handlebars'
+      File.open(src_path, 'w') {|f| f.write("<div>{foo}</div>")}
+      File.open('javascripts/templates/foo.handlebars', 'w') {|f| f.write('foo')}
+
+      dst_path = 'public/templates.js'
+      File.open(dst_path, 'w') {|f| f.write("this['templates'] = {home: 'home', foo: 'bar'}")}
+      @guard_templates = Guard::Templates.new([Guard::Watcher.new(/javascripts\/templates\/(.*)\.handlebars/)],
+                                              :output => 'public/templates.js')
+      eval_js(File.read(dst_path)).keys.should =~ ['home', 'foo']
+
+      FileUtils.rm(src_path)
+      @guard_templates.run_on_deletion([src_path])
+      templates = eval_js(File.read(dst_path))
+      templates.keys.should == ['foo']
+    end
+  end
+
+  describe '#run_all' do 
+    it "should compile everything" do
+      paths = ['foo', 'bar/baz', 'duck/duck/go']
+      paths.each do |p| 
+        target = "javascripts/templates/#{p}.handlebars"
+        FileUtils.mkdir_p Pathname.new(target).dirname.to_s
+        File.open(target, 'w') {|f| f.write(p)}
+      end
+      @guard_templates = Guard::Templates.new([Guard::Watcher.new(/javascripts\/templates\/(.*)\.handlebars/)],
+                                              :output => 'public/templates/')
+
+      @guard_templates.run_all
+      paths.each do |p| 
+        File.exists?("public/templates/#{p}.js").should == true
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,159 @@
+--- !ruby/object:Gem::Specification 
+name: guard-templates
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Thomas Mayfield
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-04-01 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: guard
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: execjs
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: json
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: fakefs
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id006
+description: Guard plugin for smart, automatic compilation of your Javascript template files into usable Javascript
+email: 
+- Thomas.Mayfield@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- guard-templates.gemspec
+- lib/engines/jade-runtime.js
+- lib/engines/jade.js
+- lib/guard/compilers.rb
+- lib/guard/templates.rb
+- lib/guard/templates/templates/Guardfile
+- spec/guard-templates-spec.rb
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: guard-templates
+rubygems_version: 1.8.17
+signing_key: 
+specification_version: 3
+summary: Javascript template compilation via Guard
+test_files: 
+- spec/guard-templates-spec.rb