opal-cj 0.7.0.beta1

data/lib/opal/compiler.rb

@@ -0,0 +1,307 @@
+require 'set'
+require 'opal/parser'
+require 'opal/fragment'
+require 'opal/nodes'
+
+module Opal
+  def self.compile(source, options = {})
+    Compiler.new(source, options).compile
+  end
+
+  class Compiler
+    # Generated code gets indented with two spaces on each scope
+    INDENT = '  '
+
+    # All compare method nodes - used to optimize performance of
+    # math comparisons
+    COMPARE = %w[< > <= >=]
+
+    # defines a compiler option, also creating method of form 'name?'
+    def self.compiler_option(name, default_value, options = {})
+      mid          = options[:as]
+      valid_values = options[:valid_values]
+      define_method(mid || name) do
+        value = @options.fetch(name) { default_value }
+        raise ArgumentError if valid_values and not(valid_values.include?(value))
+        value
+      end
+    end
+
+    # used for __FILE__ directives as well as finding relative require()
+    compiler_option :file, '(file)'
+
+    # adds method stubs for all used methods in file
+    compiler_option :method_missing, true, :as => :method_missing?
+
+    # adds an arity check to every method definition
+    compiler_option :arity_check, false, :as => :arity_check?
+
+    # compile top level local vars with support for irb style vars
+    compiler_option :irb, false, :as => :irb?
+
+    # how to handle dynamic requires (:error, :warning, :ignore)
+    compiler_option :dynamic_require_severity, :error, :valid_values => [:error, :warning, :ignore]
+
+    # Prepare the code for future requires
+    compiler_option :requirable, false, :as => :requirable?
+
+    # are operators compiled inline
+    compiler_option :inline_operators, false, :as => :inline_operators?
+
+    attr_reader :result, :fragments
+
+    # Current scope
+    attr_accessor :scope
+
+    # Current case_stmt
+    attr_reader :case_stmt
+
+    # Any content in __END__ special construct
+    attr_reader :eof_content
+
+    def initialize(source, options = {})
+      @source = source
+      @indent = ''
+      @unique = 0
+      @options = options
+    end
+
+    # Compile some ruby code to a string.
+    def compile
+      @parser = Parser.new
+
+      @sexp = s(:top, @parser.parse(@source, self.file) || s(:nil))
+      @eof_content = @parser.lexer.eof_content
+
+      @fragments = process(@sexp).flatten
+
+      @result = @fragments.map(&:code).join('')
+    end
+
+    def source_map(source_file = nil)
+      Opal::SourceMap.new(@fragments, source_file || self.file)
+    end
+
+    # Any helpers required by this file
+    def helpers
+      @helpers ||= Set.new([:breaker, :slice])
+    end
+
+    # Operator helpers
+    def operator_helpers
+      @operator_helpers ||= Set.new
+    end
+
+    # Method calls made in this file
+    def method_calls
+      @method_calls ||= Set.new
+    end
+
+    # This is called when a parsing/processing error occurs. This
+    # method simply appends the filename and curent line number onto
+    # the message and raises it.
+    def error(msg, line = nil)
+      raise SyntaxError, "#{msg} :#{file}:#{line}"
+    end
+
+    # This is called when a parsing/processing warning occurs. This
+    # method simply appends the filename and curent line number onto
+    # the message and issues a warning.
+    def warning(msg, line = nil)
+      warn "WARNING: #{msg} :#{file}:#{line}"
+    end
+
+    # Instances of `Scope` can use this to determine the current
+    # scope indent. The indent is used to keep generated code easily
+    # readable.
+    def parser_indent
+      @indent
+    end
+
+    # Create a new sexp using the given parts. Even though this just
+    # returns an array, it must be used incase the internal structure
+    # of sexps does change.
+    def s(*parts)
+      Sexp.new(parts)
+    end
+
+    def fragment(str, sexp = nil)
+      Fragment.new(str, sexp)
+    end
+
+    # Used to generate a unique id name per file. These are used
+    # mainly to name method bodies for methods that use blocks.
+    def unique_temp
+      "TMP_#{@unique += 1}"
+    end
+
+    # Use the given helper
+    def helper(name)
+      self.helpers << name
+    end
+
+    # To keep code blocks nicely indented, this will yield a block after
+    # adding an extra layer of indent, and then returning the resulting
+    # code after reverting the indent.
+    def indent(&block)
+      indent = @indent
+      @indent += INDENT
+      @space = "\n#@indent"
+      res = yield
+      @indent = indent
+      @space = "\n#@indent"
+      res
+    end
+
+    # Temporary varibales will be needed from time to time in the
+    # generated code, and this method will assign (or reuse) on
+    # while the block is yielding, and queue it back up once it is
+    # finished. Variables are queued once finished with to save the
+    # numbers of variables needed at runtime.
+    def with_temp(&block)
+      tmp = @scope.new_temp
+      res = yield tmp
+      @scope.queue_temp tmp
+      res
+    end
+
+    # Used when we enter a while statement. This pushes onto the current
+    # scope's while stack so we know how to handle break, next etc.
+    def in_while
+      return unless block_given?
+      @while_loop = @scope.push_while
+      result = yield
+      @scope.pop_while
+
+      result
+    end
+
+    def in_case
+      return unless block_given?
+      old = @case_stmt
+      @case_stmt = {}
+      yield
+      @case_stmt = old
+    end
+
+    # Returns true if the parser is curently handling a while sexp,
+    # false otherwise.
+    def in_while?
+      @scope.in_while?
+    end
+
+    # Process the given sexp by creating a node instance, based on its type,
+    # and compiling it to fragments.
+    def process(sexp, level = :expr)
+      return fragment('') if sexp == nil
+
+      if handler = handlers[sexp.type]
+        return handler.new(sexp, level, self).compile_to_fragments
+      else
+        raise "Unsupported sexp: #{sexp.type}"
+      end
+    end
+
+    def handlers
+      @handlers ||= Opal::Nodes::Base.handlers
+    end
+
+    # An array of requires used in this file
+    def requires
+      @requires ||= []
+    end
+
+    # An array of trees required in this file
+    # (typically by calling #require_tree)
+    def required_trees
+      @required_trees ||= []
+    end
+
+    # The last sexps in method bodies, for example, need to be returned
+    # in the compiled javascript. Due to syntax differences between
+    # javascript any ruby, some sexps need to be handled specially. For
+    # example, `if` statemented cannot be returned in javascript, so
+    # instead the "truthy" and "falsy" parts of the if statement both
+    # need to be returned instead.
+    #
+    # Sexps that need to be returned are passed to this method, and the
+    # alterned/new sexps are returned and should be used instead. Most
+    # sexps can just be added into a s(:return) sexp, so that is the
+    # default action if no special case is required.
+    def returns(sexp)
+      return returns s(:nil) unless sexp
+
+      case sexp.type
+      when :break, :next, :redo
+        sexp
+      when :yield
+        sexp[0] = :returnable_yield
+        sexp
+      when :scope
+        sexp[1] = returns sexp[1]
+        sexp
+      when :block
+        if sexp.length > 1
+          sexp[-1] = returns sexp[-1]
+        else
+          sexp << returns(s(:nil))
+        end
+        sexp
+      when :when
+        sexp[2] = returns(sexp[2])
+        sexp
+      when :rescue
+        sexp[1] = returns sexp[1]
+
+        if sexp[2] and sexp[2][0] == :resbody
+          if sexp[2][2]
+            sexp[2][2] = returns sexp[2][2]
+          else
+            sexp[2][2] = returns s(:nil)
+          end
+        end
+        sexp
+      when :ensure
+        sexp[1] = returns sexp[1]
+        sexp
+      when :begin
+        sexp[1] = returns sexp[1]
+        sexp
+      when :rescue_mod
+        sexp[1] = returns sexp[1]
+        sexp[2] = returns sexp[2]
+        sexp
+      when :while
+        # sexp[2] = returns(sexp[2])
+        sexp
+      when :return, :js_return
+        sexp
+      when :xstr
+        sexp[1] = "return #{sexp[1]};" unless /return|;/ =~ sexp[1]
+        sexp
+      when :dxstr
+        sexp[1] = "return #{sexp[1]}" unless /return|;|\n/ =~ sexp[1]
+        sexp
+      when :if
+        sexp[2] = returns(sexp[2] || s(:nil))
+        sexp[3] = returns(sexp[3] || s(:nil))
+        sexp
+      else
+        s(:js_return, sexp).tap { |s|
+          s.source = sexp.source
+        }
+      end
+    end
+
+    def handle_block_given_call(sexp)
+      @scope.uses_block!
+      if @scope.block_name
+        fragment("(#{@scope.block_name} !== nil)", sexp)
+      elsif scope = @scope.find_parent_def and scope.block_name
+        fragment("(#{scope.block_name} !== nil)", sexp)
+      else
+        fragment("false", sexp)
+      end
+    end
+  end
+end

