bel 0.3.2-x64-mingw32 → 0.3.3-x64-mingw32

data/lib/bel/libbel/library_load_error.rb

@@ -0,0 +1,30 @@
+module BEL
+  module LibBEL
+
+    class LibraryLoadError < StandardError
+
+      ERROR_MSG = %Q{
+        The C extension library could not be loaded for your platform.
+
+        Host information:
+
+        RUBY_PLATFORM:                #{RUBY_PLATFORM},
+        RbConfig::CONFIG['host_os']:  #{RbConfig::CONFIG['host_os']},
+        RbConfig::CONFIG['host_cpu']: #{RbConfig::CONFIG['host_cpu']},
+        library:                      %s
+
+        Original error:
+
+        Name:                         %s,
+        Message:                      %s
+      }.gsub(/^\s+/, '')
+
+      attr_reader :cause
+
+      def initialize(library_name, cause=$!)
+        super(ERROR_MSG % [library_name, cause.class, cause.message])
+        @cause = cause;
+      end
+    end
+  end
+end

data/lib/bel/libbel/library_resolver.rb

@@ -0,0 +1,103 @@
+require_relative 'platform_support_error'
+
+module BEL
+  module LibBEL
+
+    module LibraryResolver
+
+      EXT_BASE_PATH = File.join(File.expand_path('..', __FILE__), 'ext')
+
+      def resolve_library(lib_name)
+        case library_type(lib_name)
+        when :compiled
+          compiled_library(lib_name)
+        when :windows
+          windows_library(lib_name)
+        when :java
+          java_library(lib_name)
+        when :unknown
+          raise BEL::LibBEL::PlatformSupportError.new
+        end
+      end
+
+      private
+
+      def library_type(lib_name)
+        exist = File.method(:exist?)
+        if compiled_library_paths(lib_name).any?(&exist)
+          :compiled
+        else
+          case RUBY_PLATFORM
+          when /mingw/i
+            :windows
+          when /java/i
+            :java
+          else
+            :unsupported
+          end
+        end
+      end
+
+      def compiled_library(lib_name)
+        exist = File.method(:exist?)
+        compiled_library_paths(lib_name).select(&exist).first
+      end
+
+      def compiled_library_paths(lib_name)
+        base_path    = "#{EXT_BASE_PATH}"
+        extensions   = ['so', 'bundle', 'dylib']
+
+        extensions.map { |ext|
+          "%s/%s.%s" % [base_path, lib_name, ext]
+        }
+      end
+
+      def windows_library(lib_name)
+        unless RUBY_VERSION =~ /^2/
+          raise BEL::LibBEL::PlatformSupportError.new
+        end
+
+        base_path    = "#{EXT_BASE_PATH}/mingw"
+        host_cpu     = RbConfig::CONFIG['host_cpu']
+        File.join(base_path, host_cpu, ruby_version, 'libbel.so')
+      end
+
+      def java_library(lib_name)
+        # extra check to make sure jruby supports Ruby 2 (e.g. JRuby 9.0.0.0)
+        unless RUBY_VERSION =~ /^2/
+          raise BEL::LibBEL::PlatformSupportError.new
+        end
+
+        base_path      = "#{EXT_BASE_PATH}/java"
+        host_os        = RbConfig::CONFIG['host_os']
+        host_cpu       = RbConfig::CONFIG['host_cpu']
+
+        case host_os
+        when /darwin/i
+          File.join(base_path, 'darwin', host_cpu, 'libbel.bundle')
+        when /mswin/i
+          File.join(base_path, 'mswin',  host_cpu, ruby_version, 'libbel.so')
+        when /linux/i
+          File.join(base_path, 'linux',  host_cpu, 'libbel.so')
+        else
+          raise BEL::LibBEL::PlatformSupportError.new
+        end
+      end
+
+      def host_cpu
+        RbConfig::CONFIG['host_cpu']
+      end
+
+      def host_os
+        RbConfig::CONFIG['host_os']
+      end
+
+      def ruby_version
+        major = RbConfig::CONFIG['MAJOR']
+        minor = RbConfig::CONFIG['MINOR']
+
+        "%s.%s" % [major, minor]
+      end
+    end
+  end
+end

