jactive_support 1.0.2

data/lib/jactive_support/java_ext/number.rb

@@ -0,0 +1,91 @@
+class java::lang::Number
+  def self.number_format_instance(format=:default, locale=nil)
+    case format
+    when :number then ::Java::JavaText::NumberFormat.getNumberInstance(locale.to_locale)
+    when :currency then ::Java::JavaText::NumberFormat.getCurrencyInstance(locale.to_locale)
+    when :percent then ::Java::JavaText::NumberFormat.getPercentInstance(locale.to_locale)
+    when :scientific then ::Java::JavaText::NumberFormat.getScientificInstance(locale.to_locale)
+    when :integer then ::Java::JavaText::NumberFormat.getIntegerInstance(locale.to_locale)
+    when :default then ::Java::JavaText::NumberFormat.getInstance(locale.to_locale)
+    end
+  end
+  
+  NUMBER_FORMATS = {
+    :number => lambda {|value, locale| number_format_instance(:number, locale).format(value.to_primitive)},
+    :currency => lambda {|value, locale| number_format_instance(:currency, locale).format(value.to_primitive)},
+    :percent => lambda {|value, locale| number_format_instance(:percent, locale).format(value.to_primitive)},
+    :scientific => lambda {|value, locale| number_format_instance(:scientific, locale).format(value.to_primitive)},
+    :integer => lambda {|value, locale| number_format_instance(:integer, locale).format(value.to_primitive)},
+    :default => lambda {|value, locale| number_format_instance(:default, locale).format(value.to_primitive)},
+  }
+  
+  def to_formatted_s(format=:default, locale=nil)
+    return to_default_s unless formatter = self.class::NUMBER_FORMATS[format]
+    formatter.respond_to?(:call) ? (formatter.arity==2 ? formatter.call(self, locale) : formatter.call(self)).to_s : format_number(formatter)
+  end
+  alias :to_default_s :to_s
+  alias :to_s :to_formatted_s
+
+  def format_number(format, locale=nil)
+    symbols = ::Java::JavaText::DecimalFormatSymbols.new(locale.to_locale)
+    formatter = ::Java::JavaText::DecimalFormat.new(format, symbols)
+    formatter.format(self)
+  end
+  
+  def to_primitive
+    self
+  end
+end
+
+class java::lang::Byte
+  #alias :to_default_s :to_s
+  #alias :to_s :to_formatted_s
+  
+  alias :to_primitive :byte_value
+end
+
+class java::lang::Short
+  #alias :to_default_s :to_s
+  #alias :to_s :to_formatted_s
+
+  alias :to_primitive :short_value
+end
+
+class java::lang::Integer
+  #alias :to_default_s :to_s
+  #alias :to_s :to_formatted_s
+
+  alias :to_primitive :int_value
+end
+
+class java::lang::Long
+  #alias :to_default_s :to_s
+  #alias :to_s :to_formatted_s
+
+  alias :to_primitive :long_value
+end
+
+class java::lang::Float
+  #alias :to_default_s :to_s
+  #alias :to_s :to_formatted_s
+
+  alias :to_primitive :float_value
+end
+
+class java::lang::Double
+  #alias :to_default_s :to_s
+  #alias :to_s :to_formatted_s
+
+  alias :to_primitive :double_value
+end
+
+
+#class Java::JavaMath::BigDecimal
+#  alias :to_default_s :to_s
+#  alias :to_s :to_formatted_s
+#end
+
+#class Java::JavaMath::BigInteger
+#  alias :to_default_s :to_s
+#  alias :to_s :to_formatted_s
+#end

data/lib/jactive_support/java_ext/sql_date.rb

@@ -0,0 +1,7 @@
+require 'active_support/core_ext/date/behavior'
+require 'jactive_support/java_ext/sql_date/conversions'
+
+class java::sql::Date
+  include ActiveSupport::CoreExtensions::Date::Behavior
+  include JactiveSupport::JavaExtensions::SqlDate::Conversions
+end

