jactive_support 1.0.0-universal-java-1.6

data/lib/jactive_support/java_ext/iterable.rb

@@ -0,0 +1,74 @@
+require 'jactive_support/java_ext/iterator'
+
+module java::lang::Iterable
+  if RUBY_VERSION >= '1.9'
+    FrozenError = RuntimeError
+  else
+    FrozenError = TypeError
+  end
+  
+  def iterate
+    return enum_for(:iterate) unless block_given?
+    it = iterator
+    while it.next?
+      ob = it.next
+      yield(it,ob)
+    end
+  end
+
+  def delete_if
+    raise FrozenError, "can't modify frozen iterable" if frozen?
+    return enum_for(:delete_if) unless block_given?
+    iterate do |it,ob|
+      it.remove if yield(ob)
+    end
+    self
+  end
+  
+  def reject!
+    raise FrozenError, "can't modify frozen iterable" if frozen?
+    return enum_for(:reject!) unless block_given?
+    ret = nil
+    iterate do |it,ob|
+      if yield(ob)
+        it.remove 
+        ret = self
+      end
+    end
+    ret
+  end
+  
+  def shift(*args)
+    raise ArgumentError, "wrong # of arguments(#{args.size} for 1)" if args.size > 1
+    raise FrozenError, "can't modify frozen iterable" if frozen?
+    it = iterator
+    if args.size == 1
+      n = args.first
+      raise TypeError, "Can't convert #{n} into Integer" unless n.respond_to?(:to_int)
+      n = n.to_int
+      raise TypeError, "#to_int should return Integer" unless n.kind_of?(Integer)
+      raise ArgumentError, "negative array size" if n < 0
+      ret = []
+      while n > 0 && it.next?
+        ret << it.next
+        it.remove
+        n -= 1
+      end
+      ret
+    elsif it.next?
+      ret = it.next 
+      it.remove
+      ret
+    end
+  end
+  
+  def empty?
+    !iterator.next?
+  end
+  
+  def clear
+    raise FrozenError, "can't modify frozen iterable" if frozen?
+    iterate {|it, o| it.remove}
+    self
+  end
+end

data/lib/jactive_support/java_ext/iterator.rb

@@ -0,0 +1,8 @@
+module java::util::Iterator
+  def has_next?
+    hasNext
+  end
+  def next?
+    hasNext
+  end
+end

data/lib/jactive_support/java_ext/list.rb

@@ -0,0 +1,65 @@
+require 'jactive_support/java_ext/list_iterator'
+
+module java::util::List
+  if RUBY_VERSION >= '1.9'
+    FrozenError = RuntimeError
+  else
+    FrozenError = TypeError
+  end
+  
+  def inspect
+    content = map{|e| e.inspect}.join(', ')
+    "JavaList[#{content}]"
+  end
+
+  def iterate
+    return enum_for(:iterate) unless block_given?
+    it = listIterator
+    while it.next?
+      ob = it.next
+      yield(it,ob)
+    end
+  end  
+
+  def map!
+    raise FrozenError, "can't modify frozen iterable" if frozen?
+    return enum_for(:map!) unless block_given?
+    iterate{|it, ob| it.set(yield(ob))}
+    self
+  end
+  alias :collect! :map!
+  
+  def push(*args)
+    raise FrozenError, "can't modify frozen iterable" if frozen? && ( RUBY_VERSION >= '1.9' || args.size > 0 )
+    args.each{|a| add(a)}
+    self
+  end
+
+  def last(*args)
+    raise ArgumentError, "wrong # of arguments(#{args.size} for 1)" if args.size > 1
+    if args.size == 1
+      n = args.first
+      raise TypeError, "Can't convert #{n} into Integer" unless n.respond_to?(:to_int)
+      n = n.to_int
+      raise TypeError, "#to_int should return Integer" unless n.kind_of?(Integer)
+      raise ArgumentError, "negative array size" if n < 0
+
+      it = listIterator(size)
+      ret = []
+      while n > 0 && it.previous?
+        ret.unshift it.previous
+        n -= 1
+      end
+      ret
+    elsif size > 0 
+      self.get(size-1) 
+    end
+  end
+  
+  def clear
+    raise FrozenError, "can't modify frozen list" if frozen?
+    super
+    self
+  end
+  
+end

data/lib/jactive_support/java_ext/list_iterator.rb

@@ -0,0 +1,8 @@
+module java::util::ListIterator
+  def has_previous?
+    hasPrevious
+  end
+  def previous?
+    hasPrevious
+  end
+end

data/lib/jactive_support/java_ext/locale.rb

@@ -0,0 +1,32 @@
+class java::util::Locale
+  def self.current_locale
+    self.getDefault
+  end
+
+  def self.current_locale=(l)
+    self.setDefault(l.to_locale)
+  end
+  
+  def to_locale
+    self
+  end
+  
+  def human_name
+    l = Locale.current_locale
+    display_country = country.blank? ? "" : " (#{getDisplayCountry(l)})"
+    display_variant = variant.blank? ? "" : " - #{getDisplayVariant(l)}"
+    "#{getDisplayLanguage(l)}#{display_country}#{display_variant}"
+  end
+  
+  def inspect
+    "Locale[#{human_name}]"
+  end
+
+  def to_str
+    to_s
+  end
+  
+  def to_sym
+    to_s.to_sym
+  end
+end