data/lib/bel/libbel/node_test.rb

@@ -1,44 +1,46 @@
-module LibBEL
-  module NodeTest
+module BEL
+  module LibBEL
+    module NodeTest
 
-    def any?(predicates)
-      predicates.each do |predicate|
-        if predicate.call(self)
-          return true
+      def any?(predicates)
+        predicates.each do |predicate|
+          if predicate.call(self)
+            return true
+          end
         end
+        return false
       end
-      return false
-    end
 
-    def any_in_tree?(predicates)
-      predicates.each do |predicate|
-        self.traversal_method(self, :depth_first).call do |ast_node|
-          if predicate.call(ast_node)
-            return true
+      def any_in_tree?(predicates)
+        predicates.each do |predicate|
+          self.traversal_method(self, :depth_first).call do |ast_node|
+            if predicate.call(ast_node)
+              return true
+            end
           end
         end
+        return false
       end
-      return false
-    end
 
-    def all?(predicates)
-      predicates.each do |predicate|
-        if !predicate.call(self)
-          return false
+      def all?(predicates)
+        predicates.each do |predicate|
+          if !predicate.call(self)
+            return false
+          end
         end
+        return true
       end
-      return true
-    end
 
-    def all_in_tree?(predicates)
-      predicates.each do |predicate|
-        self.traversal_method(self, :depth_first).call do |ast_node|
-          if !predicate.call(ast_node)
-            return false
+      def all_in_tree?(predicates)
+        predicates.each do |predicate|
+          self.traversal_method(self, :depth_first).call do |ast_node|
+            if !predicate.call(ast_node)
+              return false
+            end
           end
         end
+        return true
       end
-      return true
     end
   end
 end

data/lib/bel/libbel/node_transformation.rb

@@ -1,31 +1,33 @@
-module LibBEL
-  module NodeTransformation
+module BEL
+  module LibBEL
+    module NodeTransformation
 
-    def transform(transforms, options = {})
-      if options[:mutate] == true
-        ast_node = self
-      else
-        ast_node = LibBEL::copy_ast_node(self)
-      end
+      def transform(transforms, options = {})
+        if options[:mutate] == true
+          ast_node = self
+        else
+          ast_node = LibBEL::copy_ast_node(self)
+        end
 
-      transforms.each do |transform|
-        transform.call(ast_node)
+        transforms.each do |transform|
+          transform.call(ast_node)
+        end
+        ast_node
       end
-      ast_node
-    end
 
-    def transform_tree(transforms, traversal = :depth_first, options = {})
-      if options[:mutate] == true
-        ast_node = self
-      else
-        ast_node = LibBEL::copy_ast_node(self)
-      end
+      def transform_tree(transforms, traversal = :depth_first, options = {})
+        if options[:mutate] == true
+          ast_node = self
+        else
+          ast_node = LibBEL::copy_ast_node(self)
+        end
 
-      transforms.each do |transform|
-        self.traversal_method(ast_node, traversal).call(transform)
-      end
+        transforms.each do |transform|
+          self.traversal_method(ast_node, traversal).call(transform)
+        end
 
-      ast_node
+        ast_node
+      end
     end
   end
 end

data/lib/bel/libbel/node_traversal.rb

@@ -1,97 +1,99 @@
-module LibBEL
-  module NodeTraversal
-    include Enumerable
+module BEL
+  module LibBEL
+    module NodeTraversal
+      include Enumerable
 
