jactive_support 1.0.0-universal-java-1.6

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/.rvmrc

@@ -0,0 +1,63 @@
+#!/usr/bin/env bash
+
+# This is an RVM Project .rvmrc file, used to automatically load the ruby
+# development environment upon cd'ing into the directory
+
+# First we specify our desired <ruby>[@<gemset>], the @gemset name is optional,
+# Only full ruby name is supported here, for short names use:
+#     echo "rvm use jruby" > .rvmrc
+environment_id="jruby-1.6.7@jactive_support"
+
+# Uncomment the following lines if you want to verify rvm version per project
+# rvmrc_rvm_version="1.10.3" # 1.10.1 seams as a safe start
+# eval "$(echo ${rvm_version}.${rvmrc_rvm_version} | awk -F. '{print "[[ "$1*65536+$2*256+$3" -ge "$4*65536+$5*256+$6" ]]"}' )" || {
+#   echo "This .rvmrc file requires at least RVM ${rvmrc_rvm_version}, aborting loading."
+#   return 1
+# }
+
+# Uncomment following line if you want options to be set only for given project.
+# PROJECT_JRUBY_OPTS=( --1.9 )
+# The variable PROJECT_JRUBY_OPTS requires the following to be run in shell:
+#    chmod +x ${rvm_path}/hooks/after_use_jruby_opts
+
+# First we attempt to load the desired environment directly from the environment
+# file. This is very fast and efficient compared to running through the entire
+# CLI and selector. If you want feedback on which environment was used then
+# insert the word 'use' after --create as this triggers verbose mode.
+if [[ -d "${rvm_path:-$HOME/.rvm}/environments"
+  && -s "${rvm_path:-$HOME/.rvm}/environments/$environment_id" ]]
+then
+  \. "${rvm_path:-$HOME/.rvm}/environments/$environment_id"
+  [[ -s "${rvm_path:-$HOME/.rvm}/hooks/after_use" ]] &&
+    \. "${rvm_path:-$HOME/.rvm}/hooks/after_use" || true
+else
+  # If the environment file has not yet been created, use the RVM CLI to select.
+  rvm --create  "$environment_id" || {
+    echo "Failed to create RVM environment '${environment_id}'."
+    return 1
+  }
+fi
+
+# If you use an RVM gemset file to install a list of gems (*.gems), you can have
+# it be automatically loaded. Uncomment the following and adjust the filename if
+# necessary.
+#
+# filename=".gems"
+# if [[ -s "$filename" ]]
+# then
+#   rvm gemset import "$filename" | grep -v already | grep -v listed | grep -v complete | sed '/^$/d'
+# fi
+
+# If you use bundler, this might be useful to you:
+# if [[ -s Gemfile ]] && {
+#   ! builtin command -v bundle >/dev/null ||
+#   builtin command -v bundle | grep $rvm_path/bin/bundle >/dev/null
+# }
+# then
+#   printf "%b" "The rubygem 'bundler' is not installed. Installing it now.\n"
+#   gem install bundler
+# fi
+# if [[ -s Gemfile ]] && builtin command -v bundle >/dev/null
+# then
+#   bundle install | grep -vE '^Using|Your bundle is complete'
+# fi

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in jactivesupport.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Brian Olsen <brian@maven-group.org>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,45 @@
+require 'bundler/setup'
+require 'rspec/core/rake_task'
+
+def install_tasks(opts = nil)
+  dir = caller.find{|c| /Rakefile:/}[/^(.*?)\/Rakefile:/, 1]
+  h = Bundler::GemHelper.new(dir, opts && opts[:name])
+  h.install
+  h
+end
+helper = install_tasks
+spec = helper.gemspec
+
+require 'rake/clean'
+CLEAN.include 'pkg'
+
+task :git_local_check do
+  sh "git diff --no-ext-diff --ignore-submodules --quiet --exit-code" do |ok, _|
+    raise "working directory is unclean" if !ok
+    sh "git diff-index --cached --quiet --ignore-submodules HEAD --" do |ok, _|
+      raise "git index is unclean" if !ok
+    end
+  end
+end
+task :release => :git_local_check
+task :build => :git_local_check
+
+class MyRSpec < RSpec::Core::RakeTask
+  def task(*args,&block)
+    super(*args) do
+      old, ENV['RUBYOPT'] = ENV['RUBYOPT'], "#{ENV['RUBYOPT']} #{ruby_opts}"
+      yield
+      ENV['RUBYOPT'] = old
+    end
+  end
+end
+
+MyRSpec.new("spec:1.8") do |t|
+  t.ruby_opts = '--1.8'
+end
+MyRSpec.new("spec:1.9") do |t|
+  t.ruby_opts = '--1.9'
+end
+task :spec => ["spec:1.8", "spec:1.9"]
+task :test => :spec
+task :default => :spec

