orientdb 0.0.1-jruby → 0.0.2-jruby

data/.gitignore

@@ -20,6 +20,7 @@ tmtags
 .rvmrc
 
 ## PROJECT::GENERAL
+.bundle
 coverage
 rdoc
 pkg

data/Gemfile.lock

@@ -0,0 +1,20 @@
+PATH
+  remote: .
+  specs:
+    orientdb (0.0.1-java)
+      hashie
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    awesome_print (0.2.1)
+    hashie (0.4.0)
+
+PLATFORMS
+  java
+
+DEPENDENCIES
+  awesome_print
+  bundler (>= 1.0.0)
+  hashie
+  orientdb!

data/README.rdoc

@@ -0,0 +1,85 @@
+= orientdb
+
+orientdb is a little gem that wraps the Java OrientDB library into a more comfortable Ruby package (in JRuby, of course).
+
+== What is OrientDB?
+
+According to the website:
+
+OrientDB is a new Open Source NoSQL DBMS born with the best features of all the others. It's written in Java and it's amazing fast: can store up to 150,000 records per second on common hardware. Even if it's Document based database the relationships are managed as in Graph Databases with direct connections among records. You can travere entire or part of trees and graphs of records in few milliseconds. Supports schema-less, schema-full and schema-mixed modes. Has a strong security profiling system based on user and roles and support the SQL between the query languages. Thank to the SQL layer it's straightforward to use it for people skilled in Relational world.
+
+== Getting started
+
+Let's get the gem installed and test out the interactive console.
+
+  shell> rvm jruby
+  shell> gem install orientdb
+  shell> orientdb_console
+
+  >> db = OrientDB::Database.connect "remote:localhost/demo", 'admin', 'admin'
+  => #<OrientDB::Database:0x6a346239 @proxy_object=#<Java::ComOrientechnologiesOrientCoreDbDocument::ODatabaseDocumentTx:0x14860315>
+  >> customer = db.get_class "Customer"
+  => #<OrientDB::OClass:Customer name:string>
+  >> customer.add :name, :string
+  => true
+  >> db.schema.save
+  => #<Java::ComOrientechnologiesOrientCoreMetadataSchema::OSchema:0x4a5afcb1>
+  >> invoice = db.get_or_create_class "Invoice"
+  => #<OrientDB::OClass:Invoice id:integer date:date customer:link total:float>
+  >> invoice.add :id, :int
+  => true
+  >> invoice.add :date, :date
+  => true
+  >> invoice.add :total, :float
+  => true
+  >> invoice.add :customer, customer
+  => true
+  >> db.schema.save
+  => #<Java::ComOrientechnologiesOrientCoreMetadataSchema::OSchema:0x4a5afcb1>
+  >> c1 = OrientDB::Document.create db, "Customer", :name => "Leonardo"
+  => #<OrientDB::Document:Customer name:Leonardo>
+  >> i1 = OrientDB::Document.create db, "Invoice", :id => 1, :data => DateTime.now, :total => 350.75, :customer => c1
+  => #<OrientDB::Document:Invoice total:350.75 id:1 data:Wed Nov 02 18:21:13 MDT 3910 customer:#<OrientDB::Document:Customer name:Leonardo>>
+  >> i2 = OrientDB::Document.new db, "Invoice", :id => 12
+  => #<OrientDB::Document:Invoice id:12>
+  >> i2.date = DateTime.now
+  => #<DateTime: 5893210835369/2400000,-1/4,2299161>
+  >> i2.total = 275.25
+  => 275.25
+  >> i2.customer = c1
+  => #<OrientDB::Document:Customer name:Leonardo>
+  >> i2.extra = [3.50, 0.75]
+  => [3.5, 0.75]
+  >> i2.save
+  => #<Java::ComOrientechnologiesOrientCoreRecordImpl::ODocument:0x18b9459c>
+  >> i2
+  => #<OrientDB::Document:Invoice total:275.25 id:12 extra:3.50.75 customer:#<OrientDB::Document:Customer name:Leonardo> date:Wed Nov 02 18:21:13 MDT 3910>
+  >> db.count_class "Customer"
+  => 1
+  >> db.count_class "Invoice"
+  => 2
+  >> cs = db.all_in_class "Customer"
+  => [#<OrientDB::Document:Customer name:Leonardo>]
+  >> c1 = cs.first
+  => #<OrientDB::Document:Customer name:Leonardo>
+  >> is = db.all_in_class "Invoice"
+  => [#<OrientDB::Document:Invoice total:275.25 id:12 extra:[3.5, 0.75] customer:#<OrientDB::Document:Customer name:Leonardo> date:Wed Nov 02 18:21:13 MDT 3910>, #<OrientDB::Document:Invoice total:350.75 id:1 data:61246887673000 customer:#<OrientDB::Document:Customer name:Leonardo>>]
+  >> i1 = is.first
+  => #<OrientDB::Document:Invoice total:275.25 id:12 extra:[3.5, 0.75] customer:#<OrientDB::Document:Customer name:Leonardo> date:Wed Nov 02 18:21:13 MDT 3910>
+  >> i2 = is.last
+  => #<OrientDB::Document:Invoice total:350.75 id:1 data:61246887673000 customer:#<OrientDB::Document:Customer name:Leonardo>>
+
+
+== Note on Patches/Pull Requests
+
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2010 Adrian Madrid. See LICENSE for details.

data/bin/orientdb_console

@@ -0,0 +1,6 @@
+#!/usr/bin/env jruby
+require File.expand_path(File.dirname(__FILE__) + "/../lib/orientdb")
+
+require 'irb'
+ARGV.clear
+IRB.start(__FILE__)

data/lib/orientdb.rb

@@ -1,18 +1,24 @@
 raise "Rubyhaze only runs on JRuby. Sorry!" unless (RUBY_PLATFORM =~ /java/)
 
 $: << File.dirname(__FILE__)
-path = File.expand_path('../../jars/', __FILE__)
-puts "path : #{path}"
-$: << path
+$: << File.expand_path('../../jars/', __FILE__)
 
 require 'java'
 require 'orientdb-client-0.9.23'
 
-module OrientDB
+class OrientDB
+
+  def self.const_missing(missing)
+    puts "[#{name}:const_missing] #{missing}"
+    super
+  end
+
 end
 
+require 'orientdb/ext'
 require 'orientdb/version'
-require 'orientdb/mixins/proxy'
+require 'orientdb/proxy_mixin'
 require 'orientdb/user'
 require 'orientdb/database'
 require 'orientdb/document'
+require 'orientdb/oclass'

data/lib/orientdb/database.rb

@@ -1,8 +1,12 @@
 class OrientDB::Database
 
-  include OrientDB::Mixins::Proxy
+  include OrientDB::ProxyMixin
 
-  KLASS = com.orientechnologies.orient.core.db.document.ODatabaseDocumentTx
+  KLASS         = com.orientechnologies.orient.core.db.document.ODatabaseDocumentTx
+
+  Record        = com.orientechnologies.orient.core.record.ORecord
+  Schema        = com.orientechnologies.orient.core.metadata.schema.OSchema
+  SQLQuery      = com.orientechnologies.orient.core.sql.query.OSQLSynchQuery
 
   def initialize(database_url)
     @proxy_object = KLASS.new database_url
@@ -13,21 +17,105 @@ class OrientDB::Database
   end
 
   def user
-    OrientDB::User.from_ouser proxy_object.getUser
+    User.from_ouser proxy_object.getUser
+  end
+
+  def query(sql_query = nil)
+    sql_query = prepare_sql_query sql_query
+    proxy_object.query(sql_query).map { |x| OrientDB::Document.new x }
+  end
+
+  alias :find :query
+
+  def first(sql_query = nil)
+    sql_query = prepare_sql_query sql_query
+    proxy_object.query(sql_query).setLimit(1).map { |x| Document.new x }.first
+  end
+
+  def prepare_sql_query(sql_query)
+    return if sql_query.nil?
+    case sql_query
+      when SQLQuery
+        sql_query
+      when String
+        SQLQuery.new sql_query
+      when Hash
+        SQLQuery.new sql_query_from_hash(sql_query)
+      else
+        raise "Unknown query type"
+    end
+  end
+
+  def sql_query_from_hash(options = {})
+    klass_name = options.delete :class
+    raise "Missing class name" unless klass_name
+    columns    = options.delete(:columns) || '*'
+    order      = options.delete :order
+    order_sql  = order ? " ORDER BY #{order}" : ''
+    fields     = options.map do |field, value|
+      cmp = '='
+      if value.is_a?(String)
+        value = "'" + value + "'"
+        cmp = 'LIKE' if value.index('%')
+      end
+      "#{field} #{cmp} #{value}"
+    end
+    "SELECT #{columns} FROM #{klass_name} WHERE #{fields.join(' AND ')}#{order_sql}"
+  end
+
+  def schema
+    proxy_object.getMetadata.getSchema
+  end
+
+  def storage
+    proxy_object.storage
+  end
+
+  def create_class(name, fields = {})
+    OrientDB::OClass.create self, name, fields
+  end
+
+  def each_in_class(klass_name)
+    proxy_object.browseClass(klass_name.to_s).each do |record|
+      yield OrientDB::Document.new(record)
+    end
   end
 
-  alias :each_in_class  :browseClass
-  alias :each_in_custer :browseCluster
+  def all_in_class(klass_name)
+    proxy_object.browseClass(klass_name.to_s).map { |x| OrientDB::Document.new x }
+  end
 
+  def each_in_custer(cluster_name)
+    proxy_object.browseCluster(cluster_name.to_s).each do |record|
+      yield OrientDB::Document.new(record)
+    end
+  end
+
+  def all_in_custer(cluster_name)
+    proxy_object.browseCluster(cluster_name.to_s).map { |x| OrientDB::Document.new x }
+  end
+
+  def get_class(klass_name)
+    klass = schema.get_class klass_name
+    klass && OrientDB::OClass.new(klass)
+  end
+
+  def get_or_create_class(klass_name)
+    get_class(klass_name) || OrientDB::OClass.create(klass_name)
+  end
 
   class << self
 
     def create(database_url)
-      new(database_url).create
+      obj = new(database_url)
+      obj.create
+      obj
     end
 
     def connect(database_url, username, password)
-      new(database_url).auth(username, password)
+      obj = new(database_url)
+      obj.auth(username, password)
+      obj
     end
 
   end

data/lib/orientdb/database_pool.rb

@@ -1,6 +1,6 @@
 class OrientDB::DatabasePool
 
-  include OrientDB::Mixins::Proxy
+  include OrientDB::ProxyMixin
 
   KLASS = com.orientechnologies.orient.core.db.document.ODatabaseDocumentPool
 
@@ -11,7 +11,8 @@ class OrientDB::DatabasePool
   class << self
 
     def connect(database_url, username, password)
-      new database_url, username, password
+      obj = new database_url, username, password
+      obj
     end
 
   end

data/lib/orientdb/document.rb

@@ -1,21 +1,78 @@
 class OrientDB::Document
 
-  include OrientDB::Mixins::Proxy
+  include OrientDB::ProxyMixin
 
   KLASS = com.orientechnologies.orient.core.record.impl.ODocument
 
-  def initialize(db, klass_name, fields = {})
-    @proxy_object = KLASS.new db, klass_name
-    fields.each do |name, value|
-      @proxy_object.field name.to_s, value
+  def initialize(*args)
+    if args.first.is_a?(KLASS)
+      @proxy_object = args.first
+    else
+      db, klass_name = args[0], args[1]
+      fields = args[2] || {}
+      if db && klass_name
+        @proxy_object = KLASS.new db.proxy_object, klass_name
+        fields.each do |name, value|
+          self[name] = value
+        end
+      else
+        @proxy_object = KLASS.new
+      end
     end
   end
 
+  def values
+    proxy_object.fieldNames.map{|field_name| [field_name, self[field_name]] }
+  end
+
+  def db
+    proxy_object.getDatabase
+  end
+
+#  def save
+#    db.save proxy_object
+#  end
+
+  def [](field_name)
+    value = proxy_object.field field_name.to_s
+    value = OrientDB::Document.new(value) if value.is_a?(KLASS)
+    value
+  end
+
+  def []=(field_name, value)
+    value = value.proxy_object if value.respond_to?(:proxy_object)
+#    value = value.to_java if value.respond_to?(:to_java)
+    proxy_object.field field_name.to_s, value
+  end
+
+  def method_missing(method_name, *args, &blk)
+    return self[method_name] if proxy_object.containsField(method_name.to_s)
+    match = method_name.to_s.match(/(.*?)([?=!]?)$/)
+    case match[2]
+      when "="
+        self[match[1]] =  args.first
+      when "?"
+        !!self[match[1]]
+      else
+        super
+    end
+  end
+
+  def inspect
+    props = values.map{|k,v| "#{k}:#{v}" }.join(' ')
+    %{#<OrientDB::Document:#{proxy_object.getClassName}#{props.empty? ? '' : ' ' + props}>}
+  end
+
+  alias :to_s :inspect
+
   class << self
 
     def create(db, klass_name, fields = {})
-      new(db, klass_name, fields).save
+      obj = new(db, klass_name, fields)
+      obj.save
+      obj
     end
+
   end
 
 end

data/lib/orientdb/ext.rb

@@ -0,0 +1,13 @@
+require 'date'
+
+class Date
+  def proxy_object
+    java.util.Date.new year, month - 1, day - 1, 0, 0, 0
+  end
+end
+
+class DateTime
+  def proxy_object
+    java.util.Date.new year, month - 1, day - 1, hour, min, sec
+  end
+end

data/lib/orientdb/oclass.rb

@@ -0,0 +1,145 @@
+class OrientDB::OClass
+
+  include OrientDB::ProxyMixin
+
+  KLASS         = com.orientechnologies.orient.core.metadata.schema.OClass
+
+  SchemaType    = com.orientechnologies.orient.core.metadata.schema.OType
+  ClusterType   = com.orientechnologies.orient.core.storage.OStorage::CLUSTER_TYPE
+  IndexType     = com.orientechnologies.orient.core.metadata.schema.OProperty::INDEX_TYPE
+
+  FIELD_TYPES   = {
+    :binary        => "BINARY",
+    :bool          => "BOOLEAN",
+    :boolean       => "BOOLEAN",
+    :double        => "BYTE",
+    :date          => "DATE",
+    :datetime      => "DATE",
+    :decimal       => "FLOAT",
+    :double        => "DOUBLE",
+    :embedded      => "EMBEDDED",
+    :embedded_list => "EMBEDDEDLIST",
+    :embedded_map  => "EMBEDDEDMAP",
+    :embedded_set  => "EMBEDDEDSET",
+    :float         => "FLOAT",
+    :int           => "INTEGER",
+    :integer       => "INTEGER",
+    :link          => "LINK",
+    :link_list     => "LINKLIST",
+    :link_map      => "LINKMAP",
+    :link_set      => "LINKSET",
+    :long          => "LONG",
+    :short         => "SHORT",
+    :string        => "STRING",
+  }.inject({}) do |h, (k, v)|
+    h[k] = SchemaType.const_get v
+    h
+  end
+
+  STORAGE_TYPES = %w{ LOGICAL MEMORY PHYSICAL }.inject({}) do |h, s|
+    h[s.downcase.to_sym] = ClusterType.const_get s
+    h
+  end
+
+  INDEX_TYPES   = %w{ FULLTEXT NOT_UNIQUE UNIQUE }.inject({}) do |h, s|
+    h[s.downcase.to_sym] = IndexType.const_get s
+    h
+  end
+
+  def initialize(*args)
+    if args.first.is_a?(KLASS)
+      @proxy_object = args.first
+    else
+      @proxy_object = KLASS.new
+    end
+  end
+
+  def add(property_name, type)
+    property_name = property_name.to_s
+    if proxy_object.existsProperty(property_name)
+      puts "We already have that property name [#{property_name}]"
+      return false
+    end
+
+    case type
+      when Symbol
+        proxy_object.createProperty property_name, FIELD_TYPES[type]
+      when OrientDB::OClass
+        proxy_object.createProperty property_name, FIELD_TYPES[:link], type.proxy_object
+      when Array
+        type[0] = FIELD_TYPES[type[0]] if type[0].is_a?(Symbol)
+        proxy_object.createProperty property_name, *type
+      when Hash
+        type[:type] = FIELD_TYPES[:link] if type[:type].is_a?(Symbol)
+        prop    = proxy_object.createProperty property_name, type[:type]
+        prop.setMin(type[:min]) unless type[:min].nil?
+        prop.setMax(type[:max]) unless type[:max].nil?
+        prop.setMandatory(!!type[:mandatory]) unless type[:mandatory].nil?
+        prop.setNotNull(type[:not_null]) unless type[:not_null].nil?
+        unless type[:index].nil?
+          index_type = type[:index] == true ? INDEX_TYPES[:not_unique] : INDEX_TYPES[type[:index]]
+          prop.createIndex index_type
+        end
+      else
+        puts "ERROR! Unknown type [ #{property_name} | #{type} : #{type.class.name} ]"
+    end
+    self
+  end
+
+  def [](property_name)
+    property_name = property_name.to_s
+    proxy_object.exists_property(property_name) ? proxy_object.getProperty(property_name) : nil
+  end
+
+  def db
+    proxy_object.getDocument.getDatabase
+  end
+
+  def schema
+    db.getMetadata.getSchema
+  end
+
+  def create_document(fields = {})
+    OrientDB::Document.create db, name, fields
+  end
+  alias :ceate :create_document
+
+  def inspect
+    props = properties.map { |x| "#{x.getName}:#{x.getType.to_s.downcase}" }.join(' ')
+    %{#<OrientDB::OClass:#{name}#{props.empty? ? '' : ' ' + props}>}
+  end
+
+  alias :to_s :inspect
+
+  class << self
+
+    def create(db, name, fields = {})
+      add_cluster = fields.delete :add_cluster
+      add_cluster = true if add_cluster.nil?
+
+      if add_cluster
+        cluster = db.storage.addCluster name.downcase, STORAGE_TYPES[:physical]
+        klass   = db.schema.createClass name, cluster
+      else
+        klass = db.schema.createClass name
+      end
+
+      super_klass = fields.delete :super
+      klass.setSuperClass(super_klass) if super_klass
+      db.schema.save
+
+      obj         = new klass
+
+      unless fields.empty?
+        fields.each do |property_name, type|
+          obj.add property_name, type
+        end
+        db.schema.save
+      end
+
+      obj
+    end
+
+  end
+
+end

data/lib/orientdb/proxy_mixin.rb

@@ -0,0 +1,65 @@
+class OrientDB
+  module ProxyMixin
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    attr_reader :proxy_object
+
+    def respond_to?(meth)
+      proxy_object.respond_to?(meth) || super
+    end
+
+    def method_missing(meth, *args, &blk)
+      if proxy_object.respond_to? meth
+        puts "mm : #{meth}"
+        proxy_object.send meth, *args, &blk
+      else
+        super
+      end
+    end
+
+    alias_method :decorator_methods, :methods
+
+    def methods
+      (decorator_methods + proxy_object.methods).uniq
+    end
+
+    module ClassMethods
+
+      def proxy_method(aliased_name, real_name = nil)
+        real_name ||= aliased_name
+        class_eval %{def #{aliased_name}(*args) puts "pm : #{real_name}"; proxy_object.send :#{real_name}, *args end}
+      end
+
+      def proxy_methods(*args)
+        args.each { |arg| proxy_method *arg }
+      end
+
+      def proxy_accessor(aliased_name, real_name = nil)
+        real_name    ||= aliased_name
+        aliased_name = aliased_name.to_s
+        if aliased_name[-1, 1] == '?'
+          class_eval %{def #{aliased_name[0..-2]}() puts "pa : #{real_name}"; proxy_object.send :is_#{real_name}? end}
+          class_eval %{def #{aliased_name}() puts "pa : #{real_name}"; proxy_object.send :is_#{real_name}? end}
+          class_eval %{def #{aliased_name[0..-2]}=(v) puts "pa : #{real_name}"; proxy_object.send :set_#{real_name}, v end}
+        else
+          class_eval %{def #{aliased_name}() puts "pa : #{real_name}"; proxy_object.send :get_#{real_name}? end}
+          class_eval %{def #{aliased_name}=(v) puts "pa : #{real_name}"; proxy_object.send :set_#{real_name}, v end}
+        end
+      end
+
+      def proxy_accessors(*args)
+        args.each { |arg| proxy_accessor *arg }
+      end
+
+      def self.const_missing(missing)
+        puts "[#{name}:const_missing] #{missing}"
+        super
+      end
+
+    end
+
+  end
+end

data/lib/orientdb/user.rb

@@ -1,6 +1,6 @@
 class OrientDB::User
 
-  include OrientDB::Mixins::Proxy
+  include OrientDB::ProxyMixin
 
   KLASS = com.orientechnologies.orient.core.metadata.security.OUser
 

data/lib/orientdb/version.rb

@@ -1,3 +1,3 @@
-module OrientDB
-  VERSION = "0.0.1"
+class OrientDB
+  VERSION = "0.0.2"
 end

data/orientdb.gemspec

@@ -14,7 +14,9 @@ Gem::Specification.new do |s|
   s.required_rubygems_version = ">= 1.3.6"
   s.rubyforge_project         = "orientdb"
 
+  s.add_dependency "hashie"
   s.add_development_dependency "bundler", ">= 1.0.0"
+  s.add_development_dependency "awesome_print"
 
   s.files        = `git ls-files`.split("\n")
   s.test_files   = Dir["test/test*.rb"]

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
     - 0
     - 0
-    - 1
-  version: 0.0.1
+    - 2
+  version: 0.0.2
 platform: jruby
 authors: 
   - Adrian Madrid
@@ -14,13 +14,25 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-11-02 00:00:00 -06:00
+date: 2010-11-03 00:00:00 -06:00
 default_executable: 
 dependencies: 
   - !ruby/object:Gem::Dependency 
-    name: bundler
+    name: hashie
     prerelease: false
     requirement: &id001 !ruby/object:Gem::Requirement 
+      requirements: 
+        - - ">="
+          - !ruby/object:Gem::Version 
+            segments: 
+              - 0
+            version: "0"
+    type: :runtime
+    version_requirements: *id001
+  - !ruby/object:Gem::Dependency 
+    name: bundler
+    prerelease: false
+    requirement: &id002 !ruby/object:Gem::Requirement 
       requirements: 
         - - ">="
           - !ruby/object:Gem::Version 
@@ -30,12 +42,24 @@ dependencies:
               - 0
             version: 1.0.0
     type: :development
-    version_requirements: *id001
+    version_requirements: *id002
+  - !ruby/object:Gem::Dependency 
+    name: awesome_print
+    prerelease: false
+    requirement: &id003 !ruby/object:Gem::Requirement 
+      requirements: 
+        - - ">="
+          - !ruby/object:Gem::Version 
+            segments: 
+              - 0
+            version: "0"
+    type: :development
+    version_requirements: *id003
 description: JRuby wrapper for OrientDB
 email: 
   - aemadrid@gmail.com
-executables: []
-
+executables: 
+  - orientdb_console
 extensions: []
 
 extra_rdoc_files: []
@@ -44,7 +68,10 @@ files:
   - .gitignore
   - .rvmrc
   - Gemfile
+  - Gemfile.lock
+  - README.rdoc
   - Rakefile
+  - bin/orientdb_console
   - jars/orient-commons-0.9.23.jar
   - jars/orientdb-client-0.9.23.jar
   - jars/orientdb-core-0.9.23.jar
@@ -55,7 +82,9 @@ files:
   - lib/orientdb/database.rb
   - lib/orientdb/database_pool.rb
   - lib/orientdb/document.rb
-  - lib/orientdb/mixins/proxy.rb
+  - lib/orientdb/ext.rb
+  - lib/orientdb/oclass.rb
+  - lib/orientdb/proxy_mixin.rb
   - lib/orientdb/user.rb
   - lib/orientdb/version.rb
   - orientdb.gemspec

data/lib/orientdb/mixins/proxy.rb

@@ -1,46 +0,0 @@
-module OrientDB
-  module Mixins
-    module Proxy
-
-      def self.included(base)
-        base.extend ClassMethods
-      end
-
-      attr_reader :proxy_object
-
-      def respond_to?(meth)
-        proxy_object.respond_to?(meth) || super
-      end
-
-      def method_missing(meth, *args, &blk)
-        if proxy_object.respond_to? meth
-          proxy_object.send meth, *args, &blk
-        else
-          super
-        end
-      end
-
-      module ClassMethods
-
-        def proxy_accessor(aliased_name, real_name = nil)
-          real_name ||= aliased_name
-          aliased_name = aliased_name.to_s
-          if aliased_name[-1,1] == '?'
-            class_eval %{def #{aliased_name[0..-2]}() proxy_object.send :is_#{real_name}? end}
-            class_eval %{def #{aliased_name}() proxy_object.send :is_#{real_name}? end}
-            class_eval %{def #{aliased_name[0..-2]}=(v) proxy_object.send :set_#{real_name}, v end}
-          else
-            class_eval %{def #{aliased_name}() proxy_object.send :get_#{real_name}? end}
-            class_eval %{def #{aliased_name}=(v) proxy_object.send :set_#{real_name}, v end}
-          end
-        end
-
-        def proxy_accessors(*args)
-          args.each { |arg| proxy_accessor *arg }
-        end
-
-      end
-
-    end
-  end
-end