opal 0.4.3 → 0.4.4

data/corelib/{opal/string.rb → string.rb}

@@ -145,10 +145,6 @@ class String
     }
   end
 
-  def as_json
-    self
-  end
-
   def capitalize
     `#{self}.charAt(0).toUpperCase() + #{self}.substr(1).toLowerCase()`
   end
@@ -402,15 +398,19 @@ class String
 
   def ljust(width, padstr = ' ')
     %x{
-      if (width <= #{self}.length) {
-          return #{self};
+      var length = #{self}.length;
+
+      if (width <= length) {
+        return #{self};
       }
       else {
-        var n_chars = Math.floor(width - #{self}.length)
-        var n_patterns = Math.floor(n_chars/padstr.length);
-        var result = Array(n_patterns + 1).join(padstr);
-        var remaining = n_chars - result.length;
-        return result + padstr.slice(0, remaining) + #{self};
+        var index = -1, result = "";
+
+        while (++index < (width - length)) {
+          result += padstr;
+        }
+
+        return #{self} + result.slice(0, width - length);
       }
     }
   end
@@ -504,8 +504,11 @@ class String
           return #{self};
       }
       else {
-          var ljustified = #{ self.ljust(width, padstr) };
-          return #{self} + ljustified.slice(0, -#{self}.length);
+        var n_chars = Math.floor(width - #{self}.length)
+        var n_patterns = Math.floor(n_chars/padstr.length);
+        var result = Array(n_patterns + 1).join(padstr);
+        var remaining = n_chars - result.length;
+        return result + padstr.slice(0, remaining) + #{self};
       }
     }
   end
@@ -684,8 +687,6 @@ class String
     }
   end
 