data/jactive_support.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "jactive_support/version"
+
+Gem::Specification.new do |s|
+  s.name        = "jactive_support"
+  s.platform    = Gem::Platform::CURRENT
+  s.version     = JActiveSupport::VERSION
+  s.author      = "Brian Olsen"
+  s.email       = "brian@maven-group.org"
+  s.homepage    = "http://github.com/griff/jactive_support"
+  s.summary     = "Extensions to add some activesupport flavor to java classes"
+  s.description = %q{Extensions to add some activesupport flavor to java classes}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency 'activesupport', "~> 2.3.8"
+  s.add_development_dependency "bundler", ">= 1.0.0"
+  s.add_development_dependency "rspec", "~> 2.6.0"
+  s.add_development_dependency "rake", ">= 0.9.2"
+  s.add_development_dependency "jruby-openssl", ">= 0"
+end

data/lib/jactive_support/constantize.rb

@@ -0,0 +1,19 @@
+require 'active_support/inflector'
+
+module ActiveSupport
+  module Inflector
+    def constantize_with_jruby(camel_cased_word)
+      names = camel_cased_word.split('::')
+      names.shift if names.empty? || names.first.empty?
+
+      if names.first == "Java" && names.size == 3
+        last = names.pop
+        constantize_without_jruby(names.join('::')).__send__ last
+      else
+        constantize_without_jruby(camel_cased_word)
+      end
+    end
+    alias :constantize_without_jruby :constantize
+    alias :constantize :constantize_with_jruby
+  end
+end

data/lib/jactive_support/core_ext/enum.rb

@@ -0,0 +1,43 @@
+require 'jactive_support/java_ext/enum'
+
+module JactiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module Enum
+      def self.included(other_mod)
+        other_mod.send :alias_method, :flash_without_enum, :===
+        other_mod.send :alias_method, :===, :flash_with_enum
+
+        other_mod.send :alias_method, :to_java_without_enum, :to_java
+        other_mod.send :alias_method, :to_java, :to_java_with_enum
+      end
+      
+      def flash_with_enum(other)
+        if other.java_kind_of? java::lang::Enum
+          other.name == self.to_s || other.name == self.to_s.camelize
+        else
+          flash_without_enum(other)
+        end
+      end
+      
+      def to_java_with_enum(other=nil)
+        if other.superclass == java::lang::Enum
+          begin
+            other.find_value_of(self)
+          rescue java::lang::IllegalArgumentException => e
+            raise TypeError, e.cause.message
+          end
+        else
+          to_java_without_enum(other)
+        end
+      end
+    end
+  end
+end
+
+class Symbol
+  include ::JactiveSupport::CoreExtensions::Enum
+end
+
+class String
+  include ::JactiveSupport::CoreExtensions::Enum
+end

data/lib/jactive_support/core_ext/hash/assert_valid_params.rb

