knjrbfw 0.0.8 → 0.0.9

data/lib/knj/rhodes/delegate.rb

@@ -0,0 +1,414 @@
+# = delegate -- Support for the Delegation Pattern
+#
+# Documentation by James Edward Gray II and Gavin Sinclair
+#
+# == Introduction
+#
+# This library provides three different ways to delegate method calls to an
+# object.  The easiest to use is SimpleDelegator.  Pass an object to the
+# constructor and all methods supported by the object will be delegated.  This
+# object can be changed later.
+#
+# Going a step further, the top level DelegateClass method allows you to easily
+# setup delegation through class inheritance.  This is considerably more
+# flexible and thus probably the most common use for this library.
+#
+# Finally, if you need full control over the delegation scheme, you can inherit
+# from the abstract class Delegator and customize as needed.  (If you find
+# yourself needing this control, have a look at _forwardable_, also in the
+# standard library.  It may suit your needs better.)
+#
+# == Notes
+#
+# Be advised, RDoc will not detect delegated methods.
+#
+# <b>delegate.rb provides full-class delegation via the
+# DelegateClass() method.  For single-method delegation via
+# def_delegator(), see forwardable.rb.</b>
+#
+# == Examples
+#
+# === SimpleDelegator
+#
+# Here's a simple example that takes advantage of the fact that
+# SimpleDelegator's delegation object can be changed at any time.
+#
+#   class Stats
+#     def initialize
+#       @source = SimpleDelegator.new([])
+#     end
+#
+#     def stats( records )
+#       @source.__setobj__(records)
+#
+#       "Elements:  #{@source.size}\n" +
+#       " Non-Nil:  #{@source.compact.size}\n" +
+#       "  Unique:  #{@source.uniq.size}\n"
+#     end
+#   end
+#
+#   s = Stats.new
+#   puts s.stats(%w{James Edward Gray II})
+#   puts
+#   puts s.stats([1, 2, 3, nil, 4, 5, 1, 2])
+#
+# <i>Prints:</i>
+#
+#   Elements:  4
+#    Non-Nil:  4
+#     Unique:  4
+#
+#   Elements:  8
+#    Non-Nil:  7
+#     Unique:  6
+#
+# === DelegateClass()
+#
+# Here's a sample of use from <i>tempfile.rb</i>.
+#
+# A _Tempfile_ object is really just a _File_ object with a few special rules
+# about storage location and/or when the File should be deleted.  That makes for
+# an almost textbook perfect example of how to use delegation.
+#
+#   class Tempfile < DelegateClass(File)
+#     # constant and class member data initialization...
+#
+#     def initialize(basename, tmpdir=Dir::tmpdir)
+#       # build up file path/name in var tmpname...
+#
+#       @tmpfile = File.open(tmpname, File::RDWR|File::CREAT|File::EXCL, 0600)
+#
+#       # ...
+#
+#       super(@tmpfile)
+#
+#       # below this point, all methods of File are supported...
+#     end
+#
+#     # ...
+#   end
+#
+# === Delegator
+#
+# SimpleDelegator's implementation serves as a nice example here.
+#
+#    class SimpleDelegator < Delegator
+#      def initialize(obj)
+#        super             # pass obj to Delegator constructor, required
+#        @delegate_sd_obj = obj    # store obj for future use
+#      end
+#
+#      def __getobj__
+#        @delegate_sd_obj          # return object we are delegating to, required
+#      end
+#
+#      def __setobj__(obj)
+#        @delegate_sd_obj = obj    # change delegation object, a feature we're providing
+#      end
+#
+#      # ...
+#    end
+
+#
+# Delegator is an abstract class used to build delegator pattern objects from
+# subclasses.  Subclasses should redefine \_\_getobj\_\_.  For a concrete
+# implementation, see SimpleDelegator.
+#
+class Delegator < BasicObject
+  kernel = ::Kernel.dup
+  kernel.class_eval do
+    [:to_s,:inspect,:=~,:!~,:===,:<=>,:eql?,:hash].each do |m|
+      undef_method m
+    end
+  end
+  include kernel
+
+  # :stopdoc:
+  def self.const_missing(n)
+    ::Object.const_get(n)
+  end
+  # :startdoc:
+
+  #
+  # Pass in the _obj_ to delegate method calls to.  All methods supported by
+  # _obj_ will be delegated to.
+  #
+  def initialize(obj)
+    __setobj__(obj)
+  end
+
+  #
+  # Handles the magic of delegation through \_\_getobj\_\_.
+  #
+  def method_missing(m, *args, &block)
+    target = self.__getobj__
+    begin
+      target.respond_to?(m) ? target.__send__(m, *args, &block) : super(m, *args, &block)
+    ensure
+      $@.delete_if {|t| %r"\A#{Regexp.quote(__FILE__)}:#{__LINE__-2}:"o =~ t} if $@
+    end
+  end
+
+  #
+  # Checks for a method provided by this the delegate object by forwarding the
+  # call through \_\_getobj\_\_.
+  #
+  def respond_to_missing?(m, include_private)
+    r = self.__getobj__.respond_to?(m, include_private)
+    if r && include_private && !self.__getobj__.respond_to?(m, false)
+      warn "#{caller(3)[0]}: delegator does not forward private method \##{m}"
+      return false
+    end
+    r
+  end
+
+  #
+  # Returns the methods available to this delegate object as the union
+  # of this object's and \_\_getobj\_\_ methods.
+  #
+  def methods
+    __getobj__.methods | super
+  end
+
+  #
+  # Returns the methods available to this delegate object as the union
+  # of this object's and \_\_getobj\_\_ public methods.
+  #
+  def public_methods(all=true)
+    __getobj__.public_methods(all) | super
+  end
+
+  #
+  # Returns the methods available to this delegate object as the union
+  # of this object's and \_\_getobj\_\_ protected methods.
+  #
+  def protected_methods(all=true)
+    __getobj__.protected_methods(all) | super
+  end
+
+  # Note: no need to specialize private_methods, since they are not forwarded
+
+  #
+  # Returns true if two objects are considered of equal value.
+  #
+  def ==(obj)
+    return true if obj.equal?(self)
+    self.__getobj__ == obj
+  end
+
+  #
+  # Returns true if two objects are not considered of equal value.
+  #
+  def !=(obj)
+    return false if obj.equal?(self)
+    __getobj__ != obj
+  end
+
+  def !
+    !__getobj__
+  end
+
+  #
+  # This method must be overridden by subclasses and should return the object
+  # method calls are being delegated to.
+  #
+  def __getobj__
+    raise NotImplementedError, "need to define `__getobj__'"
+  end
+
+  #
+  # This method must be overridden by subclasses and change the object delegate
+  # to _obj_.
+  #
+  def __setobj__(obj)
+    raise NotImplementedError, "need to define `__setobj__'"
+  end
+
+  #
+  # Serialization support for the object returned by \_\_getobj\_\_.
+  #
+  def marshal_dump
+    ivars = instance_variables.reject {|var| /\A@delegate_/ =~ var}
+    [
+      :__v2__,
+      ivars, ivars.map{|var| instance_variable_get(var)},
+      __getobj__
+    ]
+  end
+
+  #
+  # Reinitializes delegation from a serialized object.
+  #
+  def marshal_load(data)
+    version, vars, values, obj = data
+    if version == :__v2__
+      vars.each_with_index{|var, i| instance_variable_set(var, values[i])}
+      __setobj__(obj)
+    else
+      __setobj__(data)
+    end
+  end
+
+  def initialize_clone(obj) # :nodoc:
+    self.__setobj__(obj.__getobj__.clone)
+  end
+  def initialize_dup(obj) # :nodoc:
+    self.__setobj__(obj.__getobj__.dup)
+  end
+  private :initialize_clone, :initialize_dup
+
+  ##
+  # :method: trust
+  # Trust both the object returned by \_\_getobj\_\_ and self.
+  #
+
+  ##
+  # :method: untrust
+  # Untrust both the object returned by \_\_getobj\_\_ and self.
+  #
+
+  ##
+  # :method: taint
+  # Taint both the object returned by \_\_getobj\_\_ and self.
+  #
+
+  ##
+  # :method: untaint
+  # Untaint both the object returned by \_\_getobj\_\_ and self.
+  #
+
+  [:trust, :untrust, :taint, :untaint].each do |method|
+    define_method method do
+      __getobj__.send(method)
+      super()
+    end
+  end
+
+  #
+  # Freeze self and target at once.
+  #
+  def freeze
+    __getobj__.freeze
+    super
+  end
+
+  @delegator_api = self.public_instance_methods
+  def self.public_api   # :nodoc:
+    @delegator_api
+  end
+end
+
+#
+# A concrete implementation of Delegator, this class provides the means to
+# delegate all supported method calls to the object passed into the constructor
+# and even to change the object being delegated to at a later time with
+# \_\_setobj\_\_ .
+#
+class SimpleDelegator<Delegator
+  # Returns the current object method calls are being delegated to.
+  def __getobj__
+    @delegate_sd_obj
+  end
+
+  #
+  # Changes the delegate object to _obj_.
+  #
+  # It's important to note that this does *not* cause SimpleDelegator's methods
+  # to change.  Because of this, you probably only want to change delegation
+  # to objects of the same type as the original delegate.
+  #
+  # Here's an example of changing the delegation object.
+  #
+  #   names = SimpleDelegator.new(%w{James Edward Gray II})
+  #   puts names[1]    # => Edward
+  #   names.__setobj__(%w{Gavin Sinclair})
+  #   puts names[1]    # => Sinclair
+  #
+  def __setobj__(obj)
+    raise ArgumentError, "cannot delegate to self" if self.equal?(obj)
+    @delegate_sd_obj = obj
+  end
+end
+
+# :stopdoc:
+def Delegator.delegating_block(mid)
+  lambda do |*args, &block|
+    target = self.__getobj__
+    begin
+      target.__send__(mid, *args, &block)
+    ensure
+      $@.delete_if {|t| /\A#{Regexp.quote(__FILE__)}:#{__LINE__-2}:/o =~ t} if $@
+    end
+  end
+end
+# :startdoc:
+
+#
+# The primary interface to this library.  Use to setup delegation when defining
+# your class.
+#
+#   class MyClass < DelegateClass( ClassToDelegateTo )    # Step 1
+#     def initialize
+#       super(obj_of_ClassToDelegateTo)                   # Step 2
+#     end
+#   end
+#
+def DelegateClass(superclass)
+  klass = Class.new(Delegator)
+  methods = superclass.instance_methods
+  methods -= ::Delegator.public_api
+  methods -= [:to_s,:inspect,:=~,:!~,:===]
+  klass.module_eval do
+    def __getobj__  # :nodoc:
+      @delegate_dc_obj
+    end
+    def __setobj__(obj)  # :nodoc:
+      raise ArgumentError, "cannot delegate to self" if self.equal?(obj)
+      @delegate_dc_obj = obj
+    end
+    methods.each do |method|
+      define_method(method, Delegator.delegating_block(method))
+    end
+  end
+  klass.define_singleton_method :public_instance_methods do |all=true|
+    super(all) - superclass.protected_instance_methods
+  end
+  klass.define_singleton_method :protected_instance_methods do |all=true|
+    super(all) | superclass.protected_instance_methods
+  end
+  return klass
+end
+
+# :enddoc:
+
+if __FILE__ == $0
+  class ExtArray<DelegateClass(Array)
+    def initialize()
+      super([])
+    end
+  end
+
+  ary = ExtArray.new
+  p ary.class
+  ary.push 25
+  p ary
+  ary.push 42
+  ary.each {|x| p x}
+
+  foo = Object.new
+  def foo.test
+    25
+  end
+  def foo.iter
+    yield self
+  end
+  def foo.error
+    raise 'this is OK'
+  end
+  foo2 = SimpleDelegator.new(foo)
+  p foo2
+  foo2.instance_eval{print "foo\n"}
+  p foo.test == foo2.test	# => true
+  p foo2.iter{[55,true]}        # => true
+  foo2.error			# raise error!
+end

data/lib/knj/rhodes/rhodes.rb

@@ -1,29 +1,44 @@
 $knjautoload = false
 
 class Knj::Rhodes
+  attr_accessor :locale
   attr_reader :db, :ob, :gettext, :args
   
   def initialize(args = {})
-    require "Knj/arrayext.rb"
-    require "Knj/php.rb"
-    require "Knj/objects.rb"
-    require "Knj/datarow.rb"
-    require "Knj/event_handler.rb"
-    require "Knj/hash_methods.rb"
-    require "Knj/errors.rb"
-    require "Knj/gettext_threadded.rb"
-    require "Knj/locales.rb"
-    require "Knj/web.rb"
-    require "Knj/rhodes/mutex.rb"
-    require "Knj/opts.rb"
-    
-    require "Knj/knjdb/libknjdb.rb"
-    require "Knj/knjdb/drivers/sqlite3/knjdb_sqlite3.rb"
-    require "Knj/knjdb/drivers/sqlite3/knjdb_sqlite3_tables.rb"
-    require "Knj/knjdb/drivers/sqlite3/knjdb_sqlite3_columns.rb"
-    require "Knj/knjdb/drivers/sqlite3/knjdb_sqlite3_indexes.rb"
+    require "#{$knjpath}arrayext.rb"
+    require "#{$knjpath}datet.rb"
+    require "#{$knjpath}php.rb"
+    require "#{$knjpath}objects.rb"
+    require "#{$knjpath}datarow.rb"
+    require "#{$knjpath}event_handler.rb"
+    require "#{$knjpath}hash_methods.rb"
+    require "#{$knjpath}errors.rb"
+    require "#{$knjpath}gettext_threadded.rb"
+    require "#{$knjpath}locales.rb"
+    require "#{$knjpath}web.rb"
+    
+    if !Kernel.const_defined?("Mutex")
+      print "Mutex not defined - loading alternative.\n"
+      require "#{$knjpath}rhodes/mutex.rb"
+    end
+    
+    if !Kernel.const_defined?("WeakRef")
+      print "WeakRef not defined - loading alternative.\n"
+      require "#{$knjpath}rhodes/weakref.rb"
+    end
+    
+    require "#{$knjpath}opts.rb"
+    
+    require "#{$knjpath}knjdb/libknjdb.rb"
+    require "#{$knjpath}knjdb/revision.rb"
+    require "#{$knjpath}knjdb/drivers/sqlite3/knjdb_sqlite3.rb"
+    require "#{$knjpath}knjdb/drivers/sqlite3/knjdb_sqlite3_tables.rb"
+    require "#{$knjpath}knjdb/drivers/sqlite3/knjdb_sqlite3_columns.rb"
+    require "#{$knjpath}knjdb/drivers/sqlite3/knjdb_sqlite3_indexes.rb"
     
     @args = args
+    @callbacks = {}
+    @callbacks_count = 0
     
     @db = Knj::Db.new(
       :type => "sqlite3",
@@ -47,16 +62,16 @@ class Knj::Rhodes
       ]
     }
     
