opal 0.5.5 → 0.6.0

data/lib/opal/parser/sexp.rb

@@ -1,10 +1,10 @@
 module Opal
   class Sexp
 
-    attr_accessor :line
-    attr_accessor :end_line
     attr_reader :array
 
+    attr_accessor :source
+
     def initialize(args)
       @array = args
     end
@@ -53,8 +53,20 @@ module Opal
 
     alias eql? ==
 
+    def line
+      @source && @source[0]
+    end
+
+    def column
+      @source && @source[1]
+    end
+
     def inspect
-      "(#{@array.map { |e| e.inspect }.join ' '})"
+      "(#{@array.map { |e| e.inspect }.join ', '})"
+    end
+
+    def pretty_inspect
+      "(#{line ? "#{line} " : ''}#{@array.map { |e| e.inspect }.join ', '})"
     end
 
     alias to_s inspect

data/lib/opal/source_map.rb

@@ -21,15 +21,19 @@ module Opal
               :generated_line => line,
               :generated_col  => column,
               :source_line    => source_line,
-              :source_col     => 0,
+              :source_col     => fragment.column,
               :source         => file
             )
           end
 
-
           new_lines = fragment.code.count "\n"
           line += new_lines
-          column = 0
+
+          if new_lines > 0
+            column = fragment.code.size - (fragment.code.rindex("\n") + 1)
+          else
+            column += fragment.code.size
+          end
         end
       end
     end
@@ -43,7 +47,7 @@ module Opal
     end
 
     def magic_comment map_path
-      "\n//@ sourceMappingURL=file://#{map_path}"
+      "\n//# sourceMappingURL=file://#{map_path}"
     end
   end
 end

data/lib/opal/sprockets.rb

@@ -0,0 +1,4 @@
+require 'opal/sprockets/environment'
+require 'opal/sprockets/processor'
+require 'opal/sprockets/erb'
+require 'opal/sprockets/server'

data/lib/opal/sprockets/cache_key_fix.rb

@@ -0,0 +1,17 @@
+require 'sprockets'
+require 'sprockets/base'
+
+module Sprockets
+  class Base
+    def cache_key_for(path, options)
+      "#{path}:#{options[:bundle] ? '1' : '0'}"
+      processors = attributes_for(path).processors
+      processors_key = processors.map do |p|
+        version = p.respond_to?(:version) ? p.version : '0'
+        "#{p.name}-#{version}"
+      end.join(':')
+
+      "#{path}:#{options[:bundle] ? '1' : '0'}:#{processors_key}"
+    end
+  end
+end

data/lib/opal/sprockets/environment.rb

@@ -0,0 +1,21 @@
+require 'sprockets'
+
+module Opal
+  # Environment is a subclass of Sprockets::Environment which already has our opal
+  # load paths loaded. This makes it easy for stand-alone rack apps, or test runners
+  # that have opal load paths ready to use. You can also add an existing gem's lib
+  # directory to our load path to use real gems inside your opal environment.
+  #
+  # If you are running rails, then you just need opal-rails instead, which will
+  # do this for you.
+  class Environment < ::Sprockets::Environment
+    def initialize *args
+      super
+      Opal.paths.each { |p| append_path p }
+    end
+
+    def use_gem gem_name
+      append_path File.join(Gem::Specification.find_by_name(gem_name).gem_dir, 'lib')
+    end
+  end
+end

data/lib/opal/sprockets/erb.rb

