opal-sprockets 0.4.5.1.0.3.7 → 1.0.0

data/lib/opal/sprockets/processor.rb

@@ -3,158 +3,147 @@ require 'base64'
 require 'tilt/opal'
 require 'sprockets'
 require 'opal/builder'
-require 'opal/sprockets/path_reader'
+require 'opal/sprockets'
+
+# Internal: The Processor class is used to make ruby files (with .rb or .opal
+#   extensions) available to any sprockets based server. Processor will then
+#   get passed any ruby source file to build.
+class Opal::Sprockets::Processor
+  @@cache_key = nil
+  def self.cache_key
+    @@cache_key ||= ['Opal', Opal::VERSION, Opal::Config.config].to_json.freeze
+  end
 
-module Opal
-  # Internal: The Processor class is used to make ruby files (with .rb or .opal
-  #   extensions) available to any sprockets based server. Processor will then
-  #   get passed any ruby source file to build.
-  class Processor < TiltTemplate
+  def self.reset_cache_key!
     @@cache_key = nil
-    def self.cache_key
-      @@cache_key ||= ['Opal', Opal::VERSION, Opal::Config.config].to_json.freeze
+  end
+
+  def self.call(input)
+    data, map, dependencies, required = input[:cache].fetch([self.cache_key, input[:filename], input[:data]]) do
+      new(input).call
     end
 
-    def self.reset_cache_key!
-      @@cache_key = nil
+    if map
+      map = ::Sprockets::SourceMapUtils.combine_source_maps(input[:metadata][:map], map)
     end
 
-    def evaluate(context, locals, &block)
-      return super unless context.is_a? ::Sprockets::Context
+    {
+      data: data,
+      map: map,
+      dependencies: input[:metadata][:dependencies].to_a + dependencies.to_a,
+      required: input[:metadata][:required].to_a + required.to_a,
+    }
+  end
 
-      @sprockets = sprockets = context.environment
+  def initialize(input)
+    @input = input
+    @sprockets = input[:environment]
+    @context = sprockets.context_class.new(input)
+    @data = input[:data]
+  end
 
