orientdb 0.0.2-jruby → 0.0.4-jruby

data/Gemfile.lock

@@ -1,14 +1,23 @@
 PATH
   remote: .
   specs:
-    orientdb (0.0.1-java)
+    orientdb (0.0.2-java)
       hashie
 
 GEM
   remote: http://rubygems.org/
   specs:
     awesome_print (0.2.1)
+    diff-lcs (1.1.2)
     hashie (0.4.0)
+    rspec (2.1.0)
+      rspec-core (~> 2.1.0)
+      rspec-expectations (~> 2.1.0)
+      rspec-mocks (~> 2.1.0)
+    rspec-core (2.1.0)
+    rspec-expectations (2.1.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.1.0)
 
 PLATFORMS
   java
@@ -18,3 +27,4 @@ DEPENDENCIES
   bundler (>= 1.0.0)
   hashie
   orientdb!
+  rspec (>= 2.1)

data/Rakefile

@@ -1,2 +1,10 @@
 require 'bundler'
 Bundler::GemHelper.install_tasks
+
+require 'spec/rake/spectask'
+
+Spec::Rake::SpecTask.new(:spec) do |t|
+  t.spec_files = Dir.glob('spec/**/*_spec.rb')
+  t.spec_opts << '--format specdoc'
+#  t.rcov = true
+end

data/bin/orientdb_console

@@ -1,6 +1,22 @@
 #!/usr/bin/env jruby
 require File.expand_path(File.dirname(__FILE__) + "/../lib/orientdb")
 
+if ARGV.include?('test:db')
+  GEM_ROOT  = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+  TEMP_DIR  = Dir.pwd + '/tmp'
+
+  TEST_DB_PATH = "#{TEMP_DIR}/databases/db_#{rand(999) + 1}"
+
+  puts ">> GEM_ROOT     : #{GEM_ROOT}"
+  puts ">> TEST_DB PATH : #{TEST_DB_PATH}"
+
+  require 'fileutils'
+  FileUtils.mkdir_p TEST_DB_PATH
+  @db = OrientDB::Database.new("local:#{TEST_DB_PATH}/test").create
+end
+
+include OrientDB
+
 require 'irb'
 ARGV.clear
 IRB.start(__FILE__)

data/lib/orientdb.rb

@@ -6,7 +6,7 @@ $: << File.expand_path('../../jars/', __FILE__)
 require 'java'
 require 'orientdb-client-0.9.23'
 
-class OrientDB
+module OrientDB
 
   def self.const_missing(missing)
     puts "[#{name}:const_missing] #{missing}"
@@ -17,8 +17,8 @@ end
 
 require 'orientdb/ext'
 require 'orientdb/version'
-require 'orientdb/proxy_mixin'
 require 'orientdb/user'
+require 'orientdb/schema'
 require 'orientdb/database'
 require 'orientdb/document'
 require 'orientdb/oclass'

data/lib/orientdb/database.rb

@@ -1,123 +1,104 @@
-class OrientDB::Database
+module OrientDB
 
-  include OrientDB::ProxyMixin
+  Database      = 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
-  end
+  class Database
 
-  def auth(username, password)
-    proxy_object.open username, password
-  end
+    def auth(username, password)
+      open username, password
+    end
 
-  def user
-    User.from_ouser proxy_object.getUser
-  end
+    alias_method :native_query, :query
 
-  def query(sql_query = nil)
-    sql_query = prepare_sql_query sql_query
-    proxy_object.query(sql_query).map { |x| OrientDB::Document.new x }
-  end
+    def query(sql_query = nil)
+      sql_query = prepare_sql_query sql_query
+      native_query sql_query
+    end
 
