opal-cj 0.7.0.beta1

data/lib/opal/parser/parser_scope.rb

@@ -0,0 +1,25 @@
+module Opal
+  # ParserScope is used during lexing to keep track of local variables
+  # created inside a scope. A lexer scope can be asked if it has a local
+  # variable defined, and it can also check its parent scope if applicable.
+  class ParserScope
+    attr_reader :locals
+    attr_accessor :parent
+
+    def initialize(type)
+      @block  = type == :block
+      @locals = []
+      @parent = nil
+    end
+
+    def add_local(local)
+      @locals << local
+    end
+
+    def has_local?(local)
+      return true if @locals.include? local
+      return @parent.has_local?(local) if @parent and @block
+      false
+    end
+  end
+end

data/lib/opal/parser/sexp.rb

@@ -0,0 +1,75 @@
+module Opal
+  class Sexp
+
+    attr_reader :array
+
+    attr_accessor :source
+
+    def initialize(args)
+      @array = args
+    end
+
+    def type
+      @array[0]
+    end
+
+    def type=(type)
+      @array[0] = type
+    end
+
+    def children
+      @array[1..-1]
+    end
+
+    def method_missing(sym, *args, &block)
+      @array.send sym, *args, &block
+    end
+
+    def <<(other)
+      @array << other
+      self
+    end
+
+    def push(*parts)
+      @array.push(*parts)
+      self
+    end
+
+    def to_ary
+      @array
+    end
+
+    def dup
+      Sexp.new(@array.dup)
+    end
+
+    def ==(other)
+      if other.is_a? Sexp
+        @array == other.array
+      else
+        @array == other
+      end
+    end
+
+    alias eql? ==
+
+    def line
+      @source && @source[0]
+    end
+
+    def column
+      @source && @source[1]
+    end
+
+    def inspect
+      "(#{@array.map { |e| e.inspect }.join ', '})"
+    end
+
+    def pretty_inspect
+      "(#{line ? "#{line} " : ''}#{@array.map { |e| e.inspect }.join ', '})"
+    end
+
+    alias to_s inspect
+  end
+end
+

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

@@ -0,0 +1,70 @@
+# require 'opal'
+require 'source_map'
+
+module Opal
+  class SourceMap
+    attr_reader :fragments
+    attr_reader :file
+
+    def initialize(fragments, file)
+      @fragments = fragments
+      @file = file
+    end
+
+    def map
+      @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 = source_code.count "\n"
+          generated_line += new_lines
+
+          if new_lines > 0
+            generated_column = source_code.size - (source_code.rindex("\n") + 1)
+          else
+            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
+
+    def as_json
+      map.as_json
+    end
+
+    def to_s
+      map.to_s
+    end
+
+    def magic_comment 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,37 @@
+require 'sprockets'
+require 'opal/sprockets/processor'
+require 'opal/sprockets/erb'
+
+module Opal
+  # Proccess using Sprockets
+  #
+  #   Opal.process('opal-jquery')   # => String
+  def self.process asset
+    Environment.new[asset].to_s
+  end
+
+  # 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
+      append_opal_paths
+    end
+
+    def use_gem gem_name
+      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

@@ -0,0 +1,37 @@
+require 'tilt'
+require 'sprockets'
+
+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
+
+      def initialize_engine
+        require_template_library 'opal'
+        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\//, '')
+      end
+    end
+  end
+end
+
+Tilt.register 'opalerb',               Opal::ERB::Processor
+Sprockets.register_engine '.opalerb',  Opal::ERB::Processor

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

@@ -0,0 +1,124 @@
+require 'set'
+require 'tilt'
+require 'sprockets'
+require 'opal/version'
+require 'opal/builder'
+require 'opal/sprockets/path_reader'
+
+$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
+    end
+
+    def self.version
+      ::Opal::VERSION
+    end
+
+    def initialize_engine
+      require_template_library 'opal'
+    end
+
+    def prepare
+    end
+    # ^^^ BOILERPLATE ^^^
+
+
+    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
+
+      attr_accessor :source_map_register
+    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.source_map_register         = $OPAL_SOURCE_MAPS
+
+
+    def evaluate(context, locals, &block)
+      return Opal.compile data unless context.is_a? ::Sprockets::Context
+
+      path = context.logical_path
+      prerequired = []
+
+      builder = self.class.new_builder(context)
+      result = builder.build_str(data, path, :prerequired => prerequired)
+
+      if self.class.source_map_enabled
+        register_source_map(context.logical_path, result.source_map.to_s)
+        "#{result.to_s}\n//# sourceMappingURL=#{context.logical_path}.map\n"
+      else
+        result.to_s
+      end
+    end
+
+    def register_source_map path, map_contents
+      self.class.source_map_register[path] = map_contents
+    end
+
+    def self.stubbed_files
+      @stubbed_files ||= []
+    end
+
+    def self.stub_file(name)
+      stubbed_files << name.to_s
+    end
+
+    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