embarista 1.1.5 → 2.0.3

data/lib/embarista/filters/precompile_handlebars_filter.rb

@@ -1,10 +1,17 @@
-require 'barber'
-
 module Embarista
   module Filters
     class PrecompileHandlebarsFilter < Rake::Pipeline::Filter
-      def initialize(options= {}, &block)
+      def initialize(options={}, &block)
         @template_dir = options[:template_dir] || 'templates'
+        @templates_global = options[:templates_global] || 'Ember.TEMPLATES'
+
+        options[:handlebars] ||= default_handlebars_src
+        options[:ember_template_compiler] ||= default_ember_template_compiler_src
+
+        throw Embarista::PrecompilerConfigurationError.new('Must specify handlebars source path') unless options[:handlebars]
+        throw Embarista::PrecompilerConfigurationError.new('Must specify ember_template_compiler source path') unless options[:ember_template_compiler]
+        @handlebars_src = options[:handlebars]
+        @ember_template_compiler_src = options[:ember_template_compiler]
 
         super(&block)
         unless block_given?
@@ -21,11 +28,31 @@ module Embarista
           dirname.gsub!(/^\/?#{@template_dir}\/?/,'')
 
           full_name = [dirname, name].compact.reject(&:empty?).join('/')
-          compiled = Barber::Ember::FilePrecompiler.call(input.read)
+          compiled = precompile(input.read, @handlebars_src, @ember_template_compiler_src)
 
-          output.write "\nEmber.TEMPLATES['#{full_name}'] = #{compiled};\n"
+          output.write "\n#{@templates_global}['#{full_name}'] = #{compiled};\n"
         end
       end
+
+      def default_handlebars_src
+        Dir['app/vendor/handlebars-*'].last
+      end
+
+      def default_ember_template_compiler_src
+        Dir['app/vendor/ember-template-compiler-*.js'].last
+      end
+
+    private
+
+      def precompile(template_string, handlebars_src, ember_template_compiler_src)
+        precompiler = Embarista::Precompiler.new(
+          :handlebars => handlebars_src,
+          :ember_template_compiler => ember_template_compiler_src
+        )
+        compiled = precompiler.compile(template_string)
+        js = "Ember.Handlebars.template(#{compiled})"
+        "#{js};"
+      end
     end
   end
 end

data/lib/embarista/filters/rewrite_minispade_requires_filter.rb

@@ -14,15 +14,19 @@ module Embarista
           code = input.read
           #puts input.path
           relative_root = Pathname.new(input.path).dirname
-          code.gsub!(%r{\brequire(All)?\s*\(\s*(["'/])([^"']+)\2\s*}) do |m|
-            optional_all = $1
-            quote_char = $2
-            before_path = $3
+          code.gsub!(%r{(?<!\.)\brequire\s*\(\s*["']([^"']+)["']\s*}) do |m|
+            before_path = $1
             path = before_path.dup
             path = relative_root.join(path).to_s if path.start_with?('.')
-            path.gsub!(%r{^#{options[:root]}/}, options[:prefix]) if options[:root]
-            #puts "require#{optional_all}: #{before_path} -> #{path}"
-            "minispade.require#{optional_all}(#{quote_char}#{path}#{quote_char}"
+            path = path.gsub(%r{^#{options[:root]}/}, '') if options[:root]
+            path = options[:prefix] + path if options[:prefix] && !path.include?(':')
+            # puts "require: #{before_path} -> #{path}"
+            "minispade.require('#{path}'"
+          end
+          code.gsub!(%r{(?<!\.)\brequireAll\s*\(([^)]+)\)}) do |m|
+            regex = $1
+            # puts "requireAll: #{regex}"
+            "minispade.requireAll(#{regex})"
           end
           output.write(code)
         end

data/lib/embarista/helpers.rb

@@ -34,18 +34,18 @@ module Embarista
       match pattern, &JavascriptPipeline.new(opts)
     end
 
-    def sass_uncompressed(&block)
-      sass(:additional_load_paths => 'css',
-           :style => :expanded,
-           :line_comments => true,
-           &block)
-    end
-
-    def sass_compressed(&block)
-      sass(:additional_load_paths => 'css',
-           :style => :compressed,
-           :line_comments => false,
-           &block)
+    def sass_uncompressed(options={}, &block)
+      options[:additional_load_paths] ||= 'css'
+      options[:style] = :expanded
+      options[:line_comments] = true
+      sass(options, &block)
+    end
+
+    def sass_compressed(options={}, &block)
+      options[:additional_load_paths] ||= 'css'
+      options[:style] = :compressed
+      options[:line_comments] = false
+      sass(options, &block)
     end
 
     # rename "qunit-*.css" => "qunit.css"

data/lib/embarista/precompiler.rb

@@ -0,0 +1,84 @@
+require 'execjs'
+require 'json'
+
+module Embarista
+
+  class PrecompilerError < StandardError
+    def initialize(template, error)
+      @template, @error = template, error
+    end
+
+    def to_s
+      "Pre-compilation failed for: #{@template}\n. Compiler said: #{@error}"
+    end
+  end
+
+  class PrecompilerConfigurationError < StandardError
+    def initialize(message)
+      @message = message
+    end
+
+    def to_s
+      @message
+    end
+  end
+
+  class Precompiler
+    def initialize(opts)
+      throw PrecompilerConfigurationError.new('Must specify handlebars source path') unless opts[:handlebars]
+      throw PrecompilerConfigurationError.new('Must specify ember_template_compiler source path') unless opts[:ember_template_compiler]
+      @handlebars = File.new(opts[:handlebars])
+      @ember_template_precompiler = File.new(opts[:ember_template_compiler])
+    end
+
+    def compile(template)
+      context.call(
+        "EmberHandlebarsCompiler.precompile",
+        sanitize(template)
+      )
+    rescue ExecJS::ProgramError => ex
+      raise Embarista::PrecompilerError.new(template, ex)
+    end
+
+    def sources
+      [precompiler, handlebars, ember_template_precompiler]
+    end
+
+    attr_reader :handlebars, :ember_template_precompiler
+
+    def precompiler
+      @precompiler ||= StringIO.new(<<-JS)
+        var exports = this.exports || {};
+        function require() {
+          // ember-template-compiler only requires('handlebars')
+          return Handlebars;
+        }
+        // Precompiler
+        var EmberHandlebarsCompiler = {
+          precompile: function(string) {
+            return exports.precompile(string).toString();
+          }
+        };
+      JS
+    end
+
+
+  private
+
+    def sanitize(template)
+      begin
+        JSON.load(%Q|{"template":#{template}}|)['template']
+      rescue JSON::ParserError
+        template
+      end
+    end
+
+    def context
+      @context ||= ExecJS.compile(source)
+    end
+
+    def source
+      @source ||= sources.map(&:read).join("\n;\n")
+    end
+  end
+end

data/lib/embarista/redis.rb

@@ -0,0 +1,34 @@
+require 'uri'
+require 'timeout'
+
+module Embarista
+  module Redis
+    def self.client
+      $redis ||= begin
+        uri = URI.parse(url)
+        require 'redis'
+        ::Redis.new(
+          :host => uri.host,
+          :port => uri.port,
+          :password => uri.password
+        )
+      end
+    end
+
+    def self.url
+      ENV['REDISTOGO_URL'] ||= fetch_url
+    end
+
+    def self.fetch_url
+      if App.heroku_app
+        Bundler.with_clean_env do
+          Timeout::timeout(30) do
+            `heroku config:get REDISTOGO_URL --app #{App.heroku_app}`.chomp
+          end
+        end
+      else
+        'redis://0.0.0.0:6379/'
+      end
+    end
+  end
+end

data/lib/embarista/s3.rb

@@ -0,0 +1,59 @@
+require 'aws-sdk-s3'
+require 'zopfli'
+require 'mime/types'
+require 'open-uri'
+
+module Embarista
+  # Simple interface for S3
+  class S3
+    SHOULD_ADD_CHARSET_UTF8 = %w(.js .css .html .json .xml)
+    SHOULD_GZIP_BINARY = %w(.ttf .eot .otf)
+    SHOULD_GZIP_ENCODING = %w(8bit 7bit quoted-printable)
+    DEFAULT_MIME_TYPE = MIME::Types['application/octet-stream'].first
+
+    attr_reader :bucket_name, :age
+    def initialize(bucket_name, opts={})
+      s3 = Aws::S3::Resource.new
+      @bucket = s3.bucket(bucket_name)
+      @root = Pathname.new(opts[:root] || '').expand_path
+      @age = opts[:age] || 31536000
+    end
+
+    def store(name, file_or_path=name, opts={})
+      opts[:acl] ||= 'public-read'
+
+      puts "#{bucket_name} -> #{name}"
+      s3_object = @bucket.object(name)
+      if file_or_path.is_a?(String)
+        opts[:cache_control] = "max-age=#{age.to_i}"
+        opts[:expires] = (Time.now + age).httpdate
+        path = @root + file_or_path
+        ext = path.extname
+        mime_type = MIME::Types.type_for(ext).first || DEFAULT_MIME_TYPE
+        opts[:content_type] = mime_type.to_s
+        if SHOULD_ADD_CHARSET_UTF8.include?(ext)
+          opts[:content_type] += '; charset=utf-8'
+        end
+        if SHOULD_GZIP_ENCODING.include?(mime_type.encoding) or SHOULD_GZIP_BINARY.include?(ext)
+          opts[:content_encoding] = 'gzip'
+          s3_object.put(opts.merge(body: Zopfli.deflate(path.read, format: :gzip)))
+        else
+          s3_object.put(opts.merge(body: path.read))
+        end
+      else
+        s3_object.put(opts.merge(body: file_or_path))
+      end
+    end
+
+    def read(name, &block)
+      url = @bucket.object(name).public_url
+      if block_given?
+        open(url, &block)
+      else
+        open(url) {|io| io.read }
+      end
+    rescue ::AWS::S3::Errors::NoSuchKey
+      nil
+    end
+  end
+end

data/lib/embarista/s3sync.rb

@@ -1,44 +1,18 @@
+require 'embarista/s3'
+
 module Embarista
   class S3sync
-    attr_reader :origin, :bucket_name, :pwd, :tmp_root, :local_manifest_path, :remote_manifest_path
-
-    def initialize(origin, options)
-      @bucket_name = options.fetch(:bucket_name)
-      @local_manifest_path = options[:local_manifest_path]
-      @remote_manifest_path = options[:remote_manifest_path]
-      aws_key = options.fetch(:aws_key)
-      aws_secret = options.fetch(:aws_secret)
-
-      @connection = AWS::S3::Base.establish_connection!(
-        :access_key_id     => aws_key,
-        :secret_access_key => aws_secret
-      )
+    attr_reader :local_manifest_path, :remote_manifest_path, :s3
 
-      @pwd = Pathname.new('').expand_path
-      @origin = origin
-      @tmp_root = @pwd + @origin
-      @age = options[:age] || 31556900
+    def initialize(root, opts={})
+      @local_manifest_path = opts[:local_manifest_path]
+      @remote_manifest_path = opts[:remote_manifest_path]
+      @root = Pathname.new(root).expand_path
+      @s3 = S3.new(opts.fetch(:bucket_name), root: root) 
     end
 
-    def self.sync(origin, options)
-      new(origin, options).sync
-    end
-
-    def store(name, file)
-      puts " -> #{name}"
-
-      opts = {
-        access: :public_read
-      }
-
-      if should_gzip?(name)
-        opts[:content_encoding] = 'gzip'
-      end
-
-      opts[:cache_control] = "max-age=#{@age.to_i}"
-      opts[:expires] = (Time.now + @age).httpdate
-
-      AWS::S3::S3Object.store(name, file, bucket_name, opts)
+    def self.sync(root, opts={})
+      new(root, opts).sync
     end
 
     def sync
@@ -50,43 +24,12 @@ module Embarista
       end
 
       delta_manifest.values.each do |file_name|
-        compressed_open(file_name) do |file|
-          store(file_name, file)
-        end
-      end
-
-      open(local_manifest_path) do |file|
-        store(remote_manifest_file_name, file)
-        store(local_manifest_file_name, file)
-      end
-    end
-
-    def compressed_open(file_name)
-      if should_gzip?(file_name)
-        str_io = StringIO.new
-        open(tmp_root.to_s + file_name) do |f|
-          streaming_deflate(f, str_io)
-        end
-        str_io.reopen(str_io.string, "r")
-        yield str_io
-        str_io.close
-      else
-        open(tmp_root.to_s + file_name) do |f|
-          yield f
-        end
+        file_name[0] = ''
+        s3.store(file_name)
       end
-    end
-
-    def streaming_deflate(source_io, target_io, buffer_size = 4 * 1024)
-      gz = Zlib::GzipWriter.new(target_io, Zlib::BEST_COMPRESSION)
-      while(string = source_io.read(buffer_size)) do
-        gz.write(string)
-      end
-      gz.close
-    end
 
-    def should_gzip?(name)
-      name =~ /\.css|\.js\Z/
+      s3.store(remote_manifest_file_name, local_manifest_path)
+      s3.store(local_manifest_file_name, local_manifest_path)
     end
 
     def remote_manifest_file_name
@@ -106,13 +49,18 @@ module Embarista
     end
 
     def remote_manifest
-      @remote_manifest ||= YAML.load(AWS::S3::S3Object.find(remote_manifest_file_name, bucket_name).value)
-    rescue AWS::S3::NoSuchKey
-      puts 'no remote existing manifest, uploading everything'
+      @remote_manifest ||= begin
+        if remote_manifest = s3.read(remote_manifest_file_name)
+          YAML.load(remote_manifest)
+        else
+          puts 'no remote existing manifest, uploading everything'
+          nil
+        end
+      end
     end
 
     def local_manifest
-      @local_manifest ||= YAML.load_file(local_manifest_path)
+      @local_manifest ||= YAML.load_file(@root + local_manifest_path)
     end
   end
 end

data/lib/embarista/sass_functions.rb

@@ -2,7 +2,7 @@ module Embarista
   module SassFunctions
     def manifest_url(path)
       digested_path = lookup_manifest_path(path.value)
-      Sass::Script::String.new("url(#{digested_path})")
+      Sass::Script::String.new("url(#{URI.encode(digested_path)})")
     end
 
     def manifest_path(path)
@@ -13,7 +13,7 @@ module Embarista
   private
 
     def manifest
-      @_manifest ||= begin
+      @@_manifest ||= begin
         # TODO: some switch so that this doesn't run in dev?
         manifest_path = 'public/manifest.yml'
         return {} unless File.exist?(manifest_path)
@@ -22,12 +22,22 @@ module Embarista
     end
 
     def lookup_manifest_path(path)
-      if digest?
-        raise ::Sass::SyntaxError.new "manifest-url(#{path.inspect}) missing manifest entry" unless manifest.key? path
-        manifest[path]
-      else
-        path
+      # take the anchor/querystring off if there is one
+      post_path_start = path.index(/[?#]/)
+      if post_path_start
+        post_path = path[post_path_start..-1]
+        path = path[0..post_path_start-1]
       end
+
+      resolved_path = if digest?
+                        raise ::Sass::SyntaxError.new "manifest-url(#{path.inspect}) missing manifest entry" unless manifest.key? path
+                        manifest[path]
+                      else
+                        path
+                      end
+
+      # put the anchor/querystring back on, if there is one
+      "#{resolved_path}#{post_path}"
     end
 
     def digest?