jruby-scala 0.1.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,24 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC
+*.gemspec
+doc
+.yardoc

data/LICENSE

@@ -0,0 +1,25 @@
+Copyright (c) 2010, System Insights, Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+  1. Redistributions of source code must retain the above copyright notice, this
+     list of conditions and the following disclaimer.
+  2. Redistributions in binary form must reproduce the above copyright notice,
+     this list of conditions and the following disclaimer in the documentation
+     and/or other materials provided with the distribution.
+  3. Neither the name of System Insights, Inc. nor the names of
+     its contributors may be used to endorse or promote products derived from
+     this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.rdoc

@@ -0,0 +1,29 @@
+= jruby-scala
+
+Scala integration/interop library for JRuby.
+
+Much of the code for this library is originally from an article written by
+Daniel Spiewak:
+
+  http://www.codecommit.com/blog/ruby/integrating-scala-into-jruby
+
+many thanks to Daniel for his great article and implementation.
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2010 System Insights, Inc. See LICENSE for details.
+
+This work also contains code derived from public sources.
+
+Portions Copyright (c) 2010 Daniel Spiewak
+All rights reserved.

data/Rakefile

@@ -0,0 +1,45 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "jruby-scala"
+    gem.summary = %Q{A Scala integration library for JRuby}
+    gem.description = %Q{A Scala integration library for JRuby that allows using Procs as Scala functions, including Scala traits into Ruby modules, and more.}
+    gem.email = "ingersoll@gmail.com"
+    gem.homepage = "http://github.com/wemrysi/jruby-scala"
+    gem.authors = ["Emrys Ingersoll"]
+    gem.add_development_dependency "rspec", ">= 1.2.9"
+    gem.add_development_dependency "yard", ">= 0"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+task :default => :spec
+
+begin
+  require 'yard'
+  YARD::Rake::YardocTask.new
+rescue LoadError
+  task :yardoc do
+    abort "YARD is not available. In order to run yardoc, you must: sudo gem install yard"
+  end
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/jruby_scala.rb

@@ -0,0 +1,12 @@
+require 'java'
+
+# Toplevel namespace for the core Scala classes.
+#
+# @example Access scala elements like you would in Java
+#   scala.collection.immutable.HashMap
+#
+def scala
+  Java::Scala
+end
+
+require 'jruby_scala/core_ext'

data/lib/jruby_scala/core_ext.rb

@@ -0,0 +1,4 @@
+require 'jruby_scala/core_ext/operator_translations'
+require 'jruby_scala/core_ext/java'
+require 'jruby_scala/core_ext/module'
+require 'jruby_scala/core_ext/proc'

data/lib/jruby_scala/core_ext/java.rb

@@ -0,0 +1,3 @@
+class Java::JavaLang::Object
+  include JrubyScala::CoreExt::OperatorTranslations
+end

data/lib/jruby_scala/core_ext/module.rb

@@ -0,0 +1,5 @@
+require 'jruby_scala/core_ext/module/traits'
+
+class Module #:nodoc:
+  include JrubyScala::CoreExt::Module::Traits
+end

data/lib/jruby_scala/core_ext/module/traits.rb