data/lib/opal/erb.rb

@@ -0,0 +1,64 @@
+require 'opal/compiler'
+
+module Opal
+  module ERB
+    def self.compile(source, file_name = '(erb)')
+      Compiler.new(source, file_name).compile
+    end
+
+    class Compiler
+      def initialize(source, file_name = '(erb)')
+        @source, @file_name, @result = source, file_name, source
+      end
+
+      def prepared_source
+        @prepared_source ||= begin
+          source = @source
+          source = fix_quotes(source)
+          source = find_contents(source)
+          source = find_code(source)
+          source = wrap_compiled(source)
+          source = require_erb(source)
+          source
+        end
+      end
+
+      def compile
+        Opal.compile prepared_source
+      end
+
+      def fix_quotes(result)
+        result.gsub '"', '\\"'
+      end
+
+      BLOCK_EXPR = /\s+(do|\{)(\s*\|[^|]*\|)?\s*\Z/
+
+      def require_erb(result)
+        'require "erb";'+result
+      end
+
+      def find_contents(result)
+        result.gsub(/<%=([\s\S]+?)%>/) do
+          inner = $1.gsub(/\\'/, "'").gsub(/\\"/, '"')
+
+          if inner =~ BLOCK_EXPR
+            "\")\noutput_buffer.append= #{ inner }\noutput_buffer.append(\""
+          else
+            "\")\noutput_buffer.append=(#{ inner })\noutput_buffer.append(\""
+          end
+        end
+      end
+
+      def find_code(result)
+        result.gsub(/<%([\s\S]+?)%>/) do
+          "\")\n#{ $1 }\noutput_buffer.append(\""
+        end
+      end
+
+      def wrap_compiled(result)
+        path = @file_name.sub(/\.opalerb$/, '')
+        result = "Template.new('#{path}') do |output_buffer|\noutput_buffer.append(\"#{result}\")\noutput_buffer.join\nend\n"
+      end
+    end
+  end
+end

data/lib/opal/fragment.rb

@@ -0,0 +1,41 @@
+module Opal
+  # A fragment holds a string of generated javascript that will be written
+  # to the destination. It also keeps hold of the original sexp from which
+  # it was generated. Using this sexp, when writing fragments in order, a
+  # mapping can be created of the original location => target location,
+  # aka, source-maps!
+  class Fragment
+    # String of javascript this fragment holds
+    attr_reader :code
+
+    def initialize(code, sexp = nil)
+      @code = code.to_s
+      @sexp = sexp
+    end
+
+    # In debug mode we may wish to include the original line as a comment
+    def to_code
+      if @sexp
+        "/*:#{@sexp.line}:#{@sexp.column}*/#{@code}"
+      else
+        @code
+      end
+    end
+
+    # debug:
+    # alias code to_code
+
+    # inspect the contents of this fragment, f("fooo")
+    def inspect
+      "f(#{@code.inspect})"
+    end
+
+    def line
+      @sexp.line if @sexp
+    end
+
+    def column
+      @sexp.column if @sexp
+    end
+  end
+end

data/lib/opal/hike_path_finder.rb

@@ -0,0 +1,18 @@
+require 'hike'
+require 'pathname'
+
+module Opal
+  class HikePathFinder < Hike::Trail
+    def initialize(paths = Opal.paths)
+      super()
+      append_paths(*paths)
+      append_extensions '.js', '.js.rb', '.rb', '.opalerb'
+    end
+
+    def find path
+      pathname = Pathname(path)
+      return path if pathname.absolute? and pathname.exist?
+      super
+    end
+  end
+end

data/lib/opal/nodes.rb

@@ -0,0 +1,26 @@
+require 'opal/nodes/base'
+require 'opal/nodes/literal'
+require 'opal/nodes/variables'
+require 'opal/nodes/constants'
+require 'opal/nodes/call'
+require 'opal/nodes/call_special'
+require 'opal/nodes/module'
+require 'opal/nodes/class'
+require 'opal/nodes/singleton_class'
+require 'opal/nodes/iter'
+require 'opal/nodes/def'
+require 'opal/nodes/if'
+require 'opal/nodes/logic'
+require 'opal/nodes/definitions'
+require 'opal/nodes/yield'
+require 'opal/nodes/rescue'
+require 'opal/nodes/case'
+require 'opal/nodes/super'
+require 'opal/nodes/top'
+require 'opal/nodes/while'
+require 'opal/nodes/for'
+require 'opal/nodes/hash'
+require 'opal/nodes/array'
+require 'opal/nodes/defined'
+require 'opal/nodes/masgn'
+require 'opal/nodes/arglist'