data/lib/jactive_support/java_ext/map/constructor.rb

@@ -0,0 +1,35 @@
+module JactiveSupport #:nodoc:
+  module JavaExtensions #:nodoc:
+    module Map #:nodoc:
+      module Constructor
+        def self.included(other_mod)
+          other_mod.extend(ClassExtensions)
+        end
+        
+        module ClassExtensions
+          def [](*args)
+            r = self.new
+            if args.size == 1 && ( args.first.respond_to?(:to_ary) || args.first.respond_to?(:to_hash) )
+              args = args.first
+              if args.respond_to?(:to_ary)
+                args = args.to_ary
+              elsif args.respond_to?(:to_hash)
+                args = args.to_hash
+              end
+              args.each do |e|
+                next unless e.respond_to? :to_ary
+                e = e.to_ary
+                r.put(e.shift, e.shift) if (1..2).include?(e.size)
+              end
+            else
+              raise ArgumentError, "odd number of arguments for constructor" unless (args.size % 2) == 0
+              args.each_slice(2) {|key,val| r.put(key,val)}
+            end
+            
+            r
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jactive_support/java_ext/map/hash.rb

@@ -0,0 +1,166 @@
+module JactiveSupport #:nodoc:
+  module JavaExtensions #:nodoc:
+    module Map #:nodoc:
+      module Hash
+        def self.included(other_mod)
+          other_mod.send :alias_method, :has_key?, :contains_key?
+          other_mod.send :alias_method, :key?, :has_key?
+          other_mod.send :alias_method, :include?, :has_key?
+          other_mod.send :alias_method, :member?, :has_key?
+          other_mod.send :alias_method, :has_value?, :contains_value?
+          other_mod.send :alias_method, :value?, :has_value?
+          other_mod.send :alias_method, :update, :merge!
+        end
+        
+        def [](key)
+          get(key)
+        end
+        
+        def []=(key,val)
+          put(key,val)
+        end
+        
+        def each
+          entry_set.each do |e|
+            yield [e.key, e.value]
+          end
+          self
+        end
+        
+        def each_pair
+          entry_set.each do |e|
+            yield e.key, e.value
+          end
+          self
+        end
+        
+        def contains_key?(key)
+          containsKey(key)
+        end
+        
+        def contains_value?(value)
+          containsValue(value)
+        end
+        
+        def length
+          size
+        end
+        
+        def delete_if(&block)
+          entry_set.iterate do |it, entry|
+            it.remove if yield(entry.key, entry.value)
+          end
+          self
+        end
+        
+        def each_key(&block)
+          key_set.each(&block)
+          self
+        end
+        
+        def each_value(&block)
+          values.each(&block)
+          self
+        end
+        
+        def delete(key)
+          if block_given? && !key?(key)
+            yield key
+          else
+            remove(key)
+          end
+        end
+        
+        def fetch(key,default=nil)
+          return get(key) if key?(key)
+          raise IndexError unless default || block_given?
+          return default if default
+          yield key
+        end
+        
+        def index(value)
+          ret = entry_set.find {|entry| entry.value == value}
+          return nil unless ret
+          ret.key
+        end
+        
+        def invert
+          ret = nil
+          begin
+            ret = dup
+            ret.clear
+            ret
+          rescue
+            ret = ::Hash.new
+          end
+          each_pair {|key,value| ret[value] = key}
+          ret
+        end
+        
+        def keys
+          key_set.to_a
+        end
+        
+        def merge(other_hash,&block)
+          dup.merge!(other_hash,&block)
+        end
+        
+        def merge!(other_hash)
+          if block_given?
+            other_hash.each_pair do |key, newval|
+              if has_key?(key)
+                oldval = get(key)
+                newval = yield(key,oldval,newval)
+              end
+              put(key, newval)
+            end
+          else
+            if other_hash.respond_to? :to_java_map
+              other_hash = other_hash.to_java_map
+            elsif other_hash.respond_to? :to_hash
+              other_hash = other_hash.to_hash
+            end
+            put_all(other_hash)
+          end
+          self
+        end
+        
+        def to_hash
+          ret = ::Hash.new
+          each_pair {|key,value| ret[key] = value}
+          ret
+        end
+        
+        def reject(&block)
+          dup.delete_if(&block)
+        end
+        
+        def reject!
+          ret = nil
+          entry_set.iterate do |it, entry|
+            if yield(entry.key, entry.value)
+              it.remove
+              ret = self
+            end
+          end
+          ret
+        end
+        
+        def replace(other_hash)
+          clear
+          merge!(other_hash)
+        end
+        
+        def values_at(*keys)
+          keys.inject([]) do |memo,key|
+            memo.push(get(key))
+          end
+        end
+        
+        def dup
+          clone
+        end
+      end
+    end
+  end
+end

data/lib/jactive_support/java_ext/map.rb

@@ -0,0 +1,6 @@
+require 'jactive_support/java_ext/map/hash'
+
+module java::util::Map #:nodoc:
+  include JactiveSupport::JavaExtensions::Map::Hash
+  Hash.included_modules.find_all {|m| m.name.start_with?('ActiveSupport::CoreExtensions::') }.each {|m| include m}
+end

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/conversions.rb

@@ -0,0 +1,33 @@
+module JactiveSupport #:nodoc:
+  module CoreExtensions #: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/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.rb

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

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/json.rb

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

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.0"
+end