style-script 1.0.0

data/lib/style_script/runner.js

@@ -0,0 +1,11 @@
+(function(){
+  var style, paths;
+  // Quickie script to compile and run all the files given as arguments.
+  process.mixin(require('sys'));
+  style = require('./style-script');
+  paths = process.ARGV;
+  paths = paths.slice(2, paths.length);
+  paths.length ? style.compile_files(paths, function(js) {
+    return eval(js);
+  }) : require('./repl');
+})();

data/lib/style_script/scope.js

@@ -0,0 +1,129 @@
+(function(){
+  var Scope, succ;
+  var __hasProp = Object.prototype.hasOwnProperty;
+  // Scope objects form a tree corresponding to the shape of the function
+  // definitions present in the script. They provide lexical scope, to determine
+  // whether a variable has been seen before or if it needs to be declared.
+  //
+  // Initialize a scope with its parent, for lookups up the chain,
+  // as well as the Expressions body where it should declare its variables,
+  // and the function that it wraps.
+  Scope = (exports.Scope = function Scope(parent, expressions, method) {
+    var __a;
+    this.parent = parent;
+    this.expressions = expressions;
+    this.method = method;
+    this.variables = {
+    };
+    this.temp_variable = this.parent ? this.parent.temp_variable : '__a';
+    __a = this;
+    return Scope === this.constructor ? this : __a;
+  });
+  // Look up a variable in lexical scope, or declare it if not found.
+  Scope.prototype.find = function find(name, remote) {
+    var found;
+    found = this.check(name);
+    if (found || remote) {
+      return found;
+    }
+    this.variables[name] = 'var';
+    return found;
+  };
+  // Define a local variable as originating from a parameter in current scope
+  // -- no var required.
+  Scope.prototype.parameter = function parameter(name) {
+    return this.variables[name] = 'param';
+  };
+  // Just check to see if a variable has already been declared.
+  Scope.prototype.check = function check(name) {
+    if (this.variables[name]) {
+      return true;
+    }
+    return !!(this.parent && this.parent.check(name));
+  };
+  // You can reset a found variable on the immediate scope.
+  Scope.prototype.reset = function reset(name) {
+    return delete this.variables[name];
+  };
+  // Find an available, short, name for a compiler-generated variable.
+  Scope.prototype.free_variable = function free_variable() {
+    while (this.check(this.temp_variable)) {
+      ((this.temp_variable = succ(this.temp_variable)));
+    }
+    this.variables[this.temp_variable] = 'var';
+    return this.temp_variable;
+  };
+  // Ensure that an assignment is made at the top of scope (or top-level
+  // scope, if requested).
+  Scope.prototype.assign = function assign(name, value, top_level) {
+    if (top_level && this.parent) {
+      return this.parent.assign(name, value, top_level);
+    }
+    return this.variables[name] = {
+      value: value,
+      assigned: true
+    };
+  };
+  // Does this scope reference any variables that need to be declared in the
+  // given function body?
+  Scope.prototype.has_declarations = function has_declarations(body) {
+    return body === this.expressions && this.declared_variables().length;
+  };
+  // Does this scope reference any assignments that need to be declared at the
+  // top of the given function body?
+  Scope.prototype.has_assignments = function has_assignments(body) {
+    return body === this.expressions && this.assigned_variables().length;
+  };
+  // Return the list of variables first declared in current scope.
+  Scope.prototype.declared_variables = function declared_variables() {
+    var __a, __b, key, val;
+    return ((function() {
+      __a = []; __b = this.variables;
+      for (key in __b) {
+        val = __b[key];
+        if (__hasProp.call(__b, key)) {
+          if (val === 'var') {
+            __a.push(key);
+          }
+        }
+      }
+      return __a;
+    }).call(this)).sort();
+  };
+  // Return the list of variables that are supposed to be assigned at the top
+  // of scope.
+  Scope.prototype.assigned_variables = function assigned_variables() {
+    var __a, __b, key, val;
+    return ((function() {
+      __a = []; __b = this.variables;
+      for (key in __b) {
+        val = __b[key];
+        if (__hasProp.call(__b, key)) {
+          if (val.assigned) {
+            __a.push([key, val.value]);
+          }
+        }
+      }
+      return __a;
+    }).call(this)).sort();
+  };
+  Scope.prototype.compiled_declarations = function compiled_declarations() {
+    return this.declared_variables().join(', ');
+  };
+  Scope.prototype.compiled_assignments = function compiled_assignments() {
+    var __a, __b, __c, t;
+    return ((function() {
+      __a = []; __b = this.assigned_variables();
+      for (__c = 0; __c < __b.length; __c++) {
+        t = __b[__c];
+        __a.push(t[0] + ' = ' + t[1]);
+      }
+      return __a;
+    }).call(this)).join(', ');
+  };
+  // Helper functions:
+  // The next character alphabetically, to produce the following string.
+  succ = function succ(str) {
+    return str.slice(0, str.length - 1) + String.fromCharCode(str.charCodeAt(str.length - 1) + 1);
+  };
+})();

