jruby-scala-collections-scala2.11 0.1.6-java

data/README.md

@@ -0,0 +1,83 @@
+## jruby-scala-collections [![Build Status](https://travis-ci.org/RubyAndScala/jruby-scala-collections.png?branch=master)](https://travis-ci.org/RubyAndScala/jruby-scala-collections)[![Stories in Ready](https://badge.waffle.io/RubyAndScala/jruby-scala-collections.png?label=ready)](https://waffle.io/RubyAndScala/jruby-scala-collections)
+
+jruby-scala-collections is a tiny interoperability library for passing JRuby/Scala collections back
+and forth.
+
+https://rubygems.org/gems/jruby-scala-collections
+
+## Installation
+
+$ gem install jruby-scala-collections
+
+With bundler:
+
+```gem "jruby-scala-collections", ">=0.1.1", require: "jruby/scala_support"```
+
+Beware that you have to have ```scala-library.jar``` loaded before you 
+load ```jruby/scala_support```. In Rails this generally means it loading in ```config/boot.rb```.
+
+## How do you use it?
+
+Each ```Object``` has two methods: ```#to_scala``` and ```#from_scala```.
+These can be used to wrap JRuby/Scala collections.
+
+Example:
+
+    gem 'jruby-scala-collections'
+    require 'jruby/scala_support'
+    
+    r_arr = [1,2,3,4]
+    scala_arr = scala_object.do_stuff(r_arr.to_scala)
+    scala_arr.from_scala
+
+* ```Array#to_scala``` becomes ```scala.collection.mutable.Buffer```
+* ```Hash#to_scala``` becomes ```scala.collection.mutable.Map```
+* ```Set#to_scala``` becomes ```scala.collection.mutable.Set```
+
+Take node that even collections inside collections are wrapped:
+
+    > a = [1,[2,3],{4=>5}].to_scala
+     => #<Java::JrubyCollection::ListWrapper:0x768bdb> 
+    > a.apply(1)
+     => #<Java::JrubyCollection::ListWrapper:0x884ab9> 
+    > a.apply(2)
+     => #<Java::JrubyCollection::MapWrapper:0x1bb605> 
+
+From Scala side Ruby primitives are converted using default JRuby conversions
+that are listed in https://github.com/jruby/jruby/wiki/CallingJavaFromJRuby section
+"Conversion of Types".
+
+So if you expect Array of Fixnums coming to your scala method, it should accept:
+
+    // Either
+    def scalaMethod(args: collection.mutable.Buffer[Long])
+    // Or
+    def scalaMethod(args: collection.Seq[Long])
+
+It also adds ```#Some``` and ```None``` so you could pass values to Scala
+methods:
+
+    scala_object.set(Some(3))
+    scala_object.get(None)
+
+## Disclaimer
+
+This library was written by Artūras 'arturaz' Šlajus for personal
+usage.
+
+## Contributing
+```#to_scala``` should work pretty well, however Ruby wrappers
+in ```#from_scala``` may be missing methods. Patches are welcome.
+jruby-scala-collections uses rubyspec and mspec to test that the behaviour
+of the Ruby wrappers is correct.
+Currently only a part of those tests pass. You can contribute by grabbing
+any of the tests marked as `fails` in `rubyspec/tags/**/*_tags.txt`, marking it as
+`focus` and implement the needed behaviour.
+Guard is configured so that `bundle exec guard` runs all tests that have the focus tag.
+If you want to run all tests that should be working, use `bundle exec mspec -G fails rubyspec`.
+If you have implemented functionality, run `bundle exec mspec tag rubyspec` to update the list
+of failing tests and check with a `git diff` that you haven't broken other functionality.
+
+### Development environment
+In order to compile and package the project, an existing [SBT](http://www.scala-sbt.org/) installation must be available. Then just go to the 
+`ext` directory and execute `sbt dist`. Then go back to the upper directory and execute `gem build jruby-scala-collections.gemspec`

data/lib/jruby/scala_support.rb

@@ -0,0 +1,479 @@
+require 'jruby'
+require 'set'
+require 'ext/collections.jar'
+
+module JRuby::ScalaSupport
+  class ImmutableException < StandardError; end
+
+  module Common
+    include Enumerable
+
+    # Fake _target_ identity. This extends #is_a?, #kind_of?, #instance_of? on
+    # _target_ and #=== on _pretended_klass_.
+    #
+    # Example: fake_identity YourCustomHash, Hash
+    #
+    # Beware that #<, #<= and #ancestors on _target_ will still return that
+    # _target_ is not _pretended_klass_.
+    #
+    # @param [Class] target class that is being given fake identity
+    # @param [Class] pretended_klass class that target is pretending to be
+    def self.fake_identity(target, pretended_klass)
+      target.instance_eval do
+        [:is_a?, :kind_of?, :instance_of?].each do |method|
+          define_method(method) do |klass|
+            klass == pretended_klass ? true : super(klass)
+          end
+        end
+      end
+
+      (class << pretended_klass; self; end).instance_eval do
+        define_method(:===) do |object|
+          if object.is_a?(target)
+            true
+          else
+            super(object)
+          end
+        end
+      end
+    end
+
+    def initialize(raw)
+      @raw = raw
+    end
+
+    def scala_collection
+      @raw
+    end
+
+    def empty?
+      @raw.isEmpty
+    end
+
+    def size
+      @raw.size
+    end
+  end
+
+  module Map
+    module Common
+      include JRuby::ScalaSupport::Common
+
+      def [](key)
+        value = @raw.get(key)
+        if value == None
+          nil
+        else
+          value.get.from_scala
+        end
+      end
+
+      def keys
+        @raw.keys.toSeq.from_scala.to_a
+      end
+
+      def values
+        @raw.values.toSeq.from_scala.to_a
+      end
+
+      def value?(v)
+        values.include?(v)
+      end
+
+      alias_method :has_value?, :value?
+
+      def has_key?(key)
+        @raw.contains(key)
+      end
+
+      alias_method :key?, :has_key?
+      alias_method :member?, :has_key?
+      alias_method :include?, :has_key?
+
+      def key(val)
+        kv = find {|_,v| v == val }
+        kv && kv.first
+      end
+
+      def each
+        if block_given?
+          @raw.foreach do |tuple|
+            yield tuple._1.from_scala, tuple._2.from_scala
+          end
+        else
+          iterator = @raw.iterator
+
+          Enumerator.new do |yielder|
+            while iterator.hasNext
+              tuple = iterator.next
+              yielder << [tuple._1.from_scala, tuple._2.from_scala]
+            end
+          end
+        end
+      end
+
+      alias_method :each_pair, :each
+
+      def to_s
+        first = true
+        each_with_object("{") do |(key, value), str|
+          first ? first = false : str << ", "
+          str << "#{key.inspect}=>#{value.inspect}"
+        end << "}"
+      end
+
+      alias_method :inspect, :to_s
+
+      def as_json(options=nil)
+        each_with_object({}) do |(key, value), hash|
+          hash[key.as_json(options)] = value.as_json(options)
+        end
+      end
+
+      def eql?(other)
+        return true if self.equal? other
+
+        unless other.kind_of? Hash
+          return false unless other.respond_to? :to_hash
+          return other.eql?(self)
+        end
+
+        return false unless other.size == size
+
+        other.each do |k,v|
+
+          return false unless (entry = real_map.send(:findEntry,k)) && (entry.key.from_scala.eql?(k)) && (item = entry.value)
+
+          # Order of the comparison matters! We must compare our value with
+          # the other Hash's value and not the other way around.
+          return false unless item.eql?(v)
+        end
+
+        true
+      end
+
+      alias_method :==, :eql?
+
+      alias_method :length, :size
+
+      private
+      def real_map
+        case @raw
+        when scala.collection.Map::WithDefault then @raw.send(:underlying)
+        else @raw
+        end
+      end
+    end
+
+    class Immutable
+      include Common
+      JRuby::ScalaSupport::Common.fake_identity self, Hash
+
+      def []=(key, value)
+        raise ImmutableException,
+          "Cannot change #{key} on #{self} because it is immutable!"
+      end
+    end
+
+    class Mutable
+      include Common
+      JRuby::ScalaSupport::Common.fake_identity self, Hash
+
+      class << self
+        alias_method :previous_new, :new
+
+        def [](*args)
+          hash = new
+          if args.size == 1
+            obj = args.first
+            case obj
+            when Array, Hash then obj.each {|k,v| hash[k] = v}
+            else
+              raise "Don't yet know what to do with a #{obj.inspect}"
+            end
+            return hash
+          end
+
+          return new if args.empty?
+
+          if args.size & 1 == 1
+            raise ArgumentError, "Expected an even number, got #{args.length}"
+          end
+
+          i = 0
+          total = args.size
+
+          while i < total
+            hash[args[i]] = args[i+1]
+            i += 2
+          end
+
+          hash
+        end
+
+        def new(default_value=nil, &default_block)
+          raise ArgumentError, "You can only provide either a default value or a block" if default_value && default_block
+          h = scala.collection.mutable.HashMap.new
+          if default_block
+            h = h.with_default {|k| default_block.call(h,k) }
+          end
+          h = h.with_default_value(default_value) if default_value
+          previous_new(h)
+        end
+      end
+
+      def []=(key, value)
+        @raw.update(key, value.to_scala)
+      end
+    end
+  end
+
+  module Seq
+    module Common
+      include JRuby::ScalaSupport::Common
+
+      def [](index)
+        if index < 0
+          @raw.apply(size + index).from_scala
+        elsif index >= size
+          nil
+        else
+          @raw.apply(index).from_scala
+        end
+      end
+
+      def each
+        if block_given?
+          @raw.foreach do |item|
+            yield item.from_scala
+          end
+        else
+          iterator = @raw.iterator
+
+          Enumerator.new do |yielder|
+            yielder << iterator.next.from_scala while iterator.hasNext
+          end
+        end
+      end
+
+      def to_s
+        first = true
+        each_with_object("[") do |item, str|
+          first ? first = false : str << ", "
+          str << item.to_s
+        end << "]"
+      end
+    end
+
+    class Immutable
+      include Common
+      JRuby::ScalaSupport::Common.fake_identity self, Array
+
+      def []=(index, value)
+        raise ImmutableException,
+          "Cannot assign #{value} to index #{index} on #{self
+          }: collection immutable"
+      end
+    end
+
+    class Mutable
+      include Common
+      JRuby::ScalaSupport::Common.fake_identity self, Array
+
+      def []=(index, value)
+        if index < 0
+          @raw.update(size + index, value.to_scala)
+        elsif index >= size
+          (index - size + 1).times { @raw.send(:"+=", nil) }
+          self[index] = value
+        else
+          @raw.update(index, value.to_scala)
+        end
+      end
+    end
+  end
+
+  module Set
+    module Common
+      include JRuby::ScalaSupport::Common
+
+      def +(o)
+        (@raw + o).from_scala
+      end
+
+      def -(o)
+        (@raw - o).from_scala
+      end
+
+      def each
+        if block_given?
+          @raw.foreach { |item| yield item.from_scala }
+        else
+          Enumerator.new do |yielder|
+            each { |item| yielder << item }
+          end
+        end
+      end
+
+      def to_s
+        first = true
+        each_with_object("#<Set: {") do |item, str|
+          first ? first = false : str << ", "
+          str << item.to_s
+        end << "}>"
+      end
+    end
+
+    class Immutable
+      include Common
+      JRuby::ScalaSupport::Common.fake_identity self, Set
+
+      def add(o)
+        raise ImmutableException,
+          "Cannot add #{o} to #{self}: immutable collection"
+      end
+
+      def delete(o)
+        raise ImmutableException,
+          "Cannot delete #{o} from #{self}: immutable collection"
+      end
+    end
+
+    class Mutable
+      include Common
+      JRuby::ScalaSupport::Common.fake_identity self, Set
+
+      def add(o)
+        @raw.send(:"+=", o.to_scala)
+        self
+      end
+
+      def delete(o)
+        @raw.send(:"-=", o.to_scala)
+        self
+      end
+    end
+  end
+
+  class Tuple
+    include Common
+    Common.fake_identity self, Array
+
+    def initialize(raw, size)
+      super(raw)
+      @size = size
+    end
+
+    def size
+      @size
+    end
+
+    def empty?
+      false
+    end
+
+    def each
+      if block_given?
+        (0...size).each do |index|
+          yield self[index]
+        end
+        self
+      else
+        Enumerator.new do |yielder|
+          self.each { |item| yielder << item }
+        end
+      end
+    end
+
+    def to_s
+      first = true
+      each_with_object("[") do |item, str|
+        first ? first = false : str << ","
+        str << item.to_s
+      end << "]"
+    end
+
+    def [](index)
+      if index < 0
+        @raw.send("_#{size + index + 1}").from_scala
+      elsif index >= size
+        nil
+      else
+        @raw.send("_#{index + 1}").from_scala
+      end
+    end
+
+    def []=(index, value)
+      raise ImmutableException,
+        "Cannot assign #{value} to index #{index} on #{self
+        }: collection immutable"
+    end
+  end
+end
+
+# Scala <-> Ruby interoperability.
+class Object
+  def to_scala
+    case self
+    when JRuby::ScalaSupport::Common
+      self.scala_collection
+    when Hash
+      Java::jruby.collection.MapWrapper.new(self)
+    when Set
+      Java::jruby.collection.SetWrapper.new(self)
+    when Array
+      Java::jruby.collection.ListWrapper.new(self)
+    when Symbol
+      Java::scala.Symbol.apply(to_s)
+    else
+      self.to_java
+    end
+  end
+
+  def from_scala
+    case self
+    when Java::jruby.collection.MapWrapper
+      self.rubyHash
+    when Java::scala.collection.mutable.Map
+      JRuby::ScalaSupport::Map::Mutable.new(self)
+    when Java::scala.collection.Map, Java::scala.collection.immutable.Map
+      JRuby::ScalaSupport::Map::Immutable.new(self)
+    when Java::jruby.collection.ListWrapper
+      self.rubyArray
+    when Java::scala.collection.mutable.Seq
+      JRuby::ScalaSupport::Seq::Mutable.new(self)
+    when Java::scala.collection.Seq, Java::scala.collection.immutable.Seq
+      JRuby::ScalaSupport::Seq::Immutable.new(self)
+    when Java::scala.Product
+      # Sometimes tuples have some wraping classes, like "#<Class:...>" on top
+      # of them. Some magic is needed to find actual tuple name.
+      match = nil
+      self.class.ancestors.find do |klass|
+        match = klass.to_s.match(/^Java::Scala::Tuple(\d+)$/)
+        ! match.nil?
+      end
+
+      if match
+        size = match[1].to_i
+        JRuby::ScalaSupport::Tuple.new(self, size)
+      else
+        self
+      end
+    when Java::jruby.collection.SetWrapper
+      self.rubySet
+    when Java::scala.collection.mutable.Set
+      JRuby::ScalaSupport::Set::Mutable.new(self)
+    when Java::scala.collection.Set, Java::scala.collection.immutable.Set,
+      JRuby::ScalaSupport::Set::Immutable.new(self)
+    when Java::scala.Symbol
+      self.name.to_sym
+    else
+      self
+    end
+  end
+end
+
+module Kernel
+  def Some(value); Java::scala.Some.new(value); end
+  None = Java::jruby.collection.Utils.None
+end

metadata

@@ -0,0 +1,178 @@
+--- !ruby/object:Gem::Specification
+name: jruby-scala-collections-scala2.11
+version: !ruby/object:Gem::Version
+  version: 0.1.6
+  prerelease: 
+platform: java
+authors:
+- Artūras Šlajus
+- Martin Mauch
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-04-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rubygems-tasks
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.14'
+- !ruby/object:Gem::Dependency
+  name: mspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.2'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec-jruby
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: guard-shell
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.6'
+description: Interoperability layer for passing JRuby & Scala collections back and
+  forth. See README.md for more info.
+email: arturas.slajus@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/jruby/scala_support.rb
+- lib/ext/collections.jar
+- README.md
+homepage: https://github.com/RubyAndScala/jruby-scala-collections
+licenses:
+- Apache 2.0
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Compiled against JRuby 1.7.4/Scala 2.11.6
+test_files: []