@@ -0,0 +1,102 @@
+require 'set'
+require 'jruby_scala/core_ext/operator_translations'
+
+module JrubyScala
+  module CoreExt
+    module Module
+      # Enables the inclusion of Scala traits into Ruby modules.
+      #
+      # TODO: Currently, JRuby throws an exception when attempting to load
+      # many of the top-level traits: List, Iterator, Equiv, Ordered, etc.
+      # Oddly enough, scala.FunctionN works fine. We need to investigate
+      # why this happens.
+      #
+      module Traits
+        def self.included(base)
+          base.module_eval do
+            alias_method :include_without_scala_trait_support, :include
+            alias_method :include, :include_with_scala_trait_support
+          end
+        end
+
+        # Mixes the given modules into the current module, including Scala
+        # Traits.
+        def include_with_scala_trait_support(*modules)
+          modules.each do |m|
+            if m.respond_to?(:java_class) and m.java_class.interface?
+              loader = m.java_class.class_loader
+              unless loader.nil?
+                mixin_methods_from_trait(loader.load_class(m.java_class.to_s), loader)
+                unless self < JrubyScala::CoreExt::OperatorTranslations
+                  include_without_scala_trait_support(JrubyScala::CoreExt::OperatorTranslations)
+                end
+              end
+            end
+
+            if defined?(@@trait_methods)
+              define_method(:scala_reflective_trait_methods) {@@trait_methods}
+            end
+
+            include_without_scala_trait_support(m)
+          end
+        end
+
+        # Mixes the methods from a Scala trait into the module.
+        #
+        # @param trait_class The trait to mixin
+        # @param [java.lang.ClassLoader] loader The Java ClassLoader for the trait
+        # @param [Set] done The set of traits that have already been mixed in,
+        #   for memoization purposes
+        def mixin_methods_from_trait(trait_class, loader, done = Set.new)
+          return if done.include?(trait_class)
+          done << trait_class
+
+          begin
+            klass = loader.load_class("#{trait_class.name}$class")
+          rescue java.lang.ClassNotFoundException
+            # Unable to load the <TraitName>$class, probably because this is
+            # a standard Java interface, not a Scala trait, so just return.
+            return
+          end
+
+          # TODO: Should this happen before attempting to load the special
+          # <TraitName>$class?
+          trait_class.interfaces.each do |iface| 
+            mixin_methods_from_trait(iface, loader, done)
+          end
+
+          klass.declared_methods.each do |meth|
+            mods = meth.modifiers
+            
+            if java.lang.reflect.Modifier.static?(mods) and java.lang.reflect.Modifier.public?(mods)
+              @@trait_methods ||= []
+
+              unless meth.name.include?('$')
+                module_eval <<-CODE
+                  def #{meth.name}(*args, &block)
+                    args.insert(0, self)
+                    args << block unless block.nil?
+                    args.map! {|a| defined?(a.java_object) ? a.java_object : a}
+                    scala_reflective_trait_methods[#{@@trait_methods.size}].invoke(nil, args.to_java)
+                  end
+                CODE
+
+                @@trait_methods << meth
+              else
+                # Method name contains special characters, so use a fallback
+                # implementation with define_method.
+                #
+                # Caveat: This impl can't deal with methods with function
+                # arguments (blocks)
+                define_method(meth.name) do |*args|
+                  args.insert(0, self)
+                  meth.invoke(nil, args.to_java)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jruby_scala/core_ext/operator_translations.rb

@@ -0,0 +1,131 @@
+module JrubyScala
+  module CoreExt
+    # Provides translations between the standard set of Ruby operators and their
+    # Scala counterparts allowing the natural use of Ruby operators on Scala
+    # objects.
+    #
+    # Currently, translates the ruby-style array/hash access operator #[] and
+    # handles Proc methods on objects that extend scala.FunctionN.  Other
+    # operators may be added as necessary.
+    #
+    # @example Ruby-style hash access
+    #   h = scala.collection.immutable.HashMap.new
+    #   h = h.update(0, 4)
+    #   puts h[0]   --> 4
+    #
+    module OperatorTranslations
+      # A mapping of ruby operators to their respective method invocations in
+      # Scala
+      OPERATORS = {
+        "=" => "$eq",
+        ">" => "$greater",
+        "<" => "$less",
+        "+" => "$plus",
+        "-" => "$minus",
+        "*" => "$times",
+        "/" => "div",
+        "!" => "$bang",
+        "@" => "$at",
+        "#" => "$hash",
+        "%" => "$percent",
+        "^" => "$up",
+        "&" => "$amp",
+        "~" => "$tilde",
+        "?" => "$qmark",
+        "|" => "$bar",
+        "\\" => "$bslash"}
+
+      def self.included(base)
+        alias_method :method_missing_without_scala_operator_translations, :method_missing
+        alias_method :method_missing, :method_missing_with_scala_operator_translations
+      end
+
+      def method_missing_with_scala_operator_translations(sym, *args)
+        if sym == :[] or (sym == :call and type_of_scala_function?(self))
+          apply(*args)
+        elsif sym == :arity and (ar = type_of_scala_function?(self))
+          ar
+        elsif sym == :binding and type_of_scala_function?(self)
+          binding
+        elsif sym == :to_proc and type_of_scala_function?(self)
+          self
+        else
+          method_missing_without_scala_operator_translations(sym, *args)
+=begin
+          str = sym.to_s
+          str = $&[1] + '_=' if str =~ /^(.*[^\]=])=$/
+          OPERATORS.each {|from, to| str.gsub!(from, to)}
+        
+          if respond_to?(str)
+            send(str.to_sym, *args)
+          else
+            method_missing_without_scala_operator_translations(sym, *args)
+          end
+=end
+        end
+      end
+
+    private
+
+      # Predicate returning whether the given object extends one of the Scala
+      # FunctionN traits.
+      #
+      # @param [Object] An object to interrogate
+      #
+      # @return [Fixnum or FalseClass] The arity if the object is a function or
+      #   false if not
+      #
+      def type_of_scala_function?(obj)
+        if obj.java_kind_of? scala.Function0
+          0
+        elsif obj.java_kind_of? scala.Function1
+          1
+        elsif obj.java_kind_of? scala.Function2
+          2
+        elsif obj.java_kind_of? scala.Function3
+          3
+        elsif obj.java_kind_of? scala.Function4
+          4
+        elsif obj.java_kind_of? scala.Function5
+          5
+        elsif obj.java_kind_of? scala.Function6
+          6
+        elsif obj.java_kind_of? scala.Function7
+          7
+        elsif obj.java_kind_of? scala.Function8
+          8
+        elsif obj.java_kind_of? scala.Function9
+          9
+        elsif obj.java_kind_of? scala.Function10
+          10
+        elsif obj.java_kind_of? scala.Function11
+          11
+        elsif obj.java_kind_of? scala.Function12
+          12
+        elsif obj.java_kind_of? scala.Function13
+          13
+        elsif obj.java_kind_of? scala.Function14
+          14
+        elsif obj.java_kind_of? scala.Function15
+          15
+        elsif obj.java_kind_of? scala.Function16
+          16
+        elsif obj.java_kind_of? scala.Function17
+          17
+        elsif obj.java_kind_of? scala.Function18
+          18
+        elsif obj.java_kind_of? scala.Function19
+          19
+        elsif obj.java_kind_of? scala.Function20
+          20
+        elsif obj.java_kind_of? scala.Function21
+          21
+        elsif obj.java_kind_of? scala.Function22
+          22
+        else
+          false
+        end
+      end
+    end
+  end
+end

