therubyracer-xcode 0.12.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0648e002ee82460ca2d2573675f00dde30742b83
+  data.tar.gz: 5742afdd1b75323673779b97c0ff8fda91cb5250
+SHA512:
+  metadata.gz: 55b4a3fea60525ff60238728a97d745d2899501bfc4fdea179af63ff20c3342e367f64050645135b27c9f95c90f062e99c4599ae8642bd065c4f153a0fea0db5
+  data.tar.gz: a8c868b5baa07747b876d7cd9ce0554dcf417c608496f83d6c15b8dec87735ed72058d03e9fda06220b1bea192c58763571ff53a31caa35c5cc56c4b3711684a

data/.gitignore

@@ -0,0 +1,23 @@
+*.gem
+*.rbc
+.rbx/
+.rvmrc
+.bundle
+.config
+.yardoc
+.project
+.cproject
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+lib/v8/*.bundle
+lib/v8/*.so
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.travis.yml

@@ -0,0 +1,14 @@
+cache: bundler
+rvm:
+  - 2.1
+  - 2.0.0
+  - 1.9.3
+  - 1.9.2
+  - 1.8.7
+#  - rbx-2.5.2
+notifications:
+  recipients:
+    - cowboyd@thefrontside.net
+before_install:
+  - gem update --system 2.1.11
+script: bundle exec rake compile spec

data/Changelog.md

@@ -0,0 +1,263 @@
+# Changelog
+
+## 0.12.2 2015/04/06
+
+* fix memory leak where weak hash map entries were not being cleaned
+  up. Thanks to @SamSaffon
+
+## 0.12.1 2014/02/03
+
+* add `timeout` option to `V8::Context` to forcibly abort long running scripts (thanks to @SamSaffron)
+* allow canonical require via  `require "therubyracer"` instead of oddball `require "v8"`(thanks @gaffneyc)
+
+## 0.12.0 2013/08/20
+
+* upgrade v8 to 3.16.4 (thanks to @ignisf)
+* enable native (and functional) weakref implementation for MRI > 2.0
+* expose low level interface for `V8::C::HeapStatistics#total_physical_size`
+
+## 0.11.1 2013/01/04
+
+* reintroduce the dependency on libv8
+* libv8 can be disabled by installing it with the --with-system-v8 flag
+
+## 0.11.0 2012/12/04
+
+* upgrade V8 version to 3.11.8
+* remove dependency on libv8. enable compilation against system v8
+* complete re-write of low-level C layer for dramatically increased stability and performance
+* more faithful and complete coverage of the low-level C API
+* ease the building of binary gems
+* official support for Rubinius
+* ability to query V8 for memory usage and set resource constraints
+* extensible conversion framework for thunking Ruby values to V8 and vice-versa
+* extensible invocation framework for calling Ruby code (Proc, Method, etc...) from JavaScript
+* extensible access framework for interacting with Ruby properties from JavaScript
+* provide explicit context teardown for distributed cycles of garbage.
+
+
+## 0.10.1 2012/04/05
+
+* [bugfix] V8::Object#respond_to? did not call super
+
+## 0.10.0 2012/03/28
+
+* [incompatible] embedded lambdas now take JS `this` object as first object
+* add sponsorship image to the README
+* enable Travis CI
+
+## 0.9.9 2011/11/08
+
+* remove GCC specific C++ extension to fix llvm build.
+
+## 0.9.8 2011/11/07
+
+* let Rake version float again.
+
+## 0.9.7 2011/10/06
+* build fixes
+* fix rake dependency at 0.8.7 while the Rake team sorts some shit out.
+
+## 0.9.6 2011/10/06
+
+* make build compatible with Gentoo
+
+## 0.9.5 - 2011/10/05
+
+* remove GCC specific code to enable build on BSD
+* let Rake dependency float
+
+## 0.9.4 - 2011/08/22
+
+* Fix an issue with the compilation include paths which allowed compilation against conflicting libv8's
+
+## 0.9.3 - 2011/08/11
+
+* Better documentation for the C extension memory management
+* Always lock V8 operations, always.
+* GH-86 Context#[], Context#[]= always looks up values from the JavaScript scope, even when it's a Ruby object
+
+## 0.9.2 - 2011/06/23
+
+* fix issue with 1.8.7 where object allocation inside of GC was segfaulting
+
+## 0.9.1 - 2011/06/17
+
+* never perform V8 operations inside Ruby GC
+* refactor locking interface
+* add documentation for v8_handle
+
+## 0.9.0 - 2011/06/10
+
+* extract libv8 into installable binary for most platforms
+* fix numerous memory leaks
+* expose the V8 debugger via V8::C::Debug::EnableAgent()
+* force UTf-8 encoding on strings returned from javascript in ruby 1.9
+* remove deprecated evaluate() methods
+* make the currently executing JavaScript stack available via Context#stack
+
+## 0.8.1 - 2011/03/07
+
+* upgrade to v8 3.1.8
+* remove bin/v8 which conflicted with v8 executeable
+* decruft all the crap that had accumulated in the gem
+* Javascript Objects are now always mapped to the same V8::Object when read from the context
+
+## 0.8.0 - 2010/12/02
+
+* every V8 Context gets its own unique access strategy
+* ruby methods and procs embedded in javascript always return the same function per context.
+* ruby classes and subclasses are now all connected via the javascript prototype chain
+* better error reporting on syntax errors
+* upgrade to rspec 2
+* several bug fixes and stability fixes
+
+## 0.7.5 - 2010/08/03
+
+* upgrade to V8 2.3.3
+* property interceptors from ruby via [] and []=
+* indexed property access via [] and []=
+* property
+* several bugfixes
+* stability: eliminate many segfaults
+* don't enumerate property setters such as foo= from javascript
+
+## 0.7.4 - 2010/06/15
+
+* bug fix for rvm ruby installs incorrectly detected as 32bit
+
+## 0.7.3 - 2010/06/15
+
+* don't catch SystemExit and NoMemoryError
+* fix bug bundling gem
+
+## 0.7.2 - 2010/06/14
+
+* embed ruby classes as constructors
+* support for rubinius
+* uniform backtrace() function on JSError mixes the ruby
+* String::NewSymbol() is now scriptable
+* InstanceTemplate(), PrototypeTemplate(), Inherit() methods on v8::FunctionTemplate now scriptable.
+* reuse the standard ruby object access template
+* fix a bunch of compile warnings
+* Store any ruby object in V8 with V8::C::External
+
+## 0.7.1 - 2010/06/03
+
+* Function#call() now uses the global scope for 'this' by default
+* Function#methodcall() added to allow passing in 'this' object
+* Function#new() method to invoke javascript constructor from ruby
+* access javascript properties and call javascript methods from ruby
+* bundled Jasmine DOM-Less browser testing framework.
+
+* added Object::GetHiddenValue() to v8 metal
+* added Handle::IsEmpty() to v8 metal
+* fixed bug where iterating over arrays sometimes failed
+* numerous bug /segfault fixes.
+
+## 0.7.0 - 2010/05/31
+
+* upgraded to V8 2.1.10
+* added low level scripting interface for V8 objects
+* ruby object property/method access is now implemented in ruby
+* auto-convert javascript arrays to rb arrays and vice-versa
+* auto-convert ruby hashes into javascript objects
+* auto-convert javascript Date into ruby Time object and vice versa.
+* better exception handling when passing through multiple language boundaries
+* objects maintain referential integrity when passing objects from ruby to javascript and vice-versa
+* added debug compile option for getting C/C++ backtraces whenever segfaults occur.
+* official support for REE 1.8.7
+* fixed numerous segfaults
+* implemented V8::Value#to_s
+* the global scope is available to every V8::Context as the 'scope' attribute
+* properly convert ruby boolean values into V8 booleans.
+
+## 0.6.3 - 2010/05/07
+
+* FIX: linkage error on OSX /usr/bin/ruby
+
+## 0.6.2 - 2010/05/06
+
+* FIX: linkage error on OSX 10.5
+
+## 0.6.1 - 2010/05/03
+
+* call JavaScript functions from Ruby
+
+## 0.6.0 - 2010/03/31
+
+* ruby 1.9 compatible
+* full featured command line bin/v8 and bin/therubyracer
+* self validating install (v8 --selftest)
+* Only dependency to build gem from source is rubygems.
+
+## 0.5.5 - 2010/03/15
+
+* fix string encoding issue that was breaking RHEL 5.x
+* fix pthread linking issue on RHEL 5.2
+
+## 0.5.4 - 2010/03/09
+
+* add ext directory to gem require paths which was causing problems for non-binary gems
+
+## 0.5.3 - 2010/03/01
+
+* added full back trace to javascript code
+
+## 0.5.2 - 2010/02/26
+
+* added javascript shell (bin/therubyracer)
+* added to_s method for embedded ruby objects
+* added line number and file name to error message.
+
+## 0.5.1 - 2010/02/17
+
+* fix bug in 1.8.6 by creating Object#tap if it does not exist
+
+## 0.5.0 - 2010/02/17
+
+* support for Linux 64 bit
+
+## 0.4.9 - 2010/02/16
+
+* support for Linux 32 bit
+
+## 0.4.8 - 2010/02/08
+
+* expose line number and source name on JavascriptErrors.
+
+## 0.4.5 - 2010/01/18
+
+* case munging so that ruby methods(perl_case) are accessed through javascript in camelCase.
+* access 0-arity ruby methods as javascript properties
+* invoke ruby setters from javascript as properties
+* contexts detect whether they are open or not and open when needed
+
+## 0.4.4 - 2010/01/14
+
+* Ruby objects embedded into javascript are passed back to ruby as themselves and not a wrapped V8 object wrapping a ruby object.
+* Use any ruby object as the scope of eval().
+* quick and dirty V8.eval() method added
+* native objects have a reference to the context that created them.
+* context now has equality check.
+* expose InContext() and GetCurrent() methods.
+* fix a couple of segmentation faults
+
+## 0.4.3 - 2010/10/11
+
+* access properties on Ruby objects with their camel case equivalents
+* reflect JavaScript objects into Ruby and access their properties
+* load JavaScript source from an IO object or by filename
+
+## 0.4.2 - 2010/10/10
+
+* embed Ruby Objects into Javascript and call their methods
+
+## 0.4.1 - 2010/01/09
+
+* embed bare Proc and Method objects into JavaScript and call them
+* catch JavaScript exceptions from Ruby
+
+## 0.4.0 - 2009/12/21
+
+* evaluate JavaScript code from inside Ruby.

data/Gemfile

@@ -0,0 +1,12 @@
+source 'http://rubygems.org'
+
+gemspec
+
+group :development do
+  gem "rubysl", :platforms => :rbx
+  gem 'redjs', :git => 'https://github.com/cowboyd/redjs.git'
+  gem "rake"
+  gem "rspec", "~> 2.0"
+  gem "rake-compiler"
+  gem "gem-compiler", :platforms => :mri
+end

data/README.md

@@ -0,0 +1,227 @@
+# therubyracer
+
+## This version compiles with XCode 7.3
+
+[![Gem Version](https://badge.fury.io/rb/therubyracer.png)](http://badge.fury.io/rb/therubyracer)
+[![Build Status](https://travis-ci.org/cowboyd/therubyracer.png?branch=master)](https://travis-ci.org/cowboyd/therubyracer)
+[![Build status](https://ci.appveyor.com/api/projects/status/aqw06doke164dca7?svg=true)](https://ci.appveyor.com/project/cowboyd/therubyracer)
+[![Dependency Status](https://gemnasium.com/cowboyd/therubyracer.png)](https://gemnasium.com/cowboyd/therubyracer)
+[![Join the chat at https://gitter.im/cowboyd/therubyracer](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/cowboyd/therubyracer?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+
+
+* GitHub Project: [http://github.com/cowboyd/therubyracer](http://github.com/cowboyd/therubyracer)
+* Mailing List: [http://groups.google.com/group/therubyracer](http://groups.google.com/group/therubyracer)
+* Documentation: [GitHub Wiki](https://github.com/cowboyd/therubyracer/wiki) and [RubyDoc](http://rubydoc.info/gems/therubyracer)
+
+### DESCRIPTION
+
+Embed the V8 JavaScript interpreter into Ruby.
+
+### FEATURES
+
+* Evaluate JavaScript from within Ruby
+* Embed your Ruby objects into the JavaScript world
+* Manipulate JavaScript objects and call JavaScript functions from Ruby
+* API compatible with the The Ruby Rhino (for JRuby: http://github.com/cowboyd/therubyrhino)
+
+### SYNOPSIS
+
+    gem install therubyracer
+
+then in your Ruby code
+
+    require 'v8'
+
+or if using bundler (as with Rails), add the following to your Gemfile
+
+    gem "therubyracer"
+
+evaluate some simple JavaScript
+
+    cxt = V8::Context.new
+    cxt.eval('7 * 6') #=> 42
+
+access values inside your JavaScript context from Ruby
+
+    cxt.eval 'var val = {num: 5, isTruthy: function (arg) { return !!arg }}'
+    val = cxt[:val] #=> V8::Object
+    cxt[:val] == cxt.scope.val #=> true
+    val.num #=> 5
+    val.isTruthy(1) #=> true
+
+this includes references to JavaScript functions
+
+    truthy = val[:isTruthy] #=> V8::Function
+    truthy.call(' ') #=> true
+    truthy.call(0) #=> false
+
+
+embed values into the scope of your context
+
+    cxt['foo'] = "bar"
+    cxt.eval('foo') # => "bar"
+
+embed Ruby code into your scope and call it from JavaScript
+
+    cxt["say"] = lambda {|this, word, times| word * times}
+    cxt.eval("say('Hello', 3)") #=> HelloHelloHello
+
+embed a Ruby object into your scope and access its properties/methods
+from JavaScript
+
+    class MyMath
+      def plus(lhs, rhs)
+        lhs + rhs
+      end
+    end
+
+    cxt['math'] = MyMath.new
+    cxt.eval("math.plus(20,22)") #=> 42
+
+make a Ruby object *be* your global JavaScript scope.
+
+    math = MyMath.new
+    V8::Context.new(:with => math) do |cxt|
+      cxt.eval("plus(20,22)") #=> 42
+    end
+
+you can do the same thing with Object#eval_js
+
+    math.eval_js("plus(20,22)")
+
+### Different ways of loading JavaScript source
+
+In addition to just evaluating strings, you can also use streams, such
+as files.
+
+evaluate bytes read from any File/IO object:
+
+    File.open("mysource.js") do |file|
+      cxt.eval(file, "mysource.js")
+    end
+
+or load it by filename
+
+    cxt.load("mysource.js")
+
+### Safe by default, dangerous by demand
+
+The Ruby Racer is designed to let you evaluate JavaScript as safely as
+possible unless you tell it to do something more dangerous. The
+default context is a hermetically sealed JavaScript environment with
+only the standard JavaScript objects and functions. Nothing from the
+Ruby world is accessible at all.
+
+For Ruby objects that you explicitly embed into JavaScript, by default
+only the _public_ methods _below_ `Object` are exposed by default.
+E.g.
+
+    class A
+      def a
+        "a"
+      end
+
+      def to_s
+        super
+      end
+    end
+
+    class B < A
+      def b
+        "b"
+      end
+    end
+
+
+    V8::Context.new do |cxt|
+      cxt['a'] = A.new
+      cxt['b'] = B.new
+      cxt.eval("a.a") # => 'a'
+      cxt.eval("b.b") # => 'b'
+      cxt.eval("b.a") # => 'a'
+      cxt.eval("b.to_s") # => #<B:0x101776be8> (because A explicitly defined it)
+      cxt.eval("b.object_id") #=> undefined, object_id is on Object
+    end
+
+If needed, you can override the [Ruby Access][access] to allow whatever
+behavior you'd like.
+
+[access]:https://github.com/cowboyd/therubyracer/blob/master/lib/v8/access.rb
+
+More documentation can be found on the [GitHub wiki](https://github.com/cowboyd/therubyracer/wiki)
+
+### Protecting Your CPU cycles
+
+When running untrusted JavaScript code, you not only have to protect
+which functions it has access to, but also how much of your CPU it can
+consume. Take this simple, yet thoroughly malicious script:
+
+```javascript
+while (true) {}
+```
+
+It will loop forever and never return control to the calling Ruby
+thread. To protect against such JavaScript code that either
+deliberately or accidentally runs longer that it should, you can
+set an explicit timeout on your context. If the code runs longer that
+the allowed timeout, then it will throw an exception. Note that this
+exception could be raised at any point in the execution of the
+JavaScript.
+
+To specify the timeout (in milliseconds), pass in the `timeout` option
+to the constructor.
+
+```ruby
+cxt = V8::Context.new timeout: 700
+cxt.eval "while (true);" #= exception after 700ms!
+```
+
+### PREREQUISITES
+
+The Ruby Racer requires the V8 Javascript engine, but it offloads the
+handling of this dependency to the
+[libv8](https://github.com/cowboyd/libv8) gem. Because libv8 is now a
+gem dependency, you do not need a separate libv8 entry in your
+project's Gemfile.
+
+Please see [libv8](https://github.com/cowboyd/libv8) for V8 runtime
+installation options.
+
+### DEVELOP
+
+    git clone git://github.com/cowboyd/therubyracer.git
+    cd therubyracer
+    bundle install
+    rake compile
+
+### Sponsored by
+
+<a href="http://thefrontside.net">![The Frontside](http://github.com/cowboyd/therubyracer/raw/master/thefrontside.png)</a>
+
+### LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2009,2010,2011,2012 Charles Lowell
+
+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.
+
+[1]: https://github.com/cowboyd/libv8
+[2]: http://code.google.com/p/v8/wiki/BuildingWithGYP

data/Rakefile

@@ -0,0 +1,42 @@
+#!/usr/bin/env rake
+require 'bundler/setup'
+require "bundler/gem_tasks"
+
+task :clean do
+  sh "rm -rf lib/v8/init.bundle lib/v8/init.so"
+  sh "rm -rf pkg"
+end
+
+require "rake/extensiontask"
+Rake::ExtensionTask.new("init", eval(File.read("therubyracer.gemspec"))) do |ext|
+  ext.ext_dir = "ext/v8"
+  ext.lib_dir = "lib/v8"
+  ext.source_pattern = "*.{cc,h}"
+end
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |task|
+  task.rspec_opts = '--tag ~memory --tag ~threads'
+end
+
+task :sanity => [:clean, :compile] do
+  sh %q{ruby -Ilib -e "require 'v8'"}
+end
+
+NativeGem = "pkg/therubyracer-#{V8::VERSION}-#{Gem::Platform.new(RUBY_PLATFORM)}.gem"
+file NativeGem => :build do
+  require "rubygems/compiler"
+  compiler = Gem::Compiler.new("pkg/therubyracer-#{V8::VERSION}.gem", 'pkg')
+  compiler.compile
+end
+
+desc "Build #{NativeGem} into the pkg directory"
+task "build:native" => NativeGem
+
+desc "Build and install #{File.basename NativeGem} into system gems"
+task "install:native" => "build:native" do
+  sh "gem install #{NativeGem}"
+end
+
+task :default => :spec
+