@@ -0,0 +1,19 @@
+module JactiveSupport
+  class InvalidParameter < ArgumentError
+  end
+end
+
+class Hash
+  # Validate all keys in a hash match *valid keys, raising JactiveSupport::InvalidParameter on a mismatch.
+  # Note that keys are NOT treated indifferently, meaning if you use strings for keys but assert symbols
+  # as keys, this will fail.
+  #
+  # ==== Examples
+  #   { :name => "Rob", :years => "28" }.assert_valid_params(:name, :age) # => raises "InvalidParameter: Unknown key(s): years"
+  #   { :name => "Rob", :age => "28" }.assert_valid_params("name", "age") # => raises "InvalidParameter: Unknown key(s): name, age"
+  #   { :name => "Rob", :age => "28" }.assert_valid_params(:name, :age) # => passes, raises nothing
+  def assert_valid_params(*valid_keys)
+    unknown_keys = keys.map{|key| key.to_sym} - [valid_keys].flatten
+    raise(::JactiveSupport::InvalidParameter, "Unknown key(s): #{unknown_keys.join(", ")}") unless unknown_keys.empty?
+  end
+end

data/lib/jactive_support/core_ext/hash/with_keys_values.rb

@@ -0,0 +1,9 @@
+class Hash
+  def Hash.with_keys_values(keys, values)
+    raise ArgumentError, "Unmatching sizes #{keys.size} != #{values.size}" unless keys.size == values.size
+    #Hash[keys.zip(values).flatten]
+    ret = Hash.new
+    keys.each_with_index{|key, idx| ret[key] = values[idx]}
+    ret
+  end
+end

data/lib/jactive_support/core_ext/hash.rb

@@ -0,0 +1,2 @@
+require 'jactive_support/core_ext/hash/assert_valid_params'
+require 'jactive_support/core_ext/hash/with_keys_values'

data/lib/jactive_support/core_ext/locale.rb

@@ -0,0 +1,28 @@
+require 'jactive_support/java_ext/locale'
+
+Locale = java::util::Locale
+
+class NilClass
+  def to_locale
+    java::util::Locale.current_locale
+  end
+end
+
+class String
+  # Returns the java.util.Locale that maches this string
+  def to_locale
+    if self =~ /^(.+)[-_](.+)[-_](.+)$/
+      java::util::Locale.new($1, $2, $3)
+    elsif self =~ /^(.+)[-_](.+)$/
+      java::util::Locale.new($1, $2)
+    else
+      java::util::Locale.new(self)
+    end
+  end
+end
+
+class Symbol
+  def to_locale
+    to_s.to_locale
+  end
+end

data/lib/jactive_support/core_ext/module.rb

@@ -0,0 +1,9 @@
+class Module
+  def define_class(name, base)
+    module_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
+      class #{name} < ::#{base.name}
+      end
+    RUBY_EVAL
+    const_get(name)
+  end
+end

data/lib/jactive_support/core_ext/numeric.rb

@@ -0,0 +1,7 @@
+require 'jactive_support/java_ext/number'
+
+class Numeric
+  def to_formatted_s(format=:default, locale=nil)
+    self.to_java.to_formatted_s(format, locale)
+  end
+end

data/lib/jactive_support/core_ext/ordering.rb

@@ -0,0 +1,17 @@
+class TrueClass
+  def <=>(o)
+    o.is_a?(TrueClass) ? 0 : -1
+  end
+end
+
+class FalseClass
+  def <=>(o)
+    o.is_a?(FalseClass) ? 0 : 1
+  end
+end
+
+class NilClass #:nodoc:
+  def <=>(other)
+    other.nil? ? 0 : -1;
+  end
+end

data/lib/jactive_support/core_ext/to_java.rb

@@ -0,0 +1,9 @@
+class Object
+  def to_java(cls=nil)
+    if cls.is_a?(Symbol) && respond_to?("to_java_#{cls}")
+      send "to_java_#{cls}"
+    else
+      super
+    end
+  end
+end

data/lib/jactive_support/core_ext/to_java_date.rb