data/lib/style_script/scope.rb

@@ -0,0 +1,95 @@
+module StyleScript
+
+  # Scope objects form a tree corresponding to the shape of the function
+  # definitions present in the script. They provide lexical scope, to determine
+  # whether a variable has been seen before or if it needs to be declared.
+  class Scope
+
+    attr_reader :parent, :expressions, :function, :variables, :temp_variable
+
+    # Initialize a scope with its parent, for lookups up the chain,
+    # as well as the Expressions body where it should declare its variables,
+    # and the function that it wraps.
+    def initialize(parent, expressions, function)
+      @parent, @expressions, @function = parent, expressions, function
+      @variables = {}
+      @temp_variable = @parent ? @parent.temp_variable.dup : '__a'
+    end
+
+    # Look up a variable in lexical scope, or declare it if not found.
+    def find(name, remote=false)
+      found = check(name)
+      return found if found || remote
+      @variables[name.to_sym] = :var
+      found
+    end
+
+    # Define a local variable as originating from a parameter in current scope
+    # -- no var required.
+    def parameter(name)
+      @variables[name.to_sym] = :param
+    end
+
+    # Just check to see if a variable has already been declared.
+    def check(name)
+      return true if @variables[name.to_sym]
+      !!(@parent && @parent.check(name))
+    end
+
+    # You can reset a found variable on the immediate scope.
+    def reset(name)
+      @variables[name.to_sym] = false
+    end
+
+    # Find an available, short, name for a compiler-generated variable.
+    def free_variable
+      @temp_variable.succ! while check(@temp_variable)
+      @variables[@temp_variable.to_sym] = :var
+      Value.new(@temp_variable.dup)
+    end
+
+    # Ensure that an assignment is made at the top of scope (or top-level
+    # scope, if requested).
+    def assign(name, value, top=false)
+      return @parent.assign(name, value, top) if top && @parent
+      @variables[name.to_sym] = Value.new(value)
+    end
+
+    # Does this scope reference any variables that need to be declared in the
+    # given function body?
+    def declarations?(body)
+      !declared_variables.empty? && body == @expressions
+    end
+
+    # Does this scope reference any assignments that need to be declared at the
+    # top of the given function body?
+    def assignments?(body)
+      !assigned_variables.empty? && body == @expressions
+    end
+
+    # Return the list of variables first declared in current scope.
+    def declared_variables
+      @variables.select {|k, v| v == :var }.map {|pair| pair[0].to_s }.sort
+    end
+
+    # Return the list of variables that are supposed to be assigned at the top
+    # of scope.
+    def assigned_variables
+      @variables.select {|k, v| v.is_a?(Value) }.sort_by {|pair| pair[0].to_s }
+    end
+
+    def compiled_declarations
+      declared_variables.join(', ')
+    end
+
+    def compiled_assignments
+      assigned_variables.map {|name, val| "#{name} = #{val}"}.join(', ')
+    end
+
+    def inspect
+      "<Scope:#{__id__} #{@variables.inspect}>"
+    end
+
+  end
+
+end

data/lib/style_script/std/style-script.js