@@ -0,0 +1,30 @@
+require 'opal'
+require 'opal/compiler'
+require 'sprockets'
+
+module Opal
+  module ERB
+    class Processor < Tilt::Template
+      self.default_mime_type = 'application/javascript'
+
+      def self.engine_initialized?
+        true
+      end
+
+      def initialize_engine
+        require_template_library 'opal'
+      end
+
+      def prepare
+      end
+
+      def evaluate(context, locals, &block)
+        context.require_asset 'erb'
+        Opal::ERB.compile data, context.logical_path.sub(/^templates\//, '')
+      end
+    end
+  end
+end
+
+Tilt.register 'opalerb',               Opal::ERB::Processor
+Sprockets.register_engine '.opalerb',  Opal::ERB::Processor

data/lib/opal/sprockets/processor.rb

@@ -0,0 +1,127 @@
+require 'set'
+require 'sprockets'
+require 'opal/version'
+
+$OPAL_SOURCE_MAPS = {}
+
+module Opal
+  # Proccess using Sprockets
+  #
+  #   Opal.process('opal-jquery')   # => String
+  def self.process asset
+    Environment.new[asset].to_s
+  end
+
+  # 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. There are some options you can override globally
+  # which effect how certain ruby features are handled:
+  #
+  #   * method_missing_enabled      [true by default]
+  #   * optimized_operators_enabled [true by default]
+  #   * arity_check_enabled         [false by default]
+  #   * const_missing_enabled       [true by default]
+  #   * dynamic_require_severity    [true by default]
+  #   * source_map_enabled          [true by default]
+  #   * irb_enabled                 [false by default]
+  #
+  class Processor < Tilt::Template
+    self.default_mime_type = 'application/javascript'
+
+    def self.engine_initialized?
+      true
+    end
+
+    def self.version
+      ::Opal::VERSION
+    end
+
+    class << self
+      attr_accessor :method_missing_enabled
+      attr_accessor :arity_check_enabled
+      attr_accessor :const_missing_enabled
+      attr_accessor :dynamic_require_severity
+      attr_accessor :source_map_enabled
+      attr_accessor :irb_enabled
+    end
+
+    self.method_missing_enabled      = true
+    self.arity_check_enabled         = false
+    self.const_missing_enabled       = true
+    self.dynamic_require_severity    = :error # :error, :warning or :ignore
+    self.source_map_enabled          = true
+    self.irb_enabled                 = false
+
+    def self.stub_file(name)
+      stubbed_files << name.to_s
+    end
+
+    def self.stubbed_files
+      @stubbed_files ||= Set.new
+    end
+
+    def initialize_engine
+      require_template_library 'opal'
+    end
+
+    def prepare
+    end
+
+    def evaluate(context, locals, &block)
+      options = {
+        :method_missing           => self.class.method_missing_enabled,
+        :arity_check              => self.class.arity_check_enabled,
+        :const_missing            => self.class.const_missing_enabled,
+        :dynamic_require_severity => self.class.dynamic_require_severity,
+        :irb                      => self.class.irb_enabled,
+        :file                     => context.logical_path,
+      }
+
+      compiler = Opal::Compiler.new
+      result = compiler.compile data, options
+
+      compiler.requires.each do |r|
+        next if stubbed_file? r
+        path = find_opal_require context.environment, r
+        context.require_asset path
+      end
+
+      if self.class.source_map_enabled
+        $OPAL_SOURCE_MAPS[context.pathname] = compiler.source_map(source_file_url(context)).to_s
+        "#{result}\n//# sourceMappingURL=#{source_map_url(context)}\n"
+      else
+        result
+      end
+    end
+
+    def source_map_url(context)
+      "#{prefix}/#{context.logical_path}.js.map"
+    end
+
+    def source_file_url(context)
+      "#{prefix}/#{context.logical_path.to_s}"
+    end
+
+    def prefix
+      "/__opal_source_maps__"
+    end
+
+    def stubbed_file?(name)
+      self.class.stubbed_files.include? name
+    end
+
+    def find_opal_require(environment, r)
+      path = environment.paths.find do |p|
+        File.exist?(File.join(p, "#{r}.rb"))
+      end
+
+      path ? File.join(path, "#{r}.rb") : r
+    end
+  end
+end
+
+Tilt.register 'rb',               Opal::Processor
+Sprockets.register_engine '.rb',  Opal::Processor
+
+Tilt.register 'opal',               Opal::Processor
+Sprockets.register_engine '.opal',  Opal::Processor

data/lib/opal/sprockets/server.rb

@@ -0,0 +1,166 @@
+require 'rack/file'
+require 'rack/urlmap'
+require 'rack/builder'
+require 'rack/directory'
+require 'rack/showexceptions'
+require 'opal/source_map'
+require 'opal/sprockets/environment'
+require 'erb'
+
+module Opal
+
+  class SourceMapServer
+    def initialize sprockets
+      @sprockets = sprockets
+    end
+
+    attr_reader :sprockets
+
+    attr_writer :prefix
+
+    def prefix
+      @prefix ||= '/__opal_source_maps__'
+    end
+
+    def inspect
+      "#<#{self.class}:#{object_id}>"
+    end
+
+    def call(env)
+      path_info = env['PATH_INFO']
+
+      if path_info =~ /\.js\.map$/
+        path   = env['PATH_INFO'].gsub(/^\/|\.js\.map$/, '')
+        asset  = sprockets[path]
+        return [404, {}, []] if asset.nil?
+
+        return [200, {"Content-Type" => "text/json"}, [$OPAL_SOURCE_MAPS[asset.pathname].to_s]]
+      else
+        return [200, {"Content-Type" => "text/text"}, [File.read(sprockets.resolve(path_info))]]
+      end
+    end
+  end
+
+  class Server
+
+    attr_accessor :debug, :use_index, :index_path, :main, :public_root, :public_urls, :sprockets
+
+    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   = Environment.new
+      @debug       = options.fetch(:debug, true)
+
+      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 = self, @sprockets
+
+      @app = Rack::Builder.app do
+        not_found = lambda { |env| [404, {}, []] }
+
+        use Rack::Deflater
+        use Rack::ShowExceptions
+        map('/assets') { run sprockets }
+        map(server.source_maps.prefix) { run server.source_maps } if server.source_map_enabled
+        use Index, server if server.use_index
+        run Rack::Static.new(not_found, :root => server.public_root, :urls => server.public_urls)
+      end
+    end
+
+    def source_maps
+      @source_maps ||= SourceMapServer.new(@sprockets)
+    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
+          ::ERB.new(SOURCE).result binding
+        end
+      end
+
+      def javascript_include_tag source
+        if @server.debug
+          assets = @server.sprockets[source].to_a
+
+          raise "Cannot find asset: #{source}" if assets.empty?
+
+          scripts = assets.map do |a|
+            %Q{<script src="/assets/#{ a.logical_path }?body=1"></script>}
+          end
+
+          scripts.join "\n"
+        else
+          "<script src=\"/assets/#{source}.js\"></script>"
+        end
+      end
+
+      SOURCE = <<-HTML
+  <!DOCTYPE html>
+  <html>
+  <head>
+    <title>Opal Server</title>
+  </head>
+  <body>
+    <%= javascript_include_tag @server.main %>
+  </body>
+  </html>
+      HTML
+    end
+  end
+end

data/lib/opal/util.rb

@@ -0,0 +1,29 @@
+module Opal
+  module Util
+    extend self
+
+    # Used for uglifying source to minify
+    def uglify(str)
+      IO.popen('uglifyjs 2> /dev/null', 'r+') do |i|
+        i.puts str
+        i.close_write
+        return i.read
+      end
+    rescue Errno::ENOENT, Errno::EPIPE
+      $stderr.puts '"uglifyjs" command not found (install with: "npm install -g uglify-js")'
+      nil
+    end
+
+    # Gzip code to check file size
+    def gzip(str)
+      IO.popen('gzip -f 2> /dev/null', 'r+') do |i|
+        i.puts str
+        i.close_write
+        return i.read
+      end
+    rescue Errno::ENOENT, Errno::EPIPE
+      $stderr.puts '"gzip" command not found, it is required to produce the .gz version'
+      nil
+    end
+  end
+end