@@ -0,0 +1,25 @@
+class Date
+  def to_java_date
+    java::util::Date.new((to_time.tv_sec*1000).to_i)
+  end
+end
+class Time
+  def to_java_date
+    java::util::Date.new((tv_sec*1000).to_i)
+  end
+end
+class ActiveSupport::TimeWithZone
+  def to_java_date
+    java::util::Date.new((tv_sec*1000).to_i)
+  end
+end
+class java::util::Date
+  def to_java_date
+    self
+  end
+end
+class String
+  def to_java_date
+    to_datetime.to_java_date
+  end
+end

data/lib/jactive_support/core_ext/to_java_list.rb

@@ -0,0 +1,11 @@
+class Array
+  def to_java_list
+    self
+  end
+end
+
+module java::util::List
+  def to_java_list
+    self
+  end
+end

data/lib/jactive_support/core_ext/to_java_map.rb

@@ -0,0 +1,11 @@
+class Hash
+  def to_java_map
+    self
+  end
+end
+
+module java::util::Map #:nodoc:
+  def to_java_map
+    self
+  end
+end

data/lib/jactive_support/core_ext.rb

@@ -0,0 +1,4 @@
+Dir[File.dirname(__FILE__) + "/core_ext/*.rb"].sort.each do |path|
+  filename = File.basename(path)
+  require "jactive_support/core_ext/#{filename}"
+end

data/lib/jactive_support/java_ext/date/calculations.rb

