opal 0.6.3 → 0.7.0.beta1

data/lib/opal/parser/grammar.y

@@ -470,11 +470,19 @@ rule
                       result = new_binary_call(val[0], val[1], val[2])
                     }
                 | '-@NUM' tINTEGER tPOW arg
+                    {
+                      result = new_call new_binary_call(new_int(val[1]), val[2], val[3]), [:"-@", []], []
+                    }
                 | '-@NUM' tFLOAT tPOW arg
+                    {
+                      result = new_call new_binary_call(new_float(val[1]), val[2], val[3]), [:"-@", []], []
+                    }
                 | tUPLUS arg
                     {
                       result = new_call val[1], [:"+@", []], []
-                      result = val[1] if [:int, :float].include? val[1].type
+                      if [:int, :float].include? val[1].type
+                        result = val[1]
+                      end
                     }
                 | tUMINUS arg
                     {
@@ -843,15 +851,19 @@ rule
                     {
                       result = s(:case, nil, val[3])
                     }
-                | kFOR mlhs kIN
+                | kFOR for_var kIN
                     {
-                      # ...
+                      lexer.cond_push 1
+                      result = lexer.line
                     }
                     expr_value do
                     {
-                      # ...
+                      lexer.cond_pop
                     }
                     compstmt kEND
+                    {
+                      result = s(:for, val[4], val[1], val[7])
+                    }
                 | kCLASS cpath superclass
                     {
                       # ...
@@ -1130,7 +1142,7 @@ opt_block_args_tail: tCOMMA block_args_tail
                     {
                       part = s(:when, s(:array, *val[2]), val[4])
                       result = [part]
-                      result.push *val[5] if val[5]
+                      result.push(*val[5]) if val[5]
                     }
 
            cases: opt_else
@@ -1184,6 +1196,9 @@ opt_block_args_tail: tCOMMA block_args_tail
 
           string: string1
                 | string string1
+                  {
+                    result = str_append val[0], val[1]
+                  }
 
          string1: tSTRING_BEG string_contents tSTRING_END
                     {
@@ -1343,7 +1358,21 @@ xstring_contents: none
                       result = new_float(val[0])
                     }
                 | '-@NUM' tINTEGER =tLOWEST
+                  {
+                    result = negate_num(new_int(val[1]))
+                  }
                 | '-@NUM' tFLOAT   =tLOWEST
+                  {
+                    result = negate_num(new_float(val[1]))
+                  }
+                | '+@NUM' tINTEGER =tLOWEST
+                  {
+                    result = new_int(val[1])
+                  }
+                | '+@NUM' tFLOAT   =tLOWEST
+                  {
+                    result = new_float(val[1])
+                  }
 
         variable: tIDENTIFIER
                     {
@@ -1499,6 +1528,9 @@ xstring_contents: none
                       result = val[1]
                     }
 
+         for_var: lhs
+                | mlhs
+
           f_marg: f_norm_arg
                     {
                       result = s(:lasgn, val[0])

data/lib/opal/parser/keywords.rb

@@ -28,7 +28,9 @@ module Opal
       ["end",       [:kEND,      :kEND],        :expr_end],
       ["ensure",    [:kENSURE,   :kENSURE],     :expr_beg],
       ["false",     [:kFALSE,    :kFALSE],      :expr_end],
+      ["for",       [:kFOR,      :kFOR],        :expr_beg],
       ["if",        [:kIF,       :kIF_MOD],     :expr_beg],
+      ["in",        [:kIN,       :kIN],         :expr_beg],
       ["module",    [:kMODULE,   :kMODULE],     :expr_beg],
       ["nil",       [:kNIL,      :kNIL],        :expr_end],
       ["next",      [:kNEXT,     :kNEXT],       :expr_mid],

data/lib/opal/parser/lexer.rb

@@ -21,7 +21,7 @@ module Opal
     STR_SSYM   = STR_FUNC_SYMBOL
     STR_DSYM   = STR_FUNC_SYMBOL | STR_FUNC_EXPAND
 
-    attr_reader :line
+    attr_reader :line, :column
     attr_reader :scope
     attr_reader :eof_content
 
@@ -43,6 +43,9 @@ module Opal
 
       @scanner = StringScanner.new(source)
       @scanner_stack = [@scanner]
+
+      @case_stmt = nil
+      @start_of_lambda = nil
     end
 
     def has_local?(local)
@@ -173,21 +176,24 @@ module Opal
     def process_numeric
       @lex_state = :expr_end
 
-      if scan(/0b?(0|1|_)+/)
-        self.yylval = scanner.matched.to_i(2)
-        return :tINTEGER
-      elsif scan(/0o?([0-7]|_)+/)
-        self.yylval = scanner.matched.to_i(8)
-        return :tINTEGER
-      elsif scan(/[\d_]+\.[\d_]+\b|[\d_]+(\.[\d_]+)?[eE][-+]?[\d_]+\b/)
+      if scan(/[\d_]+\.[\d_]+\b|[\d_]+(\.[\d_]+)?[eE][-+]?[\d_]+\b/) # FLOATS
         self.yylval = scanner.matched.gsub(/_/, '').to_f
         return :tFLOAT
-      elsif scan(/[\d_]+\b/)
+      elsif scan(/([^0][\d_]*|0)\b/)                                 # BASE 10
         self.yylval = scanner.matched.gsub(/_/, '').to_i
         return :tINTEGER
-      elsif scan(/0(x|X)(\d|[a-f]|[A-F]|_)+/)
+      elsif scan(/0[bB](0|1|_)+/)                                    # BASE 2
+        self.yylval = scanner.matched.to_i(2)
+        return :tINTEGER
+      elsif scan(/0[xX](\d|[a-f]|[A-F]|_)+/)                         # BASE 16
         self.yylval = scanner.matched.to_i(16)
         return :tINTEGER
+      elsif scan(/0[oO]?([0-7]|_)+/)                                 # BASE 8
+        self.yylval = scanner.matched.to_i(8)
+        return :tINTEGER
+      elsif scan(/0[dD]([0-9]|_)+/)                                  # BASE 10
+        self.yylval = scanner.matched.gsub(/_/, '').to_i
+        return :tINTEGER
       else
         raise "Lexing error on numeric type: `#{scanner.peek 5}`"
       end
@@ -1057,7 +1063,11 @@ module Opal
           if beg?
             @lex_state = :expr_mid
             self.yylval = matched
-            return utype
+            if scanner.peek(1) =~ /\d/ and
+              return utype == :tUMINUS ? '-@NUM' : '+@NUM'
+            else
+              return utype
+            end
           elsif after_operator?
             @lex_state = :expr_arg
             if scan(/@/)

data/lib/opal/path_reader.rb

@@ -0,0 +1,28 @@
+require 'opal/hike_path_finder'
+
+module Opal
+  class PathReader
+    def initialize(file_finder = HikePathFinder.new)
+      @file_finder = file_finder
+    end
+
+    def read(path)
+      full_path = expand(path)
+      return nil if full_path.nil?
+      File.read(full_path)
+    end
+
+    def expand(path)
+      file_finder.find(path)
+    end
+
+    def paths
+      file_finder.paths
+    end
+
+
+    private
+
+    attr_reader :file_finder
+  end
+end

data/lib/opal/paths.rb

@@ -0,0 +1,38 @@
+module Opal
+  def self.gem_dir
+    File.expand_path('../..', __FILE__.untaint)
+  end
+
+  def self.core_dir
+    File.expand_path('../../../opal', __FILE__.untaint)
+  end
+
+  def self.std_dir
+    File.expand_path('../../../stdlib', __FILE__.untaint)
+  end
+
+  # Add a file path to opals load path. Any gem containing ruby code that Opal
+  # has access to should add a load path through this method. Load paths added
+  # here should only be paths which contain code targeted at being compiled by
+  # Opal.
+  def self.append_path(path)
+    paths << path
+  end
+
+  def self.use_gem(gem_name, include_dependecies = true)
+    spec = Gem::Specification.find_by_name(gem_name)
+
+    spec.runtime_dependencies.each do |dependency|
+      use_gem dependency.name
+    end if include_dependecies
+
+    spec.require_paths.each do |path|
+      Opal.append_path File.join(spec.gem_dir, path)
+    end
+  end
+
+  # Private, don't add to these directly (use .append_path instead).
+  def self.paths
+    @paths ||= [core_dir.untaint, std_dir.untaint, gem_dir.untaint]
+  end
+end

data/lib/opal/source_map.rb

@@ -12,29 +12,46 @@ module Opal
     end
 
     def map
-      @map ||= ::SourceMap.new.tap do |map|
-        line, column = 1, 0
-
-        @fragments.each do |fragment|
-          if source_line = fragment.line
-            map.add_mapping(
-              :generated_line => line,
-              :generated_col  => column,
-              :source_line    => source_line,
-              :source_col     => fragment.column,
-              :source         => file
+      @map ||= begin
+        source_file = file+'.rb'
+        generated_line, generated_column = 1, 0
+
+        mappings = @fragments.map do |fragment|
+          mapping = nil
+          source_line   = fragment.line
+          source_column = fragment.column
+          source_code   = fragment.code
+
+          if source_line and source_column
+            source_offset    = ::SourceMap::Offset.new(source_line, source_column)
+            generated_offset = ::SourceMap::Offset.new(generated_line, generated_column)
+
+            mapping = ::SourceMap::Mapping.new(
+              source_file,
+              generated_offset,
+              source_offset
             )
           end
 
-          new_lines = fragment.code.count "\n"
-          line += new_lines
+          new_lines = source_code.count "\n"
+          generated_line += new_lines
 
           if new_lines > 0
-            column = fragment.code.size - (fragment.code.rindex("\n") + 1)
+            generated_column = source_code.size - (source_code.rindex("\n") + 1)
           else
-            column += fragment.code.size
+            generated_column += source_code.size
           end
+
+          mapping
         end
+
+        # Ensure mappings isn't empty: https://github.com/maccman/sourcemap/issues/11
+        unless mappings.any?
+          zero_offset = ::SourceMap::Offset.new(0,0)
+          mappings = [::SourceMap::Mapping.new(source_file,zero_offset,zero_offset)]
+        end
+
+        ::SourceMap::Map.new(mappings.compact)
       end
     end
 

data/lib/opal/sprockets/environment.rb

@@ -20,11 +20,18 @@ module Opal
   class Environment < ::Sprockets::Environment
     def initialize *args
       super
-      Opal.paths.each { |p| append_path p }
+      append_opal_paths
     end
 
     def use_gem gem_name
-      append_path File.join(Gem::Specification.find_by_name(gem_name).gem_dir, 'lib')
+      Opal.use_gem gem_name
+      append_opal_paths
+    end
+
+    private
+
+    def append_opal_paths
+      Opal.paths.each { |p| append_path p }
     end
   end
 end

data/lib/opal/sprockets/erb.rb

@@ -1,6 +1,4 @@
-require 'opal'
 require 'tilt'
-require 'opal/erb'
 require 'sprockets'
 
 module Opal
@@ -19,6 +17,7 @@ module Opal
 
       def initialize_engine
         require_template_library 'opal'
+        require_template_library 'opal/erb'
       end
 
       def prepare

data/lib/opal/sprockets/path_reader.rb

@@ -0,0 +1,34 @@
+module Opal
+  module Sprockets
+
+    class PathReader
+      def initialize(env, context)
+        @env ||= env
+        @context ||= context
+      end
+
+      def read path
+        if path.end_with? '.js'
+          context.depend_on_asset(path)
+          env[path].to_s
+        else
+          context.depend_on(path)
+          File.read(expand(path))
+        end
+      rescue ::Sprockets::FileNotFound
+        nil
+      end
+
+      def expand path
+        env.resolve(path)
+      end
+
+      def paths
+        env.paths
+      end
+
+      attr_reader :env, :context
+    end
+
+  end
+end

data/lib/opal/sprockets/processor.rb

@@ -1,6 +1,9 @@
 require 'set'
+require 'tilt'
 require 'sprockets'
 require 'opal/version'
+require 'opal/builder'
+require 'opal/sprockets/path_reader'
 
 $OPAL_SOURCE_MAPS = {}
 
@@ -11,12 +14,12 @@ module Opal
   # 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]
+  #   * 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
@@ -46,6 +49,9 @@ module Opal
       attr_accessor :dynamic_require_severity
       attr_accessor :source_map_enabled
       attr_accessor :irb_enabled
+      attr_accessor :inline_operators_enabled
+
+      attr_accessor :source_map_register
     end
 
     self.method_missing_enabled      = true
@@ -55,63 +61,58 @@ module Opal
     self.source_map_enabled          = true
     self.irb_enabled                 = false
 
-    def self.stub_file(name)
-      stubbed_files << name.to_s
-    end
+    self.source_map_register         = $OPAL_SOURCE_MAPS
 
-    def self.stubbed_files
-      @stubbed_files ||= Set.new
-    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,
-      }
+      return Opal.compile data unless context.is_a? ::Sprockets::Context
 
-      compiler = Opal::Compiler.new
-      result = compiler.compile data, options
+      path = context.logical_path
+      prerequired = []
 
-      compiler.requires.each do |r|
-        next if stubbed_file? r
-        path = find_opal_require context.environment, r
-        context.require_asset path
-      end
+      builder = self.class.new_builder(context)
+      result = builder.build_str(data, path, :prerequired => prerequired)
 
       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"
+        register_source_map(context.logical_path, result.source_map.to_s)
+        "#{result.to_s}\n//# sourceMappingURL=#{context.logical_path}.map\n"
       else
-        result
+        result.to_s
       end
     end
 
-    def source_map_url(context)
-      "#{prefix}/#{context.logical_path}.js.map"
+    def register_source_map path, map_contents
+      self.class.source_map_register[path] = map_contents
     end
 
-    def source_file_url(context)
-      "#{prefix}/#{context.logical_path.to_s}"
+    def self.stubbed_files
+      @stubbed_files ||= []
     end
 
-    def prefix
-      "/__opal_source_maps__"
+    def self.stub_file(name)
+      stubbed_files << name.to_s
     end
 
-    def stubbed_file?(name)
-      self.class.stubbed_files.include? name
+    def stubbed_files
+      self.class.stubbed_files
     end
 
-    def find_opal_require(environment, r)
-      path = environment.paths.find do |p|
-        File.exist?(File.join(p, "#{r}.rb"))
-      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 ? File.join(path, "#{r}.rb") : r
+      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