-  alias :find :query
+    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 first(sql_query = nil)
+      sql_query = prepare_sql_query sql_query
+      query(sql_query).setLimit(1).map { |x| 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"
+    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
-  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('%')
+    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
-      "#{field} #{cmp} #{value}"
+      "SELECT #{columns} FROM #{klass_name} WHERE #{fields.join(' AND ')}#{order_sql}"
     end
-    "SELECT #{columns} FROM #{klass_name} WHERE #{fields.join(' AND ')}#{order_sql}"
-  end
 
-  def schema
-    proxy_object.getMetadata.getSchema
-  end
+    def schema
+      metadata.schema
+    end
 
-  def storage
-    proxy_object.storage
-  end
+    def get_class(klass_name)
+      schema.get_class klass_name.to_s
+    end
 
-  def create_class(name, fields = {})
-    OrientDB::OClass.create self, name, fields
-  end
+    def create_class(klass_name, fields = {})
+      OrientDB::OClass.create self, klass_name.to_s, fields
+    end
 
-  def each_in_class(klass_name)
-    proxy_object.browseClass(klass_name.to_s).each do |record|
-      yield OrientDB::Document.new(record)
+    def get_or_create_class(klass_name)
+      get_class(klass_name) || create_class(klass_name)
     end
-  end
 
-  def all_in_class(klass_name)
-    proxy_object.browseClass(klass_name.to_s).map { |x| OrientDB::Document.new x }
-  end
+    alias :each_in_class :browseClass
 
-  def each_in_custer(cluster_name)
-    proxy_object.browseCluster(cluster_name.to_s).each do |record|
-      yield OrientDB::Document.new(record)
+    def all_in_class(klass_name)
+      browse_class(klass_name.to_s).map
     end
-  end
 
-  def all_in_custer(cluster_name)
-    proxy_object.browseCluster(cluster_name.to_s).map { |x| OrientDB::Document.new x }
-  end
+    alias :each_in_cluster :browseCluster
 
-  def get_class(klass_name)
-    klass = schema.get_class klass_name
-    klass && OrientDB::OClass.new(klass)
-  end
+    def all_in_cluster(cluster_name)
+      browse_cluster(cluster_name.to_s).map
+    end
 
-  def get_or_create_class(klass_name)
-    get_class(klass_name) || OrientDB::OClass.create(klass_name)
-  end
+    class << self
 
-  class << self
+      def create(database_url)
+        obj = new(database_url)
+        obj.create
+        obj
+      end
 
-    def create(database_url)
-      obj = new(database_url)
-      obj.create
-      obj
-    end
+      def connect(database_url, username, password)
+        obj = new(database_url)
+        obj.auth(username, password)
+        obj
+      end
 
-    def connect(database_url, username, password)
-      obj = new(database_url)
-      obj.auth(username, password)
-      obj
     end
-
   end
 
+
 end

data/lib/orientdb/database_pool.rb

@@ -1,18 +1,11 @@
-class OrientDB::DatabasePool
+module OrientDB
 
-  include OrientDB::ProxyMixin
+  DatabasePool = com.orientechnologies.orient.core.db.document.ODatabaseDocumentPool
 
-  KLASS = com.orientechnologies.orient.core.db.document.ODatabaseDocumentPool
+  class DatabasePool
 
-  def initialize(database_url, username, password)
-    @proxy_object = KLASS.global.acquire database_url, username, password
-  end
-
-  class << self
-
-    def connect(database_url, username, password)
-      obj = new database_url, username, password
-      obj
+    def initialize(database_url, username, password)
+      self.class.global.acquire database_url, username, password
     end
 
   end

data/lib/orientdb/document.rb

@@ -1,76 +1,61 @@
-class OrientDB::Document
+module OrientDB
 
-  include OrientDB::ProxyMixin
+  Document = com.orientechnologies.orient.core.record.impl.ODocument
 
-  KLASS = com.orientechnologies.orient.core.record.impl.ODocument
+  class Document
 
-  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
+    def values
+      field_names.map { |field_name| [field_name, self[field_name]] }
     end
-  end
 
-  def values
-    proxy_object.fieldNames.map{|field_name| [field_name, self[field_name]] }
-  end
+    alias :db :database
 
-  def db
-    proxy_object.getDatabase
-  end
-
-#  def save
-#    db.save proxy_object
-#  end
+    def [](field_name)
+      field field_name.to_s
+    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)
+      field field_name.to_s, 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 contains_field(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 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
+    def inspect
+      props = values.map { |k, v| "#{k}:#{v}" }.join(' ')
+      %{#<OrientDB::Document:#{get_class_name}#{props.empty? ? '' : ' ' + props}>}
     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
 
-  alias :to_s :inspect
+      alias_method :native_new, :new
 
-  class << self
+      def new(db, klass_name, fields = {})
+        obj = native_new db, klass_name
+        fields.each do |name, value|
+          obj.field name, value
+        end
+        obj
+      end
+
+      def create(db, klass_name, fields = {})
+        obj = new db, klass_name, fields
+        obj.save
+        obj
+      end
 
-    def create(db, klass_name, fields = {})
-      obj = new(db, klass_name, fields)
-      obj.save
-      obj
     end
 
   end

data/lib/orientdb/oclass.rb

@@ -1,13 +1,13 @@
-class OrientDB::OClass
+module OrientDB
 
-  include OrientDB::ProxyMixin
 
-  KLASS         = com.orientechnologies.orient.core.metadata.schema.OClass
+  OClass        = com.orientechnologies.orient.core.metadata.schema.OClass
 
-  SchemaType    = com.orientechnologies.orient.core.metadata.schema.OType
+#  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",
@@ -36,110 +36,100 @@ class OrientDB::OClass
     h
   end
 
-  STORAGE_TYPES = %w{ LOGICAL MEMORY PHYSICAL }.inject({}) do |h, s|
-    h[s.downcase.to_sym] = ClusterType.const_get s
-    h
-  end
+  STORAGE_TYPES = %w{ LOGICAL MEMORY PHYSICAL }.inject({}) { |h, s| h[s.downcase.to_sym] = ClusterType.const_get s; h }
+  INDEX_TYPES   = %w{ FULLTEXT NOT_UNIQUE UNIQUE }.inject({}) { |h, s| h[s.downcase.to_sym] = IndexType.const_get s; h }
 
-  INDEX_TYPES   = %w{ FULLTEXT NOT_UNIQUE UNIQUE }.inject({}) do |h, s|
-    h[s.downcase.to_sym] = IndexType.const_get s
-    h
-  end
+  class OClass
 
-  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 exists_property(property_name)
+        puts "We already have that property name [#{property_name}]"
+        return false
+      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
+      case type
+        when Symbol
+          create_property property_name, FIELD_TYPES[type]
+        when OrientDB::OClass
+          create_property property_name, FIELD_TYPES[:link], type
+        when Array
+          type[0] = FIELD_TYPES[type[0]] if type[0].is_a?(Symbol)
+          create_property property_name, *type
+        when Hash
+          raise "Missing property type for [#{property_name}]" unless type[:type]
+          if type[:type].is_a?(OrientDB::OClass)
+            prop = create_property property_name, FIELD_TYPES[:link], type[:type]
+          else
+            prop = create_property property_name, FIELD_TYPES[type[:type]]
+          end
+          prop.set_min type[:min].to_s unless type[:min].nil?
+          prop.set_max type[:max].to_s unless type[:max].nil?
+          prop.set_mandatory !!type[:mandatory] unless type[:mandatory].nil?
+          prop.set_not_null 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
 
-    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} ]"
+    def [](property_name)
+      property_name = property_name.to_s
+      exists_property(property_name) ? get_property(property_name) : nil
     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 db