data/lib/jactive_support/java_ext/sql_date/conversions.rb

@@ -0,0 +1,33 @@
+module JactiveSupport #:nodoc:
+  module JavaExtensions #:nodoc:
+    module SqlDate #:nodoc:
+      # Converting dates to formatted strings, times, and datetimes.
+      module Conversions
+        DATE_FORMATS = {
+          :db           => "yyyy-MM-dd",
+          :i18n         => lambda { |clazz, locale| 
+                              format = I18n.translate(:"formats.date", :default=>'')
+                              !format.blank? ? clazz.pattern_formatter(format) : clazz.date_instance(:default, locale)
+                            },
+          :number       => "YYYMMdd",
+          :full         => lambda { |clazz, locale| clazz.date_instance(:full, locale) },
+          :long         => lambda { |clazz, locale| clazz.date_instance(:long, locale) },
+          :medium       => lambda { |clazz, locale| clazz.date_instance(:medium, locale) },
+          :short        => lambda { |clazz, locale| clazz.date_instance(:short, locale) },
+          :default      => lambda { |clazz, locale| clazz.date_instance(:default, locale) },
+          :long_ordinal => lambda { |clazz| clazz.pattern_formatter("%B #{time.day.ordinalize}, %Y %H:%M") },
+          :rfc822       => lambda { |clazz| clazz.pattern_formatter("%a, %d %b %Y %H:%M:%S #{time.formatted_offset(false)}") },
+          :httpdate     => lambda { |clazz| clazz.pattern_formatter("EEE, dd MMM yyyy HH:mm:ss z", "GMT") }
+        }
+        
+        def to_java_sqldate
+          self
+        end
+        
+        def acts_like_time?
+          false
+        end
+      end
+    end
+  end
+end

data/lib/jactive_support/json.rb

@@ -0,0 +1 @@
+require 'jactive_support/json/encoding'

data/lib/jactive_support/json/encoders/collection.rb

@@ -0,0 +1,12 @@
+module java::util::Collection #:nodoc:
+
+  # Returns a JSON string representing the Array. +options+ are passed to each element.
+  def to_json(options = nil) #:nodoc:
+    "[#{map { |value| ActiveSupport::JSON.encode(value, options) } * ','}]"
+  end
+
+  def as_json(options = nil) #:nodoc:
+    self
+  end
+
+end

data/lib/jactive_support/json/encoders/locale.rb

@@ -0,0 +1,6 @@
+class java::util::Locale
+
+  def to_json(options = {}) #:nodoc:
+    ActiveSupport::JSON.encode(to_s)
+  end
+end

data/lib/jactive_support/json/encoders/map.rb

@@ -0,0 +1,55 @@
+module java::util::Map #:nodoc:
+  # Returns a JSON string representing the hash.
+  #
+  # Without any +options+, the returned JSON string will include all
+  # the hash keys. For example:
+  #
+  #   { :name => "Konata Izumi", 'age' => 16, 1 => 2 }.to_json
+  #   # => {"name": "Konata Izumi", 1: 2, "age": 16}
+  #
+  # The keys in the JSON string are unordered due to the nature of hashes.
+  #
+  # The <tt>:only</tt> and <tt>:except</tt> options can be used to limit the
+  # attributes included, and will accept 1 or more hash keys to include/exclude.
+  #
+  #   { :name => "Konata Izumi", 'age' => 16, 1 => 2 }.to_json(:only => [:name, 'age'])
+  #   # => {"name": "Konata Izumi", "age": 16}
+  #
+  #   { :name => "Konata Izumi", 'age' => 16, 1 => 2 }.to_json(:except => 1)
+  #   # => {"name": "Konata Izumi", "age": 16}
+  #
+  # The +options+ also filter down to any hash values. This is particularly
+  # useful for converting hashes containing ActiveRecord objects or any object
+  # that responds to options in their <tt>to_json</tt> method. For example:
+  #
+  #   users = User.find(:all)
+  #   { :users => users, :count => users.size }.to_json(:include => :posts)
+  #
+  # would pass the <tt>:include => :posts</tt> option to <tt>users</tt>,
+  # allowing the posts association in the User model to be converted to JSON
+  # as well.
+  def to_json(options = {}) #:nodoc:
+    hash = as_json(options)
+    return ActiveSupport::JSON.encode(hash, options) if hash != self
+
+    result = '{'
+    result << hash.map do |key, value|
+      "#{ActiveSupport::JSON.encode(key.to_s)}:#{ActiveSupport::JSON.encode(value, options)}"
+    end * ','
+    result << '}'
+  end
+
+  def as_json(options = nil) #:nodoc:
+    if options
+      if attrs = options[:except]
+        except(*Array.wrap(attrs))
+      elsif attrs = options[:only]
+        slice(*Array.wrap(attrs))
+      else
+        self
+      end
+    else
+      self
+    end
+  end
+end

