opal-wedge 0.9.0.dev

data/lib/opal/sprockets/server.rb

@@ -0,0 +1,160 @@
+require 'rack/file'
+require 'rack/static'
+require 'rack/urlmap'
+require 'rack/builder'
+require 'rack/deflater'
+require 'rack/directory'
+require 'rack/showexceptions'
+require 'opal/source_map'
+require 'sprockets'
+require 'sourcemap'
+require 'erb'
+require 'opal/sprockets/source_map_server'
+require 'opal/sprockets/source_map_header_patch'
+
+module Opal
+  class Server
+    SOURCE_MAPS_PREFIX_PATH = '/__OPAL_SOURCE_MAPS__'
+
+    attr_accessor :debug, :use_index, :index_path, :main, :public_root,
+                  :public_urls, :sprockets, :prefix
+
+    def initialize debug_or_options = {}
+      unless Hash === debug_or_options
+        warn "passing a boolean to control debug is deprecated.\n"+
+             "Please pass an Hash instead: Server.new(debug: true)"
+        options = {:debug => debug_or_options}
+      else
+        options = debug_or_options
+      end
+
+      @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 source_map=(enabled)
+      Opal::Processor.source_map_enabled = enabled
+    end
+
+    def source_map_enabled
+      Opal::Processor.source_map_enabled
+    end
+
+    def append_path path
+      @sprockets.append_path path
+    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
+      source_map_enabled = self.source_map_enabled
+      if source_map_enabled
+        maps_prefix = SOURCE_MAPS_PREFIX_PATH
+        maps_app = SourceMapServer.new(sprockets, maps_prefix)
+        ::Opal::Sprockets::SourceMapHeaderPatch.inject!(maps_prefix)
+      end
+
+      @app = Rack::Builder.app do
+        not_found = lambda { |env| [404, {}, []] }
+        use Rack::Deflater
+        use Rack::ShowExceptions
+        use Index, server if server.use_index
+        if source_map_enabled
+          map(maps_prefix) do
+            require 'rack/conditionalget'
+            require 'rack/etag'
+            use Rack::ConditionalGet
+            use Rack::ETag
+            run maps_app
+          end
+        end
+        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)
+        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
+        asset = sprockets[name]
+        raise "Cannot find asset: #{name}" if asset.nil?
+        scripts = []
+
+        if @server.debug
+          asset.to_a.map do |dependency|
+            scripts << %{<script src="#{prefix}/#{dependency.logical_path}?body=1"></script>}
+          end
+        else
+          scripts << %{<script src="#{prefix}/#{name}.js"></script>}
+        end
+
+        scripts << %{<script>#{Opal::Processor.load_asset_code(sprockets, name)}</script>}
+
+        scripts.join "\n"
+      end
+
+      def source
+        <<-HTML
+          <!DOCTYPE html>
+          <html>
+          <head>
+            <title>Opal Server</title>
+          </head>
+          <body>
+            #{javascript_include_tag @server.main}
+          </body>
+          </html>
+        HTML
+      end
+    end
+  end
+end

data/lib/opal/sprockets/source_map_header_patch.rb

@@ -0,0 +1,41 @@
+require 'sprockets/server'
+
+module Opal
+  module Sprockets
+    module SourceMapHeaderPatch
+      # Adds the source map header to all sprocket responses for assets
+      # with a .rb or .opal extension in the extension chain.
+      def headers_with_opal_source_maps(env, asset, length)
+        headers_without_opal_source_maps(env, asset, length).tap do |current_headers|
+          if asset.pathname.to_s =~ /\.(rb|opal)\b/
+            base_path = asset.logical_path.gsub('.js', '')
+            current_headers['X-SourceMap'] = "#{::Opal::Sprockets::SourceMapHeaderPatch.prefix}/#{base_path}.map"
+          end
+        end
+      end
+
+      def self.included(base)
+        # Poor man's alias_method_chain :)
+        base.send(:alias_method, :headers_without_opal_source_maps, :headers)
+        base.send(:alias_method, :headers, :headers_with_opal_source_maps)
+      end
+
+      def self.inject!(prefix)
+        self.prefix = prefix
+        unless ::Sprockets::Server.ancestors.include?(self)
+          ::Sprockets::Server.send :include, self
+        end
+      end
+
+      def self.prefix
+        @prefix
+      end
+
+      def self.prefix= val
+        @prefix = val
+      end
+    end
+  end
+end
+
+

data/lib/opal/sprockets/source_map_server.rb

@@ -0,0 +1,115 @@
+module Opal
+  class SourceMapServer
+    # Carelessly taken from Sprockets::Caching (Sprockets v2)
+    class Cache
+      def initialize
+        @cache = {}
+      end
+
+      attr_reader :cache
+
+      def cache_get(key)
+        # `Cache#get(key)` for Memcache
+        if cache.respond_to?(:get)
+          cache.get(key)
+
+        # `Cache#[key]` so `Hash` can be used
+        elsif cache.respond_to?(:[])
+          cache[key]
+
+        # `Cache#read(key)` for `ActiveSupport::Cache` support
+        elsif cache.respond_to?(:read)
+          cache.read(key)
+
+        else
+          nil
+        end
+      end
+
+      def cache_set(key, value)
+        # `Cache#set(key, value)` for Memcache
+        if cache.respond_to?(:set)
+          cache.set(key, value)
+
+        # `Cache#[key]=value` so `Hash` can be used
+        elsif cache.respond_to?(:[]=)
+          cache[key] = value
+
+        # `Cache#write(key, value)` for `ActiveSupport::Cache` support
+        elsif cache.respond_to?(:write)
+          cache.write(key, value)
+        end
+
+        value
+      end
+    end
+
+    def self.get_map_cache(sprockets, logical_path)
+      logical_path = logical_path.gsub(/\.js#{REGEXP_END}/, '')
+      cache_key = cache_key_for_path(logical_path+'.map')
+      cache(sprockets).cache_get(cache_key)
+    end
+
+    def self.set_map_cache(sprockets, logical_path, map_contents)
+      logical_path = logical_path.gsub(/\.js#{REGEXP_END}/, '')
+      cache_key = cache_key_for_path(logical_path+'.map')
+      cache(sprockets).cache_set(cache_key, map_contents)
+    end
+
+    def self.cache(sprockets)
+      @cache ||= sprockets.cache ? sprockets : Cache.new
+    end
+
+    def self.cache_key_for_path(logical_path)
+      base_name = logical_path.gsub(/\.js#{REGEXP_END}/, '')
+      File.join('opal', 'source_maps', base_name)
+    end
+
+
+    def initialize sprockets, prefix = '/'
+      @sprockets = sprockets
+      @prefix = prefix
+    end
+
+    attr_reader :sprockets, :prefix
+
+    def inspect
+      "#<#{self.class}:#{object_id}>"
+    end
+
+    def call(env)
+      prefix_regex = %r{^(?:#{prefix}/|/)}
+      path_info = env['PATH_INFO'].to_s.sub(prefix_regex, '')
+
+      case path_info
+      when %r{^(.*)\.self\.map$}
+        path = $1
+        asset  = sprockets[path+'.js']
+        return not_found(path) if asset.nil?
+
+        # "logical_name" of a BundledAsset keeps the .js extension
+        source = SourceMapServer.get_map_cache(sprockets, asset.logical_path)
+        return not_found(asset) if source.nil?
+
+        map = JSON.parse(source)
+        map['sources'] = map['sources'].map {|s| "#{prefix}/#{s}"}
+        source = map.to_json
+
+        return [200, {"Content-Type" => "text/json"}, [source.to_s]]
+      when %r{^(.*)\.rb$}
+        begin
+          asset = sprockets.resolve(path_info.sub(/\.rb#{REGEXP_END}/,''))
+        rescue Sprockets::FileNotFound
+          return not_found(path_info)
+        end
+        return [200, {"Content-Type" => "text/ruby"}, [Pathname(asset).read]]
+      else
+        not_found(path_info)
+      end
+    end
+
+    def not_found(*messages)
+      not_found = [404, {}, [{not_found: messages}.inspect]]
+    end
+  end
+end

data/lib/opal/util.rb

@@ -0,0 +1,69 @@
+module Opal
+  module Util
+    extend self
+
+    # Used for uglifying source to minify.
+    #
+    #     Opal::Util.uglify("javascript contents")
+    #
+    # @param str [String] string to minify
+    # @return [String]
+    def uglify(str)
+      uglifyjs = DigestSourceCommand.new(:uglifyjs, nil, ' (install with: "npm install -g uglify-js")')
+      uglifyjs.digest(str)
+    end
+
+    # Gzip code to check file size.
+    def gzip(str)
+      gzip = DigestSourceCommand.new(:gzip, '-f', ', it is required to produce the .gz version')
+      gzip.digest(str)
+    end
+
+    class Command
+      def initialize(command, options, message = nil)
+        @command, @options, @message = command, options, message
+        return unless command_installed? command, message
+      end
+      attr_reader :command, :options, :message
+
+      private
+
+      def hide_stderr
+        if (/mswin|mingw/ =~ RUBY_PLATFORM).nil?
+          '2> /dev/null'
+        else
+          '2> nul'
+        end
+      end
+
+      # Code from http://stackoverflow.com/questions/2108727/which-in-ruby-checking-if-program-exists-in-path-from-ruby
+      def which(cmd)
+        exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
+        ENV['PATH'].split(File::PATH_SEPARATOR).find do |path|
+          exts.find { |ext|
+            exe = File.join(path, "#{cmd}#{ext}")
+            exe if File.executable? exe
+          }
+        end
+      end
+
+      INSTALLED = {}
+      def command_installed?(cmd, install_comment)
+        command_installed = Command::INSTALLED[cmd.to_s] ||= which(cmd)
+        $stderr.puts %Q("#{cmd}" command not found#{install_comment}) unless command_installed
+        command_installed
+      end
+    end
+
+    class DigestSourceCommand < Command
+      def digest(source)
+        IO.popen("#{command} #{options} #{hide_stderr}", 'r+') do |i|
+          i.puts source
+          i.close_write
+          i.read
+        end
+      end
+    end
+
+  end
+end

data/lib/opal/version.rb

@@ -0,0 +1,5 @@
+module Opal
+  # WHEN RELEASING:
+  # Remember to update RUBY_ENGINE_VERSION in opal/corelib/variables.rb too!
+  VERSION = '0.9.0.dev'
+end

data/lib/tilt/opal.rb

@@ -0,0 +1,54 @@
+require 'tilt'
+require 'opal/builder'
+require 'opal/config'
+require 'opal/version'
+
+$OPAL_SOURCE_MAPS = {}
+
+module Opal
+  class TiltTemplate < Tilt::Template
+    self.default_mime_type = 'application/javascript'
+
+    def self.inherited(subclass)
+      subclass.default_mime_type = 'application/javascript'
+    end
+
+    def self.engine_initialized?
+      true
+    end
+
+    def self.version
+      ::Opal::VERSION
+    end
+
+    def self.compiler_options
+      Opal::Config.compiler_options.merge(requirable: true)
+    end
+
+    def initialize_engine
+      require_template_library 'opal'
+    end
+
+    def prepare
+    end
+
+    def evaluate(_, _, &block)
+      if builder = @options[:builder]
+        builder.dup.build(file).to_s
+      elsif @options[:build]
+        Opal::Builder.build(file).to_s
+      else
+        compiler_options = (compiler_options || {}).merge!(file: file)
+        compiler = Compiler.new(data, compiler_options)
+        compiler.compile.to_s
+      end
+    end
+
+    def compiler_options
+      self.class.compiler_options
+    end
+  end
+end
+
+Tilt.register 'rb',   Opal::TiltTemplate
+Tilt.register 'opal', Opal::TiltTemplate