intersys 0.0.2

data/lib/extconf.rb

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+
+require "mkmf"
+#CONFIG["CPP"] = "g++"
+CONFIG["CC"] = "gcc -g"
+
+
+alias :old_cpp_include :cpp_include
+#def cpp_include(header)
+#  old_cpp_include(header) + <<-EOF
+#  int main(void) {
+#  }
+#EOF
+#end
+#find_library "cbind", "cbind_alloc_db","/Applications/Cache/bin" 
+
+find_header "c_api.h", "/Applications/Cache/dev/cpp/include/", "/Developer/Examples/Cache/cpp/include/"
+$CFLAGS << " -I/Applications/Cache/dev/cpp/include/ -I/Developer/Examples/Cache/cpp/include/ -Wall" 
+create_makefile 'intersys_cache'
+

data/lib/intersys.c

@@ -0,0 +1,83 @@
+#include "intersys.h"
+
+VALUE mIntersys, cDatabase, cQuery, cObject, cDefinition, cProperty, cMethod, cArgument, cObjectNotFound, cStatus;
+VALUE cTime, cMarshallError, cUnMarshallError;
+
+static VALUE my_debug(VALUE self) {
+	printf("Hi!\n");
+	return Qnil;
+}
+
+void Init_intersys_cache() {
+	rb_define_method(rb_mKernel, "my_debug", my_debug, 0);
+	rb_define_method(rb_cString, "to_wchar", string_to_wchar, 0);
+	rb_define_method(rb_cString, "from_wchar", string_from_wchar, 0);
+
+
+	mIntersys = rb_define_module("Intersys");
+	cObjectNotFound = rb_const_get(mIntersys, rb_intern("ObjectNotFound"));
+	cMarshallError = rb_const_get(mIntersys, rb_intern("MarshallError"));
+	cUnMarshallError = rb_const_get(mIntersys, rb_intern("UnMarshallError"));
+	cStatus = rb_const_get(mIntersys, rb_intern("Status"));
+	cTime = rb_const_get(rb_cObject, rb_intern("Time"));
+
+
+	cDatabase = rb_define_class_under(mIntersys, "Database", rb_cObject);
+	rb_define_alloc_func(cDatabase, intersys_base_s_allocate);
+	rb_define_method(cDatabase, "initialize", intersys_base_initialize, 1);
+	rb_define_method(cDatabase, "connect", intersys_base_connect, 1);
+	rb_define_method(cDatabase, "begin_db_transaction", intersys_base_start, 0);
+	rb_define_method(cDatabase, "start", intersys_base_start, 0);
+	rb_define_method(cDatabase, "commit_db_transaction", intersys_base_commit, 0);
+	rb_define_method(cDatabase, "commit", intersys_base_commit, 0);
+	rb_define_method(cDatabase, "rollback_db_transaction", intersys_base_rollback, 0);
+	rb_define_method(cDatabase, "rollback", intersys_base_rollback, 0);
+	rb_define_method(cDatabase, "level", intersys_base_level, 0);
+
+	cQuery = rb_define_class_under(mIntersys, "Query", rb_cObject);
+	rb_define_alloc_func(cQuery, intersys_query_s_allocate);
+	rb_define_method(cQuery, "native_initialize", intersys_query_initialize, 2);
+	rb_define_method(cQuery, "execute", intersys_query_execute, 0);
+	rb_define_method(cQuery, "fetch", intersys_query_fetch, 0);
+	rb_define_method(cQuery, "column_name", intersys_query_column_name, 1);
+	rb_define_method(cQuery, "get_data", intersys_query_get_data, 1);
+	rb_define_method(cQuery, "close", intersys_query_close, 0);
+
+	cObject = rb_define_class_under(mIntersys, "Object", rb_cObject);
+	rb_define_alloc_func(cObject, intersys_object_s_allocate);
+	rb_define_method(cObject, "initialize", intersys_object_initialize, 0);
+	rb_define_singleton_method(cObject, "create_intern", intersys_object_create, 0);
+	rb_define_singleton_method(cObject, "open_intern", intersys_object_open_by_id, 1);
+
+	cDefinition = rb_const_get(mIntersys, rb_intern("Definition"));
+	rb_define_alloc_func(cDefinition, intersys_definition_s_allocate);
+	rb_define_method(cDefinition, "intern_initialize", intersys_definition_initialize, 3);
+	rb_define_method(cDefinition, "cpp_type", intersys_definition_cpp_type, 0);
+	rb_define_method(cDefinition, "cache_type", intersys_definition_cache_type, 0);
+	rb_define_method(cDefinition, "name", intersys_definition_name, 0);
+	rb_define_method(cDefinition, "in_name", intersys_definition_in_name, 0);
+
+	cProperty = rb_const_get(mIntersys, rb_intern("Property"));
+	rb_define_method(cProperty, "initialize", intersys_property_initialize, 4);
+	rb_define_method(cProperty, "extract_retval!", intersys_method_extract_retval, 0);
+	rb_define_method(cProperty, "get", intersys_property_get, 0);
+	rb_define_method(cProperty, "set", intersys_property_set, 1);
+	rb_define_method(cProperty, "marshall!", intersys_argument_set, 1);
+
+	cMethod = rb_const_get(mIntersys, rb_intern("Method"));
+	rb_define_method(cMethod, "method_initialize", intersys_method_initialize, 1);
+	rb_define_method(cMethod, "is_func?", intersys_method_is_func, 0);
+	rb_define_method(cMethod, "is_class_method?", intersys_method_is_class_method, 0);
+	rb_define_method(cMethod, "num_args", intersys_method_num_args, 0);
+	rb_define_method(cMethod, "prepare_call!", intersys_method_prepare_call, 0);
+	rb_define_method(cMethod, "intern_call!", intersys_method_call, 0);
+	rb_define_method(cMethod, "extract_retval!", intersys_method_extract_retval, 0);
+	
+	cArgument = rb_const_get(mIntersys, rb_intern("Argument"));
+	rb_define_method(cArgument, "initialize", intersys_argument_initialize, 4);
+	rb_define_method(cArgument, "default", intersys_argument_default_value, 0);
+	rb_define_method(cArgument, "marshall_dlist_element", intersys_argument_marshall_dlist_elem, 1);
+	rb_define_method(cArgument, "marshall!", intersys_argument_set, 1);
+//	printf("Inited\n");
+}
+