data/lib/jactive_support/json/encoding.rb

@@ -0,0 +1,5 @@
+require 'active_support/json/encoding'
+Dir["#{File.dirname(__FILE__)}/encoders/**/*.rb"].each do |file|
+  basename = File.basename(file, '.rb')
+  require "jactive_support/json/encoders/#{basename}"
+end

data/lib/jactive_support/rescuable.rb

@@ -0,0 +1,62 @@
+require 'active_support/rescuable'
+
+module ActiveSupport
+  module Rescuable
+    module ClassMethods
+      def rescue_from(*klasses, &block)
+        options = klasses.extract_options!
+
+        unless options.has_key?(:with)
+          if block_given?
+            options[:with] = block
+          else
+            raise ArgumentError, "Need a handler. Supply an options hash that has a :with key as the last argument."
+          end
+        end
+
+        klasses.each do |klass|
+          key = if klass.is_a?(Class) && ( klass <= Exception || klass <= ::Java::JavaLang::Exception )
+            klass.name
+          elsif klass.is_a?(String)
+            klass
+          else
+            raise ArgumentError, "#{klass} is neither an Exception nor a String"
+          end
+
+          # put the new handler at the end because the list is read in reverse
+          self.rescue_handlers += [[key, options[:with]]]
+        end
+      end
+    end
+
+    def handler_for_rescue(exception)
+      # We go from right to left because pairs are pushed onto rescue_handlers
+      # as rescue_from declarations are found.
+      _, rescuer = self.class.rescue_handlers.reverse.detect do |klass_name, handler|
+        # The purpose of allowing strings in rescue_from is to support the
+        # declaration of handler associations for exception classes whose
+        # definition is yet unknown.
+        #
+        # Since this loop needs the constants it would be inconsistent to
+        # assume they should exist at this point. An early raised exception
+        # could trigger some other handler and the array could include
+        # precisely a string whose corresponding constant has not yet been
+        # seen. This is why we are tolerant to unknown constants.
+        #
+        # Note that this tolerance only matters if the exception was given as
+        # a string, otherwise a NameError will be raised by the interpreter
+        # itself when rescue_from CONSTANT is executed.
+        klass = self.class.const_get(klass_name) rescue nil
+        klass ||= klass_name.constantize rescue nil
+        exception.is_a?(klass) || (exception.is_a?(NativeException) && exception.cause.is_a?(klass)) if klass
+      end
+
+      case rescuer
+      when Symbol
+        method(rescuer)
+      when Proc
+        rescuer.bind(self)
+      end
+    end
+  end
+end

data/lib/jactive_support/version.rb

@@ -0,0 +1,3 @@
+module JActiveSupport
+  VERSION = "1.0.2"
+end

data/spec/constantize_spec.rb

