bluenode 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 76a6c00ed8a1f68bec728bc59028ebfcbf20535a
+  data.tar.gz: 5a83087d85a05e5f89ced711c3451f6ab7c8ee72
+SHA512:
+  metadata.gz: 6b4f14a41e278b967b9e01c394d26a25b1b410d46a1291d405ef1aab600554d4bb82420bc741e168fb1b0dca85a6c284fc0b9f1ba646110261a0143f9571ce76
+  data.tar.gz: 5a961a4a15eec7785327a80df26f1a03673adfd4e0f1d57e2fc265cbf39060e965a3c983581a0fad7cabdead52fd1915a127318e7c8e3fbd39917517555b6b7c

data/.gitignore

@@ -0,0 +1,34 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalisation:
+/.bundle/
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+Gemfile.lock
+.ruby-version
+.ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in bluenode.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Martin Andert
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

data/README.md

@@ -0,0 +1,31 @@
+# Bluenode
+
+A subset of Node.js running in therubyracer. More info coming soon.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'bluenode'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install bluenode
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/martinandert/bluenode/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/bluenode.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'bluenode/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'bluenode'
+  spec.version       = Bluenode::VERSION
+  spec.authors       = ['Martin Andert']
+  spec.email         = ['mandert@gmail.com']
+  spec.summary       = 'A subset of Node.js running in therubyracer.'
+  spec.description   = 'A subset of Node.js running in therubyracer.'
+  spec.homepage      = 'https://github.com/martinandert/bluenode'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.7'
+  spec.add_development_dependency 'rake', '~> 10.0'
+
+  spec.add_dependency 'therubyracer', '~> 0.12.1'
+  spec.add_dependency 'ref'
+end

data/lib/bluenode.rb

@@ -0,0 +1,15 @@
+require 'bluenode/version'
+require 'v8'
+require 'ref'
+
+# do not use TRR's built-in weakref implementation
+V8::Weak.send :remove_const, :Ref
+V8::Weak::Ref = Ref::WeakReference
+V8::Weak.send :remove_const, :WeakValueMap
+V8::Weak::WeakValueMap = Ref::WeakValueMap
+
+module Bluenode
+  autoload :Context,      'bluenode/context'
+  autoload :Module,       'bluenode/module'
+  autoload :NativeModule, 'bluenode/native_module'
+end

data/lib/bluenode/context.rb