+      document.database
+    end
 
-  def schema
-    db.getMetadata.getSchema
-  end
+    def schema
+      db.metadata.schema
+    end
 
-  def create_document(fields = {})
-    OrientDB::Document.create db, name, fields
-  end
-  alias :ceate :create_document
+    def inspect
+      props = properties.map { |x| "#{x.name}:#{x.type.to_s.downcase}" }.join(' ')
+      %{#<OrientDB::OClass:#{name}#{props.empty? ? '' : ' ' + props}>}
+    end
 
-  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
 
-  alias :to_s :inspect
 
-  class << self
+    class << self
 
-    def create(db, name, fields = {})
-      add_cluster = fields.delete :add_cluster
-      add_cluster = true if add_cluster.nil?
+      def create(db, name, fields = {})
+        name        = name.to_s
+        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
+        if add_cluster
+          cluster = db.storage.add_cluster name.downcase, STORAGE_TYPES[:physical]
+          klass   = db.schema.create_class name, cluster
+        else
+          klass = db.schema.create_class name
+        end
 
-      obj         = new klass
+        super_klass = fields.delete :super
+        super_klass = db.get_class(super_klass.to_s) unless super_klass.is_a?(OrientDB::OClass)
+        klass.set_super_class super_klass if super_klass
+        db.schema.save
 
-      unless fields.empty?
-        fields.each do |property_name, type|
-          obj.add property_name, type
+        unless fields.empty?
+          fields.each do |property_name, type|
+            klass.add property_name, type
+          end
+          db.schema.save
         end
-        db.schema.save
+
+        klass
       end
 
-      obj
     end
 
   end
 
+
 end

data/lib/orientdb/schema.rb

@@ -0,0 +1,6 @@
+module OrientDB
+
+  Schema        = com.orientechnologies.orient.core.metadata.schema.OSchema
+  SchemaType    = com.orientechnologies.orient.core.metadata.schema.OType
+
+end

data/lib/orientdb/user.rb

@@ -1,16 +1,5 @@
-class OrientDB::User
+module OrientDB
 
-  include OrientDB::ProxyMixin
-
-  KLASS = com.orientechnologies.orient.core.metadata.security.OUser
-
-  def initialize
-    @proxy_object = KLASS.new
-  end
-
-  def self.from_ouser(ouser)
-    obj = new
-    obj.instance_variable_set "@proxy_object", ouser
-  end
+  User = com.orientechnologies.orient.core.metadata.security.OUser
 
 end

data/lib/orientdb/version.rb

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

data/orientdb.gemspec

@@ -17,6 +17,7 @@ Gem::Specification.new do |s|
   s.add_dependency "hashie"
   s.add_development_dependency "bundler", ">= 1.0.0"
   s.add_development_dependency "awesome_print"
+  s.add_development_dependency "rspec", ">= 2.1"
 
   s.files        = `git ls-files`.split("\n")
   s.test_files   = Dir["test/test*.rb"]

data/spec/orientdb_spec.rb

@@ -0,0 +1,31 @@
+require File.expand_path("../spec_helper", __FILE__)
+
+describe "OrientDB" do
+
+  before :all do
+    @db             = OrientDB::Database.new("local:#{TEST_DB_PATH}/test").create
+    @person_class   = @db.create_class :person, :name => :string
+    @customer_class = @db.create_class :customer, :super => @person_class
+    @product_class  = @db.create_class :product, :sku => :string, :title => :string, :price => :float
+    @line_class     = @db.create_class :invoice_line, :product => @product_class, :quantity => :int, :price => :float
+    @invoice_class  = @db.create_class :invoice,
+                                       :number   => {:type => :int, :mandatory => true, :index => true},
+                                       :customer => {:type => @customer_class, :not_null => true},
+                                       :sold_on  => :date,
+                                       :total    => {:type => :float, :min => 0.01, :max => 100_000.0},
+                                       :lines    => :embedded_list
+  end
+
+  after :all do
+    @db.close
+#    puts "Removing files in #{TEMP_DIR}/databases/*"
+#    FileUtils.rm_rf "#{TEMP_DIR}/databases/test"
+  end
+
+  it "should create a valid database" do
+    puts "Creating db #{@db_path}..."
+    @db.should be_a_kind_of OrientDB::Database
+    @db.name.should == "test"
+  end
+
+end

data/spec/spec.opts

@@ -0,0 +1,7 @@
+--colour
+--format
+nested
+--loadby
+mtime
+--reverse
+--backtrace

data/spec/spec_helper.rb

@@ -0,0 +1,25 @@
+unless defined?(SPEC_HELPER_LOADED)
+
+  GEM_ROOT  = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+  LIB_ROOT  = GEM_ROOT + '/lib'
+  SPEC_ROOT = GEM_ROOT + '/spec'
+  TEMP_DIR  = SPEC_ROOT + '/tmp'
+
+  TEST_DB_PATH = "#{TEMP_DIR}/databases/db_#{rand(999) + 1}"
+
+  puts ">> GEM_ROOT     : #{GEM_ROOT}"
+  puts ">> TEST_DB PATH : #{TEST_DB_PATH}"
+
+  $LOAD_PATH.unshift(LIB_ROOT) unless $LOAD_PATH.include?(LIB_ROOT)
+
+  require 'orientdb'
+  require 'spec'
+  require 'fileutils'
+
+  FileUtils.mkdir_p TEST_DB_PATH
+
+  Spec::Runner.configure do |config|
+  end
+
+  SPEC_HELPER_LOADED = true
+end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
     - 0
     - 0
-    - 2
-  version: 0.0.2
+    - 4
+  version: 0.0.4
 platform: jruby
 authors: 
   - Adrian Madrid
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-11-03 00:00:00 -06:00
+date: 2010-11-12 00:00:00 -07:00
 default_executable: 
 dependencies: 
   - !ruby/object:Gem::Dependency 
@@ -55,6 +55,19 @@ dependencies:
             version: "0"
     type: :development
     version_requirements: *id003
+  - !ruby/object:Gem::Dependency 
+    name: rspec
+    prerelease: false
+    requirement: &id004 !ruby/object:Gem::Requirement 
+      requirements: 
+        - - ">="
+          - !ruby/object:Gem::Version 
+            segments: 
+              - 2
+              - 1
+            version: "2.1"
+    type: :development
+    version_requirements: *id004
 description: JRuby wrapper for OrientDB
 email: 
   - aemadrid@gmail.com
@@ -84,10 +97,13 @@ files:
   - lib/orientdb/document.rb
   - lib/orientdb/ext.rb
   - lib/orientdb/oclass.rb
-  - lib/orientdb/proxy_mixin.rb
+  - lib/orientdb/schema.rb
   - lib/orientdb/user.rb
   - lib/orientdb/version.rb
   - orientdb.gemspec
+  - spec/orientdb_spec.rb
+  - spec/spec.opts
+  - spec/spec_helper.rb
 has_rdoc: true
 homepage: http://rubygems.org/gems/orientdb
 licenses: []

data/lib/orientdb/proxy_mixin.rb

@@ -1,65 +0,0 @@
-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