@@ -0,0 +1,57 @@
+require 'java'
+require 'active_support'
+require 'jactive_support/constantize'
+
+class InflectorTest
+  def call_constantize(name)
+    ActiveSupport::Inflector.constantize(name)
+  end
+end
+module Ace
+  module Base
+    class Case
+    end
+  end
+end
+
+describe "constantize with jruby" do
+
+  it "should find named ruby constants" do
+    ActiveSupport::Inflector.constantize("Ace::Base::Case").should be(Ace::Base::Case)
+    ActiveSupport::Inflector.constantize("::Ace::Base::Case").should be(Ace::Base::Case)
+    ActiveSupport::Inflector.constantize("::InflectorTest").should be(InflectorTest)
+  end
+  
+  it "raises a NameError on invalid ruby constants" do
+    expect { ActiveSupport::Inflector.constantize("UnknownClass") }.to raise_error(NameError, 'uninitialized constant UnknownClass')
+    expect { ActiveSupport::Inflector.constantize("An invalid string") }.to raise_error(NameError, 'wrong constant name An invalid string')
+    expect { ActiveSupport::Inflector.constantize("InvalidClass\n") }.to raise_error(NameError, "wrong constant name InvalidClass\n")
+  end
+
+  it "should do lexical lookup" do
+    expect{ puts InflectorTest.new.call_constantize("::Ace::Base::InflectorTest").inspect }.to raise_error(NameError, 'uninitialized constant Ace::Base::InflectorTest')
+  end
+  
+  it "should find a java class" do
+    ActiveSupport::Inflector.constantize("Java::JavaLang::Thread").should be(java.lang.Thread);
+  end
+  
+  it "should be able to lookup the canonical name of a java class" do
+    ActiveSupport::Inflector.constantize(java.lang.Thread.name).should be(java.lang.Thread);
+  end
+
+  it "should raise a NameError when trying to lookup an unknown java class" do
+    expect{ ActiveSupport::Inflector.constantize("Java::ComMuh::Miav") }.to raise_error(NameError, 'cannot load Java class com.muh.Miav')
+  end
+  
+#=begin comment
+  #Java packages currently don't have a should method with the normal setup
+  it "should find a java package" do
+    ActiveSupport::Inflector.constantize("Java::JavaLang").should be(java.lang);
+  end
+
+  it "should find an unknown java package" do
+    ActiveSupport::Inflector.constantize("Java::ComMuh").should be(nil)
+  end
+#=end
+end

data/spec/core_ext/hash_spec.rb

@@ -0,0 +1,34 @@
+require 'jactive_support/core_ext/hash'
+
+describe Hash do
+  describe "assert_valid_params" do
+    it "should not raise an error when assert_valid_params is called with correct parameters" do
+      { :failure => "stuff", :funny => "business" }.assert_valid_params([ :failure, :funny ])
+      { :failure => "stuff", :funny => "business" }.assert_valid_params(:failure, :funny)
+    end
+
+    it "should raise an error when assert_valid_params is called with incorrect parameters" do
+      expect{ 
+        { :failore => "stuff", :funny => "business" }.assert_valid_params([ :failure, :funny ])
+      }.to raise_error(JactiveSupport::InvalidParameter, "Unknown key(s): failore")
+  
+      expect{ 
+        { :failore => "stuff", :funny => "business" }.assert_valid_params(:failure, :funny) 
+      }.to raise_error(JactiveSupport::InvalidParameter, "Unknown key(s): failore")
+    end
+  end
+  
+  describe "supports with_keys_values" do
+    it "should make a new Hash with arguments as keys and values" do
+      Hash.with_keys_values([:one, :two], [1, 2]).should eq(:one=>1, :two=>2)
+    end
+    
+    it "should support empty arrays" do
+      Hash.with_keys_values([], []).should eq({})
+    end
+    
+    it "raises ArgumentError when keys and values don't have same size" do
+      expect { Hash.with_keys_values([:one, :two], [1]) }.to raise_error(ArgumentError, "Unmatching sizes 2 != 1")
+    end
+  end
+end

data/spec/core_ext/module_spec.rb