-    def each(traversal = :depth_first, callable = nil, &block)
-      func = if block_given?
-               block
-             else
-               callable
-             end
-      if !func
-        if traversal == :depth_first
-          enum_for(:each_depth_first)
-        elsif traversal == :breadth_first
-          enum_for(:each_breadth_first)
-        end
-      else
-        if traversal == :depth_first
-          each_depth_first(callable, &block)
-        elsif traversal == :breadth_first
-          each_breadth_first(callable, &block)
+      def each(traversal = :depth_first, callable = nil, &block)
+        func = if block_given?
+                 block
+               else
+                 callable
+               end
+        if !func
+          if traversal == :depth_first
+            enum_for(:each_depth_first)
+          elsif traversal == :breadth_first
+            enum_for(:each_breadth_first)
+          end
+        else
+          if traversal == :depth_first
+            each_depth_first(callable, &block)
+          elsif traversal == :breadth_first
+            each_breadth_first(callable, &block)
+          end
         end
       end
-    end
 
-    def each_depth_first(callable = nil, &block)
-      func = if block_given?
-               block
-             else
-               callable
-             end
-      if !func
-        enum_for(:each_depth_first)
-      else
-        typed_node = self.to_typed_node
-        func.call(typed_node)
+      def each_depth_first(callable = nil, &block)
+        func = if block_given?
+                 block
+               else
+                 callable
+               end
+        if !func
+          enum_for(:each_depth_first)
+        else
+          typed_node = self.to_typed_node
+          func.call(typed_node)
 
-        if typed_node.is_a? (LibBEL::BelAstNodeToken)
-          if !typed_node.left.pointer.null?
-            typed_node.left.each_depth_first(func)
-          end
-          if func.respond_to?(:between)
-            func.between(typed_node)
-          end
-          if !typed_node.right.pointer.null?
-            typed_node.right.each_depth_first(func)
+          if typed_node.is_a? (LibBEL::BelAstNodeToken)
+            if !typed_node.left.pointer.null?
+              typed_node.left.each_depth_first(func)
+            end
+            if func.respond_to?(:between)
+              func.between(typed_node)
+            end
+            if !typed_node.right.pointer.null?
+              typed_node.right.each_depth_first(func)
+            end
           end
-        end
 
-        if func.respond_to?(:after)
-          func.after(typed_node)
+          if func.respond_to?(:after)
+            func.after(typed_node)
+          end
         end
       end
-    end
 
-    def each_breadth_first(callable = nil, queue = [], &block)
-      func = if block_given?
-               block
-             else
-               callable
-             end
-      if !func
-        enum_for(:each_breadth_first)
-      else
-        typed_node = (queue.shift || self).to_typed_node
-        func.call(typed_node)
+      def each_breadth_first(callable = nil, queue = [], &block)
+        func = if block_given?
+                 block
+               else
+                 callable
+               end
+        if !func
+          enum_for(:each_breadth_first)
+        else
+          typed_node = (queue.shift || self).to_typed_node
+          func.call(typed_node)
 
-        if typed_node.is_a? (LibBEL::BelAstNodeToken)
-          if !typed_node.left.pointer.null?
-            queue << typed_node.left
-          end
-          if func.respond_to?(:between)
-            func.between(typed_node)
+          if typed_node.is_a? (LibBEL::BelAstNodeToken)
+            if !typed_node.left.pointer.null?
+              queue << typed_node.left
+            end
+            if func.respond_to?(:between)
+              func.between(typed_node)
+            end
+            if !typed_node.right.pointer.null?
+              queue << typed_node.right
+            end
           end
-          if !typed_node.right.pointer.null?
-            queue << typed_node.right
-          end
-        end
 
-        if func.respond_to?(:after)
-          func.after(typed_node)
-        end
+          if func.respond_to?(:after)
+            func.after(typed_node)
+          end
 
-        if !queue.empty?
-          queue.first.each_breadth_first(queue, &block)
+          if !queue.empty?
+            queue.first.each_breadth_first(queue, &block)
+          end
         end
       end
-    end
 
-    def traversal_method(obj, traversal)
-      if traversal == :breadth_first
-        obj.method(:each_breadth_first)
-      else
-        obj.method(:each_depth_first)
+      def traversal_method(obj, traversal)
+        if traversal == :breadth_first
+          obj.method(:each_breadth_first)
+        else
+          obj.method(:each_depth_first)
+        end
       end
     end
   end