-  alias to_json inspect
-
   def to_proc
     %x{
       var name = '$' + #{self};
@@ -705,6 +706,10 @@ class String
 
   alias to_sym intern
 
+  def to_n
+    `#{self}.valueOf()`
+  end
+
   def tr(from, to)
     %x{
       if (from.length == 0 || from === to) {

data/corelib/struct.rb

@@ -0,0 +1,139 @@
+class Struct
+  def self.new(name = undefined, *args)
+    return super unless self == Struct
+
+    if name[0] == name[0].upcase
+      Struct.const_set(name, new(*args))
+    else
+      args.unshift name
+
+      Class.new(self) {
+        args.each { |arg| define_struct_attribute arg }
+      }
+    end
+  end
+
+  def self.define_struct_attribute(name)
+    if self == Struct
+      raise ArgumentError, 'you cannot define attributes to the Struct class'
+    end
+
+    members << name
+
+    define_method name do
+      instance_variable_get "@#{name}"
+    end
+
+    define_method "#{name}=" do |value|
+      instance_variable_set "@#{name}", value
+    end
+  end
+
+  def self.members
+    if self == Struct
+      raise ArgumentError, 'the Struct class has no members'
+    end
+
+    @members ||= []
+  end
+
+  include Enumerable
+
+  def initialize(*args)
+    if args.length == 1 && native?(args[0])
+      object = args[0]
+
+      members.each {|name|
+        instance_variable_set "@#{name}", Native(`#{object}[#{name}]`)
+      }
+    else
+      members.each_with_index {|name, index|
+        instance_variable_set "@#{name}", args[index]
+      }
+    end
+  end
+
+  def members
+    self.class.members
+  end
+
+  def [](name)
+    if Integer === name
+      raise IndexError, "offset #{name} too large for struct(size:#{members.size})" if name >= members.size
+
+      name = members[name]
+    else
+      raise NameError, "no member '#{name}' in struct" unless members.include?(name.to_sym)
+    end
+
+    instance_variable_get "@#{name}"
+  end
+
+  def []=(name, value)
+    if Integer === name
+      raise IndexError, "offset #{name} too large for struct(size:#{members.size})" if name >= members.size
+
+      name = members[name]
+    else
+      raise NameError, "no member '#{name}' in struct" unless members.include?(name.to_sym)
+    end
+
+    instance_variable_set "@#{name}", value
+  end
+
+  def each
+    return enum_for :each unless block_given?
+
+    members.each { |name| yield self[name] }
+  end
+
+  def each_pair
+    return enum_for :each_pair unless block_given?
+
+    members.each { |name| yield name, self[name] }
+  end
+
+  def eql?(other)
+    hash == other.hash || other.each_with_index.all? {|object, index|
+      self[members[index]] == object
+    }
+  end
+
+  def length
+    members.length
+  end
+
+  alias size length
+
+  def to_a
+    members.map { |name| self[name] }
+  end
+
+  alias values to_a
+
+  def to_n
+    result = `{}`
+
+    each_pair {|name, value|
+      `#{result}[#{name}] = #{value.to_n}`
+    }
+
+    result
+  end
+
+  def inspect
+    result = "#<struct "
+
+    if self.class == Struct
+      result += "#{self.class.name} "
+    end
+
+    result += each_pair.map {|name, value|
+      "#{name}=#{value.inspect}"
+    }.join ", "
+
+    result += ">"
+
+    result
+  end
+end

data/lib/opal.rb

@@ -34,6 +34,10 @@ module Opal
     paths << path
   end
 
+  def self.use_gem(gem_name)
+    Opal.append_path File.join(Gem::Specification.find_by_name(gem_name).gem_dir, 'lib')
+  end
+
   # Private, don't add to these directly (use .append_path instead).
   def self.paths
     @paths ||= [core_dir, std_dir]

data/lib/opal/cli.rb

@@ -1,5 +1,3 @@
-require 'opal'
-
 begin
   require 'opal-sprockets'
 rescue LoadError
@@ -10,25 +8,63 @@ rescue LoadError
   exit -1
 end
 
+require 'opal'
+require 'rack'
+
 module Opal
   class CLI
     attr_reader :options, :filename
 
-    def initialize _filename, options
-      require 'rack'
+    def initialize filename, options
+      @options = options || {}
+      @filename = filename
+    end
+
+    def puts *args
+      output.puts *args
+    end
+
+    def output
+      @output ||= options[:output] || $stdout
+    end
+
+
+    def run
+      set_processor_options
+      prepare_eval_code
+
+      case
+      when options[:sexp];    show_sexp
+      when options[:compile]; show_compiled_source
+      when options[:server];  start_server
+      else                    run_code
+      end
+    end
+
+    def show_compiled_source
+      if sprockets[filename]
+        puts sprockets[filename].to_a.last
+      else
+        puts Opal.parse(filename, options)
+      end
+    end
 
-      @options = options
-      @filename = _filename
+    def show_sexp
+      puts sexp.inspect
+    end
 
+    def set_processor_options
       processor_options.each do |option|
         key = option.to_sym
         next unless options.has_key? key
         Opal::Processor.send("#{option}=", options[key])
       end
+    end
 
+    def prepare_eval_code
       if options[:evals] and options[:evals].any?
-        require 'tempfile'
-        path = File.join(Dir.tmpdir,"opal-#{$$}.js.rb")
+        require 'tmpdir'
+        path = File.join(Dir.mktmpdir,"opal-#{$$}.js.rb")
         File.open(path, 'w') do |tempfile|
           options[:load_paths] ||= []
           options[:load_paths] << File.dirname(path)
@@ -40,39 +76,46 @@ module Opal
         end
         @filename = File.basename(path)
       end
-
-      case
-      when options[:sexp]
-        puts sexp.inspect
-      when options[:compile]
-        if File.exist?(filename)
-          puts sprockets[filename].to_a.last
-        else
-          puts Opal.parse(filename, options)
-        end
-      when options[:server]
-        server_start
-      else
-        run
-      end
     end
 
-    def run
+    def run_code
       begin
         full_source = sprockets[filename]
-        IO.popen('node', 'w') do |stdin|
-          stdin.write full_source
-        end
-      rescue Errno::ENOENT
-        $stderr.puts 'Please install Node.js to be able to run Opal scripts.'
-        exit 127
+      rescue Sprockets::FileOutsidePaths => e
+        @server = nil
+        full_path = File.expand_path(filename)
+        load_paths << File.dirname(full_path)
+        _filename = File.basename(full_path)
+        full_source = sprockets[_filename]
       end
+
+      require 'open3'
+
+      # out, err, status = Open3.capture3('node', :stdin_data => full_source)
+      i, o, e = Open3.popen3('node')
+      i.write full_source
+      i.close
+      output_text = o.read
+      status = $?
+
+      raise "Errored: #{e}" if status != 0
+      puts output_text
+
+    rescue Errno::ENOENT
+      $stderr.puts 'Please install Node.js to be able to run Opal scripts.'
+      exit 127
     end
 
     def sexp
       Opal::Grammar.new.parse(source)
     end
 
+    def map
+      parser = Opal::Parser.new
+      parser.parse(filename, options)
+      parser.source_map
+    end
+
     def source
       File.exist?(filename) ? File.read(filename) : filename
     end
@@ -95,14 +138,18 @@ module Opal
 
     def server
       @server ||= Opal::Server.new do |s|
-        (options[:load_paths] || []).each do |path|
+        load_paths.each do |path|
           s.append_path path
         end
         s.main = File.basename(filename, '.rb')
       end
     end
 
-    def server_start
+    def load_paths
+      @load_paths ||= options[:load_paths] || []
+    end
+
+    def start_server
       require 'rack'
       require 'webrick'
       require 'logger'

data/lib/opal/cli_options.rb

@@ -0,0 +1,91 @@
+require 'optparse'
+
+module Opal
+  class CLIOptions < OptionParser
+    def initialize
+      @options = {}
+
+      super do |opts|
+        opts.banner = 'Usage: opal [options] -- [programfile]'
+
+        opts.on('-v', '--version', 'Display Opal Version') do |v|
+          require 'opal/version'
+          puts "Opal v#{Opal::VERSION}"
+          exit
+        end
+
+        opts.on("-h", "--help", "Show this message") do
+          puts opts
+          exit
+        end
+
+        opts.separator ''
+        opts.separator 'Basic Options:'
+
+        opts.on('-I', '--include DIR',
+                'Append a load path (may be used more than once)') do |i|
+          options[:load_paths] ||= []
+          options[:load_paths] << i
+        end
+
+        opts.on('-e', '--eval SOURCE', String,
+                'One line of script. Several -e\'s allowed. Omit [programfile]') do |source|
+          options[:evals] ||= []
+          options[:evals] << source
+        end
+
+        opts.on('-s', '--sexp', 'Show Sexps') do
+          options[:sexp] = true
+        end
+
+        opts.on('-m', '--map', 'Show sourcemap') do
+          options[:map] = true
+        end
+
+        opts.on('-c', '--compile', 'Compile to JavaScript') do
+          options[:compile] = true
+        end
+
+        opts.on('-s', '--server [PORT]', 'Start a server (default port: 3000)') do |port|
+          options[:server] = port.to_i
+        end
+
+
+        opts.separator ''
+        opts.separator 'Compilation Options:'
+
+        opts.on('-M', '--no-method-missing', 'Disable method missing') do |value|
+          options[:method_missing] = false
+        end
+
+        opts.on('-O', '--no-optimized-operators', 'Disable optimized operators') do |value|
+          options[:optimized_operators_enabled] = false
+        end
+
+        opts.on('-A', '--arity-check', 'Enable arity check') do |value|
+          options[:arity_check] = true
+        end
+
+        opts.on('-C', '--no-const-missing', 'Disable const missing') do |value|
+          options[:const_missing] = false
+        end
+
+        dynamic_require_levels = %w[error warning ignore]
+        opts.on('-D', '--dynamic-require LEVEL', dynamic_require_levels,
+                      'Set levelDynamic require severity') do |level|
+          options[:dynamic_require_severity] = level
+        end
+
+        opts.on('-P', '--no-source-map', 'Disable source map') do |value|
+          options[:source_map_enabled] = false
+        end
+
+        opts.on("--irb", "IRB var mode") do |i|
+          options[:irb] = true
+        end
+      end
+    end
+
+    attr_reader :options
+  end
+end