@@ -0,0 +1,96 @@
+(function(){
+  var File, OS, Readline, checkForErrors, stylePath, factories, loader, puts;
+  // The Narwhal-compatibility wrapper for StyleScript.
+  // Require external dependencies.
+  OS = require('os');
+  File = require('file');
+  Readline = require('readline');
+  // The path to the StyleScript Compiler.
+  stylePath = File.path(module.path).dirname().dirname().dirname().dirname().join('bin', 'style');
+  // Our general-purpose error handler.
+  checkForErrors = function checkForErrors(styleProcess) {
+    if (styleProcess.wait() === 0) {
+      return true;
+    }
+    system.stderr.print(styleProcess.stderr.read());
+    throw new Error("StyleScript compile error");
+  };
+  // Alias print to "puts", for Node.js compatibility:
+  puts = print;
+  // Run a simple REPL, round-tripping to the StyleScript compiler for every
+  // command.
+  exports.run = function run(args) {
+    var __a, __b, i, path, result;
+    if (args.length) {
+      __a = args;
+      for (i = 0; i < __a.length; i++) {
+        path = __a[i];
+        exports.evalCS(File.read(path));
+        delete args[i];
+      }
+      return true;
+    }
+    __b = [];
+    while (true) {
+      __b.push((function() {
+        try {
+          system.stdout.write('style> ').flush();
+          result = exports.evalCS(Readline.readline(), ['--globals']);
+          if (result !== undefined) {
+            return print(result);
+          }
+        } catch (e) {
+          return print(e);
+        }
+      }).call(this));
+    }
+    return __b;
+  };
+  // Compile a given StyleScript file into JavaScript.
+  exports.compileFile = function compileFile(path) {
+    var style;
+    style = OS.popen([stylePath, "--print", "--no-wrap", path]);
+    checkForErrors(style);
+    return style.stdout.read();
+  };
+  // Compile a string of StyleScript into JavaScript.
+  exports.compile = function compile(source, flags) {
+    var style;
+    style = OS.popen([stylePath, "--eval", "--no-wrap"].concat(flags || []));
+    style.stdin.write(source).flush().close();
+    checkForErrors(style);
+    return style.stdout.read();
+  };
+  // Evaluating a string of StyleScript first compiles it externally.
+  exports.evalCS = function evalCS(source, flags) {
+    return eval(exports.compile(source, flags));
+  };
+  // Make a factory for the StyleScript environment.
+  exports.makeNarwhalFactory = function makeNarwhalFactory(path) {
+    var code, factoryText;
+    code = exports.compileFile(path);
+    factoryText = "function(require,exports,module,system,print){" + code + "/**/\n}";
+    if (system.engine === "rhino") {
+      return Packages.org.mozilla.javascript.Context.getCurrentContext().compileFunction(global, factoryText, path, 0, null);
+    } else {
+      // eval requires parentheses, but parentheses break compileFunction.
+      return eval("(" + factoryText + ")");
+    }
+  };
+  // The Narwhal loader for '.style' files.
+  factories = {
+  };
+  loader = {
+  };
+  // Reload the style-script environment from source.
+  loader.reload = function reload(topId, path) {
+    return factories[topId] = function() {
+      return exports.makeNarwhalFactory(path);
+    };
+  };
+  // Ensure that the style-script environment is loaded.
+  loader.load = function load(topId, path) {
+    return factories[topId] = factories[topId] || this.reload(topId, path);
+  };
+  require.loader.loaders.unshift([".style", loader]);
+})();

data/lib/style_script/style-script.js

@@ -0,0 +1,50 @@
+(function(){
+  var compiler, path;
+  // Executes the `style` Ruby program to convert from StyleScript to JavaScript.
+  path = require('path');
+  // The path to the StyleScript executable.
+  compiler = path.normalize(path.dirname(__filename) + '/../../bin/style');
+  // Compile a string over stdin, with global variables, for the REPL.
+  exports.compile = function compile(code, callback) {
+    var style, js;
+    js = '';
+    style = process.createChildProcess(compiler, ['--eval', '--no-wrap', '--globals']);
+    style.addListener('output', function(results) {
+      if ((typeof results !== "undefined" && results !== null)) {
+        return js += results;
+      }
+    });
+    style.addListener('exit', function() {
+      return callback(js);
+    });
+    style.write(code);
+    return style.close();
+  };
+  // Compile a list of StyleScript files on disk.
+  exports.compile_files = function compile_files(paths, callback) {
+    var style, exit_ran, js;
+    js = '';
+    style = process.createChildProcess(compiler, ['--print'].concat(paths));
+    style.addListener('output', function(results) {
+      if ((typeof results !== "undefined" && results !== null)) {
+        return js += results;
+      }
+    });
+    // NB: we have to add a mutex to make sure it doesn't get called twice.
+    exit_ran = false;
+    style.addListener('exit', function() {
+      if (exit_ran) {
+        return null;
+      }
+      exit_ran = true;
+      return callback(js);
+    });
+    return style.addListener('error', function(message) {
+      if (!(message)) {
+        return null;
+      }
+      puts(message);
+      throw new Error("StyleScript compile error");
+    });
+  };
+})();

data/lib/style_script/value.rb

@@ -0,0 +1,64 @@
+module StyleScript
+
+  # Instead of producing raw Ruby objects, the Lexer produces values of this
+  # class, wrapping native objects tagged with line number information.
+  # Values masquerade as both strings and nodes -- being used both as nodes in
+  # the AST, and as literally-interpolated values in the generated code.
+  class Value
+    attr_reader :value, :line
+
+    def initialize(value, line=nil)
+      @value, @line = value, line
+    end
+
+    def to_str
+      @value.to_s
+    end
+    alias_method :to_s, :to_str
+
+    def to_sym
+      to_str.to_sym
+    end
+
+    def compile(o={})
+      to_s
+    end
+
+    def inspect
+      @value.inspect
+    end
+
+    def ==(other)
+      @value == other
+    end
+
+    def [](index)
+      @value[index]
+    end
+
+    def eql?(other)
+      @value.eql?(other)
+    end
+
+    def hash
+      @value.hash
+    end
+
+    def match(regex)
+      @value.match(regex)
+    end
+
+    def children
+      []
+    end
+
+    def statement_only?
+      false
+    end
+
+    def contains?
+      false
+    end
+  end
+
+end