@@ -0,0 +1,278 @@
+require 'json'
+require 'rbconfig'
+
+module Bluenode
+  class Context
+    class << self
+      def main(basedir = Dir.pwd)
+        context = new(basedir)
+        context.require './'
+      end
+
+      def node_module_paths(from)
+        from = File.expand_path(from)
+
+        split_re  = windows? && /[\/\\]/ || /\//
+        paths     = []
+        parts     = from.split(split_re)
+        tip       = parts.size - 1
+
+        while tip >= 0
+          if parts[tip] != 'node_modules'
+            dir = File.join(*parts[0..tip], 'node_modules')
+            paths << dir
+          end
+
+          tip -= 1
+        end
+
+        paths
+      end
+
+      def windows?
+        @windows ||= !!(RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/)
+      end
+    end
+
+    attr_reader :runtime, :basedir
+
+    def initialize(basedir = Dir.pwd, env = ENV.dup, stdout = $stdout, stderr = $stderr)
+      @runtime  = V8::Context.new
+      @basedir  = basedir.to_s
+
+      startup env, stdout, stderr
+    end
+
+    def process
+      @runtime['process']
+    end
+
+    def eval_as_module(script, name = '[eval]', is_main = false)
+      Module.new(self, name).tap do |mod|
+        mod.filename  = File.join(basedir, name)
+        mod.paths     = self.class.node_module_paths(basedir)
+
+        if is_main
+          runtime['process'].mainModule = mod
+          mod.id = '.'
+        end
+
+        mod.send :compile, script, "#{name}-wrapper"
+      end
+    end
+
+    def require(path)
+      script  = "module.exports = require('#{path}')"
+      mod     = eval_as_module(script, '[main]', true)
+
+      mod.exports
+    end
+
+    def new_object
+      @runtime['Object'].new
+    end
+
+    def new_function(callable, props = {})
+      @runtime.enter do
+        function = @runtime.to_v8(callable)
+
+        props.each do |name, value|
+          function.Set @runtime.to_v8(name.to_s), @runtime.to_v8(value)
+        end
+
+        function
+      end
+    end
+
+    def modules
+      @modules ||= {}
+    end
+
+    def extensions
+      @extensions ||= {}.tap do |extensions|
+        extensions['.js'] = lambda do |mod, filename|
+          mod.send :compile, File.read(filename), filename
+        end
+
+        extensions['.json'] = lambda do |mod, filename|
+          begin
+            mod.exports = JSON.parse(File.read(filename))
+          rescue => exc
+            raise $!, "#{filename}: #{$!}", $!.backtrace
+          end
+        end
+
+        extensions['.node'] = lambda do |mod, filename|
+          raise 'requiring modules with a .node extension is not supported'
+        end
+      end
+    end
+
+    def global_paths
+      @global_paths ||= begin
+        home_dir  = self.class.windows? && ENV['USERPROFILE'] || ENV['HOME']
+        exec_path = `which node`.chomp
+
+        paths = [File.expand_path(File.join('..', '..', 'lib', 'node'), exec_path)]
+
+        if home_dir
+          paths.unshift File.expand_path('.node_libraries', home_dir)
+          paths.unshift File.expand_path('.node_modules', home_dir)
+        end
+
+        if node_path = ENV['NODE_PATH']
+          paths = node_path.split(File::PATH_SEPARATOR).concat(paths)
+        end
+
+        paths
+      end
+    end
+
+    def find_path(request, paths)
+      exts  = extensions.keys
+      paths = [''] if request[0] == '/'
+      trailing_slash = request[-1] == '/'
+      cache_key = { request: request, paths: paths }.to_json
+
+      return path_cache[cache_key] if path_cache.key?(cache_key)
+
+      i, ii = 0, paths.size
+
+      while i < ii
+        base_path = File.expand_path(request, paths[i])
+        filename = nil
+
+        unless trailing_slash
+          filename = try_file(base_path)
+          filename = try_extensions(base_path, exts) unless filename
+        end
+
+        filename = try_package(base_path, exts) unless filename
+        filename = try_extensions(File.expand_path('index', base_path), exts) unless filename
+
+        if filename
+          path_cache[cache_key] = filename
+          return filename
+        end
+
+        i += 1
+      end
+
+      false
+    end
+
+    private
+      def path_cache
+        @path_cache ||= {}
+      end
+
+      def realpath_cache
+        @realpath_cache ||= {}
+      end
+
+      def package_main_cache
+        @package_main_cache ||= {}
+      end
+
+      def try_file(path)
+        return false unless File.file?(path)
+
+        realpath_cache[path] ||= File.realpath(path)
+      end
+
+      def try_extensions(path, exts)
+        i, ii = 0, exts.size
+
+        while i < ii
+          filename = try_file(path + exts[i])
+          return filename if filename
+
+          i += 1
+        end
+
+        false
+      end
+
+      def try_package(path, exts)
+        pkg = read_package(path)
+
+        return false unless pkg
+
+        filename = File.expand_path(pkg, path)
+
+        try_file(filename) || try_extensions(filename, exts) || try_extensions(File.expand_path('index', filename), exts)
+      end
+
+      def read_package(path)
+        return package_main_cache[path] if package_main_cache.key?(path)
+
+        begin
+          json_path = File.expand_path('package.json', path)
+          json = File.read(json_path)
+        rescue => exc
+          return false
+        end
+
+        package_main_cache[path] = JSON.parse(json)['main']
+      rescue => exc
+        raise $!, "error parsing #{json_path}: #{$!}", $!.backtrace
+      end
+
+      def startup(env, stdout, stderr)
+        function = runtime.eval <<-EOS
+          var global = this;
+
+          (function(process) {
+            global.process = process;
+            global.global = global;
+            global.GLOBAL = global;
+            global.root = global;
+            global.Buffer = function Buffer() { throw new Error('global.Buffer is not supported'); };
+
+            function noop() {};
+
+            process.domain = null;
+            process.on = noop;
+            process.once = noop;
+            process.off = noop;
+            process.addListener = noop;
+            process.removeListener = noop;
+            process.removeAllListeners = noop;
+            process.emit = noop;
+
+            process.chdir = function(dir) {
+              throw new Error('process.chdir is not supported');
+            };
+
+            process.umask = function() { return 0; };
+          })
+        EOS
+
+        process = {
+          title: $0,
+          pid: Process.pid,
+          env: env,
+
+          cwd: lambda { |*args| basedir },
+
+          stdout: {
+            write: lambda do |_, chunk, *args|
+              stdout.write chunk
+              true
+            end
+          },
+
+          stderr: {
+            write: lambda do |_, chunk, *args|
+              stderr.write chunk
+              true
+            end
+          }
+        }
+
+        function.call process
+
+        runtime['global'].console = NativeModule.require(self, 'console')
+      end
+  end
+end