data/lib/intersys.h

@@ -0,0 +1,154 @@
+#ifndef __cache_ruby
+#define __cache_ruby
+
+#include "ruby.h"
+#include "rubyio.h"
+#include "intern.h"
+#include <time.h>
+#include <c_api.h>
+
+struct rbDatabase {
+	h_connection connection;
+	h_database database;
+};
+
+struct rbQuery {
+	h_query query;
+	bool_t empty;
+};
+
+struct rbObject {
+	h_database database;
+	int oref;
+	VALUE class_name;
+};
+
+struct rbDefinition {
+	int type;
+	h_database database;
+    void *def;
+    short cpp_type;
+	h_class_def cl_def;
+    const wchar_t* cache_type;
+    const wchar_t* name;
+	wchar_t* in_name;
+	// Method definitions
+	bool_t is_func;
+	bool_t is_class_method;
+	int num_args;
+	void *args_info;
+	int arg_counter;
+	//Argument definitions
+	bool_t is_by_ref;
+	bool_t is_default;
+	const char* default_value;
+	long default_value_size;
+	int arg_number;
+	
+	char* current_dlist;
+	int current_dlist_size;
+	VALUE class_name;
+	//Property definitions
+	int oref;
+};
+
+enum { D_PROPERTY, D_METHOD, D_ARGUMENT};
+
+enum {
+	ERR_CONN_LINK_FAILURE = 461
+};
+
+
+extern VALUE mIntersys, cDatabase, cQuery, cObject, cDefinition, cProperty, cMethod, cArgument, cObjectNotFound, cStatus;
+extern VALUE cTime, cMarshallError, cUnMarshallError;
+
+
+/****** Common functions ******/
+
+VALUE string_to_wchar(VALUE self);
+int run(int error, char* file, int line);
+VALUE string_from_wchar(VALUE self);
+VALUE rb_wcstr_new(const wchar_t *w_str, const char_size_t len);
+VALUE rb_wcstr_new2(const wchar_t *w_str);
+VALUE wcstr_new(const wchar_t *w_str, const char_size_t len);
+
+/******* Database functions *******/
+
+VALUE intersys_base_s_allocate(VALUE klass);
+VALUE intersys_base_initialize(VALUE self, VALUE options);
+VALUE intersys_base_connect(VALUE self, VALUE options);
+VALUE intersys_base_start(VALUE self);
+VALUE intersys_base_commit(VALUE self);
+VALUE intersys_base_rollback(VALUE self);
+VALUE intersys_base_level(VALUE self);
+
+
+/******* Query functions *******/
+
+VALUE intersys_query_s_allocate(VALUE klass);
+VALUE intersys_query_initialize(VALUE self, VALUE database, VALUE sql_query);
+VALUE intersys_query_execute(VALUE self);
+VALUE intersys_query_column_name(VALUE self, VALUE index);
+VALUE intersys_query_get_data(VALUE self, VALUE index);
+VALUE intersys_query_fetch(VALUE self);
+VALUE intersys_query_close(VALUE self);
+
+
+
+/******* Object functions *******/
+
+VALUE intersys_object_s_allocate(VALUE klass);
+VALUE intersys_object_initialize(VALUE self);
+VALUE intersys_object_open_by_id(VALUE self, VALUE oid);
+VALUE intersys_object_create(VALUE self);
+
+
+/******* Properties, definitions, arguments, methods functions *******/
+
+VALUE intersys_definition_s_allocate(VALUE klass);
+VALUE intersys_definition_initialize(VALUE self, VALUE r_database, VALUE class_name, VALUE name);
+VALUE intersys_definition_cpp_type(VALUE self);
+VALUE intersys_definition_cache_type(VALUE self);
+VALUE intersys_definition_name(VALUE self);
+VALUE intersys_definition_in_name(VALUE self);
+VALUE intersys_property_initialize(VALUE self, VALUE r_database, VALUE class_name, VALUE name, VALUE object);
+VALUE intersys_property_get(VALUE self);
+VALUE intersys_property_set(VALUE self, VALUE value);
+VALUE intersys_method_initialize(VALUE self, VALUE object);
+VALUE intersys_method_is_func(VALUE self);
+VALUE intersys_method_is_class_method(VALUE self);
+VALUE intersys_method_num_args(VALUE self);
+VALUE intersys_method_prepare_call(VALUE self);
+VALUE intersys_method_call(VALUE self);
+VALUE intersys_method_extract_retval(VALUE self);
+VALUE intersys_argument_initialize(VALUE self, VALUE r_database, VALUE class_name, VALUE name, VALUE r_method);
+VALUE intersys_argument_default_value(VALUE self);
+VALUE intersys_argument_marshall_dlist_elem(VALUE self, VALUE elem);
+VALUE intersys_argument_set(VALUE self, VALUE obj);
+
+
+
+
+
+
+
+#define RUN(x) run((x), __FILE__, __LINE__)
+#define QUERY_RUN(x) {int sql_code = 0; (x); run(sql_code, __FILE__, __LINE__);}
+#define STR(x) (RSTRING(x)->ptr)
+#define LEN(x) (RSTRING(x)->len)
+#define CALL(x, method) (rb_funcall((x), rb_intern(method), 0))
+
+#define WCHARSTR(x) ((wchar_t *)STR(x))
+
+#define FROMWCHAR(x) (rb_funcall((x), rb_intern("from_wchar"), 0))
+#define TOWCHAR(x) (rb_funcall((x), rb_intern("to_wchar"), 0))
+
+#define FROMWCSTR(x) (FROMWCHAR(rb_wcstr_new2(x))) // From wchar_t* -> VALUE with utf8
+#define PRINTABLE(x) STR(FROMWCHAR(x))         // from VALUE with ucs -> char * with utf8
+#define CLASS_NAME(x) WCHARSTR((x)->class_name)  // from object description -> wchar_t*
+
+#define DLISTSIZE (argument->current_dlist_amount - argument->current_dlist_size)
+#define PUT_DLIST(func, value) RUN(func(argument->current_dlist, DLISTSIZE, value, &elem_size))
+
+
+#endif /* __cache_ruby */

