libv8 3.16.14.3 → 3.16.14.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 04c80c22b9645f11ff0916bf95d18a23cc6837c1
-  data.tar.gz: 11ba356b2faa6c9ebff5c14f6b836b4189fdfb35
+  metadata.gz: 9b5ca0adef389868bd9b38aa3838d79fd4ce0b86
+  data.tar.gz: 9d9b1024787acb57297050fc139a31692b6fce4f
 SHA512:
-  metadata.gz: 50f823acc2eba5c9126dff2de946b97d746875b263affa7da8e688ff1cba512bbf8b0c1f3a93e420be4b3a68baff58c6570e478d069707ce01df59a09114a1a0
-  data.tar.gz: a7463d396e8c59f0a4330b54c253d7a1b58a8bdd010ba7a53b20c6df598dd229d3be7c3f03ac6ef16565a8117e6630118817376d5354bdf0a8f0cd1ef04feb57
+  metadata.gz: 0a7f48927eaef75a822eca0bd2a8e841f87d4d22784bc989e99577496430f96ded65c6f1eb12e7e4a20335c7b3fb4f14c606e71e8ec77064323abd8b90b06667
+  data.tar.gz: e4cecdcc0c59c16ac14b275a969c6495be3b459fde3b93fabb886a8036e32390b5db1d91fa62be170050ea0e2e384ce0b9f9a428046510899aa347a359f0adaf

data/.travis.yml

@@ -1,12 +1,12 @@
 rvm:
   - 2.0.0
-  - 1.9.2
+  - 2.1.0
   - 1.9.3
-  - rbx-19mode
+  - rbx-2
 notifications:
   recipients:
     - cowboyd@thefrontside.net
     - bordjukov@gmail.com
 before_install:
   - sudo apt-get update
-  - sudo apt-get install git-svn
+  - sudo apt-get install git-svn

data/README.md

@@ -21,10 +21,13 @@ platforms.
 * x86_64-darwin10.7.0
 * x86_64-darwin-10
 * x86_64-darwin-11
-* x86_64-darwin-10
+* x86_64-darwin-12
+* x86_64-darwin-13
 * x86_64-linux
 * x86-linux
 * x86_64-freebsd-9
+* x86_64-freebsd-10
+* x86_64-solaris-2.11
 
 If you don't see your platform on this list, first, make sure that it
 installs from source, and second talk to us about setting up a binary
@@ -38,19 +41,6 @@ own point release after the main v8 version. So libv8 `3.11.8.5` and
 think about it would be that `3.11.8.14` is the 14th release of the
 libv8 rubygem based on v8 version `3.11.8`
 
