opal-wedge 0.9.0.dev

data/lib/opal/parser/parser_scope.rb

@@ -0,0 +1,28 @@
+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
+
+    # Create new parse scope. Valid types are :block, :class, :module, :def.
+    #
+    # @param type [Symbol] scope type
+    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,81 @@
+module Opal
+  # [Opal::Sexp] is used to build up the syntax tree inside [Opal::Parser]. The
+  # compiler then steps through the sexp trees to generate the javascript code.
+  #
+  # For example, an array of integers `[1, 2]` might be represented by:
+  #
+  #     s(:array, s(:int, 1), s(:int, 2))
+  #
+  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,35 @@
+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.open(full_path, 'rb:UTF-8'){|f| f.read}
+    end
+
+    def expand(path)
+      if Pathname.new(path).absolute? || path =~ %r{\A\.?\.#{File::SEPARATOR}}
+        path
+      else
+        file_finder.find(path)
+      end
+    end
+
+    def paths
+      file_finder.paths
+    end
+
+    def append_paths(*paths)
+      file_finder.append_paths(*paths)
+    end
+
+    private
+
+    attr_reader :file_finder
+  end
+end

data/lib/opal/paths.rb

@@ -0,0 +1,55 @@
+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)
+    append_paths(path)
+  end
+  def self.append_paths(*paths)
+    self.paths.concat(paths)
+  end
+
+  module UseGem
+    def use_gem(gem_name, include_dependencies = true)
+      append_paths(*require_paths_for_gem(gem_name, include_dependencies))
+    end
+    
+    private
+
+    def require_paths_for_gem(gem_name, include_dependencies)
+      paths = []
+      spec = Gem::Specification.find_by_name(gem_name)
+
+      spec.runtime_dependencies.each do |dependency|
+        paths += require_paths_for_gem(dependency.name, include_dependencies)
+      end if include_dependencies
+
+      gem_dir = spec.gem_dir
+      spec.require_paths.map do |path|
+        paths << File.join(gem_dir, path)
+      end
+
+      paths
+    end
+  end
+
+  extend UseGem
+
+  # 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/regexp_anchors.rb

@@ -0,0 +1,5 @@
+module Opal
+  REGEXP_START = RUBY_ENGINE == 'opal' ? '^' : '\A'.freeze
+  REGEXP_END = RUBY_ENGINE == 'opal' ? '$' : '\z'.freeze 
+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,3 @@
+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,31 @@
+require 'sprockets'
+require 'opal/sprockets/processor'
+require 'opal/sprockets/erb'
+
+module Opal
+  # @deprecated
+  def self.process asset
+    Environment.new[asset].to_s
+  end
+
+  # @deprecated
+  class Environment < ::Sprockets::Environment
+    def initialize *args
+      warn "WARNING: Opal::Sprockets::Environment is deprecated. "\
+           "Please use Opal::Server directly or append Opal.paths to the environment manually."
+      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,23 @@
+require 'tilt'
+require 'sprockets'
+require 'opal/sprockets/processor'
+
+module Opal
+  module ERB
+    class Processor < ::Opal::Processor
+      def initialize_engine
+        super
+        require_template_library 'opal/erb'
+      end
+
+      def evaluate(context, locals, &block)
+        compiler = Opal::ERB::Compiler.new(@data, context.logical_path.sub(/#{REGEXP_START}templates\//, ''))
+        @data = compiler.prepared_source
+        super
+      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,36 @@
+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, bundle: true].to_s
+        else
+          context.depend_on(path)
+          File.open(expand(path), 'rb:UTF-8'){|f| f.read}
+        end
+      rescue ::Sprockets::FileNotFound
+        nil
+      end
+
+      def expand path
+        env.resolve(path) or
+          # Sprockets 3 just returns nil for unknown paths
+          raise ::Sprockets::FileNotFound, path.inspect
+      end
+
+      def paths
+        env.paths
+      end
+
+      attr_reader :env, :context
+    end
+
+  end
+end

data/lib/opal/sprockets/processor.rb

@@ -0,0 +1,167 @@
+require 'set'
+require 'tilt/opal'
+require 'sprockets'
+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.
+  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 evaluate(context, locals, &block)
+      return super unless context.is_a? ::Sprockets::Context
+
+      @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
+      root_path_regexp = Regexp.escape(context.root_path)
+      logical_path = filename.gsub(%r{^#{root_path_regexp}/?(.*?)#{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'
+
+      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
+
+    def self.sprockets_extnames_regexp(sprockets)
+      joined_extnames = (['.js']+sprockets.engines.keys).map { |ext| Regexp.escape(ext) }.join('|')
+      Regexp.new("(#{joined_extnames})*$")
+    end
+
+    def sprockets_extnames_regexp
+      @sprockets_extnames_regexp ||= self.class.sprockets_extnames_regexp(@sprockets)
+    end
+
+    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
+
+    # 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)}#{REGEXP_END}/, '')
+      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
+
+        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
+
+    def self.load_asset_code(sprockets, name)
+      asset = sprockets[name.sub(/(\.(js|rb|opal))*#{REGEXP_END}/, '.js')]
+      return '' if asset.nil?
+
+      opal_extnames = sprockets.engines.map do |ext, engine|
+        ext if engine <= ::Opal::Processor
+      end.compact
+
+      module_name = -> asset { asset.logical_path.sub(/\.js#{REGEXP_END}/, '') }
+      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? }
+
+      non_opal_assets = ([asset]+asset.dependencies)
+        .select { |asset| not(processed_by_opal[asset]) }
+        .map { |asset| module_name[asset] }
+
+      mark_as_loaded = (['opal'] + non_opal_assets + stubbed_files.to_a)
+        .map { |path| mark_as_loaded[path] }
+
+      if processed_by_opal[asset]
+        load_asset_code = "Opal.load(#{module_name[asset].inspect});"
+      end
+
+      <<-JS
+      if (typeof(Opal) !== 'undefined') {
+        #{mark_as_loaded.join("\n")}
+        #{load_asset_code}
+      }
+      JS
+    end
+
+    def self.stubbed_files
+      @stubbed_files ||= Set.new
+    end
+
+    def self.stub_file(name)
+      stubbed_files << name.to_s
+    end
+
+    def stubbed_files
+      self.class.stubbed_files
+    end
+  end
+end
+
+Sprockets.register_engine '.rb',  Opal::Processor
+Sprockets.register_engine '.opal',  Opal::Processor