data/lib/intersys.rb

@@ -0,0 +1,419 @@
+#!/usr/bin/env ruby
+require 'dl/import'
+require 'rubygems'
+require_gem 'activesupport'
+require 'active_support'
+
+#
+# Module, keeping all classes, required to work with Cache via object and SQL interfaces
+module Intersys
+  extend DL::Importable
+  dlload("/Applications/Cache/bin/libcbind.dylib")
+  
+  # Basic exception, thrown in intersys driver
+  class IntersysException < StandardError
+  end
+  
+  # Exception, thrown from Object.open method, when no such ID in database
+  class ObjectNotFound < IntersysException
+  end
+  
+  # Error of marshalling arguments
+  class MarshallError < IntersysException
+  end
+
+  # Error of unmarshalling results
+  class UnMarshallError < IntersysException
+  end
+  
+  # Error establishing connection with database
+  class ConnectionError < IntersysException
+  end
+  
+  def self.handle_error(error_code, message, file, line)
+    #raise ConnectionError if error_code == 461
+  end
+
+  # Basic class for arguments, methods and properties description
+  # for internal use only
+  class Definition
+    def initialize(database, class_name, name)
+      @database = database
+      @class_name = class_name
+      @name = name
+      intern_initialize(database, class_name, name)
+    end
+  end
+  
+  # Class representing one object property
+  # for internal use only
+  class Property < Definition
+  end
+  
+  # Class representing one object method
+  # for internal use only
+  class Method < Definition
+    attr_accessor :args
+  protected
+    def arg!
+      Argument.new(@database, @class_name, @name, self)
+    end
+  public
+    
+    def initialize(database, class_name, name, object)
+      super(database, class_name, name.to_s)
+      method_initialize(object)
+      @args = []
+      num_args.times do
+        @args << arg!
+      end
+    end
+    
+    def call(*method_args)
+      prepare_call!
+      raise ArgumentError, "wrong number of arguments (#{method_args.size} for #{args.size})" if method_args.size > args.size 
+      args.each_with_index do |arg, i|
+        arg.marshall!(method_args[i])
+      end
+      intern_call!
+      extract_retval!
+    end
+  end
+  
+  # Class representing one method argument
+  # for internal use only
+  class Argument < Definition
+    def marshall_dlist(list)
+      list.each do |elem|
+        marshall_dlist_element(elem)
+      end
+    end
+  end
+
+  # Method can return Cache %Status. It is marshalled to this class
+  class Status
+    attr_accessor :code
+    attr_accessor :message
+    def initialize(code, message)
+      @code = code
+      @message = message
+    end
+  end
+
+  require File.dirname(__FILE__) + '/intersys_cache'
+  
+
+  # Basic class for all classes, through which is performed access to Cache classes
+  # For each Cache class must be created ruby class, inherited from Intersys::Object
+  # 
+  # By default prefix "User" is selected. If Cache class has another prefix, it must
+  # be provided explicitly via method "prefix":
+  #   class List < Intersys::Object
+  #     prefix "%Library"
+  #   end
+  #
+  # By default name of Cache class is taken the same as name of ruby class.
+  # Thus in this example this class List will be marshalled to Cache class 
+  # %Library.List
+  #
+  class Object
+
+    class << self
+    protected      
+      def class_names
+        common_get_or_set("@class_names", {})
+      end
+
+      def prefix=(name)
+        @prefix = name
+        @class_name = @prefix + "." + (@class_name ? @class_name.split(".").last : self.to_s)
+        register_name!
+      end
+
+      def class_name=(name)
+        if name.index(".")
+          self.prefix = name.split(".").first
+          @class_name = name
+        else
+          @class_name = self.prefix + "." + name
+        end
+        register_name!
+      end
+
+      # Register class name of current class in global list
+      def register_name!
+        if i = class_names.index(self)
+          class_names.delete(i)
+        end
+        class_names[class_name] = self
+        class_name
+      end
+    public    
+      # Help to work with instance variables of Intersys::Object class
+      # required, because list of registered descendants of Intersys::Object,
+      # database connection etc. should be in one place
+      def common_get_or_set(name, default_value = nil)
+        unless var = Intersys::Object.instance_variable_get(name)
+          default = block_given? ? yield : default_value
+          var = Intersys::Object.instance_variable_set(name, default)
+        end
+        var
+      end
+
+      # Takes Cache class name and try to resolve it to Ruby class
+      def lookup(class_name)
+        class_names[class_name] || raise(UnMarshallError, "Couldn't find registered class with Cache name '#{class_name}'")
+      end
+    
+      # Each Cache class has prefix before it's name: namespace.
+      # this method set's prefix for current class is provided,
+      # or just returns current prefix
+      def prefix(name = nil)
+        self.prefix = name if name
+        @prefix ||= "User"
+      end
+
+      def class_name(name = nil)
+        self.class_name = name if name
+        self.class_name = (prefix + "." + to_s) unless @class_name
+        @class_name 
+      end
+
+      def database(db = nil)
+        common_get_or_set("@database") do
+          db || Intersys::Database.new(:user => "_SYSTEM", :password => "SYS", :namespace => "User")
+        end
+      end
+            
+      # This method takes block and executes it between
+      # START TRANSACTION and COMMIT TRANSACTION
+      #
+      # In case of exception ROLLBACK TRANSACTION is called
+      def transaction
+        return unless block_given?
+        database.start
+        begin
+          yield
+          database.commit
+        rescue StandardError => e
+          database.rollback
+          raise e
+        end
+      end
+
+      # Returns ClassDefinition object for current class
+      def reflector
+        @reflector ||= Intersys::Reflection::ClassDefinition.open(class_name)
+      end
+      
+      # returns list of methods for this class
+      def intersys_methods
+        @methods ||= reflector.intersys_get("Methods")
+      end
+
+      # returns list of properties for current class
+      def intersys_properties
+        @properties ||= reflector.properties
+      end
+      
+      def inherited(klass)
+        class_names[klass.class_name] = klass
+      end
+    
+      def concurrency
+        1
+      end
+    
+      # timeout for connection
+      def timeout
+        5
+      end
+    
+      # create new instance of this class
+      def create
+        create_intern
+      end
+
+      # try to load class instance from database for this id
+      # ID can be not integer
+      def open(id)
+        open_intern(id.to_s.to_wchar)
+      end
+      
+      # Loads property definition with required name for required object
+      # for internal use only
+      def property(name, object)
+        Property.new(database, class_name, name.to_s.to_wchar, object)
+      end
+  
+      # Loads method definition with required name for required object
+      # for internal use only
+      def method(name, object)
+        Method.new(database, class_name, name.to_s.to_wchar, object)
+      end
+      
+      # call class method
+      def call(method_name, *args)
+        method(method_name, nil).call(*args)
+      end
+      alias :intersys_call :call
+    #def self.method_missing(method_name, *args)
+    #end
+    
+    end
+    
+    # Get the specified property
+    def intersys_get(property)
+      self.class.property(property, self).get
+    end
+    
+    # Set the specified property
+    def intersys_set(property, value)
+      self.class.property(property, self).set(value)
+    end
+    
+    # Call the specified method
+    def intersys_call(method, *args)
+      self.class.method(method, self).call(*args)
+    end
+    
+    def method_missing(method, *args)
+      method_name = method.to_s.camelize
+      if match_data = method_name.match(/(\w+)=/)
+        return intersys_set(match_data.captures.first, args.first)
+      end
+      begin
+        return intersys_get(method_name)
+      rescue StandardError => e
+        puts e
+        begin
+          return intersys_call(method_name, *args)
+        rescue
+        end
+      end
+      super(method, *args)
+    end
+    
+    def save
+      intersys_call("%Save")
+    end
+    
+    # Returns id of current object
+    def id
+      intersys_call("%Id").to_i
+    end
+  end
+  
+  # Class representing one query
+  # You shouldn't create it yourself
+  class Query
+    attr_reader :database
+    
+    def initialize(database, query)
+      @database = database
+      native_initialize(database, query.to_wchar)
+    end
+  end
+  
+  # Class representing Cache database connection
+  class Database
+    def create_query(query)
+      Query.new(self, query)
+    end
+    
+    # This method creates SQL query, runs it, restores data
+    # and closes query
+    def query(query)
+      q = create_query(query).execute
+      data = []
+      while (row = q.fetch) && row.size > 0
+        data << row
+      end
+      q.close
+      1.upto(data.first.size) do |i|
+        puts q.column_name(i)
+      end
+      data
+    end
+  end
+  
+  # Module reflection keeps classes required to get information
+  # about methods and properties of Cache classes
+  module Reflection
+    
+    # This class is basic reflection class
+    # If has class method Open(class_name), that creates instance of
+    # this class, representing its internals
+    # 
+    # Usually creates via Intersys::Object.reflector
+    #
+    # Then it is possible to call such methods as _methods, properties
+    # to get access to methods and properties of Cache class
+    class ClassDefinition < Intersys::Object
+      class_name "%Dictionary.ClassDefinition"
+      
+      # After all changes to class definition required to call save
+      def save
+        intersys_call("%Save")
+      end
+      
+      # short alias to intersys_get("Methods")
+      def _methods
+        intersys_get("Methods")
+      end
+    end
+
+    class PropertyDefinition < Intersys::Object
+      class_name "%Dictionary.PropertyDefinition"
+    end
+    
+    class MethodDefinition < Intersys::Object
+      class_name "%Dictionary.MethodDefinition"
+    end
+    
+    # This is a proxy object to Cache RelationshipObject, which is just like Rails Association object
+    #
+    class RelationshipObject < Intersys::Object
+      class_name "%Library.RelationshipObject"
+      
+      def empty?
+        intersys_call("IsEmpty")
+      end
+      
+      def count
+        intersys_call("Count")
+      end
+      alias :size :count
+      
+      def [](index)
+        intersys_call("GetAt", index.to_s)
+      end
+      
+      def each
+        1.upto(count) do |i|
+          yield self[i]
+        end
+      end
+      
+      def each_with_index
+        1.upto(count) do |i|
+          yield self[i], i
+        end
+      end
+      
+      def inspect
+        list = []
+        each do |prop|
+          list << prop.name
+        end
+        list.inspect
+      end
+      alias :to_s :inspect
+      
+      def <<(object)
+        intersys_call("Insert", object)
+      end
+      alias :insert :<<
+    end
+  end
+end