data/lib/jruby_scala/core_ext/proc.rb

@@ -0,0 +1,5 @@
+require 'jruby_scala/core_ext/proc/conversions'
+
+class Proc #:nodoc:
+  include JrubyScala::CoreExt::Proc::Conversions
+end

data/lib/jruby_scala/core_ext/proc/conversions.rb

@@ -0,0 +1,19 @@
+require 'jruby_scala/core_ext/proc/scala_function'
+
+module JrubyScala
+  module CoreExt
+    module Proc
+      module Conversions
+        # Converts a Proc object into a Scala function of the same arity
+        #
+        # @return [JrubyScala::CoreExt::Proc::Function] A Scala-compatible proc
+        def to_function
+          eval "Function#{arity}.new(self)"
+        end
+
+        alias_method :java_object,  :to_function
+        alias_method :scala_object, :to_function
+      end
+    end
+  end
+end

data/lib/jruby_scala/core_ext/proc/scala_function.rb

@@ -0,0 +1,25 @@
+module JrubyScala
+  module CoreExt
+    module Proc
+      class ScalaFunction
+        def initialize(delegate)
+          @delegate = delegate
+        end
+        
+        def apply(*args)
+          @delegate.call(*args)
+        end
+      end
+
+      SCALA_MAX_ARITY = 22
+
+      for n in 0..SCALA_MAX_ARITY
+        eval <<-CLASS
+          class Function#{n} < ScalaFunction
+            include scala.Function#{n}
+          end
+        CLASS
+      end
+    end
+  end
+end

data/spec/jruby_scala/core_ext/module/traits_spec.rb