@@ -0,0 +1,43 @@
+module JactiveSupport #:nodoc:
+  module JavaExtensions #:nodoc:
+    module Date #:nodoc:
+      module Calculations
+        CALCULATION_FIELDS = {
+          :years => ::Java::JavaUtil::Calendar::YEAR,
+          :months => ::Java::JavaUtil::Calendar::MONTH,
+          :weeks => ::Java::JavaUtil::Calendar::WEEK_OF_YEAR,
+          :days => ::Java::JavaUtil::Calendar::DAY_OF_MONTH,
+          :hours => ::Java::JavaUtil::Calendar::HOUR_OF_DAY,
+          :minutes => ::Java::JavaUtil::Calendar::MINUTE,
+          :seconds => ::Java::JavaUtil::Calendar::SECOND,
+          :millis => ::Java::JavaUtil::Calendar::MILLISECOND
+        }
+        
+        def advance(options)
+          cal = ::Java::JavaUtil::Calendar.getInstance
+          cal.setTime(self)
+          options.each do |field, value|
+            cal.add(CALCULATION_FIELDS[field], value)
+          end
+          cal.getTime
+        end
+        
+        def age(since=java.util.Date.new)
+          difference(:years, since)
+        end
+        
+        def difference(field=:years, since=java.util.Date.new)
+          local_date = ::Java::OrgJodaTime::LocalDate.fromDateFields(self)
+          since_date = ::Java::OrgJodaTime::LocalDate.fromDateFields(since)
+          if field == :days
+            return ::Java::OrgJodaTime::Days.daysBetween(local_date, since_date).getDays
+          elsif field == :months
+            return ::Java::OrgJodaTime::Months.monthsBetween(local_date, since_date).getMonths
+          else
+            return ::Java::OrgJodaTime::Years.yearsBetween(local_date, since_date).getYears
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,135 @@
+module JactiveSupport #:nodoc:
+  module JavaExtensions #:nodoc:
+    module Date #:nodoc:
+      # Converting dates to formatted strings, times, and datetimes.
+      module Conversions
+        DATE_FORMATS = {
+          :db           => "yyyy-MM-dd HH:mm:ss.SSS",
+          :i18n         => lambda { |clazz, locale| 
+                              format = I18n.translate(:"formats.timestamp", :default=>'')
+                              !format.blank? ? clazz.pattern_formatter(format) : clazz.date_time_instance(:default, :default, locale)
+                            },
+          :number       => "YYYMMddHHmmssSSS",
+          :time         => "HH:mm",
+          :full         => lambda { |clazz, locale| clazz.date_time_instance(:full, :full, locale) },
+          :long         => lambda { |clazz, locale| clazz.date_time_instance(:long, :long, locale) },
+          :medium       => lambda { |clazz, locale| clazz.date_time_instance(:medium, :medium, locale) },
+          :short        => lambda { |clazz, locale| clazz.date_time_instance(:short, :short, locale) },
+          :default      => lambda { |clazz, locale| clazz.date_time_instance(:default, :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 self.included(other) #:nodoc:
+          other.class_eval do
+            alias_method :to_default_s, :to_s
+            alias_method :to_s, :to_formatted_s
+          end
+          other.extend ClassMethods
+        end
+
+        module ClassMethods
+          def format(format=:i18n, locale=nil)
+            return format(:default, locale) unless formatter = self::DATE_FORMATS[format]
+            locale = locale.to_locale
+            formatter = formatter.respond_to?(:call) ? (formatter.arity==2 ? formatter.call(self, locale) : formatter.call(self)) : self.pattern_formatter(formatter)
+            formatter.to_pattern
+          end
+
+          def formatter(format=:i18n, locale=nil)
+            return formatter(:default, locale) unless formatter = self::DATE_FORMATS[format]
+            locale = locale.to_locale
+            formatter.respond_to?(:call) ? (formatter.arity==2 ? formatter.call(self, locale) : formatter.call(self)) : self.pattern_formatter(formatter)
+          end
+
+          def pattern_formatter(pattern, timezone=nil, locale=nil)
+            formatter = ::Java::JavaText::SimpleDateFormat.new(pattern, locale.to_locale)
+            timezone = ::Java::JavaUtil::TimeZone.getTimeZone(timezone) unless timezone.nil? || timezone.is_a?(::Java::JavaUtil::TimeZone)
+            formatter.setTimeZone(timezone) if timezone
+            formatter
+          end
+        end
+
+        # Converts to a formatted string. See DATE_FORMATS for builtin formats.
+        #
+        # This method is aliased to <tt>to_s</tt>.
+        #
+        #   time = Time.now                     # => Thu Jan 18 06:10:17 CST 2007
+        #
+        #   time.to_formatted_s(:time)          # => "06:10:17"
+        #   time.to_s(:time)                    # => "06:10:17"
+        #
+        #   time.to_formatted_s(:db)            # => "2007-01-18 06:10:17"
+        #   time.to_formatted_s(:number)        # => "20070118061017"
+        #   time.to_formatted_s(:short)         # => "18 Jan 06:10"
+        #   time.to_formatted_s(:long)          # => "January 18, 2007 06:10"
+        #   time.to_formatted_s(:long_ordinal)  # => "January 18th, 2007 06:10"
+        #   time.to_formatted_s(:rfc822)        # => "Thu, 18 Jan 2007 06:10:17 -0600"
+        #
+        # == Adding your own time formats to +to_formatted_s+
+        # You can add your own formats to the Time::DATE_FORMATS hash.
+        # Use the format name as the hash key and either a strftime string
+        # or Proc instance that takes a time argument as the value.
+        #
+        #   # config/initializers/time_formats.rb
+        #   Time::DATE_FORMATS[:month_and_year] = "%B %Y"
+        #   Time::DATE_FORMATS[:short_ordinal] = lambda { |time| time.strftime("%B #{time.day.ordinalize}") }
+        def to_formatted_s(format=:i18n, locale=nil)
+          return to_default_s unless formatter = self.class::DATE_FORMATS[format]
+          locale = locale.to_locale
+          formatter = formatter.respond_to?(:call) ? (formatter.arity==2 ? formatter.call(self.class, locale) : formatter.call(self.class)) : self.class.pattern_formatter(formatter)
+          (formatter.respond_to?(:format) ? formatter.format(self) : formatter).to_s
+        end
+        
+        def format(format=:i18n, locale=nil)
+          self.class.format(format, locale)
+        end
+        
+        def formatter(format=:i18n, locale=nil)
+          self.class.formatter(format, locale)
+        end
+
+        def pattern_formatter(pattern, timezone=nil, locale=nil)
+          self.class.pattern_formatter(pattern, timezone, locale)
+        end
+
+        # Converts a java.util.Date object to a ruby Date, dropping hour, minute, and second precision.
+        #
+        #   my_time = java.util.Date.new  # => Mon Nov 12 22:59:51 -0500 2007
+        #   my_time.to_date     # => Mon, 12 Nov 2007
+        def to_date
+          to_time.to_date
+        end
+
+        # Converts a java.util.Date instance to a Time.
+        #
+        # ==== Examples
+        #   date = java.util.Date.new  # => Mon Nov 12 22:59:51 -0500 2007
+        #   date.to_time               # => Mon Nov 12 22:59:51 -0500 2007
+        def to_time
+          ::Time.at(self.getTime/1000)
+        end
+
+        # Converts a java.util.Date instance to a Ruby DateTime instance, preserving UTC offset.
+        #
+        #   my_time = Time.now    # => Mon Nov 12 23:04:21 -0500 2007
+        #   my_time.to_datetime   # => Mon, 12 Nov 2007 23:04:21 -0500
+        #
+        #   your_time = Time.parse("1/13/2009 1:13:03 P.M.")  # => Tue Jan 13 13:13:03 -0500 2009
+        #   your_time.to_datetime                             # => Tue, 13 Jan 2009 13:13:03 -0500
+        def to_datetime
+          to_time.to_datetime
+        end
+        
+        def to_java_sqldate
+          java.sql.Date.new(getTime)
+        end
+        
+        def httpdate
+          to_formatted_s(:httpdate)
+        end
+      end
+    end
+  end
+end

data/lib/jactive_support/java_ext/date.rb

@@ -0,0 +1,37 @@
+require 'jactive_support/java_ext/date/calculations'
+require 'jactive_support/java_ext/date/conversions'
+
+class java::util::Date
+  include JactiveSupport::JavaExtensions::Date::Calculations
+  include JactiveSupport::JavaExtensions::Date::Conversions
+
+  FULL_STYLE = java::text::DateFormat::FULL
+  LONG_STYLE = java::text::DateFormat::LONG
+  MEDIUM_STYLE = java::text::DateFormat::MEDIUM
+  SHORT_STYLE = java::text::DateFormat::SHORT
+  DEFAULT_STYLE = java::text::DateFormat::DEFAULT
+  
+  STYLE = {
+    :full => FULL_STYLE,
+    :long => LONG_STYLE,
+    :medium => MEDIUM_STYLE,
+    :short => SHORT_STYLE,
+    :default => DEFAULT_STYLE
+  }
+  
+  def acts_like_time?
+    true
+  end
+  
+  def self.date_time_instance(date_style=:default, time_style=:default, locale=nil)
+    java::text::DateFormat.getDateTimeInstance(STYLE[date_style], STYLE[time_style], locale.to_locale)
+  end
+
+  def self.time_instance(time_style=:default, locale=nil)
+    java::text::DateFormat.getTimeInstance(STYLE[time_style], locale.to_locale)
+  end
+
+  def self.date_instance(date_style=:default, locale=nil)
+    java::text::DateFormat.getDateInstance(STYLE[date_style], locale.to_locale)
+  end
+end

data/lib/jactive_support/java_ext/enum.rb

@@ -0,0 +1,19 @@
+class java::lang::Enum
+  def self.find_value_of(value)
+    value = value.to_s
+    camel_name = value.camelize
+    if(camel_name == value)
+      self.valueOf(value)
+    else
+      ret = self.java_class.to_java.getEnumConstants.find {|e| e.name == value || e.name == camel_name}
+      #raise java::lang::IllegalArgumentException.new("No enum const class #{java_class.name}.#{value}") unless ret
+      self.valueOf(value) unless ret # Above does not throw the exception the same way as java code
+      ret
+    end
+  end
+  
+  def ===(other)
+    other = other.to_s
+    self.name == other || self.name == other.camelize
+  end
+end