opal 0.2.2 → 0.3.0

data/gems/dev/tools/racc2js/parser.js

@@ -0,0 +1,218 @@
+var parser = function() {
+  
+};
+
+parser.prototype.do_parse = function() {
+  return this.do_parse_js(parser.Racc_arg, false);
+};
+
+parser.prototype.do_parse_js = function(arg, in_debug) {
+  var action_table    = arg[0],
+      action_check    = arg[1],
+      action_default  = arg[2],
+      action_pointer  = arg[3],
+      
+      goto_table      = arg[4],
+      goto_check      = arg[5],
+      goto_default    = arg[6],
+      goto_pointer    = arg[7],
+      
+      nt_base         = arg[8],
+      reduce_table    = arg[9],
+      token_table     = arg[10],
+      shift_n         = arg[11],
+      reduce_n        = arg[12],
+      
+      use_result      = arg[13];
+  
+  // racc sys vars
+  var racc_state      = [0],
+      racc_tstack     = [],
+      racc_vstack     = [],
+      
+      racc_t          = null,
+      racc_tok        = null,
+      racc_val        = null,
+      racc_read_next  = true,
+      
+      racc_user_yyerror = false,
+      racc_error_status = 0;
+  
+  var token = null, act = null, i = null, nerr = 0, curstate = null;
+  
+  while (true) {
+  //  console.log('looping');
+    if ((i = action_pointer[racc_state[racc_state.length - 1]]) !== null) {
+    //  console.log('yeap');
+      if (racc_read_next) {
+        if (racc_t !== 0) { // not EOF
+          token = this.next_token();
+          racc_tok = token[0];
+          racc_val = token[1];
+          
+        //  console.log('token is: ' + token.join(','));
+          
+          if (!racc_tok) { // EOF
+            racc_t = 0;
+          }
+          else {
+            racc_t = token_table[racc_tok];
+            if (racc_t === undefined) racc_t = 1;
+          }
+          
+        //  console.log('racc_t: ' + racc_t);
+          
+          racc_read_next = false;
+        }
+      }
+            
+      i += racc_t;
+      
+    //  console.log('i is now ' + i);
+      
+      if ((i < 0) || ((act = action_table[i]) === null) || (action_check[i] !== racc_state[racc_state.length - 1])) {
+        act = action_default[racc_state[racc_state.length - 1]];
+      }
+    }
+    else {
+      act = action_default[racc_state[racc_state.length - 1]];
+    }
+    
+  //  console.log('act is: ' + act);
+    
+    // ================
+    // = racc_evalact =
+    // ================
+    
+    if (act > 0 && act < shift_n) {
+    //  console.log('shift on ' + act);
+      // 
+      // shift
+      // 
+      if (racc_error_status > 0) {
+        // error token
+      //  console.log('err part 1');
+        if (racc_t !== 1) {
+        //  console.log('err part 2');
+          racc_error_status -= 1;
+        }
+      }
+      
+      racc_vstack.push(racc_val);
+      curstate = act;
+      racc_state.push(act);
+      racc_read_next = true;
+    }
+    else if (act < 0 && act > -reduce_n) {
+    //  console.log('~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ reduce on ' + act);
+      // 
+      // reduce
+      // 
+      var reduce_i    = act * -3,
+          reduce_len  = reduce_table[reduce_i],
+          reduce_to   = reduce_table[reduce_i + 1],
+          method_id   = reduce_table[reduce_i + 2];
+      
+      var tmp_v = racc_vstack.slice(racc_vstack.length - reduce_len);
+    //  console.log('reduce len is: ' + reduce_len);
+    //  console.log('tmp_v is: ' + tmp_v.join(', '));
+      
+      // pop for number of reductions
+      while(reduce_len--) {
+      //  console.log('popping: ' + reduce_len);
+        racc_state.pop();
+        racc_vstack.pop();
+        racc_tstack.pop();
+      }
+      
+      if (use_result) {
+        // msgsend..we push on result of method call..?
+      //  console.log('reducing: ' + method_id);
+      //  console.log('['+tmp_v.join(', ')+']');
+      //  console.log('[' + racc_vstack.join(', ') + ']');
+        // racc_vstack.push(method_id);
+      //  console.log("NEED TO EXECUTE: [" + tmp_v.join(',') + ']');
+      //  console.log(this[method_id]);
+        var reduce_call_result = this[method_id](tmp_v, tmp_v[0]);
+      //  console.log(reduce_call_result);
+        racc_vstack.push(reduce_call_result);
+      }
+      else {
+        throw "not using result?!?!?!?!?!";
+      }
+      
+      racc_tstack.push(reduce_to);
+      
+    //  console.log('VSTACK: [' + racc_vstack.join(', ') + ']');
+      
+      var k1 = reduce_to - nt_base;
+    //  console.log('k1 is ' +k1);
+    //  console.log("goto pointer is: " + goto_pointer[k1]);
+      if ((reduce_i = goto_pointer[k1]) !== null) {
+        
+        reduce_i += racc_state[racc_state.length - 1];
+      //  console.log("reduce_i is now: " + reduce_i);
+      //  console.log("-- potential curstate is: " + goto_table[reduce_i]);
+        if ((reduce_i >= 0) && ((curstate = goto_table[reduce_i]) !== null) &&
+                (curstate !== undefined) && (goto_check[reduce_i] === k1)) {
+          // curstate = curstate; ..?
+        //  console.log('========== return current state: ' + curstate);
+          racc_state.push(curstate);
+        }
+        else {//
+          // console.log("dont do this??");
+          // curstate = k1;
+        //  console.log("=========== PUSHING curstate " + curstate);
+        //  console.log('=========== goto default is: ' + goto_default[k1]);
+          racc_state.push(goto_default[k1]);
+        }
+        // tmp_v is return value from stack
+        // racc_vstack.push(tmp_v[0]);
+        
+      }
+      else {
+      //  console.log('GOTO default down here init!!!!!!!!!!!');
+        racc_state.push(goto_default[k1]);
+      }
+      
+      // return;
+    }
+    else if (act === shift_n) {
+    //  console.log('accept on ' + act);
+      // 
+      // accept
+      // 
+    //  console.log('accepting!!!!');
+    //  console.log(racc_vstack[0]);
+      return racc_vstack[0];
+    }
+    else if (act === -reduce_n) {
+    //  console.log('error on ' + act);
+      // 
+      // error
+      // 
+    //  console.log('racc error status: ' + racc_error_status);
+    //  console.log(racc_tok + ", " + racc_val);
+      throw new Error('syntax error, unexpected ' + racc_tok);
+      return;
+    }
+    else {
+      throw "Racc - unknown action: " + act;
+    }
+    
+    // return;
+  }  
+};
+
+// default next token implementation
+parser.prototype.next_token = function() {
+  throw "next_token is not defined for parser."
+};
+
+parser.prototype.yyerror = function(err) {
+  throw "yyerror: " + err;
+};
+
+parser.prototype._reduce_none = function(val, result) {
+  return result;
+};