data/lib/bluenode/module.rb

@@ -0,0 +1,137 @@
+module Bluenode
+  class Module
+    class << self
+      def wrap(script)
+        "(function(exports, require, module, __filename, __dirname) {\n#{script}\n})"
+      end
+    end
+
+    attr_accessor :id, :filename, :exports, :loaded, :paths
+    attr_reader :parent, :children
+    alias :loaded? :loaded
+
+    def initialize(context, id, parent = nil)
+      @context  = context
+      @id       = id
+      @exports  = context.new_object
+      @parent   = parent
+
+      parent.children << self if parent
+
+      @filename = nil
+      @loaded   = false
+      @children = []
+      @paths    = []
+    end
+
+    def load(filename)
+      raise LoadError, 'module already loaded' if loaded?
+
+      @filename = filename
+      @paths = @context.class.node_module_paths(File.dirname(filename))
+
+      extension = File.extname(filename)
+      extension = '.js' if extension.nil? || extension == ''
+      extension = '.js' unless @context.extensions.key?(extension)
+
+      @context.extensions[extension].call self, filename
+
+      @loaded = true
+    end
+
+    def require(request)
+      filename  = resolve(request)
+      cached    = @context.modules[filename]
+
+      return cached.exports if cached
+
+      return NativeModule.require(@context, filename) if NativeModule.exist?(filename)
+
+      mod = self.class.new(@context, filename, self)
+
+      @context.modules[filename] = mod
+
+      had_exception = true
+
+      begin
+        mod.load filename
+        had_exception = false
+      ensure
+        @context.modules.delete(filename) if had_exception
+      end
+
+      mod.exports
+    end
+
+    private
+      def resolve(request)
+        return request if NativeModule.exist?(request)
+
+        id, paths = resolve_lookup_paths(request)
+        filename  = @context.find_path(request, paths)
+
+        filename or raise LoadError, "cannot find module '#{request}'"
+      end
+
+      def compile(content, filename)
+        props = {
+          main:       @context.process.mainModule,
+          cache:      @context.modules,
+          extensions: @context.extensions,
+          resolve:    resolve_proc
+        }
+
+        wrapped     = self.class.wrap(content.sub(/^#!.*/, ''))
+        function    = @context.runtime.eval(wrapped, filename)
+        dirname     = File.dirname(filename)
+        v8_require  = @context.new_function(require_proc, props)
+        args        = [exports, v8_require, self, filename, dirname]
+
+        function.methodcall exports, *args
+      end
+
+      def require_proc
+        @require_proc ||= lambda do |_, path|
+          raise LoadError, 'path must be a string' unless path.is_a?(String)
+
+          require path
+        end
+      end
+
+      def resolve_proc
+        @resolve_proc ||= lambda do |_, request|
+          resolve request
+        end
+      end
+
+      def resolve_lookup_paths(request)
+        return [request, []] if NativeModule.exist?(request)
+
+        start = request[0..1]
+
+        if start != './' && start != '..'
+          main_paths = @context.global_paths
+          main_paths = paths.concat(main_paths)
+
+          return [request, main_paths]
+        end
+
+        unless filename
+          main_paths = ['.'].concat(@context.global_paths)
+          main_paths = @context.class.node_module_paths('.').concat(main_paths)
+
+          return [request, main_paths]
+        end
+
+        is_index  = File.basename(filename) =~ /^index(\.\w+)*$/
+        id_path   = is_index ? id : File.dirname(id)
+        id        = File.expand_path(request, id_path)
+
+        if id_path == '.' && id.index('/').nil?
+          id = './' + id
+        end
+
+        [id, [File.dirname(filename)]]
+      end
+  end
+end