orientdb4r 0.1.1

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+coverage
+InstalledFiles
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+
+# YARD artifacts
+.yardoc
+_yardoc
+doc/

data/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

data/README.rdoc

@@ -0,0 +1,65 @@
+= orientdb4r - Ruby binding for Orient DB
+
+A Ruby client for the NoSQL Graph/Document database Orient DB (http://orientdb.org).
+
+== USAGE
+
+  require 'orientdb4r'
+
+  CLASS = 'myclass'
+
+  client = Orientdb4r.client  # equivalent for :host => 'localhost', :port => 2480, :ssl => false
+
+  client.connect :database => 'temp', :user => 'admin', :password => 'admin'
+
+
+  client.create_class(CLASS) do |c|
+    c.property 'prop1', :integer
+    c.property 'prop2', :string, :mandatory => true, :notnull => :true, :min => 1, :max => 99
+  end
+
+
+  1.upto(10) { |i| client.command "INSERT INTO #{CLASS} (prop1, prop2) VALUES (#{i}, 'string#{i}')" }
+
+
+  puts client.query "SELECT FROM #{CLASS}"
+  > {"@type"=>"d", "@rid"=>"#6:0", "@version"=>0, "@class"=>"testing", "prop1"=>1, "prop2"=>"string1"}
+  > {"@type"=>"d", "@rid"=>"#6:1", "@version"=>0, "@class"=>"testing", "prop1"=>2, "prop2"=>"string2"}
+  > {"@type"=>"d", "@rid"=>"#6:2", "@version"=>0, "@class"=>"testing", "prop1"=>3, "prop2"=>"string3"}
+  > {"@type"=>"d", "@rid"=>"#6:3", "@version"=>0, "@class"=>"testing", "prop1"=>4, "prop2"=>"string4"}
+  > {"@type"=>"d", "@rid"=>"#6:4", "@version"=>0, "@class"=>"testing", "prop1"=>5, "prop2"=>"string5"}
+  > {"@type"=>"d", "@rid"=>"#6:5", "@version"=>0, "@class"=>"testing", "prop1"=>6, "prop2"=>"string6"}
+  > {"@type"=>"d", "@rid"=>"#6:6", "@version"=>0, "@class"=>"testing", "prop1"=>7, "prop2"=>"string7"}
+  > {"@type"=>"d", "@rid"=>"#6:7", "@version"=>0, "@class"=>"testing", "prop1"=>8, "prop2"=>"string8"}
+  > {"@type"=>"d", "@rid"=>"#6:8", "@version"=>0, "@class"=>"testing", "prop1"=>9, "prop2"=>"string9"}
+  > {"@type"=>"d", "@rid"=>"#6:9", "@version"=>0, "@class"=>"testing", "prop1"=>10, "prop2"=>"string10"}
+  puts client.query "SELECT count(*) FROM #{CLASS}"
+  > {"@type"=>"d", "@version"=>0, "count"=>10, "@fieldTypes"=>"count=l"}
+  puts client.query "SELECT max(prop1) FROM #{CLASS}"
+  > {"@type"=>"d", "@version"=>0, "max"=>10}
+  puts client.query "SELECT FROM #{CLASS} WHERE prop2 LIKE '%10'"
+  > {"@type"=>"d", "@rid"=>"#6:9", "@version"=>0, "@class"=>"testing", "prop1"=>10, "prop2"=>"string10"}
+
+
+  client.drop_class CLASS
+  client.disconnect
+
+== FEATURES/PROBLEMS
+
+* Supports only REST API right now
+
+== REQUIREMENTS
+
+Tested on
+* Ruby 1.9.3
+* OrientDB 1.0.0
+
+== AUTHOR
+
+* vaclav.sykora@gmail.com
+* https://plus.google.com/115674031373998885915
+
+== LICENSE
+
+* Apache License, Version 2.0, http://www.apache.org/licenses/
+* see LICENSE file for more details...

data/Rakefile

@@ -0,0 +1,8 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+end
+
+desc "Run tests"
+task :default => :test

data/lib/orientdb4r/client.rb

@@ -0,0 +1,130 @@
+module Orientdb4r
+
+  class Client
+    include Utils
+
+    ###
+    # Constructor.
+    def initialize
+      @connected = false
+    end
+
+    ###
+    # Connects client to the server.
+    def connect options
+      raise NotImplementedError, 'this should be overridden by concrete client'
+    end
+
+    ###
+    # Disconnects client from the server.
+    def disconnect
+      raise NotImplementedError, 'this should be overridden by concrete client'
+    end
+
+    ###
+    # Gets flag whenever the client is connected or not.
+    def connected?
+      @connected
+    end
+
+    ###
+    # Creates a new database.
+    # You can provide an additional authentication to the server with 'database.create' resource
+    # or the current one will be used.
+    def create_database(options)
+      raise NotImplementedError, 'this should be overridden by concrete client'
+    end
+
+    ###
+    # Gets informations about requested class.
+    def get_class(name)
+      raise NotImplementedError, 'this should be overridden by concrete client'
+    end
+
+    ###
+    # Executes a query against the database.
+    def query(sql)
+      raise NotImplementedError, 'this should be overridden by concrete client'
+    end
+
+    ###
+    # Executes a command against the database.
+    def command(sql, options={})
+      raise NotImplementedError, 'this should be overridden by concrete client'
+    end
+
+    ###
+    # Creates a new class in the schema.
+    def create_class(name, options={})
+      raise ArgumentError, "class name is blank" if blank?(name)
+      opt_pattern = { :extends => :optional , :cluster => :optional, :force => false }
+      verify_options(options, opt_pattern)
+
+      sql = "CREATE CLASS #{name}"
+      sql << " EXTENDS #{options[:extends]}" if options.include? :extends
+      sql << " CLUSTER #{options[:cluster]}" if options.include? :cluster
+
+      drop_class name if options[:force]
+
+      command sql, :http_code_500 => 'failed to create class (exists already, bad supperclass?)'
+
+      if block_given?
+        proxy = Orientdb4r::Utils::Proxy.new(self, name)
+        def proxy.property(property, type, options={})
+          self.target.send :create_property, self.context, property, type, options
+        end
+        yield proxy
+      end
+    end
+
+    ###
+    # Removes a class from the schema.
+    def drop_class(name)
+      # TODO in :mode=>:strict verify if the class is no a super class
+      raise ArgumentError, "class name is blank" if blank?(name)
+      command "DROP CLASS #{name}"
+    end
+
+    ###
+    # Creates a new property in the schema.
+    # You need to create the class before.
+    def create_property(clazz, property, type, options={})
+      raise ArgumentError, "class name is blank" if blank?(clazz)
+      raise ArgumentError, "property name is blank" if blank?(property)
+      opt_pattern = {
+        :mandatory => :optional , :notnull => :optional, :min => :optional, :max => :optional,
+        :regexp =>  :optional, :custom => :optional
+      }
+      verify_options(options, opt_pattern)
+
+      cmd = "CREATE PROPERTY #{clazz}.#{property} #{type.to_s}"
+      command cmd, :http_code_500 => 'failed to create property (exists already?)'
+
+      unless options.empty?
+        options.each do |k,v|
+          command "ALTER PROPERTY #{clazz}.#{property} #{k.to_s.upcase} #{v}"
+        end
+      end
+    end
+
+    protected
+
+      ###
+      # Asserts if the client is connected and raises an error if not.
+      def assert_connected
+        raise OrientdbError, "not connected" unless @connected
+      end
+
+      ###
+      # Around advice to meassure and print the method time.
+      def time_around(&block)
+        start = Time.now
+        rslt = block.call
+        Orientdb4r::DEFAULT_LOGGER.debug \
+          "#{aop_context[:class].name}##{aop_context[:method]}: elapsed time = #{Time.now - start} [s]"
+        rslt
+      end
+
+  end
+
+end

data/lib/orientdb4r/document.rb

@@ -0,0 +1,6 @@
+module Orientdb4r
+
+  class Document
+  end
+
+end

data/lib/orientdb4r/rest/client.rb

@@ -0,0 +1,165 @@
+module Orientdb4r
+
+  class RestClient < Client
+    include Aop2
+
+    before [:query, :command, :get_class], :assert_connected
+    around [:query, :command], :time_around
+
+    attr_reader :host, :port, :ssl, :user, :password
+
+
+    def initialize(options) #:nodoc:
+      super()
+      options_pattern = { :host => 'localhost', :port => 2480, :ssl => false }
+      verify_and_sanitize_options(options, options_pattern)
+      @host = options[:host]
+      @port = options[:port]
+      @ssl = options[:ssl]
+    end
+
+
+    def connect(options) #:nodoc:
+      options_pattern = { :database => :mandatory, :user => :mandatory, :password => :mandatory }
+      verify_and_sanitize_options(options, options_pattern)
+      @database = options[:database]
+      @user = options[:user]
+      @password = options[:password]
+
+      @resource = ::RestClient::Resource.new(url, :user => user, :password => password)
+
+      begin
+        response = @resource["connect/#{@database}"].get
+        rslt = process_response(response, :mode => :strict)
+        @connected = true
+      rescue ::RestClient::Exception => e
+        @connected = false
+        raise process_error e, :http_code_401 => 'connect failed (bad credentials?)'
+      rescue Exception => e
+        Orientdb4r::DEFAULT_LOGGER.error e.message
+        Orientdb4r::DEFAULT_LOGGER.error e.backtrace.inspect
+        @connected = false
+        raise e
+      end
+      rslt
+    end
+
+
+    def disconnect #:nodoc:
+      return unless @connected
+
+      begin
+        response = @resource['disconnect'].get
+      rescue ::RestClient::Unauthorized
+        Orientdb4r::DEFAULT_LOGGER.warn '401 Unauthorized - bug in disconnect?'
+      ensure
+        @connected = false
+      end
+    end
+
+
+    def create_database(options) #:nodoc:
+      options_pattern = {
+        :database => :mandatory, :type => 'memory',
+        :user => :optional, :password => :optional, :ssl => false
+      }
+      verify_and_sanitize_options(options, options_pattern)
+
+      u = options.include?(:user) ? options[:user] : user
+      p = options.include?(:password) ? options[:password] : password
+      resource = ::RestClient::Resource.new(url, :user => u, :password => p)
+      begin
+        response = resource["database/#{options[:database]}/#{options[:type]}"].post ''
+      rescue ::RestClient::Exception => e
+        raise process_error e, \
+          :http_code_403 => 'forbidden operation (insufficient rights?)', \
+          :http_code_500 => 'failed to create database (exists already?)'
+
+      end
+      process_response(response)
+    end
+
+
+    def get_class(name) #:nodoc:
+      raise ArgumentError, "class name is blank" if blank?(name)
+
+      # there seems to be a bug in REST API, only data are returned
+      #response = @resource["class/#{@database}/#{name}"].get
+      #rslt = process_response(response)
+
+      # workaround - use metadate delivered by 'connect'
+      response = @resource["connect/#{@database}"].get
+      connect_info = process_response(response, :mode => :strict)
+      clazz = connect_info['classes'].select { |i| i['name'] == name }
+      raise ArgumentError, "class not found, name=#{name}" if 1 != clazz.size
+      clazz[0]
+    end
+
+    def query(sql) #:nodoc:
+      response = @resource["query/#{@database}/sql/#{URI.escape(sql)}"].get
+      rslt = process_response(response)
+      rslt['result']
+    end
+
+    def command(sql, options={}) #:nodoc:
+      begin
+#puts "REQ #{sql}"
+        response = @resource["command/#{@database}/sql/#{URI.escape(sql)}"].post ''
+        rslt = process_response(response)
+        rslt
+#puts "RESP #{response.code}"
+      rescue Exception => e
+        raise process_error e, options.select { |k,v| k.to_s.start_with? 'http_code' }
+      end
+    end
+
+    private
+
+      ###
+      # Gets URL of the REST interface.
+      def url
+        "http#{'s' if ssl}://#{host}:#{port}"
+      end
+
+      ###
+      # ==== options
+      # * strict
+      # * warning
+      def process_response(response, options={})
+        raise ArgumentError, 'response is null' if response.nil?
+
+        # raise problem if other code than 200
+        if options[:mode] == :strict and 200 != response.code
+          raise OrientdbError, "unexpeted return code, code=#{response.code}"
+        end
+        # log warning if other than 200 and raise problem if other code than 'Successful 2xx'
+        if options[:mode] == :warning
+          if 200 != response.code and 2 == (response.code / 100)
+            Orientdb4r::DEFAULT_LOGGER.warn "expected return code 200, but received #{response.code}"
+          elseif 200 != response.code
+            raise OrientdbError, "unexpeted return code, code=#{response.code}"
+          end
+        end
+
+        content_type = response.headers[:content_type]
+        content_type ||= 'text/plain'
+
+        rslt = case
+          when content_type.start_with?('text/plain')
+            response.body
+          when content_type.start_with?('application/json')
+            ::JSON.parse(response.body)
+          end
+
+        rslt
+      end
+
+      def process_error(error, messages={})
+        code = "http_code_#{error.http_code}".to_sym
+        msg = messages.include?(code) ? "#{messages[code]}, cause = " : ''
+        OrientdbError.new "#{msg}#{error.to_s}"
+      end
+
+  end
+
+end

data/lib/orientdb4r/utils.rb

@@ -0,0 +1,173 @@
+module Orientdb4r
+
+  module Utils
+
+    def verify_options(options, pattern)
+      # unknown key?
+      options.keys.each do |k|
+        raise ArgumentError, "unknow option: #{k}" unless pattern.keys.include? k
+      end
+      # missing mandatory option?
+      pattern.each do |k,v|
+        raise ArgumentError, "missing mandatory option: #{k}" if v == :mandatory and !options.keys.include? k
+      end
+      options
+    end
+
+    def verify_and_sanitize_options(options, pattern)
+      verify_options(options, pattern)
+
+      # set default values if missing in options
+      pattern.each do |k,v|
+        options[k] = v if !v.nil? and !options.keys.include? k
+      end
+      options
+    end
+
+
+    ###
+    # Checks if a given string is either 'nil' or empty string.
+    def blank?(str)
+      str.nil? or str.strip.empty?
+    end
+
+    ###
+    # Generates a random string with given length.
+    def random_string(len=8)
+      (0...len).map{65.+(rand(25)).chr}.join
+    end
+
+
+    class Proxy
+
+      attr_reader :target, :context
+
+      def initialize(target, context)
+        @target = target
+        @context = context
+      end
+
+      def proxy(&block)
+        block.call
+      end
+
+    end
+
+  end
+
+
+  # TODO extend it to work with already defined methods ('before :foo, :baz' after method definition)
+  module Aop2
+
+    def self.included(base)
+      base.extend ClassMethods2
+      base.init_aop_extension
+    end
+
+    def aop_context
+      Thread.current[:aop2_context]
+    end
+    def aop_context=(ctx={})
+      Thread.current[:aop2_context] = ctx
+    end
+
+    module ClassMethods2
+
+      def init_aop_extension
+        @hooks = {}
+        [:before, :after, :around].each { |where| @hooks[where] = Hash.new { |hash, key| hash[key] = [] }}
+        # will be like this:
+        # {:before=>{:disconnect=>[:assert_connected], :query=>[:assert_connected], :command=>[:assert_connected]}, :after=>{}, :around=>{}}
+        class << self
+          attr_reader :hooks
+        end
+        @@redefining = false # flag whether the process of method redefining is running
+      end
+      def method_added(method)
+        unless @@redefining # avoid recursion
+          redefine_method(method) if is_hooked?(method)
+        end
+      end
+
+      #----------------------------------------------------------------- Helpers
+
+      def is_hooked?(method)
+        # look into array of keys (method names) in 2nd level hashs (see above)
+        hooks.values.map(&:keys).flatten.uniq.include? method
+      end
+
+
+
+      def before(original_method, *hooks)
+        add_hook(:before, original_method, *hooks)
+      end
+      def after(original_method, *hooks)
+        add_hook(:after, original_method, *hooks)
+      end
+      def around(original_method, *hooks)
+        add_hook(:around, original_method, *hooks)
+      end
+
+
+      def add_hook(type, original_method, *hooks) #!!
+        Array(original_method).each do |method|
+          store_hook(type, method, *hooks)
+        end
+      end
+      def store_hook(type, method_name, *hook_methods) #!!
+        hooks[type.to_sym][method_name.to_sym] += hook_methods.flatten.map(&:to_sym)
+      end
+
+      def redefine_method(orig_method)
+        @@redefining = true
+
+        arity = instance_method(orig_method.to_sym).arity
+        params = ''
+        fixed_cnt = arity.abs
+        fixed_cnt -= 1 if arity < 0
+        # build up a list of params
+        1.upto(fixed_cnt).each {|x| params << "p#{x},"}
+        params << "*argv" if arity < 0
+        params.gsub!(/,$/, '') # remove last ','
+
+        alias_method "#{orig_method}_aop2_orig".to_sym, orig_method.to_sym
+
+        class_eval <<-FILTER,__FILE__,__LINE__ + 1
+          def #{orig_method}(#{params})
+            self.aop_context = { :method => '#{orig_method}', :class => self.class }
+            begin
+              self.class.invoke_hooks(self, :before, :#{orig_method})
+              rslt = self.class.invoke_arround_hooks(self, :#{orig_method}, self.class.hooks[:around][:#{orig_method}].clone) {
+                #{orig_method}_aop2_orig(#{params})
+              }
+              self.class.invoke_hooks(self, :after, :#{orig_method})
+#            rescue Exception => e
+#              # TODO use logging
+#              $stderr.puts '' << e.class.name << ': ' << e.message
+#              $stderr.puts e.backtrace.inspect
+#              raise e
+            ensure
+              self.aop_context = nil
+            end
+            rslt
+          end
+        FILTER
+
+        @@redefining = false
+      end
+
+      def invoke_hooks(obj, hook_type, method_name)
+        hooks[hook_type][method_name.to_sym].each { |hook| obj.send hook }
+      end
+      def invoke_arround_hooks(obj, method_name, hooks, &block)
+        hook = hooks.slice! 0
+        return block.call if hook.nil? # call original method if no more hook
+
+        # invoke the hook with lambda containing recursion
+        obj.send(hook.to_sym) { invoke_arround_hooks(obj, method_name, hooks, &block); }
+      end
+
+    end # ClassMethods2
+  end # Aop2
+
+end

data/lib/orientdb4r/version.rb

@@ -0,0 +1,12 @@
+module Orientdb4r
+
+  # Version history.
+  VERSION_HISTORY = [
+    ['0.1.1', '2012-06-08', 'First working version (including unit tests)'],
+    ['0.1.0', '2012-06-02', 'Initial version on Ruby-1.9.3p194 and OrientDB-1.0.0']
+  ]
+
+  # Current version.
+  VERSION = VERSION_HISTORY[0][0]
+
+end

data/lib/orientdb4r.rb

@@ -0,0 +1,46 @@
+require 'json'
+require 'rest_client'
+require 'logger'
+require 'orientdb4r/version'
+
+
+###
+# This module represents the entry point for using the Ruby OrientDB client.
+module Orientdb4r
+
+  autoload :Utils,        'orientdb4r/utils'
+  autoload :Client,       'orientdb4r/client'
+  autoload :RestClient,   'orientdb4r/rest/client'
+
+
+  # Configuration of logging.
+  DEFAULT_LOGGER = Logger.new(STDOUT)
+  DEFAULT_LOGGER.level = Logger::INFO
+
+
+  class << self
+
+    ###
+    # Gets a new database client or an existing for the current thread.
+    def client options={}
+      Thread.current[:orientdb_client] ||= RestClient.new options
+    end
+
+    ###
+    # All calls to REST API will use the proxy specified here.
+    def rest_proxy(url)
+      RestClient.proxy = url
+    end
+
+  end
+
+
+  ###
+  # Basic error raised to signal an unexpected situation.
+  class OrientdbError < StandardError; end
+
+end
+
+
+Orientdb4r::DEFAULT_LOGGER.info \
+  "Orientdb4r #{Orientdb4r::VERSION}, running on Ruby #{RUBY_VERSION} (#{RUBY_RELEASE_DATE}) [#{RUBY_PLATFORM}]"

data/orientdb4r.gemspec

@@ -0,0 +1,35 @@
+# -*- encoding: utf-8 -*-
+
+$:.unshift File.expand_path('../lib', __FILE__)
+require 'orientdb4r/version'
+
+Gem::Specification.new do |s|
+
+  s.name = %q{orientdb4r}
+  s.version = Orientdb4r::VERSION
+
+  s.required_rubygems_version = Gem::Requirement.new('> 1.3.1') if s.respond_to? :required_rubygems_version=
+  s.authors = ['Vaclav Sykora']
+  s.date = Orientdb4r::VERSION_HISTORY[0][1]
+  s.description = %q{Orientdb4r provides a simple interface on top of OrientDB's RESTful HTTP API.}
+  s.email = %q{vaclav.sykora@gmail.com}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.extra_rdoc_files = [
+    "LICENSE",
+    "README.rdoc"
+  ]
+  s.homepage = %q{http://github.com/veny/orientdb4r}
+  s.rdoc_options = ['--charset=UTF-8']
+  s.require_paths = ['lib']
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Ruby binding for Orient DB.}
+
+  s.add_dependency(%q<rest-client>, ["~> 1.6.7"])
+#  s.add_development_dependency(%q<json>, ["~> 1.5.1"])
+
+end

data/test/test_database.rb

@@ -0,0 +1,66 @@
+require 'test/unit'
+require 'orientdb4r'
+
+###
+# This class tests following operations:
+# * CONNECT
+# * DISCONNECT
+# * CREATE DATABASE
+class TestDatabase < Test::Unit::TestCase
+
+  Orientdb4r::DEFAULT_LOGGER.level = Logger::DEBUG
+
+  def setup
+    @client = Orientdb4r.client
+  end
+
+  ###
+  # CONNECT
+  def test_connect
+    rslt = @client.connect :database => 'temp', :user => 'admin', :password => 'admin'
+    assert_instance_of Hash, rslt
+    assert rslt.size > 0
+    assert rslt.include? 'classes'
+
+    # bad DB name
+    assert_raise Orientdb4r::OrientdbError do
+      @client.connect :database => 'unknown_db', :user => 'admin', :password => 'admin'
+    end
+    # bad credentials
+    assert_raise Orientdb4r::OrientdbError do
+      @client.connect :database => 'temp', :user => 'admin1', :password => 'admin'
+    end
+  end
+
+
+  ###
+  # DISCONNECT
+  def test_disconnect
+    @client.disconnect
+    assert !@client.connected?
+    # unable to query after disconnect
+    assert_raise Orientdb4r::OrientdbError do @client.query 'SELECT FROM OUser'; end
+  end
+
+
+  ###
+  # CREATE DATABASE
+  # Temporary disabled bacause of unknown way how to drop a new created datatabse.
+  def xtest_create_database
+    @client.create_database :database => 'UniT', :user => 'root', :password => 'root'
+    # creating an existing DB
+    assert_raise Orientdb4r::OrientdbError do
+      @client.create_database :database => 'UniT', :user => 'root', :password => 'root'
+    end
+    # insufficient rights
+    assert_raise Orientdb4r::OrientdbError do
+      @client.create_database :database => 'UniT1', :user => 'admin', :password => 'admin'
+    end
+
+    # By convention 3 users are always created by default every time you create a new database.
+    # Default users are: admin, reader, writer
+    @client.connect :database => 'UniT', :user => 'admin', :password => 'admin'
+    #@client.command "DROP DATABASE UniT" : NOT WORKING now
+  end
+
+end

data/test/test_ddo.rb

@@ -0,0 +1,121 @@
+require 'test/unit'
+require 'orientdb4r'
+
+###
+# This class tests Data Definition Operarions.
+class TestDdo < Test::Unit::TestCase
+
+  CLASS = 'testing'
+  DB = 'temp'
+  Orientdb4r::DEFAULT_LOGGER.level = Logger::DEBUG
+
+  def initialize(params)
+    super params
+
+    @client = Orientdb4r.client
+  end
+
+  def setup
+    @client.connect :database => DB, :user => 'admin', :password => 'admin'
+  end
+
+  def teardown
+    # remove the testing class after each test
+    @client.drop_class(CLASS)
+    @client.disconnect
+  end
+
+
+  ###
+  # GET - Class
+  def test_get_class
+    ouser = {}
+    assert_nothing_thrown do ouser = @client.get_class 'OUser'; end
+    assert_equal 'OUser', ouser['name']
+    # class does not exist
+    assert_raise ArgumentError do @client.get_class 'OUserXXX'; end
+  end
+
+
+  ###
+  # CREATE TABLE
+  def test_create_class
+    assert_nothing_thrown do @client.create_class(CLASS); end
+    assert_nothing_thrown do @client.get_class(CLASS); end
+    # already exist
+    assert_raise Orientdb4r::OrientdbError do @client.create_class(CLASS); end
+
+    # create with :force=>true
+    assert_nothing_thrown do @client.create_class(CLASS, :force => true); end
+    assert_nothing_thrown do @client.get_class(CLASS); end
+  end
+
+
+  ###
+  # CREATE TABLE ... EXTENDS
+  def test_create_class_extends
+    assert_nothing_thrown do @client.create_class(CLASS, :extends => 'OUser'); end
+    assert_nothing_thrown do @client.get_class(CLASS); end
+
+    # bad super class
+    assert_raise Orientdb4r::OrientdbError do @client.create_class(CLASS, :extends => 'nonExistingSuperClass'); end
+  end
+
+
+  ###
+  # DROP TABLE
+  def test_drop_table
+    assert_nothing_thrown do @client.drop_class(CLASS); end
+
+    # the class is not visible in class list delivered by connect
+    rslt = @client.connect :database => DB, :user => 'admin', :password => 'admin'
+    assert rslt['classes'].select { |i| i['name'] == CLASS }.empty?
+  end
+
+
+  ###
+  # CREATE PROPERTY
+  def test_create_property
+    @client.create_class(CLASS)
+    assert_nothing_thrown do @client.create_property(CLASS, 'prop1', :integer); end
+    clazz = @client.get_class(CLASS)
+    assert clazz.include? 'properties'
+    assert_instance_of Array, clazz['properties']
+    props = clazz['properties'].select { |i| i['name'] == 'prop1' }
+    assert_equal 1, props.size
+    assert_equal 'INTEGER', props[0]['type']
+
+    # already exist
+    assert_raise Orientdb4r::OrientdbError do @client.create_property(CLASS, 'prop1', :integer); end
+  end
+
+
+  ###
+  # CREATE CLASS + PROPERTY
+  def test_create_class_with_properties
+    assert_nothing_thrown do
+      @client.create_class(CLASS) do |c|
+        c.property 'prop1', :integer
+        c.property 'prop2', :string, :mandatory => true, :notnull => :true, :min => 1, :max => 99
+      end
+    end
+
+    clazz = @client.get_class(CLASS)
+    assert_equal 2, clazz['properties'].size
+
+    prop1 = clazz['properties'].select { |i| i['name'] == 'prop1' }[0]
+    assert_equal 'INTEGER', prop1['type']
+    assert !prop1['mandatory']
+    assert !prop1['notNull']
+    assert prop1['min'].nil?
+    assert prop1['max'].nil?
+
+    prop2 = clazz['properties'].select { |i| i['name'] == 'prop2' }[0]
+    assert_equal 'STRING', prop2['type']
+    assert prop2['mandatory']
+    assert prop2['notNull']
+    assert_equal '1', prop2['min']
+    assert_equal '99',  prop2['max']
+  end
+
+end

data/test/test_dmo.rb

@@ -0,0 +1,53 @@
+require 'test/unit'
+require 'orientdb4r'
+
+###
+# This class tests Data Manipulation Operarions.
+class TestDmo < Test::Unit::TestCase
+  include Orientdb4r::Utils
+
+  CLASS = 'testing'
+  DB = 'temp'
+  Orientdb4r::DEFAULT_LOGGER.level = Logger::DEBUG
+
+
+  def setup
+    @client = Orientdb4r.client
+    @client.connect :database => DB, :user => 'admin', :password => 'admin'
+    @client.create_class(CLASS) do |c|
+      c.property 'prop1', :integer
+      c.property 'prop2', :string, :mandatory => true, :notnull => :true, :min => 1, :max => 99
+    end
+  end
+
+  def teardown
+    # remove the testing class after each test
+    @client.drop_class(CLASS)
+    @client.disconnect
+  end
+
+
+  ###
+  # INSERT INTO
+  def test_insert
+    assert_nothing_thrown do
+      1.upto(10) do |i|
+        @client.command "INSERT INTO #{CLASS} (prop1, prop2) VALUES (#{i}, '#{random_string}')"
+      end
+    end
+
+    assert_equal 10, @client.query("SELECT count(*) FROM #{CLASS}")[0]['count'].to_i
+  end
+
+
+  ###
+  # SELECT
+  def test_query
+    1.upto(10) do |i|
+      @client.command "INSERT INTO #{CLASS} (prop1, prop2) VALUES (#{i}, 'string#{i}')"
+    end
+
+    puts @client.query("SELECT FROM #{CLASS}")
+  end
+
+end

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification
+name: orientdb4r
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+  prerelease: 
+platform: ruby
+authors:
+- Vaclav Sykora
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-06-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.7
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.7
+description: Orientdb4r provides a simple interface on top of OrientDB's RESTful HTTP
+  API.
+email: vaclav.sykora@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE
+- README.rdoc
+files:
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- lib/orientdb4r.rb
+- lib/orientdb4r/client.rb
+- lib/orientdb4r/document.rb
+- lib/orientdb4r/rest/client.rb
+- lib/orientdb4r/utils.rb
+- lib/orientdb4r/version.rb
+- orientdb4r.gemspec
+- test/test_database.rb
+- test/test_ddo.rb
+- test/test_dmo.rb
+homepage: http://github.com/veny/orientdb4r
+licenses: []
+post_install_message: 
+rdoc_options:
+- --charset=UTF-8
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>'
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.19
+signing_key: 
+specification_version: 3
+summary: Ruby binding for Orient DB.
+test_files:
+- test/test_database.rb
+- test/test_ddo.rb
+- test/test_dmo.rb