-    require "knjdbrevision/knjdbrevision.rb"
-    dbrev = Knjdbrevision.new
+    dbrev = Knj::Db::Revision.new
     dbrev.init_db(schema, @db)
     
     @ob = Knj::Objects.new(
       :db => @db,
-      :class_path => "#{Rho::RhoApplication.get_base_app_path}app/Multinasser/include",
+      :class_path => "#{Rho::RhoApplication.get_base_app_path}app/models",
       :require => false,
       :module => @args[:module],
-      :datarow => true
+      :datarow => true,
+      :cache => :none
     )
     
     Knj::Opts.init(
@@ -66,6 +81,29 @@ class Knj::Rhodes
     
     @gettext = Knj::Gettext_threadded.new
     @gettext.load_dir("#{Rho::RhoApplication.get_base_app_path}app/locales")
+    
+    locale = "#{System.get_property("locale")}_#{System.get_property("country")}".downcase
+    
+    @args[:locale_default] = "en_GB" if !@args[:locale_default]
+    
+    langs = @gettext.langs.keys
+    langs.each do |lang|
+      if locale == lang.downcase
+        @locale = lang
+        break
+      end
+    end
+    
+    if !@locale
+      langs.each do |lang|
+        if locale.slice(0..2) == lang.downcase.slice(0..2)
+          @locale = lang
+          break
+        end
+      end
+    end
+    
+    @locale = @args[:locale_default] if !@locale
   end
   
   def inputs(*arr)
@@ -78,7 +116,7 @@ class Knj::Rhodes
       
       if data.key?(:value) and data[:value].is_a?(Array) and data[:value][0]
         value = data[:value][0][data[:value][1]]
-      elsif data.key?(:value)
+      elsif data.key?(:valthread_callbackue)
         value = data[:value]
       end
       
@@ -90,28 +128,64 @@ class Knj::Rhodes
       if data[:type] == :textarea
         css["height"] = data[:height] if data.key?(:height)
         
-        html += "<div data-role=\"fieldcontain\">"
-        html += "<label for=\"#{data[:name]}\">#{data[:title]}</label>"
-        html += "<textarea name=\"#{data[:name]}\" id=\"#{data[:name]}\"#{Knj::Web.style_html(css)}#{extra_args}>#{value}</textarea>"
-        html += "</div>"
+        html << "<div data-role=\"fieldcontain\">"
+        html << "<label for=\"#{data[:name]}\">#{data[:title]}</label>"
+        html << "<textarea name=\"#{data[:name]}\" id=\"#{data[:name]}\"#{Knj::Web.style_html(css)}#{extra_args}>#{value}</textarea>"
+        html << "</div>"
       else
-        html += "<div data-role=\"fieldcontain\">"
-        html += "<label for=\"#{data[:name]}\">#{data[:title]}</label>"
-        html += "<input type=\"#{data[:type]}\" name=\"#{data[:name]}\" id=\"#{data[:name]}\" value=\"#{value}\"#{Knj::Web.style_html(css)}#{extra_args} />"
-        html += "</div>"
+        html << "<div data-role=\"fieldcontain\">"
+        html << "<label for=\"#{data[:name]}\">#{data[:title]}</label>"
+        html << "<input type=\"#{data[:type]}\" name=\"#{data[:name]}\" id=\"#{data[:name]}\" value=\"#{value}\"#{Knj::Web.style_html(css)}#{extra_args} />"
+        html << "</div>"
       end
     end
     
     return html
   end
   
-	def self.html_links(args)
-		html_cont = "#{args[:html]}"
-		
-		html_cont.scan(/(<a([^>]+)href=\"(http.+?)\")/) do |match|
-			html_cont = html_cont.gsub(match[0], "<a#{match[1]}href=\"javascript: knj_rhodes_html_links({url: '#{match[2]}'});\"")
-		end
-		
-		return html_cont
-	end
+  def self.html_links(args)
+    html_cont = "#{args[:html]}"
+    
+    html_cont.scan(/(<a([^>]+)href=\"(http.+?)\")/) do |match|
+      html_cont = html_cont.gsub(match[0], "<a#{match[1]}href=\"javascript: knj_rhodes_html_links({url: '#{match[2]}'});\"")
+    end
+    
+    return html_cont
+  end
+  
+  def _(str)
+    return @gettext.trans(@locale, str.to_s)
+  end
+  
+  def session_key(key)
+    if key == :locale
+      return @locale
+    end
+    
+    raise "No such key: '#{key}'."
+  end
+  
+  def callback(&block)
+    count = @callbacks_count
+    @callbacks_count += 1
+    @callbacks[count] = block
+    return count
+  end
+  
+  def callbacks(key)
+    block = @callbacks[key.to_i]
+    raise "Block not found for key: '#{key}'." if !block
+    @callbacks.delete(key.to_i)
+    return block
+  end
+end
+
+#This method is used to emulate web-behavior and make Knj::Locales.number_out and friends work properly.
+def _session(key)
+  return $rhodes.session_key(key)
+end
+
+#This method is used to make gettext work.
+def _(key)
+  return $rhodes._(key)
 end

data/lib/knj/rhodes/weakref.rb

@@ -0,0 +1,80 @@
+# Weak Reference class that does not bother GCing.
+#
+# Usage:
+#   foo = Object.new
+#   foo = Object.new
+#   p foo.to_s			# original's class
+#   foo = WeakRef.new(foo)
+#   p foo.to_s			# should be same class
+#   ObjectSpace.garbage_collect
+#   p foo.to_s			# should raise exception (recycled)
+
+require "#{$knjpath}rhodes/delegate"
+require "thread"
+
+class WeakRef < Delegator
+
+  class RefError < StandardError
+  end
+
+  @@id_map =  {}                # obj -> [ref,...]
+  @@id_rev_map =  {}            # ref -> obj
+  @@mutex = Mutex.new
+  @@final = lambda {|id|
+    @@mutex.synchronize {
+      rids = @@id_map[id]
+      if rids
+	for rid in rids
+	  @@id_rev_map.delete(rid)
+	end
+	@@id_map.delete(id)
+      end
+      rid = @@id_rev_map[id]
+      if rid
+	@@id_rev_map.delete(id)
+	@@id_map[rid].delete(id)
+	@@id_map.delete(rid) if @@id_map[rid].empty?
+      end
+    }
+  }
+
+  def initialize(orig)
+    @__id = orig.object_id
+    ObjectSpace.define_finalizer orig, @@final
+    ObjectSpace.define_finalizer self, @@final
+    @@mutex.synchronize {
+      @@id_map[@__id] = [] unless @@id_map[@__id]
+    }
+    @@id_map[@__id].push self.object_id
+    @@id_rev_map[self.object_id] = @__id
+    super
+  end
+
+  def __getobj__
+    unless @@id_rev_map[self.object_id] == @__id
+      Kernel::raise RefError, "Invalid Reference - probably recycled", Kernel::caller(2)
+    end
+    begin
+      ObjectSpace._id2ref(@__id)
+    rescue RangeError
+      Kernel::raise RefError, "Invalid Reference - probably recycled", Kernel::caller(2)
+    end
+  end
+  def __setobj__(obj)
+  end
+
+  def weakref_alive?
+    @@id_rev_map[self.object_id] == @__id
+  end
+end
+
+if __FILE__ == $0
+#  require 'thread'
+  foo = Object.new
+  p foo.to_s			# original's class
+  foo = WeakRef.new(foo)
+  p foo.to_s			# should be same class
+  ObjectSpace.garbage_collect
+  ObjectSpace.garbage_collect
+  p foo.to_s			# should raise exception (recycled)
+end