data/gems/dev/tools/racc2js/racc2js.rb

@@ -0,0 +1,153 @@
+#!/usr/bin/env ruby -wKU
+
+class Racc2JS
+  
+  def initialize(source, output = nil)
+    @source = source
+    @output = output || 
+          File.join(File.dirname(source), File.basename(source, '.*') + '.js')
+    
+    @racc_output = File.join(
+          File.dirname(source), File.basename(source, '.*') + '.rb')
+  end
+  
+  def generate
+    puts "generating racc parser..."
+    `racc --output-file=#@racc_output #@source`
+    puts "loading generated parser.."
+    self.class.module_eval File.read(File.expand_path(@racc_output))
+    # we rely on only constant under our class being our new generated parser..
+    parser = self.class.constants[0]
+    raise "no suitable parser found in #@racc_output" unless parser
+    puts "using parser: #{parser}"
+    @parser_name = parser.to_s
+    @parser = self.class.const_get(parser)
+    
+    @parser_output = []
+    handle_parser_runtime
+    handle_racc_arg
+    handle_racc_actions
+    
+    # write output to our destination
+    File.open(@output, 'w') { |o| o.puts pre + @parser_output.join('') + post }
+    
+    # remove temp ruby file
+    File.delete @racc_output
+  end
+  
+  # pre code
+  def pre
+    %Q[var #@parser_name = (function() {\n]
+  end
+  
+  # post code
+  def post
+    %Q[\n   return parser;
+      })();
+      
+      if (typeof require !== 'undefined' && typeof module !== 'undefined') {
+        exports.#@parser_name = #@parser_name;
+      }
+    ]
+  end
+  
+  # add parser runtime to @parser_output
+  def handle_parser_runtime
+    source = File.read(File.join(File.dirname(__FILE__), 'parser.js'))
+    @parser_output << source
+  end
+  
+  # handle racc table
+  def handle_racc_arg
+    racc_arg = @parser::Racc_arg
+    
+    @parser_output << "parser.Racc_arg = [\n"
+    
+    # puts racc_arg
+    racc_arg.each_with_index do |arg, idx|
+      @parser_output.push "," if idx > 0
+      
+      case arg
+      when Array
+        @parser_output << "["
+        
+        arg.each_with_index do |ary_item, ary_idx|
+          @parser_output.push "," if ary_idx > 0
+          @parser_output.push ruby_to_javascript ary_item
+        end
+        
+        @parser_output << "]"
+      when Hash
+        @parser_output << "{"
+        done = false
+        arg.each do |key, value|
+          @parser_output.push "," if done
+          done = true
+          
+          @parser_output.push key.to_s.inspect
+          @parser_output.push ": "
+          @parser_output.push ruby_to_javascript(value)
+        end
+        
+        @parser_output << "}"
+      else
+        @parser_output << ruby_to_javascript(arg)
+      end  
+    end
+    
+    @parser_output << "];"
+  end
+  
+  # output ruby values' javascript equivalent
+  def ruby_to_javascript(literal)
+    case literal
+    when Numeric
+      literal.to_s
+    when NilClass
+      # see parser.js - saves space once minimized. - removed.
+      'null'
+    when String, Symbol
+      literal.to_s.inspect
+    when true, false
+      literal.to_s
+    else
+      raise "Error: bad native: #{literal}"
+    end
+  end
+  
+  # get all method from racc. we get all impl methods, and then output their
+  # code to js. we (for now) rely on all methods basically being:
+  # 
+  #   result = "val[0] + .."
+  # 
+  # so we assign result a string, which we can then use to output js..hacky, but
+  # only way (for now).
+  def handle_racc_actions
+    # get all methods and unique them.
+    reduce_table = @parser::Racc_arg[9].select { |a| Symbol === a }.uniq!
+    # remove racc_error and _reduce_none
+    reduce_table.delete(:racc_error)
+    reduce_table.delete(:_reduce_none)
+    # we need a parser to use
+    parser = @parser.new
+    reduce_table.each do |reduction|
+      code = parser.send(reduction, nil, nil, nil)
+      @parser_output << %Q[
+        parser.prototype.#{reduction} = function(val, result) {
+          #{code}
+          return result;
+        };]
+    end
+  end
+end
+
+# 
+# bin
+# 
+if ARGV.empty?
+  raise "no filename given"
+elsif ARGV.length == 1
+  Racc2JS.new(ARGV[0]).generate
+else
+  Racc2JS.new(ARGV[0], ARGV[1]).generate
+end

