opal 0.3.44 → 0.4.0

data/opal/opal/time.rb

@@ -53,7 +53,9 @@ class Time
     to_f <=> other.to_f
   end
 
-  alias_native :day, :getDate
+  def day
+    `#{self}.getDate()`
+  end
 
   def eql?(other)
     other.is_a?(Time) && (self <=> other).zero?
@@ -63,13 +65,19 @@ class Time
     `#{self}.getDay() === 5`
   end
 
-  alias_native :hour, :getHours
+  def hour
+    `#{self}.getHours()`
+  end
 
-  alias_native :inspect, :toString
+  def inspect
+    `#{self}.toString()`
+  end
 
   alias mday day
 
-  alias_native :min, :getMinutes
+  def min
+    `#{self}.getMinutes()`
+  end
 
   def mon
     `#{self}.getMonth() + 1`
@@ -85,7 +93,9 @@ class Time
     `#{self}.getDay() === 6`
   end
 
-  alias_native :sec, :getSeconds
+  def sec
+    `#{self}.getSeconds()`
+  end
 
   def strftime(format = '')
     %x{
@@ -127,11 +137,19 @@ class Time
     `#{self}.getDay() === 2`
   end
 
-  alias_native :wday, :getDay
+  def wday
+    `#{self}.getDay()`
+  end
 
   def wednesday?
     `#{self}.getDay() === 3`
   end
 
-  alias_native :year, :getFullYear
+  def year
+    `#{self}.getFullYear()`
+  end
+
+  def to_n
+    self
+  end
 end

data/opal/source_map.rb

@@ -0,0 +1,63 @@
+require 'opal/json'
+
+require 'source_map/vlq.rb'
+require 'source_map/generator.rb'
+require 'source_map/parser.rb'
+
+class SourceMap
+  include SourceMap::Generator
+  include SourceMap::Parser
+
+  # Create a new blank SourceMap
+  #
+  # Options may include:
+  #
+  # :file => String           # See {#file}
+  # :source_root => String    # See {#source_root}
+  # :generated_output => IO   # See {#generated_output}
+  #
+  # :sources => Array[String] # See {#sources}
+  # :names => Array[String]   # See {#names}
+  #
+  # :version => 3             # Which version of SourceMap to use (only 3 is allowed)
+  #
+  def initialize(opts={})
+    unless (remain = opts.keys - [:generated_output, :file, :source_root, :sources, :names, :version]).empty?
+      raise ArgumentError, "Unsupported options to SourceMap.new: #{remain.inspect}"
+    end
+    self.generated_output = opts[:generated_output]
+    self.file = opts[:file] || ''
+    self.source_root = opts[:source_root] || ''
+    self.version = opts[:version] || 3
+    self.sources = opts[:sources] || []
+    self.names = opts[:names] || []
+    self.mappings = []
+    raise "version #{opts[:version]} not supported" if version != 3
+  end
+
+  # The name of the file containing the code that this SourceMap describes.
+  # (default "")
+  attr_accessor :file
+
+  # The URL/directory that contains the original source files.
+  #
+  # This is prefixed to the entries in ['sources']
+  # (default "")
+  attr_accessor :source_root
+
+  # The version of the SourceMap spec we're using.
+  # (default 3)
+  attr_accessor :version
+
+  # The list of sources (used during parsing/generating)
+  # These are relative to the source_root.
+  # (default [])
+  attr_accessor :sources
+
+  # A list of names (used during parsing/generating)
+  # (default [])
+  attr_accessor :names
+
+  # A list of mapping objects.
+  attr_accessor :mappings
+end

data/opal/source_map/generator.rb

@@ -0,0 +1,251 @@
+class SourceMap
+  module Generator
+
+    # An object (responding to <<) that will be written to whenever
+    # {add_generated} is called.
+    #
+    # @example
+    #
+    #   File.open("/var/www/a.js.min"){ |f|
+    #     map = SourceMap.new(:generated_output => f)
+    #     map.add_generated('function(a,b,c){minified=1}\n', :source => 'a.js')
+    #     map.save('/var/www/a.js.map')
+    #   }
+    #   File.read('/var/www/a.js.min') == 'function(a,b,c){minified=1}\n'
+    #
+    attr_accessor :generated_output
+
+    # Add the mapping for generated code to this source map.
+    #
+    # The first parameter is the generated text that you're going to add to the output, if
+    # it contains multiple lines of code then it will be added to the source map as
+    # several mappings.
+    #
+    # If present, the second parameter represents the original source of the generated
+    # fragment, and may contain:
+    #
+    # :source => String,           # The filename of the source fille that contains this fragment.
+    # :source_line => Integer,     # The line in that file that contains this fragment
+    # :source_col => Integer,      # The column in that line at which this fragment starts
+    # :name => String              # The original name for this variable.
+    # :exact_position => Bool      # Whether all lines in the generated fragment came from
+    #                                the same position in the source.
+    #
+    # The :source key is required to set :source_line, :source_col or :name.
+    #
+    # If unset :source_line and :source_col default to 1,0 for the first line of the
+    # generated fragment.
+    #
+    # Normally :source_line is incremented and :source_col reset at every line break in
+    # the generated code (because we assume that you're copying a verbatim fragment from
+    # the source into the generated code). If that is not the case, you can set
+    # :exact_position => true, and then all lines in the generated output will be given
+    # the same :source_line and :source_col.
+    #
+    # The :name property is used if the fragment you are adding contains only a name that
+    # you have renamed in the source transformation.
+    #
+    # If you'd like to ensure that the source map stays in sync with the generated
+    # source, consider calling {source_map.generated_output = StringIO.new} and then
+    # accessing your generated javascript with {source_map.generated_output.string},
+    # otherwise be careful to always write to both.
+    #
+    # NOTE: By long-standing convention, the first line of a file is numbered 1, not 0.
+    #
+    # NOTE: when generating a source map, you should either use this method always, or use
+    # the {#add_mapping} method always.
+    #
+    def add_generated(text, opts={})
+      if !opts[:source] && (opts[:name] || opts[:source_line] || opts[:source_col])
+        raise "mapping must have :source to have :source_line, :source_col or :name"
+      elsif opts[:source_line] && opts[:source_line] < 1
+        raise "files start on line 1 (got :source_line => #{opts[:source_line]})"
+      elsif !(remain = opts.keys - [:source, :source_line, :source_col, :name, :exact_position]).empty?
+        raise "mapping had unexpected keys: #{remain.inspect}"
+      end
+
+      source_line = opts[:source_line] || 1
+      source_col = opts[:source_col] || 0
+      self.generated_line ||= 1
+      self.generated_col ||= 0
+
+      text.split(/(\n)/).each do |line|
+        if line == "\n"
+          self.generated_line += 1
+          self.generated_col = 0
+          unless opts[:exact_position]
+            source_line += 1
+            source_col = 0
+          end
+        elsif line != ""
+          mapping = {
+            :generated_line => generated_line,
+            :generated_col => generated_col,
+          }
+          if opts[:source]
+            mapping[:source] = opts[:source]
+            mapping[:source_line] = source_line
+            mapping[:source_col] = source_col
+            mapping[:name] = opts[:name] if opts[:name]
+          end
+
+          mappings << mapping
+
+          self.generated_col += line.size
+          source_col += line.size unless opts[:exact_position]
+        end
+      end
+
+      generated_output += text if generated_output
+    end
+
+    # Add a mapping to the list for this object.
+    #
+    # A mapping identifies a fragment of code that has been moved around during
+    # transformation from the source file to the generated file. The fragment should
+    # be contiguous and not contain any line breaks.
+    #
+    # Mappings are Hashes with a valid subset of the following 6 keys:
+    #
+    # :generated_line => Integer,  # The line in the generated file that contains this fragment.
+    # :generated_col  => Integer,  # The column in the generated_line that this mapping starts on
+    # :source => String,           # The filename of the source fille that contains this fragment.
+    # :source_line => Integer,     # The line in that file that contains this fragment.
+    # :source_col => Integer,      # The column in that line at which this fragment starts.
+    # :name => String              # The original name for this variable (if applicable).
+    #
+    #
+    # The only 3 valid subsets of keys are:
+    #   [:generated_line, :generated_col] To indicate that this is a fragment in the
+    #   output file that you don't have the source for.
+    #
+    #   [:generated_line, :generated_col, :source, :source_line, :source_col] To indicate
+    #   that this is a fragment in the output file that you do have the source for.
+    #
+    #   [:generated_line, :generated_col, :source, :source_line, :source_col, :name] To
+    #   indicate that this is a particular identifier at a particular location in the original.
+    #
+    # Any other combination of keys would produce an invalid source map.
+    #
+    # NOTE: By long-standing convention, the first line of a file is numbered 1, not 0.
+    #
+    # NOTE: when generating a source map, you should either use this method always,
+    # or use the {#add_generated} method always.
+    #
+    def add_mapping(map)
+      if !map[:generated_line] || !map[:generated_col]
+        raise "mapping must have :generated_line and :generated_col"
+      elsif map[:source] && !(map[:source_line] && map[:source_col])
+        raise "mapping must have :source_line and :source_col if it has :source"
+      elsif !map[:source] && (map[:source_line] || map[:source_col])
+        raise "mapping may not have a :source_line or :source_col without a :source"
+      elsif map[:name] && !map[:source]
+        raise "mapping may not have a :name without a :source"
+      elsif map[:source_line] && map[:source_line] < 1
+        raise "files start on line 1 (got :source_line => #{map[:source_line]})"
+      elsif map[:generated_line] < 1
+        raise "files start on line 1 (got :generated_line => #{map[:generated_line]})"
+      elsif !(remain = map.keys - [:generated_line, :generated_col, :source, :source_line, :source_col, :name]).empty?
+        raise "mapping had unexpected keys: #{remain.inspect}"
+      end
+
+      mappings << map
+    end
+
+    # Convert the map into an object suitable for direct serialisation.
+    def as_json
+      serialized_mappings = serialize_mappings!
+
+      {
+        'version' => version,
+        'file' => file,
+        'sourceRoot' => source_root,
+        'sources' => sources,
+        'names' => names,
+        'mappings' => serialized_mappings
+      }
+    end
+
+    # Convert the map to a string.
+    def to_s
+      as_json.to_json
+    end
+
+    # Write this map to a file.
+    def save(file)
+      File.open(file, "w"){ |f| f << to_s }
+    end
+
+    protected
+
+    attr_reader :source_ids, :name_ids
+    attr_accessor :generated_line, :generated_col
+
+    # Get the id for the given file. If we've not
+    # seen this file before, add it to the list.
+    def source_id(file)
+      if (cached = source_ids[file])
+        cached
+      else
+        sources << file
+        source_ids[file] = sources.size - 1
+      end
+    end
+
+    # Get the id for the given name. If we've not
+    # seen this name before, add it to the list.
+    def name_id(name)
+      if (cached = name_ids[file])
+        cached
+      else
+        names << name
+        name_ids[file] = names.size - 1
+      end
+    end
+
+    # Encode a vlq. As each field in the output should be relative to the
+    # previous occurance of that field, we keep track of each one.
+    def vlq(num, type)
+      ret = num - @previous_vlq[type]
+      @previous_vlq[type] = num
+      VLQ.encode(ret)
+    end
+
+    # Serialize the list of mappings into the string of base64 variable length
+    # quanities. As a side-effect, regenerate the sources and names arrays.
+    def serialize_mappings!
+      # clear all internals as we're about to re-generate them.
+      @sources  = []
+      @source_ids = {}
+      @names    = []
+      @name_ids = {}
+      @previous_vlq = Hash.new{ 0 }
+
+      return "" if mappings.empty?
+
+      by_lines = mappings.group_by{ |x| x[:generated_line] }
+
+      (1..by_lines.keys.max).map do |line|
+        # reset the generated_col on each line as indicated by the VLQ spec.
+        # (the other values continue to be relative)
+        @previous_vlq[:generated_col] = 0
+
+        fragments = (by_lines[line] || []).sort_by{ |x| x[:generated_col] }
+        fragments.map do |map|
+          serialize_mapping(map)
+        end.join(",")
+      end.join(";")
+    end
+
+    def serialize_mapping(map)
+      item = vlq(map[:generated_col], :generated_col)
+      if map[:source]
+        item += vlq(source_id(map[:source]), :source)
+        item += vlq(map[:source_line] - 1, :source_line)
+        item += vlq(map[:source_col], :source_col)
+        item += vlq(name_id(map[:name]), :name) if map[:name]
+      end
+      item
+    end
+  end
+end

data/opal/source_map/parser.rb

@@ -0,0 +1,102 @@
+class SourceMap
+
+  class ParserError < RuntimeError; end
+
+  # Load a SourceMap from a Hash such as might be returned by
+  # {SourceMap#as_json}.
+  #
+  def self.from_json(json)
+    raise ParserError, "Cannot parse version: #{json['version']} of SourceMap" unless json['version'] == 3
+
+    map = new(:file => json['file'],
+              :source_root => json['sourceRoot'],
+              :sources => json['sources'],
+              :names => json['names'])
+
+    map.parse_mappings(json['mappings'] || '')
+    map
+  end
+
+  # Load a SourceMap from a String.
+  def self.from_s(str)
+    from_json JSON.parse(str)
+  end
+
+  # Load a SourceMap from a file.
+  def self.load(filename)
+    from_s File.read(filename)
+  end
+
+  module Parser
+    # Parse the mapping string from a SourceMap.
+    #
+    # The mappings string contains one comma-separated list of segments per line
+    # in the output file, these lists are joined by semi-colons.
+    #
+    def parse_mappings(string)
+      @previous = Hash.new{ 0 }
+
+      string.split(";").each_with_index do |line, line_idx|
+        # The generated_col resets to 0 at the start of every line, though
+        # all the other differences are maintained.
+        @previous[:generated_col] = 0
+        line.split(",").each do |segment|
+          mappings << parse_mapping(segment, line_idx + 1)
+        end
+      end
+
+      self.mappings = self.mappings.sort_by{ |x| [x[:generated_line], x[:generated_col]] }
+    end
+
+    # All the numbers in SourceMaps are stored as differences from each other,
+    # so we need to remove the difference every time we read a number.
+    def undiff(int, type)
+      @previous[type] += int
+    end
+
+    # Parse an individual mapping.
+    #
+    # This is a list of variable-length-quanitity, with 1, 4 or 5 items. See the spec
+    # https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit
+    # for more details.
+    def parse_mapping(segment, line_num)
+      item = VLQ.decode_array(segment)
+
+      unless [1, 4, 5].include?(item.size)
+        raise ParserError, "In map for #{file}:#{line_num}: unparseable item: #{segment}"
+      end
+
+      map = {
+        :generated_line => line_num,
+        :generated_col => undiff(item[0], :generated_col),
+      }
+
+      if item.size >= 4
+        map[:source] = sources[undiff(item[1], :source_id)]
+        map[:source_line] = undiff(item[2], :source_line) + 1 # line numbers are stored starting from 0
+        map[:source_col] = undiff(item[3], :source_col)
+        map[:name] = names[undiff(item[4], :name_id)] if item[4]
+      end
+
+      if map[:generated_col] < 0
+        raise ParserError, "In map for #{file}:#{line_num}: unexpected generated_col: #{map[:generated_col]}"
+
+      elsif map.key?(:source) && (map[:source].nil? || @previous[:source_id] < 0)
+        raise ParserError, "In map for #{file}:#{line_num}: unknown source id: #{@previous[:source_id]}"
+
+      elsif map.key?(:source_line) && map[:source_line] < 1
+        raise ParserError, "In map for #{file}:#{line_num}: unexpected source_line: #{map[:source_line]}"
+
+      elsif map.key?(:source_col) && map[:source_col] < 0
+        raise ParserError, "In map for #{file}:#{line_num}: unexpected source_col: #{map[:source_col]}"
+
+      elsif map.key?(:name) && (map[:name].nil? || @previous[:name_id] < 0)
+        raise ParserError, "In map for #{file}:#{line_num}: unknown name id: #{@previous[:name_id]}"
+
+      else
+        map
+
+      end
+    end
+  end
+end