-      # In Sprockets 3 logical_path has an odd behavior when the filename is "index"
-      # thus we need to bake our own logical_path
-      filename = context.respond_to?(:filename) ? context.filename : context.pathname.to_s
-      root_path_regexp = Regexp.escape(context.root_path)
-      logical_path = filename.gsub(%r{^#{root_path_regexp}/?(.*?)#{sprockets_extnames_regexp}}, '\1')
+  attr_reader :input, :sprockets, :context, :data
 
-      compiler_options = self.compiler_options.merge(file: logical_path)
+  # In Sprockets 3 logical_path has an odd behavior when the filename is "index"
+  # thus we need to bake our own logical_path
+  def logical_path
+    @logical_path ||= context.filename.gsub(%r{^#{Regexp.escape(context.root_path)}/?(.*?)}, '\1')
+  end
 
-      compiler = Compiler.new(data, compiler_options)
-      result = compiler.compile
+  def call
+    compiler_options = Opal::Config.compiler_options.merge(requirable: true, file: logical_path)
 
-      process_requires(compiler.requires, context)
-      process_required_trees(compiler.required_trees, context)
+    compiler = Opal::Compiler.new(data, compiler_options)
+    result = compiler.compile
 
-      if Opal::Config.source_map_enabled
-        map_data = compiler.source_map.as_json
-        # Opal 0.11 doesn't fill sourcesContent
-        add_sources_content_if_missing(map_data, data)
-        "#{result}\n#{to_data_uri_comment(map_data.to_json)}"
-      else
-        result.to_s
-      end
-    end
+    process_requires(compiler.requires, context)
+    process_required_trees(compiler.required_trees, context)
 
-    def self.sprockets_extnames_regexp(sprockets)
-      joined_extnames = (['.js']+sprockets.engines.keys).map { |ext| Regexp.escape(ext) }.join('|')
-      Regexp.new("(#{joined_extnames})*$")
+    if Opal::Config.source_map_enabled
+      map = compiler.source_map.as_json.transform_keys!(&:to_s)
+      map["sources"][0] = input[:filename]
+      map = ::Sprockets::SourceMapUtils.format_source_map(map, input)
     end
 
-    def sprockets_extnames_regexp
-      @sprockets_extnames_regexp ||= self.class.sprockets_extnames_regexp(@sprockets)
-    end
+    [result.to_s, map , context.metadata[:dependencies], context.metadata[:required]]
+  end
 
-    def process_requires(requires, context)
-      requires.each do |required|
-        required = required.to_s.sub(sprockets_extnames_regexp, '')
-        context.require_asset required unless ::Opal::Config.stubbed_files.include? required
-      end
+  def sprockets_extnames_regexp
+    @sprockets_extnames_regexp ||= Opal::Sprockets.sprockets_extnames_regexp(@sprockets)
+  end
+
+  def process_requires(requires, context)
+    requires.each do |required|
+      required = required.to_s.sub(sprockets_extnames_regexp, '')
+      context.require_asset required unless ::Opal::Config.stubbed_files.include? required
     end
+  end
 
-    # Internal: Add files required with `require_tree` as asset dependencies.
-    #
-    # Mimics (v2) Sprockets::DirectiveProcessor#process_require_tree_directive
-    def process_required_trees(required_trees, context)
-      return if required_trees.empty?
+  # Internal: Add files required with `require_tree` as asset dependencies.
+  #
+  # Mimics (v2) Sprockets::DirectiveProcessor#process_require_tree_directive
+  def process_required_trees(required_trees, context)
+    return if required_trees.empty?
 
-      # This is the root dir of the logical path, we need this because
-      # the compiler gives us the path relative to the file's logical path.
-      dirname = File.dirname(file).gsub(/#{Regexp.escape File.dirname(context.logical_path)}#{REGEXP_END}/, '')
-      dirname = Pathname(dirname)
+    # This is the root dir of the logical path, we need this because
+    # the compiler gives us the path relative to the file's logical path.
+    dirname = File.dirname(input[:filename]).gsub(/#{Regexp.escape File.dirname(context.logical_path)}#{Opal::REGEXP_END}/, '')
+    dirname = Pathname(dirname)
 
-      required_trees.each do |original_required_tree|
-        required_tree = Pathname(original_required_tree)
+    required_trees.each do |original_required_tree|
+      required_tree = Pathname(original_required_tree)
 
-        unless required_tree.relative?
-          raise ArgumentError, "require_tree argument must be a relative path: #{required_tree.inspect}"
-        end
+      unless required_tree.relative?
+        raise ArgumentError, "require_tree argument must be a relative path: #{required_tree.inspect}"
+      end
 
-        required_tree = dirname.join(file, '..', required_tree)
+      required_tree = dirname.join(input[:filename], '..', required_tree)
 
-        unless required_tree.directory?
-          raise ArgumentError, "require_tree argument must be a directory: #{{source: original_required_tree, pathname: required_tree}.inspect}"
-        end
+      unless required_tree.directory?
+        raise ArgumentError, "require_tree argument must be a directory: #{{source: original_required_tree, pathname: required_tree}.inspect}"
+      end
 
-        context.depend_on required_tree.to_s
+      context.depend_on required_tree.to_s
 
-        environment = context.environment
+      environment = context.environment
 
-        processor = ::Sprockets::DirectiveProcessor.new
-        processor.instance_variable_set('@dirname', File.dirname(file))
-        processor.instance_variable_set('@environment', environment)
-        path = processor.__send__(:expand_relative_dirname, :require_tree, original_required_tree)
-        absolute_paths = environment.__send__(:stat_sorted_tree_with_dependencies, path).first.map(&:first)
+      processor = ::Sprockets::DirectiveProcessor.new
+      processor.instance_variable_set('@dirname', File.dirname(input[:filename]))
+      processor.instance_variable_set('@environment', environment)
+      path = processor.__send__(:expand_relative_dirname, :require_tree, original_required_tree)
+      absolute_paths = environment.__send__(:stat_sorted_tree_with_dependencies, path).first.map(&:first)
 
-        absolute_paths.each do |path|
-          path = Pathname(path)
-          pathname = path.relative_path_from(dirname).to_s
+      absolute_paths.each do |path|
+        path = Pathname(path)
+        pathname = path.relative_path_from(dirname).to_s
+        pathname_noext = pathname.sub(sprockets_extnames_regexp, '')
 
-          if name.to_s == file  then next
-          elsif path.directory? then context.depend_on(path.to_s)
-          else context.require_asset(pathname)
-          end
+        if path.to_s == logical_path then next
+        elsif ::Opal::Config.stubbed_files.include?(pathname_noext) then next
+        elsif path.directory? then context.depend_on(path.to_s)
+        else context.require_asset(pathname_noext)
         end
       end
     end
+  end
 
-    # @deprecated
-    def self.stubbed_files
-      warn "Deprecated: `::Opal::Processor.stubbed_files' is deprecated, use `::Opal::Config.stubbed_files' instead"
-      puts caller(5)
-      ::Opal::Config.stubbed_files
-    end
-
-    # @deprecated
-    def self.stub_file(name)
-      warn "Deprecated: `::Opal::Processor.stub_file' is deprecated, use `::Opal::Config.stubbed_files << #{name.inspect}.to_s' instead"
-      puts caller(5)
-      ::Opal::Config.stubbed_files << name.to_s
-    end
-
-
-    private
-
-    def add_sources_content_if_missing(data, content)
-      data[:sourcesContent] = data.delete(:sourcesContent) || data.delete('sourcesContent') || [content]
-    end
+  private
 
-    def to_data_uri_comment(map_to_json)
-      "//# sourceMappingURL=data:application/json;base64,#{Base64.encode64(map_to_json).delete("\n")}"
-    end
+  def to_data_uri_comment(map_to_json)
+    "//# sourceMappingURL=data:application/json;base64,#{Base64.encode64(map_to_json).delete("\n")}"
+  end
 
-    def stubbed_files
-      ::Opal::Config.stubbed_files
-    end
+  def stubbed_files
+    ::Opal::Config.stubbed_files
   end
-end
 
-module Opal::Sprockets::Processor
   module PlainJavaScriptLoader
     def self.call(input)
       sprockets = input[:environment]
-      asset = OpenStruct.new(input)
-
-      opal_extnames = sprockets.engines.map do |ext, engine|
-        ext if engine <= ::Opal::Processor
-      end.compact
 
-      path_extnames     = -> path  { File.basename(path).scan(/\.[^.]+/) }
-      processed_by_opal = -> asset { (path_extnames[asset.filename] & opal_extnames).any? }
+      opal_extnames_regexp = Opal::Sprockets.sprockets_extnames_regexp(sprockets, opal_only: true)
 
-      if processed_by_opal[asset]
+      if input[:filename] =~ opal_extnames_regexp
         input[:data]
       else
         "#{input[:data]}\n#{Opal::Sprockets.loaded_asset(input[:name])}"
@@ -163,7 +152,15 @@ module Opal::Sprockets::Processor
   end
 end
 
-Sprockets.register_engine '.rb',  Opal::Processor, mime_type: 'application/javascript', silence_deprecation: true
-Sprockets.register_engine '.opal',  Opal::Processor, mime_type: 'application/javascript', silence_deprecation: true
-Sprockets.register_postprocessor 'application/javascript', Opal::Sprockets::Processor::PlainJavaScriptLoader
+Sprockets.register_mime_type 'application/ruby', extensions: ['.rb', '.opal', '.js.rb', '.js.opal']
+Sprockets.register_transformer 'application/ruby', 'application/javascript', Opal::Sprockets::Processor
+Opal::Sprockets.register_mime_type 'application/ruby'
+
+Sprockets.register_mime_type 'application/ruby+ruby', extensions: ['.rb.erb', '.opal.erb', '.js.rb.erb', '.js.opal.erb']
+Sprockets.register_transformer 'application/ruby+ruby', 'application/ruby', Sprockets::ERBProcessor
+Opal::Sprockets.register_mime_type 'application/ruby+ruby'
 
+Sprockets.register_preprocessor 'application/ruby', Sprockets::DirectiveProcessor.new(comments: ["#"])
+Sprockets.register_preprocessor 'application/ruby+ruby', Sprockets::DirectiveProcessor.new(comments: ["#"])
+
+Sprockets.register_postprocessor 'application/javascript', Opal::Sprockets::Processor::PlainJavaScriptLoader

data/lib/opal/sprockets/server.rb

@@ -2,115 +2,111 @@ require 'erb'
 require 'rack'
 require 'sprockets'
 
-module Opal
-  module Sprockets
-    class Server
-      attr_accessor :debug, :use_index, :index_path, :main, :public_root,
-                    :public_urls, :sprockets, :prefix
-
-      def initialize options = {}
-        @use_index   = true
-        @public_root = nil
-        @public_urls = ['/']
-        @sprockets   = options.fetch(:sprockets, ::Sprockets::Environment.new)
-        @debug       = options.fetch(:debug, true)
-        @prefix      = options.fetch(:prefix, '/assets')
-
-        Opal.paths.each { |p| @sprockets.append_path(p) }
-
-        yield self if block_given?
-        create_app
-      end
+class Opal::Sprockets::Server
+  attr_accessor :debug, :use_index, :index_path, :main, :public_root,
+                :public_urls, :sprockets, :prefix
+
+  def initialize options = {}
+    @use_index   = true
+    @public_root = nil
+    @public_urls = ['/']
+    @sprockets   = options.fetch(:sprockets, ::Sprockets::Environment.new)
+    @debug       = options.fetch(:debug, true)
+    @prefix      = options.fetch(:prefix, '/assets')
+
+    Opal.paths.each { |p| @sprockets.append_path(p) }
+
+    yield self if block_given?
+    create_app
+  end
 
-      def public_dir=(dir)
-        @public_root = dir
-        @public_urls = ["/"]
-      end
+  def public_dir=(dir)
+    @public_root = dir
+    @public_urls = ["/"]
+  end
 
-      def source_map=(enabled)
-        Opal::Config.source_map_enabled = enabled
-      end
+  def source_map=(enabled)
+    Opal::Config.source_map_enabled = enabled
+  end
 
-      def source_map_enabled
-        Opal::Config.source_map_enabled
-      end
+  def source_map_enabled
+    Opal::Config.source_map_enabled
+  end
 
-      def append_path path
-        @sprockets.append_path path
-      end
+  def append_path path
+    @sprockets.append_path path
+  end
 
-      def use_gem gem_name
-        @sprockets.use_gem gem_name
-      end
+  def use_gem gem_name
+    @sprockets.use_gem gem_name
+  end
 
-      def create_app
-        server, sprockets, prefix = self, @sprockets, self.prefix
-        sprockets.logger.level ||= Logger::DEBUG
-
-        @app = Rack::Builder.app do
-          not_found = lambda { |env| [404, {}, []] }
-          use Rack::Deflater
-          use Rack::ShowExceptions
-          use Index, server if server.use_index
-          map(prefix)      { run sprockets }
-          run Rack::Static.new(not_found, root: server.public_root, urls: server.public_urls)
-        end
-      end
+  def create_app
+    server, sprockets, prefix = self, @sprockets, self.prefix
+    sprockets.logger.level ||= Logger::DEBUG
+
+    @app = Rack::Builder.app do
+      not_found = lambda { |env| [404, {}, []] }
+      use Rack::Deflater
+      use Rack::ShowExceptions
+      use Index, server if server.use_index
+      map(prefix)      { run sprockets }
+      run Rack::Static.new(not_found, root: server.public_root, urls: server.public_urls)
+    end
+  end
+
+  def call(env)
+    @app.call env
+  end
+
+  class Index
+
+    def initialize(app, server)
+      @app = app
+      @server = server
+      @index_path = server.index_path
+    end
 
-      def call(env)
+    def call(env)
+      if %w[/ /index.html].include? env['PATH_INFO']
+        [200, { 'Content-Type' => 'text/html' }, [html]]
+      else
         @app.call env
       end
+    end
 
-      class Index
-
-        def initialize(app, server)
-          @app = app
-          @server = server
-          @index_path = server.index_path
-        end
-
-        def call(env)
-          if %w[/ /index.html].include? env['PATH_INFO']
-            [200, { 'Content-Type' => 'text/html' }, [html]]
-          else
-            @app.call env
-          end
-        end
-
-        # Returns the html content for the root path. Supports ERB
-        def html
-          if @index_path
-            raise "index does not exist: #{@index_path}" unless File.exist?(@index_path)
-            Tilt.new(@index_path).render(self)
-          else
-            raise "Main asset path not configured (set 'main' within Opal::Server.new block)" if @server.main.nil?
-            source
-          end
-        end
-
-        def javascript_include_tag name
-          sprockets = @server.sprockets
-          prefix = @server.prefix
-          debug = @server.debug
-
-          ::Opal::Sprockets.javascript_include_tag(name, sprockets: sprockets, prefix: prefix, debug: debug)
-        end
-
-        def source
-          <<-HTML
-            <!DOCTYPE html>
-            <html>
-            <head>
-              <meta charset="utf-8">
-              <title>Opal Server</title>
-            </head>
-            <body>
-              #{javascript_include_tag @server.main}
-            </body>
-            </html>
-          HTML
-        end
+    # Returns the html content for the root path. Supports ERB
+    def html
+      if @index_path
+        raise "index does not exist: #{@index_path}" unless File.exist?(@index_path)
+        Tilt.new(@index_path).render(self)
+      else
+        raise "Main asset path not configured (set 'main' within Opal::Server.new block)" if @server.main.nil?
+        source
       end
     end
+
+    def javascript_include_tag name
+      sprockets = @server.sprockets
+      prefix = @server.prefix
+      debug = @server.debug
+
+      ::Opal::Sprockets.javascript_include_tag(name, sprockets: sprockets, prefix: prefix, debug: debug)
+    end
+
+    def source
+      <<-HTML
+        <!DOCTYPE html>
+        <html>
+        <head>
+          <meta charset="utf-8">
+          <title>Opal Server</title>
+        </head>
+        <body>
+          #{javascript_include_tag @server.main}
+        </body>
+        </html>
+      HTML
+    end
   end
 end