gravitext-util 1.6.b.0-java → 1.6.b.1-java

data/History.rdoc

@@ -1,3 +1,9 @@
+=== 1.6.b.1 (2012-2-7)
+* Reworked UniMap Ruby extension: UniMap.is_a?( Hash ) with Hash
+  behavior including interop with string or symbol keys, to_json
+  support, improved performance.
+* IOUtils, tests fixes for 1.9 mode
+
 === 1.6.b.0 (2012-1-29)
 * New jruby IOUtils, sample extension, and perf test for optimizing
   text-intensive interop.

data/Manifest.txt

@@ -16,4 +16,4 @@ test/test_concurrent.rb
 test/test_ioutils.rb
 test/test_perftest.rb
 test/test_unimap.rb
-lib/gravitext-util/gravitext-util-1.6.b.0.jar
+lib/gravitext-util/gravitext-util-1.6.b.1.jar

data/Rakefile

@@ -4,4 +4,7 @@ require 'rubygems'
 require 'bundler/setup'
 require 'rjack-tarpit'
 
-RJack::TarPit.new( 'gravitext-util' ).define_tasks
+RJack::TarPit.new( 'gravitext-util' ) do |tp|
+  tp.rdoc_destinations <<
+    'dekellum@rubyforge.org:/var/www/gforge-projects/gravitext/gravitext-util'
+end

data/lib/gravitext-util/unimap.rb

@@ -14,22 +14,22 @@
 # permissions and limitations under the License.
 #++
 
-module Gravitext
+require 'gravitext-util/version'
 
-  module HTMap
+# Magic loader hook -> HTMapService
+require 'com/gravitext/jruby/HTMap'
 
-    import 'com.gravitext.htmap.Key'
-    import 'com.gravitext.htmap.UniMap'
+module Gravitext::HTMap
 
-    # Extension to com.gravitext.htmap.UniMap providing convenience
-    # methods, including ruby accessors for keys registered in
-    # UniMap::KEY_SPACE
-    class UniMap
+  import 'com.gravitext.htmap.Key'
+  import 'com.gravitext.htmap.UniMap'
 
-      # Types requiring explicit construction on set
-      EXPLICIT_CTOR_TYPES = [ Java::java.lang.Integer,
-                              Java::java.lang.Double,
-                              Java::java.lang.Float ]
+  # Extension to com.gravitext.htmap.UniMap providing convenience
+  # methods, including ruby accessors for keys registered in
+  # UniMap::KEY_SPACE, and for ruby Hash and JSON compatibility.
+  class UniMap
+
+    class << self
 
       # Create a new key in UniMap::KEY_SPACE. Useful for ruby-only keys
       # or for keys passed as parameters to Java.
@@ -38,42 +38,199 @@ module Gravitext
       # :vtype<~java_class>:: Java class value type (default: java.lang.Object)
       # ==== Returns
       # com.gravitext.htmap.Key
-      def self.create_key( name, vtype = Java::java.lang.Object )
+      def create_key( name, vtype = Java::java.lang.Object )
         KEY_SPACE.create_generic( name, vtype.java_class )
       end
 
-      # Define accessors for each key currently in the KEY_SPACE. To
-      # define accessors for keys defined in java, statically reference
-      # the containing class before calling this method. As Ruby's
-      # define_method is not likely thread safe, invoke during
-      # initialization in advance of starting threaded execution. May
-      # be called multiple times.
-      def self.define_accessors
+      # Define class constants and accessors for each key currently in
+      # the KEY_SPACE.
+      #
+      # To define accessors for keys defined in java, statically
+      # reference the containing class before calling this method. As
+      # Ruby's define_method is not likely thread safe, invoke during
+      # initialization in advance of starting threaded execution.
+      # May be called multiple times.
+      def define_accessors
+
+        klist = []
+        khash = {}
         KEY_SPACE.keys.each do |key|
 
+          klist[ key.id ] = key.name.to_sym
+
+          khash[ key.name ] = key
+          khash[ key.name.to_sym ] = key
+
+          const = key.name.upcase
+          if const_defined?( const )
+            cval = const_get( const )
+            if cval != key
+              fail "Constant #{key} already set to incompatible value #{cval}"
+            end
+          else
+            const_set( const, key )
+          end
+
           getter = key.name.downcase
           unless method_defined?( getter )