@@ -0,0 +1,70 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
+include JrubyScala::CoreExt::Module
+
+describe "JrubyScala::CoreExt::Module::Traits" do
+  describe "when included into a module" do
+    it "should still allow normal Java interfaces to be mixed-in" do
+      class Car
+        include java.lang.Comparable
+
+        attr_reader :speed
+
+        def initialize(speed)
+          @speed = speed
+        end
+
+        def compare_to(other)
+          speed <=> other.speed
+        end
+      end
+
+      pinto = Car.new(45)
+      porsche = Car.new(180)
+      veyron = Car.new(240)
+
+      cars = java.util.TreeSet.new
+      cars.add(porsche)
+      cars.add(pinto)
+      cars.add(veyron)
+
+      cars.first.should == pinto
+      cars.lower(veyron).should == porsche
+    end
+
+    describe "when a Scala trait is included" do
+      before(:all) do
+        class MySet
+          include scala.collection.Set
+
+          def initialize(*elements)
+            @elements = elements
+          end
+
+          def contains(elem)
+            @elements.include?(elem)
+          end
+
+          def size
+            @elements.size
+          end
+        end
+
+        @s1 = MySet.new(1, 2, 3, 4, 5, 6, 7, 8)
+      end
+
+      it "should mix-in defined methods on Scala traits" do
+        @s1.should respond_to(:isEmpty)
+        @s1.isEmpty.should be_false
+        MySet.new.isEmpty.should be_true
+      end
+
+      it "should mix-in defined methods on super traits" do
+        @s1.should respond_to(:compose)
+        f = lambda {|x| x + 3}.to_function
+        g = @s1.compose(f)
+        g.apply(3).should be_true
+        g.apply(7).should be_false
+      end
+    end
+  end
+end

data/spec/jruby_scala/core_ext/operator_translations_spec.rb

@@ -0,0 +1,39 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe "JrubyScala::CoreExt::OperatorTranslations" do
+  before(:all) do
+    @h = scala.collection.immutable.HashMap.new
+    @h = @h.update(0, 5)
+  end
+
+  it "should translate #[] to #apply" do
+    @h.should_receive(:apply).with(0)
+    @h[0]
+  end
+
+  describe "when an object extends a Scala FunctionN" do
+    it "should translate #call to #apply" do
+      @h.should_receive(:apply).with(0)
+      @h.call(0)
+    end
+
+    describe "arity method" do
+      it "should return the arity of the extended FunctionN trait" do
+        @h.should be_a_java_kind_of(scala.Function1)
+        @h.arity.should == 1
+      end
+    end
+
+    describe "binding method" do
+      it "should expose the private binding method" do
+        lambda {@h.binding}.should_not raise_error(NoMethodError)
+      end
+    end
+
+    describe "to_proc method" do
+      it "should return the object itself" do
+        @h.to_proc.should == @h
+      end
+    end
+  end
+end

data/spec/jruby_scala/core_ext/proc/conversions_spec.rb

@@ -0,0 +1,17 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
+include JrubyScala::CoreExt::Proc
+
+describe "JrubyScala::CoreExt::Proc::Conversion" do
+  describe "to_function" do
+    it "should return an instance of FunctionN of the proper arity" do
+      l2 = lambda {|x, y|}
+      l3 = lambda {|x, y, z|}
+
+      f2 = l2.to_function
+      f2.should be_an_instance_of(Function2)
+
+      f3 = l3.to_function
+      f3.should be_an_instance_of(Function3)
+    end
+  end
+end

data/spec/jruby_scala/core_ext/proc/scala_function_spec.rb

