opal 0.7.2 → 0.8.0.beta1

data/lib/opal/parser/grammar.y

@@ -607,16 +607,12 @@ rule
                       result = [s(:hash, *val[0])]
                     }
 
-      paren_args: tLPAREN2 none tRPAREN
-                    {
-                      result = []
-                    }
-                | tLPAREN2 call_args opt_nl tRPAREN
+      paren_args: tLPAREN2 opt_call_args rparen
                     {
                       result = val[1]
                     }
-                | tLPAREN2 block_call opt_nl tRPAREN
-                | tLPAREN2 args tCOMMA block_call opt_nl tRPAREN
+
+          rparen: opt_nl tRPAREN
 
   opt_paren_args: none
                     {
@@ -624,6 +620,25 @@ rule
                     }
                 | paren_args
 
+   opt_call_args: none
+                    {
+                      result = []
+                    }
+                | call_args
+                | args tCOMMA
+                    {
+                      result = val[0]
+                    }
+                | args tCOMMA assocs tCOMMA
+                    {
+                      result = val[0]
+                      result << new_hash(nil, val[2], nil)
+                    }
+                | assocs tCOMMA
+                    {
+                      result = [new_hash(nil, val[0], nil)]
+                    }
+
        call_args: command
                     {
                       result = [val[0]]
@@ -899,6 +914,7 @@ rule
                 | kDEF fname
                     {
                       push_scope
+                      lexer.lex_state = :expr_endfn
                     }
                     f_arglist bodystmt kEND
                     {
@@ -912,6 +928,7 @@ rule
                     fname
                     {
                       push_scope
+                      lexer.lex_state = :expr_endfn
                     }
                     f_arglist bodystmt kEND
                     {
@@ -1456,6 +1473,7 @@ xstring_contents: none
                 | f_args term
                     {
                       result = val[0]
+                      lexer.lex_state = :expr_beg
                     }
 
      kwrest_mark: tPOW

data/lib/opal/parser/lexer.rb

@@ -249,6 +249,8 @@ module Opal
         "\v"
       elsif scan(/a/)
         "\a"
+      elsif scan(/b/)
+        "\b"
       elsif scan(/e/)
         "\e"
       elsif scan(/s/)
@@ -258,12 +260,7 @@ module Opal
       elsif scan(/x([0-9a-fA-F]{1,2})/)
         scanner[1].to_i(16).chr
       elsif scan(/u([0-9a-zA-Z]{1,4})/)
-        if defined?(::Encoding)
-          scanner[1].to_i(16).chr(Encoding::UTF_8)
-        else
-          # FIXME: no encoding on 1.8
-          ""
-        end
+        scanner[1].to_i(16).chr(Encoding::UTF_8)
       else
         # escaped char doesnt need escaping, so just return it
         scan(/./)
@@ -620,6 +617,8 @@ module Opal
 
       if [:expr_beg, :expr_dot, :expr_mid, :expr_arg, :expr_cmdarg].include? @lex_state
         @lex_state = cmd_start ? :expr_cmdarg : :expr_arg
+      elsif @lex_state == :expr_fname
+        @lex_state = :expr_endfn
       else
         @lex_state = :expr_end
       end
@@ -877,13 +876,17 @@ module Opal
           elsif scan(/\=/)
             @lex_state = :expr_beg
             return new_op_asgn('/')
-          elsif after_operator?
-            @lex_state = :expr_arg
-          elsif arg?
+          end
+
+          if arg?
             if !check(/\s/) && @space_seen
               self.strterm = new_strterm(STR_REGEXP, '/', '/')
               return :tREGEXP_BEG
             end
+          end
+
+          if after_operator?
+            @lex_state = :expr_arg
           else
             @lex_state = :expr_beg
           end

data/lib/opal/path_reader.rb

@@ -9,7 +9,7 @@ module Opal
     def read(path)
       full_path = expand(path)
       return nil if full_path.nil?
-      File.read(full_path)
+      File.open(full_path, 'rb:UTF-8'){|f| f.read}
     end
 
     def expand(path)

data/lib/opal/sprockets/erb.rb

@@ -1,33 +1,19 @@
 require 'tilt'
 require 'sprockets'
+require 'opal/sprockets/processor'
 
 module Opal
   module ERB
-    class Processor < Tilt::Template
-      # vvv BOILERPLATE vvv
-      self.default_mime_type = 'application/javascript'
-
-      def self.engine_initialized?
-        true
-      end
-
-      def self.version
-        ::Opal::VERSION
-      end
-
+    class Processor < ::Opal::Processor
       def initialize_engine
-        require_template_library 'opal'
+        super
         require_template_library 'opal/erb'
       end
 
-      def prepare
-      end
-      # ^^^ BOILERPLATE ^^^
-
-
       def evaluate(context, locals, &block)
-        context.require_asset 'erb'
-        Opal::ERB.compile data, context.logical_path.sub(/^templates\//, '')
+        compiler = Opal::ERB::Compiler.new(@data, context.logical_path.sub(/^templates\//, ''))
+        @data = compiler.prepared_source
+        super
       end
     end
   end

data/lib/opal/sprockets/path_reader.rb

@@ -13,14 +13,16 @@ module Opal
           env[path, bundle: true].to_s
         else
           context.depend_on(path)
-          File.read(expand(path))
+          File.open(expand(path), 'rb:UTF-8'){|f| f.read}
         end
       rescue ::Sprockets::FileNotFound
         nil
       end
 
       def expand path
-        env.resolve(path)
+        env.resolve(path) or
+          # Sprockets 3 just returns nil for unknown paths
+          raise ::Sprockets::FileNotFound, path.inspect
       end
 
       def paths

data/lib/opal/sprockets/processor.rb

@@ -1,93 +1,169 @@
 require 'set'
-require 'tilt'
+require 'tilt/opal'
 require 'sprockets'
-require 'opal/version'
 require 'opal/builder'
 require 'opal/sprockets/path_reader'
+require 'opal/sprockets/source_map_server'
 
 $OPAL_SOURCE_MAPS = {}
 
 module Opal
   # 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]
-  #   * arity_check_enabled         [false by default]
-  #   * const_missing_enabled       [true by default]
-  #   * dynamic_require_severity    [:error by default]
-  #   * source_map_enabled          [true by default]
-  #   * irb_enabled                 [false by default]
-  #   * inline_operators_enabled    [false by default]
-  #
-  class Processor < Tilt::Template
-    # vvv BOILERPLATE vvv
-    self.default_mime_type = 'application/javascript'
-
-    def self.engine_initialized?
-      true
+  # ruby source file to build.
+  class Processor < TiltTemplate
+    # DEPRECATED:
+    # Support legacy accessors to default options, now moved to Opal::Config
+    Opal::Config.default_config.keys.each do |config_option|
+      define_singleton_method(config_option) { Opal::Config.config[config_option] }
+      define_singleton_method("#{config_option}=") { |value| Opal::Config.config[config_option] = value }
     end
 
-    def self.version
-      ::Opal::VERSION
-    end
+    def evaluate(context, locals, &block)
+      return super unless context.is_a? ::Sprockets::Context
 
-    def initialize_engine
-      require_template_library 'opal'
-    end
+      @sprockets = sprockets = context.environment
+
+      # 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
+      logical_path = filename.sub(%r{^#{context.root_path}/?(.*?)#{sprockets_extnames_regexp}}, '\1')
+
+      compiler_options = self.compiler_options.merge(file: logical_path)
+
+      # Opal will be loaded immediately to as the runtime redefines some crucial
+      # methods such that need to be implemented as soon as possible:
+      #
+      # E.g. It forwards .toString() to .$to_s() for Opal objects including Array.
+      #      If .$to_s() is not implemented and some other lib is loaded before
+      #      corelib/* .toString results in an `undefined is not a function` error.
+      compiler_options.merge!(requirable: false) if logical_path == 'opal'
 
-    def prepare
+      compiler = Compiler.new(data, compiler_options)
+      result = compiler.compile
+
+      process_requires(compiler.requires, context)
+      process_required_trees(compiler.required_trees, context)
+
+      if Opal::Config.source_map_enabled
+        map_contents = compiler.source_map.as_json.to_json
+        ::Opal::SourceMapServer.set_map_cache(sprockets, logical_path, map_contents)
+      end
+
+      result.to_s
     end
-    # ^^^ BOILERPLATE ^^^
 
+    def self.sprockets_extnames_regexp(sprockets)
+      joined_extnames = sprockets.engines.keys.map { |ext| Regexp.escape(ext) }.join('|')
+      Regexp.new("(#{joined_extnames})*$")
+    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
-      attr_accessor :inline_operators_enabled
+    def sprockets_extnames_regexp
+      @sprockets_extnames_regexp ||= self.class.sprockets_extnames_regexp(@sprockets)
+    end
 
-      attr_accessor :source_map_register
+    def process_requires(requires, context)
+      requires.each do |required|
+        required = required.sub(sprockets_extnames_regexp, '')
+        context.require_asset required unless stubbed_files.include? required
+      end
     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
-    self.inline_operators_enabled    = false
+    # 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)}$/, '')
+      dirname = Pathname(dirname)
+
+      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
+
+        required_tree = dirname.join(file, '..', required_tree)
+
+        unless required_tree.directory?
+          raise ArgumentError, "require_tree argument must be a directory: #{[original_required_tree, required_tree].inspect}"
+        end
+
+        context.depend_on required_tree.to_s
+
+        environment = context.environment
+
+        if environment.respond_to?(:each_entry)
+          # Sprockets 2
+          environment.each_entry(required_tree) do |pathname|
+            if pathname.to_s == file
+              next
+            elsif pathname.directory?
+              context.depend_on(pathname)
+            elsif context.asset_requirable?(pathname)
+              context.require_asset(pathname)
+            end
+          end
+        else
+          # Sprockets 3
+          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)
+
+          absolute_paths.each do |path|
+            path = Pathname(path)
+            pathname = path.relative_path_from(dirname)
+
+            if name.to_s == file
+              next
+            elsif path.directory?
+              context.depend_on(path.to_s)
+            else
+              context.require_asset(pathname)
+            end
+          end
+        end
+      end
+    end
 
-    self.source_map_register         = $OPAL_SOURCE_MAPS
+    def self.load_asset_code(sprockets, name)
+      asset = sprockets[name.sub(/(\.(js|rb|opal))*$/, '.js')]
+      return '' if asset.nil?
 
+      opal_extnames = sprockets.engines.map do |ext, engine|
+        ext if engine <= ::Opal::Processor
+      end.compact
 
-    def evaluate(context, locals, &block)
-      return Opal.compile data unless context.is_a? ::Sprockets::Context
+      module_name = -> asset { asset.logical_path.sub(/\.js$/, '') }
+      path_extnames = -> path { File.basename(path).scan(/\.[^.]+/) }
+      mark_as_loaded = -> path { "Opal.mark_as_loaded(#{path.inspect});" }
+      processed_by_opal = -> asset { (path_extnames[asset.pathname] & opal_extnames).any? }
 
-      path = context.logical_path
-      prerequired = []
+      non_opal_assets = ([asset]+asset.dependencies)
+        .select { |asset| not(processed_by_opal[asset]) }
+        .map { |asset| module_name[asset] }
 
-      builder = self.class.new_builder(context)
-      result = builder.build_str(data, path, :prerequired => prerequired)
+      mark_as_loaded = (['opal'] + non_opal_assets + stubbed_files.to_a)
+        .map { |path| mark_as_loaded[path] }
 
-      if self.class.source_map_enabled
-        register_source_map(context.logical_path, result.source_map.to_s)
-        "#{result.to_s}\n//# sourceMappingURL=#{File.basename(context.logical_path)}.map\n"
-      else
-        result.to_s
+      if processed_by_opal[asset]
+        load_asset_code = "Opal.load(#{module_name[asset].inspect});"
       end
-    end
 
-    def register_source_map path, map_contents
-      self.class.source_map_register[path] = map_contents
+      <<-JS
+      if (typeof(Opal) !== 'undefined') {
+        #{mark_as_loaded.join("\n")}
+        #{load_asset_code}
+      }
+      JS
     end
 
     def self.stubbed_files
-      @stubbed_files ||= []
+      @stubbed_files ||= Set.new
     end
 
     def self.stub_file(name)
@@ -97,29 +173,8 @@ module Opal
     def stubbed_files
       self.class.stubbed_files
     end
-
-    def self.new_builder(context)
-      compiler_options = {
-        :method_missing           => method_missing_enabled,
-        :arity_check              => arity_check_enabled,
-        :const_missing            => const_missing_enabled,
-        :dynamic_require_severity => dynamic_require_severity,
-        :irb                      => irb_enabled,
-        :inline_operators         => inline_operators_enabled,
-      }
-
-      path_reader = ::Opal::Sprockets::PathReader.new(context.environment, context)
-      return Builder.new(
-        compiler_options: compiler_options,
-        stubs:            stubbed_files,
-        path_reader:      path_reader
-      )
-    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