data/gems/json/README.md

@@ -0,0 +1,4 @@
+Simple json package that uses json2.js. This package aims to have a
+similar/compatible API to the 'json' gem, and is partially implemented
+as it stands.
+

data/gems/json/json.gemspec

@@ -0,0 +1,14 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name         = "json"
+  s.version      = "0.0.1"
+  s.authors      = ["Adam Beynon"]  
+  s.email        = ["adam@adambeynon.com"]
+  s.homepage     = "http://github.com/adambeynon/opal"
+  s.summary      = "JSON implementation for opal"
+
+  s.files        = Dir.glob("{bin,lib}/**/*") + %w[README.md]
+  s.require_path = "lib"
+end
+

data/gems/json/lib/json.rb

@@ -0,0 +1,64 @@
+require 'json/ext'
+require 'json/json2'
+
+module JSON
+
+  class JSONError < StandardError; end
+
+  class ParseError < JSONError; end
+
+  def self.parse(source, opts = nil)
+    `var json = JSON.parse(source);
+
+    var to_opal = function(value) {
+
+      switch (typeof value) {
+        case 'string':
+          return value;
+
+        case 'number':
+          return value;
+
+        case 'boolean':
+          return value ? Qtrue : Qfalse;
+
+        case 'null':
+          return nil;
+
+        case 'object':
+          if (!value) return nil;
+
+          if (Object.prototype.toString.apply(value) === '[object Array]') {
+            var arr = [];
+
+            for (var i = 0, ii = value.length; i < ii; i++) {
+              arr.push(to_opal(value[i]));
+            }
+
+            return arr;
+          }
+          else {
+            var hash = VM.H(), v, assoc;
+
+            for (var k in value) {
+              if (Object.hasOwnProperty.call(value, k)) {
+                v = to_opal(value[k]);
+                assoc = k.$hash();
+                hash.$keys.push(k);
+                hash.$assocs[assoc] = v;
+              }
+            }
+          }
+
+          return hash;
+      }
+    };
+
+    return to_opal(json);`
+  end
+
+  def self.generate(obj, opts = nil)
+
+  end
+end
+