-### Using a git version
-
-If you want to use the latest unstable version of the gem you can do
-so by specifying the git repo as a gem source. Just add the following
-to your `Gemfile`:
-
-```Ruby
-gem "libv8", git: "git://github.com/cowboyd/libv8.git", submodules: true
-```
-
-You can find more info on using a git repo as a gem source in
-[Bundler's documentation](http://bundler.io/v1.3/git.html).
-
 #### Source and Binary Releases
 
 Starting with libv8 `3.11.8.0`, all even point releases contain
@@ -70,6 +60,19 @@ distribution
 
 > This step release system is a workaround to carlhuda/bundler#1537
 
+### Using a git version
+
+If you want to use the latest unstable version of the gem you can do
+so by specifying the git repo as a gem source. Just make sure you have
+`git-svn` and add the following to your `Gemfile`:
+
+```Ruby
+gem "libv8", git: "git://github.com/cowboyd/libv8.git", submodules: true
+```
+
+You can find more info on using a git repo as a gem source in
+[Bundler's documentation](http://bundler.io/v1.3/git.html).
+
 ### What if I can't install from source?
 
 If you can fix the "Makefile" so that it correctly compiles for your
@@ -88,7 +91,7 @@ To get the source, these commands will get you started:
 Because libv8 is the interface for the V8 engine used by
 [therubyracer](http://github.com/cowboyd/therubyracer), you may need
 to use libv8, even if you have V8 installed already. If you wish to
-use your own V8 installation, rather than have it built for you, use 
+use your own V8 installation, rather than have it built for you, use
 the `--with-system-v8` option.
 
 Using RubyGems:
@@ -102,6 +105,14 @@ Using Bundler (in your Gemfile):
 Please note that if you intend to run your own V8, you must install
 both V8 *and its headers* (found in libv8-dev for Debian distros).
 
+### Bring your own compiler
+
+You can specify a compiler of your choice by either setting the `CXX`
+environment variable before compilation, or by adding the
+`--with-cxx=<compiler>` option to the bundle configuration:
+
+    bundle config build.libv8 --with-cxx=clang++
+
 ### About
 
 This project spun off of

data/ext/libv8/builder.rb

@@ -3,13 +3,18 @@ require File.expand_path '../compiler', __FILE__
 require File.expand_path '../arch', __FILE__
 require File.expand_path '../make', __FILE__
 require File.expand_path '../checkout', __FILE__
+require File.expand_path '../patcher', __FILE__
 
 module Libv8
   class Builder
     include Libv8::Arch
-    include Libv8::Compiler
     include Libv8::Make
     include Libv8::Checkout
+    include Libv8::Patcher
+
+    def initialize
+      @compiler = choose_compiler
+    end
 
     def make_flags(*flags)
       profile = enable_config('debug') ? 'debug' : 'release'
@@ -17,33 +22,38 @@ module Libv8
       # FreeBSD uses gcc 4.2 by default which leads to
       # compilation failures due to warnings about aliasing.
       # http://svnweb.freebsd.org/ports/head/lang/v8/Makefile?view=markup
-      flags << "strictaliasing=off" if RUBY_PLATFORM.include?("freebsd") and !check_gcc_compiler(compiler)
+      flags << "strictaliasing=off" if @compiler.is_a?(Compiler::GCC) and @compiler.version < '4.4'
 
       # Avoid compilation failures on the Raspberry Pi.
-      flags << "vfp2=off vfp3=off" if RUBY_PLATFORM.include? "arm"
+      flags << "vfp2=off vfp3=off" if @compiler.target.include? "arm"
 
       # FIXME: Determine when to activate this instead of leaving it on by
       # default.
-      flags << "hardfp=on" if RUBY_PLATFORM.include? "arm"
+      flags << "hardfp=on" if @compiler.target.include? "arm"
 
       # Fix Malformed archive issue caused by GYP creating thin archives by
       # default.
       flags << "ARFLAGS.target=crs"
 
       # Solaris / Smart OS requires additional -G flag to use with -fPIC
-      flags << "CFLAGS=-G" if RUBY_PLATFORM =~ /solaris/
+      flags << "CFLAGS=-G" if @compiler.target =~ /solaris/
+
+      # Disable werror as this version of v8 is getting difficult to maintain
+      # with it on
+      flags << 'werror=no'
 
       "#{libv8_arch}.#{profile} #{flags.join ' '}"
     end
 
     def build_libv8!
       Dir.chdir(V8_Source) do
+        fail 'No compilers available' if @compiler.nil?
         checkout!
         setup_python!
         setup_build_deps!
-        apply_patches!
+        patch! *patch_directories_for(@compiler)
         print_build_info
-        puts `env CXX=#{compiler} LINK=#{compiler} #{make} #{make_flags}`
+        puts `env CXX=#{@compiler} LINK=#{@compiler} #{make} #{make_flags}`
       end
       return $?.exitstatus
     end
@@ -69,19 +79,21 @@ module Libv8
       `ln -fs #{GYP_Source} build/gyp`
     end
 
-    def apply_patches!
-      File.open(".applied_patches", File::RDWR|File::CREAT) do |f|
-        available_patches = Dir.glob(File.expand_path '../../../patches/*.patch', __FILE__).sort
-        applied_patches = f.readlines.map(&:chomp)
+    private
 
-        (available_patches - applied_patches).each do |patch|
-          `patch -p1 -N < #{patch}`
-          f.puts patch
-        end
-      end
-    end
+    def choose_compiler
+      compiler_names = if with_config('cxx') then [with_config('cxx')]
+                       elsif ENV['CXX']      then [ENV['CXX']]
+                       else                       Compiler::KNOWN_COMPILERS
+                       end
 
-    private
+      available_compilers = Compiler.available_compilers(*compiler_names)
+      compatible_compilers = available_compilers.select(&:compatible?)
+
+      unless compatible_compilers.empty? then compatible_compilers
+      else available_compilers
+      end.first
+    end
 
     def python_version
       if system 'which python 2>&1 > /dev/null'
@@ -96,8 +108,8 @@ module Libv8
 
       puts "Using python #{python_version}"
 
-      puts "Using compiler: #{compiler}"
-      unless check_gcc_compiler compiler
+      puts "Using compiler: #{@compiler} (#{@compiler.name} version #{@compiler.version})"
+      unless @compiler.compatible?
         warn "Unable to find a compiler officially supported by v8."
         warn "It is recommended to use GCC v4.4 or higher"
       end

data/ext/libv8/compiler.rb

@@ -1,50 +1,42 @@
+require 'mkmf'
+require 'open3'
+require File.expand_path '../compiler/generic_compiler', __FILE__
+require File.expand_path '../compiler/gcc', __FILE__
+require File.expand_path '../compiler/clang', __FILE__
+
 module Libv8
   module Compiler
-    module_function
-
-    def compiler
-      unless defined?(@compiler)
-        cc   = check_gcc_compiler with_config("cxx")
-        cc ||= check_gcc_compiler ENV["CXX"]
-        cc ||= check_gcc_compiler "g++"
+    KNOWN_COMPILERS = [
+                       'c++',
+                       'g++48', 'g++46', 'g++44', 'g++',
+                       'clang++',
+                      ]
 
-        # Check alternative GCC names
-        # These are common on BSD's after
-        # GCC has been installed by a port
-        cc ||= check_gcc_compiler "g++44"
-        cc ||= check_gcc_compiler "g++46"
-        cc ||= check_gcc_compiler "g++48"
-
-        if cc.nil?
-          warn "Unable to find a compiler officially supported by v8."
-          warn "It is recommended to use GCC v4.4 or higher"
-          @compiler = cc = 'g++'
-        end
-
-        @compiler = cc
-      end
+    module_function
 
-      @compiler
+    def system_compilers
+      available_compilers *Compiler::KNOWN_COMPILERS
     end
 
-    def check_gcc_compiler(name)
-      # in SmartOS, `which` returns success with no arguments. 'with_config' above may return nil
-      return nil if "#{name}".empty?
-
-      compiler = `which #{name} 2> /dev/null`
-      return nil unless $?.success?
-
-      compiler.chomp!
-      return nil unless `#{compiler} --version` =~ /([0-9]\.[0-9]\.[0-9])/
+    def available_compilers(*compiler_names)
+      compiler_paths = compiler_names.map { |name| find name }.reject &:nil?
+    end
 
-      return nil if $1 < "4.4"
-      compiler
+    def find(name)
+      return nil if name.empty?
+      path, _, status = Open3.capture3 "which #{name}"
+      path.chomp!
+      determine_type(path).new(path) if status.success?
     end
 
-    def check_clang_compiler(name)
-      compiler = `which #{name} 2> /dev/null`
-      return nil unless $?.success?
-      compiler.chomp
+    def determine_type(compiler_path)
+      compiler_version = Open3.capture3("#{compiler_path} -v")[0..1].join
+
+      case compiler_version
+      when /\bclang\b/i then Clang
+      when /^gcc/i      then GCC
+      else                   GenericCompiler
+      end
     end
   end
 end

data/ext/libv8/compiler/clang.rb

@@ -0,0 +1,15 @@
+module Libv8
+  module Compiler
+    class Clang < GenericCompiler
+      VERSION_REGEXP = /clang version (\d+\.\d+(\.\d+)*) \(/i
+
+      def name
+        'clang'
+      end
+
+      def compatible?
+        version >= '3.1'
+      end
+    end
+  end
+end

data/ext/libv8/compiler/gcc.rb

@@ -0,0 +1,15 @@
+module Libv8
+  module Compiler
+    class GCC < GenericCompiler
+      VERSION_REGEXP = /gcc version (\d+\.\d+(\.\d+)*)/i
+
+      def name
+        'GCC'
+      end
+
+      def compatible?
+        version > '4.3' and version < '5'
+      end
+    end
+  end
+end

data/ext/libv8/compiler/generic_compiler.rb

@@ -0,0 +1,38 @@
+module Libv8
+  module Compiler
+    class GenericCompiler
+      VERSION_REGEXP = /(\d+\.\d+(\.\d+)*)/
+      TARGET_REGEXP = /Target: ([a-z0-9\-_.]*)/
+
+      def initialize(path)
+        @path = path
+      end
+
+      def name
+        File.basename @path
+      end
+
+      def to_s
+        @path
+      end
+
+      def version
+        call('-v')[0..1].join =~ VERSION_REGEXP
+        $1
+      end
+
+      def target
+        call('-v')[0..1].join =~ TARGET_REGEXP
+        $1
+      end
+
+      def compatible?
+        false
+      end
+
+      def call(*arguments)
+        Open3.capture3 arguments.unshift(@path).join(' ')
+      end
+    end
+  end
+end

data/ext/libv8/patcher.rb

@@ -0,0 +1,55 @@
+module Libv8
+  module Patcher
+    PATCH_DIRECTORY = File.expand_path '../../../patches', __FILE__
+
+    module_function
+
+    def patch_directories_for(compiler)
+      patch_directories = []
+
+      case
+      when compiler.target =~ /arm/
+        patch_directories << 'arm'
+      end
+
+      case compiler
+      when Compiler::GCC
+        patch_directories << 'gcc48' if compiler.version >= '4.8'
+      when Compiler::Clang
+        patch_directories << 'clang'
+        patch_directories << 'clang33' if compiler.version >= '3.3'
+        patch_directories << 'clang51' if compiler.version >= '5.1'
+      end
+
+      patch_directories
+    end
+
+    def patch_directories(*additional_directories)
+      absolute_paths = [PATCH_DIRECTORY]
+
+      additional_directories.each do |directory|
+        absolute_paths << File.join(PATCH_DIRECTORY, directory)
+      end
+
+      absolute_paths.uniq
+    end
+
+    def patches(*additional_directories)
+      patch_directories(*additional_directories).map do |directory|
+        Dir.glob(File.join directory, '*.patch')
+      end.flatten.sort
+    end
+
+    def patch!(*additional_directories)
+      File.open(".applied_patches", File::RDWR|File::CREAT) do |f|
+        available_patches = patches *additional_directories
+        applied_patches = f.readlines.map(&:chomp)
+
+        (available_patches - applied_patches).each do |patch|
+          `patch -p1 -N < #{patch}`
+          f.puts patch
+        end
+      end
+    end
+  end
+end

data/lib/libv8/version.rb

@@ -1,3 +1,3 @@
 module Libv8
-  VERSION = "3.16.14.3"
+  VERSION = "3.16.14.4"
 end

data/libv8.gemspec

@@ -32,5 +32,6 @@ Gem::Specification.new do |s|
   s.add_development_dependency "rake-compiler"
   s.add_development_dependency "rspec"
   s.add_development_dependency "rspec-spies"
+  s.add_development_dependency "rubysl", "~> 2.0" if RUBY_ENGINE == "rbx"
   s.add_development_dependency "vulcan"
 end

data/patches/arm/do-not-use-vfp2.patch

@@ -0,0 +1,13 @@
+diff --git a/build/common.gypi b/build/common.gypi
+index 3a59639..594abe4 100644
+--- a/build/common.gypi
++++ b/build/common.gypi
+@@ -173,7 +173,6 @@
+           [ 'v8_use_arm_eabi_hardfloat=="true"', {
+             'defines': [
+               'USE_EABI_HARDFLOAT=1',
+-              'CAN_USE_VFP2_INSTRUCTIONS',
+             ],
+             'target_conditions': [
+               ['_toolset=="target"', {
+