jactive_support 1.0.2

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", "EN") }
+        }
+
+        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/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

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