@@ -0,0 +1,19 @@
+require 'jactive_support/core_ext/module'
+
+class Base
+  def self.inherited(other)
+    other.instance_variable_set('@thename', other.name || '')
+  end
+end
+
+Test2 = Class.new(Base)
+
+describe Module, 'define_class' do
+  it "normal dynamic class does not have access to name in inherited" do
+    Test2.instance_variable_get('@thename').should eq('')
+  end
+  
+  it "should have access to name even in inherited" do
+    Object.define_class('Test', Base).instance_variable_get('@thename').should eq('Test')
+  end
+end

data/spec/core_ext/ordering_spec.rb

@@ -0,0 +1,12 @@
+require 'jactive_support/core_ext/ordering'
+
+describe "ordering" do
+  it "has an order" do
+    (nil <=> nil).should be(0)
+    (nil <=> 1).should be(-1)
+    (true <=> true).should be(0)
+    (true <=> 1).should be(-1)
+    (false <=> false).should be(0)
+    (false <=> 1).should be(1)
+  end
+end

data/spec/enum_spec.rb

@@ -0,0 +1,67 @@
+require 'java'
+require 'active_support'
+require 'jactive_support/core_ext/enum'
+
+describe 'enum' do
+
+  it 'returns matching enum object when calling find_value_of with exact named symbol or string' do
+    java::lang::Thread::State.find_value_of(:NEW).should be(java::lang::Thread::State::NEW)
+    java::lang::Thread::State.find_value_of('NEW').should be(java::lang::Thread::State::NEW)
+  end
+  
+  it 'returns matching enum object when calling find_value_of with underscored symbol or string' do
+    java::lang::Thread::State.find_value_of(:n_e_w).should be(java::lang::Thread::State::NEW)
+    java::lang::Thread::State.find_value_of('n_e_w').should be(java::lang::Thread::State::NEW)
+  end
+
+  it 'fails when calling find_value_of with value not in enum' do
+    expect {
+      java::lang::Thread::State.find_value_of(:MISSING)
+    }.to raise_error(NativeException, "java.lang.IllegalArgumentException: No enum const class java.lang.Thread$State.MISSING")
+
+    expect {
+      java::lang::Thread::State.find_value_of(:missing_link)
+    }.to raise_error(NativeException, "java.lang.IllegalArgumentException: No enum const class java.lang.Thread$State.missing_link")
+  end
+
+  it 'should be comparable with a symbol when using ===' do
+    t = java::lang::Thread::State::NEW
+    t.should === :NEW
+    :NEW.should === t
+  end
+
+  it 'should be comparable with an underscored symbol when using ===' do
+    t = java::lang::Thread::State::NEW
+    t.should === :n_e_w
+    :n_e_w.should === t
+  end
+
+  it 'should be comparable with a string when using ===' do
+    t = java::lang::Thread::State::NEW
+    t.should === 'NEW'
+    'NEW'.should === t
+  end
+
+
+  it 'should be comparable with an underscored string when using ===' do
+    t = java::lang::Thread::State::NEW
+    t.should === 'n_e_w'
+    'n_e_w'.should === t
+  end
+  
+  it 'should return the enum object when calling to_java on a symbol or string with enum class as argument' do
+    :NEW.to_java(java::lang::Thread::State).should be(java::lang::Thread::State::NEW)
+    'NEW'.to_java(java::lang::Thread::State).should be(java::lang::Thread::State::NEW)
+    :n_e_w.to_java(java::lang::Thread::State).should be(java::lang::Thread::State::NEW)
+    'n_e_w'.to_java(java::lang::Thread::State).should be(java::lang::Thread::State::NEW)
+  end
+
+  it 'fails when calling to_java on a symbol or string whose value can not be found in the provided enum class' do
+    expect {
+      :MISSING.to_java(java::lang::Thread::State)
+      }.to raise_error(TypeError, "No enum const class java.lang.Thread$State.MISSING")
+    expect {
+      'MISSING'.to_java(java::lang::Thread::State)
+    }.to raise_error(TypeError, "No enum const class java.lang.Thread$State.MISSING")
+  end
+end