-            define_method( getter ) { get( key ) }
+            class_eval <<-RUBY
+              def #{getter}
+                get_k( #{const} )
+              end
+            RUBY
           end
 
           setter = getter + '='
           unless method_defined?( setter )
-            vtype = key.value_type
-            ctype = EXPLICIT_CTOR_TYPES.find { |ct| vtype == ct.java_class }
-            if ctype
-              define_method( setter ) do |value|
-                set( key, ( ctype.new( value ) if value ) )
+            class_eval <<-RUBY
+              def #{setter}( value )
+                set_k( #{const}, value )
               end
-            else
-              define_method( setter ) do |value|
-                set( key, value )
-              end
-            end
+            RUBY
           end
 
         end
+
+        @key_list = klist.freeze # key name symbols array indexed by key.id
+        @key_hash = khash.freeze # Hash of symbols,strings to Key
+      end
+
+      # Return cached symbol for the specified key (8bit optimized).
+      # Must have define_accessors for the key first.
+      def key_to_symbol( key )
+        @key_list.at( key.id )
+      end
+
+      # Return Key for specified string name or symbol (8bit optimized)
+      # Must have define_accessors for the key first.
+      def str_to_key( str )
+        @key_hash[ str ]
       end
 
+      # Recursive UniMap#deep_hash implementation
+      def deep_hash( m )
+        case m
+        when UniMap
+          m.inject( {} ) do |o, (k, v)|
+            o[ key_to_symbol( k ) ] = deep_hash( v )
+            o
+          end
+        when Array
+          m.map { |v| deep_hash( v ) }
+        else
+          m
+        end
+      end
+
+    end
+
+    # Set key to value, where key may be a Key, String, or Symbol.
+    # Returns prior value or nil.
+    def set( key, value )
+      unless key.is_a?( Key )
+        k = UniMap.str_to_key( key )
+        unless k
+          raise IndexError, "No Key named #{key.inspect} in UniMap.KEY_SPACE"
+        end
+        key = k
+      end
+      set_k( key, value )
+    end
+
+    # Set key<Key> to value, returning prior value or nil.
+    def set_k( key, value )
+      HTMapHelper.set_map( self, key, value )
+    end
+
+    alias :[]= :set
+
+    # Get key value or nil, where key may be a Key, String, or Symbol
+    def get( key )
+      key = UniMap.str_to_key( key ) unless key.is_a?( Key )
+      key && get_k( key )
+    end
+
+    # Get Key value or nil
+    def get_k( key )
+      HTMapHelper.get_map( self, key )
+    end
+
+    alias :[] :get
+
+    # Remove the specified key, where key may be a Key, String, or
+    # Symbol. Returning old value or nil.
+    def remove( key )
+      key = UniMap.str_to_key( key ) unless key.is_a?( Key )
+      key && HTMapHelper.remove_map( self, key )
+    end
+
+    alias :delete :remove
+
+    # Is this key set, not nil, where key may be a Key, String, or
+    # Symbol.
+    def has_key?( key )
+      key = UniMap.str_to_key( key ) unless key.is_a?( Key )
+      key && contains_key( key )
+    end
+
+    alias :include? :has_key?
+    alias :key?     :has_key?
+    alias :member?  :has_key?
+
+    # Calls block with (Key, value) for each non-nil value
+    def each( &block )
+      HTMapHelper.unimap_each( self, &block )
+    end
+
+    # Return self as array of [ key.to_sym, value ] arrays
+    def to_a
+      map { |key,val| [ UniMap.key_to_symbol( key ), val ] }
+    end
+
+    # Returns self as Hash, with symbols for keys
+    def to_hash
+      h = {}
+      each do |key,val|
+        h[ UniMap.key_to_symbol( key ) ] = val
+      end
+      h
+    end
+
+    # Like to_hash but converts all nested UniMaps to hashes as well.
+    def deep_hash
+      UniMap.deep_hash( self )
+    end
+
+    # Merge other (Hash or UniMap) and return new UniMap. Any nil
+    # values from other Hash will result in removing the associated
+    # key.
+    def merge( other )
+      clone.merge!( other )
+    end
+
+    # Merge other (Hash or UniMap) values to self. Any nil values from
+    # other Hash will result in removing key from self.
+    def merge!( other )
+      other.each do |k,v|
+        set( k, v )
+      end
+      self
+    end
+
+    # To JSON, in form supported by JSON module. Note that this only
+    # works if you also require 'json' yourself.
+    def to_json(*args)
+      to_hash.to_json(*args)
+    end
+
+    # Override: this is a Hash as well.
+    def kind_of?( klass )
+      ( klass == Hash ) || super
+    end
+
+    # Override: this is a Hash as well.
+    def is_a?( klass )
+      ( klass == Hash ) || super
     end
 
   end

data/lib/gravitext-util/version.rb

@@ -16,7 +16,7 @@
 
 module Gravitext
   module Util
-    VERSION = '1.6.b.0'
+    VERSION = '1.6.b.1'
 
     LIB_DIR = File.dirname(__FILE__) # :nodoc:
   end

data/pom.xml

@@ -4,7 +4,7 @@
   <groupId>com.gravitext</groupId>
   <artifactId>gravitext-util</artifactId>
   <packaging>jar</packaging>
-  <version>1.6.b.0</version>
+  <version>1.6.b.1</version>
   <name>Gravitext Utilities</name>
   <url>http://gravitext.com/oss/gravitext-util</url>
 

data/test/test_ioutils.rb

@@ -35,14 +35,16 @@ class TestIOUtils < MiniTest::Unit::TestCase
 
     assert_instance_of( String, ts.string )
     # IF to UTF-8 bytes, will be longer than 300
-    assert_operator( ts.string.length, :>, 300 )
+    assert_length( ts.string, 300 )
 
     assert_instance_of( String, ts.string_sequence )
-    assert_operator( ts.string_sequence.length, :>, 300 )
+    assert_length( ts.string_sequence, 300 )
 
-    if JRUBY_VERSION =~ /^1.7/
-      assert_instance_of( String, ts.char_buffer )
-      assert_instance_of( String, ts.char_buffer_sequence )
+    if JRUBY_VERSION =~ /^1.7/ && RUBY_VERSION =~ /^1.9/
+      # Skipping these due to changing nature (have seen these asserts
+      # work, and not)
+      # assert_instance_of( String, ts.char_buffer )
+      # assert_instance_of( String, ts.char_buffer_sequence )
     else
       # In Jruby < 1.7, CharBuffer isn't converted to String until
       # to_s
@@ -51,23 +53,24 @@ class TestIOUtils < MiniTest::Unit::TestCase
       assert_equal( 'java.nio.HeapCharBuffer',
                     ts.char_buffer_sequence.java_class.name )
     end
-    assert_operator( ts.char_buffer.to_s.length, :>, 300 )
-    assert_operator( ts.char_buffer_sequence.to_s.length, :>, 300 )
+    assert_length( ts.char_buffer.to_s, 300 )
+    assert_length( ts.char_buffer_sequence.to_s, 300 )
 
-    assert_operator( ts.byte_list.to_s.length, :>, 300 )
+    assert_length( ts.byte_list.to_s, 300 )
 
     s = String.from_java_bytes( ts.bytes )
     assert_instance_of( String, s )
-    assert_operator( s.length, :>, 300 )
+    s.force_encoding( "UTF-8" ) if s.respond_to?( :force_encoding )
+    assert_length( s.to_s, 300 )
   end
 
   def test_ruby_sampler
     rs = RubySampler.new( 300, 2 )
     assert_instance_of( String, rs.char_buffer_to_ruby )
-    assert_operator( rs.char_buffer_to_ruby.length, :>, 300 )
+    assert_length( rs.char_buffer_to_ruby, 300 )
 
     assert_instance_of( String, rs.string_to_ruby )
-    assert_operator( rs.string_to_ruby.length, :>, 300 )
+    assert_length( rs.string_to_ruby, 300 )
   end
 
   def test_ruby_sample_helper
@@ -75,10 +78,19 @@ class TestIOUtils < MiniTest::Unit::TestCase
     rs = RubySampleHelper
 
     assert_instance_of( String, rs.char_buffer_to_ruby( ts ) )
-    assert_operator( rs.char_buffer_to_ruby( ts ).length, :>, 300 )
+    assert_length( rs.char_buffer_to_ruby( ts ), 300 )
 
     assert_instance_of( String, rs.string_to_ruby( ts ) )
-    assert_operator( rs.string_to_ruby( ts ).length, :>, 300 )
+    assert_length( rs.string_to_ruby( ts ), 300 )
+  end
+
+  def assert_length( str, char_length )
+    if RUBY_VERSION =~ /^1.9/
+      assert_operator( str.bytesize, :>,  char_length )
+      assert_operator( str.length  , :==, char_length )
+    else
+      assert_operator( str.length  , :>, char_length )
+    end
   end
 
 end

data/test/test_unimap.rb

@@ -20,17 +20,20 @@
 require File.join( File.dirname( __FILE__ ), "setup" )
 
 require 'gravitext-util'
+require 'json'
 
 class TestUniMap < MiniTest::Unit::TestCase
   include Gravitext::HTMap
 
-  TEST_KEYS = [ [ 'int_key',  Java::java.lang.Integer,      33 ],
-                [ 'str_key',  Java::java.lang.String,       "string" ],
-                [ 'cseq_key', Java::java.lang.CharSequence, "other" ],
-                [ 'list_key', Java::java.util.List,         [ 1, 2, 3 ] ],
-                [ 'date_key', Java::java.util.Date,         Time.now ],
-                [ 'dbl_key',  Java::java.lang.Double,       3.1415 ],
-                [ 'flt_key',  Java::java.lang.Float,        1.5625 ] ] #exact
+  TEST_KEYS = [ [ 'int',  Java::java.lang.Integer,      33 ],
+                [ 'str',  Java::java.lang.String,       "string" ],
+                [ 'cseq', Java::java.lang.CharSequence, "other" ],
+                [ 'date', Java::java.util.Date,         Time.now ],
+                [ 'dbl',  Java::java.lang.Double,       3.1415 ],
+                [ 'flt',  Java::java.lang.Float,        1.5625 ], #exact
+                [ 'list', Java::java.util.List,         [ 1, 2, 3 ] ],
+                [ 'sub',  Java::com.gravitext.htmap.UniMap, UniMap.new ],
+                [ 'any',  Java::java.lang.Object,       { :foo => 'bar' } ] ]
 
   WRONG_TYPE_VALUE = Java::java.lang.RuntimeException.new
 
@@ -42,29 +45,34 @@ class TestUniMap < MiniTest::Unit::TestCase
 
   LOG = RJack::SLF4J[ name ]
 
+  def test_define_accessors
+    UniMap.define_accessors
+    pass( "define accessors can be called repeatedly." )
+  end
+
   ## Manual tests
 
   # Full integer test for demonstration
-  def test_int_key
+  def test_int
     c = UniMap.new
-    assert_nil( c.int_key )
-    c.int_key = 7
-    assert_equal( 7, c.int_key )
-    c.int_key = nil
-    assert_nil( c.int_key )
-    assert_raises NameError, NativeException do
-      c.int_key = WRONG_TYPE_VALUE
+    assert_nil( c.int )
+    c.int = 7
+    assert_equal( 7, c.int )
+    c.int = nil
+    assert_nil( c.int )
+    assert_raises( TypeError ) do
+      c.int = WRONG_TYPE_VALUE
     end
   end
 
   # Java.util.Date comparison is tricky
-  def test_date_key
+  def test_date
     c = UniMap.new
-    c.date_key = now = Time.now
-    assert( c.date_key.equals( now ) )
+    c.date = now = Time.now
+    assert( c.date.equals( now ) )
   end
 
-  # Define test_<type_key> for all not manually defined above
+  # Define test_<key> for all not manually defined above
   TEST_KEYS.each do |name, vtype, test_value, key|
     get = name
     set = name + '='
@@ -74,13 +82,14 @@ class TestUniMap < MiniTest::Unit::TestCase
         c = UniMap.new
         assert_nil( c.send( get ) )
         assert_nil( c.send( set, test_value ) )
+        assert_equal( test_value, c.set( key, test_value ) )
         assert_equal( test_value, c.send( get ) )
         assert_equal( test_value, c.get( key ) )
         assert_equal( test_value, c.send( set, nil ) )
         assert_nil( c.send( get ) )
-        assert_raises NameError, NativeException do
+        assert_raises( TypeError ) do
           c.send( set, WRONG_TYPE_VALUE )
-        end
+        end unless key.name == 'any'
         assert_nil( c.send( get ) )
       end
     end
@@ -92,4 +101,95 @@ class TestUniMap < MiniTest::Unit::TestCase
               c.methods.sort.select { |m| m =~ /[^=]=$/ }.join( " " ) )
   end
 
+  # Only tests below use this setup of a nested @sample structure.
+  def setup
+    @sample = UniMap.new
+    TEST_KEYS.each do |k,_,v|
+      @sample.send( "#{k}=", v ) if v
+    end
+    @sample.list = (1..2).map do |i|
+      UniMap.new.tap do |m|
+        m.int = i
+        m.str = i.to_s
+      end
+    end
+
+    @sample.sub = @sample.dup
+  end
+
+  def test_to_hash
+    h = @sample.to_hash
+
+    assert_equal( 33, h[ :int ], "to_hash should have symbol keys" )
+    assert_nil( h[ 'int' ],      "to_hash should not have string keys" )
+    assert_equal( Hash[ @sample.to_a ], h, "to_a, to_hash agree" )
+  end
+
+  def test_is_a_hash
+    assert_kind_of( Hash, @sample )
+    assert( @sample.is_a?( Hash ) )
+  end
+
+  def test_membership
+    assert( @sample.has_key?( :int ) )
+    assert( @sample.include?( 'int' ) )
+    assert( @sample.key?( :str ) )
+    assert( @sample.member?( :str ) )
+  end
+
+  def test_unmapped_keys
+    refute( @sample.has_key?( :non_existing ) )
+    refute( @sample.has_key?( 'non_existing' ) )
+    assert_nil( @sample.remove( :non_existing ) )
+    assert_nil( @sample.get( :non_existing ) )
+    assert_raises( IndexError ) do
+      @sample.set( :non_existing, 'value' )
+    end
+  end
+
+  def test_brackets
+    assert_equal( 33, @sample[ 'int' ] )
+    assert_equal( 33, @sample[ :int  ] )
+
+    assert_equal( 66, @sample[ :int ] = 66 )
+    assert_equal( 66, @sample[ :int ] )
+  end
+
+  def test_merge
+    m = @sample.merge( :int => 66, 'str' => "new" )
+    assert_equal( 33,       @sample.int )
+    assert_equal( "string", @sample.str )
+    assert_equal( 66,    m.int )
+    assert_equal( "new", m.str )
+
+    n = @sample.merge( m )
+    assert_equal( 66,    n.int )
+    assert_equal( "new", n.str )
+  end
+
+  def test_merge_bang
+    @sample.merge!( :int => 66, :str => "new" )
+    assert_equal( 66,    @sample.int )
+    assert_equal( "new", @sample.str )
+  end
+
+  def test_json
+
+    assert_equal( @sample.deep_hash.to_json, @sample.to_json )
+    refute_match( /int1/, @sample.to_json )
+
+    json = JSON.pretty_generate( @sample )
+    pass
+
+    LOG.debug { "JSON.pretty_generate:\n#{json}" }
+
+    s = @sample.clone
+    s.remove( :date ) #would otherwise roundtrip as string
+    s.delete( :sub )  #also has a date
+
+    assert_equal( s.deep_hash,
+                  JSON.parse( s.to_json, :symbolize_names => true ) )
+
+  end
+
 end

metadata

@@ -2,7 +2,7 @@
 name: gravitext-util
 version: !ruby/object:Gem::Version 
   prerelease: 4
-  version: 1.6.b.0
+  version: 1.6.b.1
 platform: java
 authors: 
   - David Kellum
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-01-30 00:00:00 Z
+date: 2012-02-08 00:00:00 Z
 dependencies: 
   - !ruby/object:Gem::Dependency 
     name: rjack-slf4j
@@ -86,7 +86,7 @@ files:
   - test/test_ioutils.rb
   - test/test_perftest.rb
   - test/test_unimap.rb
-  - lib/gravitext-util/gravitext-util-1.6.b.0.jar
+  - lib/gravitext-util/gravitext-util-1.6.b.1.jar
 homepage: http://gravitext.rubyforge.org
 licenses: []
 
@@ -114,7 +114,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.8.11
+rubygems_version: 1.8.15
 signing_key: 
 specification_version: 3
 summary: A collection of core java utilities, many with jruby adaptions.