@@ -0,0 +1,44 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
+include JrubyScala::CoreExt::Proc
+
+describe "JrubyScala::CoreExt::Proc::ScalaFunction" do
+  describe "apply" do
+    it "should apply the delegate object to the passed arguments" do
+      d1 = lambda {|x| x * 3}
+      d2 = lambda {|x| "#{x} red balloons"}
+
+      arg = 4
+
+      sf1 = ScalaFunction.new(d1)
+      sf1.apply(arg).should == 12
+
+      sf2 = ScalaFunction.new(d2)
+      sf2.apply(arg).should == "4 red balloons"
+    end
+  end
+
+  it "should define a FunctionN class for N = 0..SCALA_MAX_ARITY" do
+    proc_ext = JrubyScala::CoreExt::Proc
+    module Scala
+      include_package('scala')
+    end
+
+    (0..SCALA_MAX_ARITY).each do |arity|
+      klass = proc_ext.const_get("Function#{arity}")
+      f = klass.new(lambda {})
+      f.should be_a_kind_of(ScalaFunction)
+      f.should be_a_kind_of(Scala.const_get("Function#{arity}"))
+    end
+  end
+
+  describe "FunctionN" do
+    it "should be usable as a Scala Function" do
+      sum = Function2.new(lambda {|i, tuple| i + tuple._2})
+      hm = scala.collection.immutable.HashMap.new
+      hm = hm.update('a', 1)
+      hm = hm.update('b', 2)
+      hm = hm.update('c', 3)
+      hm.fold_left(0, sum).should == 6
+    end
+  end
+end

data/spec/jruby_scala_spec.rb

@@ -0,0 +1,11 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "JrubyScala" do
+  before(:all) do
+    @hmap = Java::ScalaCollectionImmutable::HashMap
+  end
+
+  it "should provide a top-level java-like namespace for scala elements" do
+    scala.collection.immutable.HashMap.should == @hmap
+  end
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--color

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'jruby_scala'
+require 'spec'
+require 'spec/autorun'
+
+Spec::Runner.configure do |config|
+end

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification 
+name: jruby-scala
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+  - Emrys Ingersoll
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-02-19 00:00:00 -05:00
+default_executable: 
+dependencies: 
+  - !ruby/object:Gem::Dependency 
+    name: rspec
+    type: :development
+    version_requirement: 
+    version_requirements: !ruby/object:Gem::Requirement 
+      requirements: 
+        - - ">="
+          - !ruby/object:Gem::Version 
+            version: 1.2.9
+      version: 
+  - !ruby/object:Gem::Dependency 
+    name: yard
+    type: :development
+    version_requirement: 
+    version_requirements: !ruby/object:Gem::Requirement 
+      requirements: 
+        - - ">="
+          - !ruby/object:Gem::Version 
+            version: "0"
+      version: 
+description: A Scala integration library for JRuby that allows using Procs as Scala functions, including Scala traits into Ruby modules, and more.
+email: ingersoll@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+  - LICENSE
+  - README.rdoc
+files: 
+  - .document
+  - .gitignore
+  - LICENSE
+  - README.rdoc
+  - Rakefile
+  - VERSION
+  - lib/jruby_scala.rb
+  - lib/jruby_scala/core_ext.rb
+  - lib/jruby_scala/core_ext/java.rb
+  - lib/jruby_scala/core_ext/module.rb
+  - lib/jruby_scala/core_ext/module/traits.rb
+  - lib/jruby_scala/core_ext/operator_translations.rb
+  - lib/jruby_scala/core_ext/proc.rb
+  - lib/jruby_scala/core_ext/proc/conversions.rb
+  - lib/jruby_scala/core_ext/proc/scala_function.rb
+  - spec/jruby_scala/core_ext/module/traits_spec.rb
+  - spec/jruby_scala/core_ext/operator_translations_spec.rb
+  - spec/jruby_scala/core_ext/proc/conversions_spec.rb
+  - spec/jruby_scala/core_ext/proc/scala_function_spec.rb
+  - spec/jruby_scala_spec.rb
+  - spec/spec.opts
+  - spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/wemrysi/jruby-scala
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+  - --charset=UTF-8
+require_paths: 
+  - lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: A Scala integration library for JRuby
+test_files: 
+  - spec/jruby_scala_spec.rb
+  - spec/spec_helper.rb
+  - spec/jruby_scala/core_ext/operator_translations_spec.rb
+  - spec/jruby_scala/core_ext/module/traits_spec.rb
+  - spec/jruby_scala/core_ext/proc/conversions_spec.rb
+  - spec/jruby_scala/core_ext/proc/scala_function_spec.rb