luruju 0.1.0 → 0.2.0

data/lib/luruju/jude_api_loader_for_cache.rb

@@ -0,0 +1,22 @@
+module Luruju
+
+  class JudeApiLoader
+    
+    @@jude_cache = {}
+    
+    def self.wrap_load_for_cache jude_file, options={}
+      raise ProjectNotFoundException unless FileTest.file?(jude_file)
+      return yield(jude_file, options) unless Luruju.config.use_jude_cache
+      mtime = File.mtime(jude_file)
+      if previous = @@jude_cache[jude_file]
+	return previous if previous.mtime == mtime
+      end
+      loaded = yield jude_file, options
+      loaded.mtime = mtime
+      @@jude_cache[jude_file] = loaded
+      loaded
+    end
+    
+  end
+
+end

data/lib/luruju/jude_api_loader_for_locked_project.rb

@@ -0,0 +1,37 @@
+require 'tmpdir'
+
+module Luruju
+
+  class JudeApiLoader
+    
+    def self.wrap_load_default_option jude_file, options={}
+      default = {:copy => :if_locked}
+      yield jude_file, default.merge(options)
+    end
+    
+    def self.wrap_load_for_tmpdir jude_file, options={}
+      do_jude_file = options[:copy] == :first ? copy_jude_file(jude_file, options) : jude_file
+      yield do_jude_file, options
+    rescue ProjectLockedException
+      raise $! if do_jude_file != jude_file or options[:copy] != :if_locked or options[:retried]
+      do_jude_file = copy_jude_file jude_file, options
+      load do_jude_file, options.update(:retried => true)
+    ensure
+      FileUtils.remove_entry(File.dirname(do_jude_file), :force => true) if do_jude_file != jude_file
+    end
+
+    @@tmpdir_no = 0
+    protected
+    def self.copy_jude_file jude_file, options
+      @@tmpdir_no += 1
+      tmpdir = options[:tmpdir] || Dir.tmpdir
+      FileUtils.makedirs(tmpdir) unless FileTest.exist? tmpdir
+      current_tmpdir = FileUtils.makedirs File.join(tmpdir,"luruju.#{$$}.#{@@tmpdir_no}")
+      copy_jude_file = File.join current_tmpdir, File.basename(jude_file)
+      FileUtils.cp jude_file, copy_jude_file
+      copy_jude_file
+    end
+    
+  end
+
+end

data/lib/luruju/jude_api_loader_in_cruby.rb

@@ -0,0 +1,38 @@
+require 'base64'
+
+module Luruju
+  
+  class JudeApiLoader
+
+    def self.load jude_file, options={}
+      dto = unmarshal send("access_jruby_using_#{Luruju.config.access_jruby_with.to_s}", jude_file, options)
+      raise dto.exception if dto.exception
+      JudeMeta.instance= dto.meta
+      dto.meta.define_all
+      dto.model
+    end
+
+    def self.access_jruby_using_drb jude_file, options
+      LurujuClient.new.marshal jude_file, options
+    end
+    
+    def self.access_jruby_using_command jude_file, options
+      encoded_options = Base64.encode64(Marshal.dump(options)).gsub(/\n/,' ')
+      %x{jruby #{luruju_bin 'access_jruby_with_command.rb'} #{jude_file} #{encoded_options}}
+    end
+    
+    def self.unmarshal marshaled
+      Marshal.load(Base64.decode64(marshaled))
+    rescue ArgumentError => e
+      define_dummy_jude_class(e.message.split(' ').last.split('::').last)
+      retry
+    end
+
+    def self.define_dummy_jude_class const_name      
+      return if /Methods$/ =~ const_name
+      JudeApi.module_eval "class #{const_name} < JudeBase ; end"
+    end
+    
+  end
+    
+end

data/lib/luruju/jude_api_loader_in_jruby.rb

@@ -0,0 +1,113 @@
+require 'java'
+require 'base64'
+require 'luruju/jude_api_loader_for_locked_project'
+
+module Luruju
+  
+  JUDEAPI_PHEAD = 'com.change_vision.jude.api.inf'
+  include_class "#{JUDEAPI_PHEAD}.project.ProjectAccessorFactory"
+  
+  def self.wrap_native_exception(exception)
+    return exception unless exception.is_a? NativeException
+    wrapped = UnexpectedNativeException.new(exception.message)
+    Luruju.constants.select{|x|/Exception$|Error$/ =~ x}.collect{|x|eval x}.each do |e|
+      wrapped = e.new(exception.message) if exception.message.match(Regexp.compile(e.name.split('::').last))
+    end
+    wrapped.set_backtrace(exception.backtrace)
+    wrapped
+  end
+  
+  class JudeApiLoader
+    
+    def initialize() @already_builded, @members = {}, [] end
+    
+    def self.marshal jude_file, options={}
+      Base64.encode64(Marshal.dump(DtoBetweenCrubyAndJruby.new(self.load(jude_file, options))))
+    rescue
+      return Base64.encode64(Marshal.dump(DtoBetweenCrubyAndJruby.new(nil, Luruju.wrap_native_exception($!))))
+    end
+    
+    def self.load jude_file, options={}
+      project_accessor = ProjectAccessorFactory.getProjectAccessor
+      project_accessor.open jude_file
+      getter = project_accessor.getClass.getDeclaredMethod "getProject", nil
+      new.build project_accessor, getter
+    rescue
+      raise Luruju.wrap_native_exception($!)
+    ensure
+      project_accessor.close rescue Exception
+    end
+
+    def build java_parent, java_getter
+      
+      return nil if java_getter.getGenericParameterTypes.length > 0
+      
+      begin
+        java_obj = java_parent.send java_getter.getName
+      rescue NativeException
+#         p "Warning(#{__FILE__},#{__LINE__}) " + java_getter.getName
+      end
+      return nil if java_obj == nil
+      
+      java_return_class = java_getter.getReturnType      
+      return build_judeapi(java_obj) if is_jude_class? java_return_class
+      return build_array(java_obj, java_getter) if java_return_class.isArray
+      return java_obj
+    end
+
+    def build_array java_obj, java_getter
+      comp_type =  java_getter.getReturnType.getComponentType
+      return java_obj.to_a unless is_jude_class? comp_type      
+      java_obj.inject([]) {|jude_objects,i| jude_objects << build_judeapi(i) }
+    end    
+    
+    def build_judeapi java_obj
+         
+      if is_jude_named_element?(java_obj) and @already_builded.key?(java_obj.getId)
+        return @already_builded[java_obj.getId] 
+      end
+
+      java_if = java_obj.getClass.getInterfaces[0]
+      jude_object = define_jude_class(java_if).new(@members)
+
+      @members << jude_object
+      @already_builded[java_obj.getId] = jude_object if jude_object.kind_of_named_element?
+
+      java_if.getMethods.each do |java_method|
+        next if java_method.getGenericParameterTypes.length > 0
+        setter_name = java_method.getName.sub(/^(get)/,'').underscore << "="
+        jude_object.send setter_name, build(java_obj, java_method)
+      end
+      
+      return jude_object
+    end
+    
+    def is_jude_class?(java_class) java_class.getName.index(JUDEAPI_PHEAD) == 0 end
+    
+    def define_jude_class java_if
+      jude_meta = JudeMeta.instance
+      jude_if_name = java_if.getSimpleName.sub(/^I/,'').sub(/ER/, "Er")
+      return jude_meta.jude_class(jude_if_name) if JudeMeta.is_defined_for_luruju?(jude_if_name)
+
+      jude_if = JudeMeta.instance.create_jude_if jude_if_name      
+      java_if.getGenericInterfaces().each do |generic_if|
+        super_if_name = generic_if.getSimpleName.sub(/^I/,'').sub(/ER/, "Er")
+        jude_if.super_if_names << super_if_name
+        define_jude_class generic_if unless JudeMeta.is_defined_for_luruju?(super_if_name)
+      end
+      java_if.getDeclaredMethods.each do |method|
+        next if method.getGenericParameterTypes.length > 0
+        jude_if.attributes << method.getName.sub(/^(get)/,'').underscore
+      end
+      java_if.getDeclaredFields.each{|f| jude_if.constants[f.getName] = f.get(nil)}
+      jude_if.define_for_luruju
+    end    
+
+    def is_jude_named_element? jude_obj
+      jude_obj.getClass.getMethod "getId", nil
+      return true
+    rescue java.lang.NoSuchMethodException
+      return false
+    end
+  end
+end

data/lib/luruju/jude_meta.rb

@@ -0,0 +1,75 @@
+require 'erb'
+
+module Luruju
+  
+  class JudeMeta
+    
+    def initialize() @interfaces = HashWithIndifferentAccess.new end
+
+    @@instance = new
+    def self.instance() @@instance end
+    def self.instance=(instance) @@instance = instance end
+    
+    attr_accessor :interfaces
+    
+    def jude_class(jude_if_name) JudeApi.module_eval "Jude#{jude_if_name}" end
+
+    def create_jude_if jude_if_name
+      jude_if = JudeInterface.new
+      jude_if.if_name = jude_if_name
+      @interfaces[jude_if_name] = jude_if
+      jude_if
+    end
+    
+    def self.is_defined_for_luruju? jude_if
+      JudeApi.const_defined? "Jude#{jude_if.if_name rescue jude_if}Methods"
+    end
+    
+    def define_all() @interfaces.each_value{|i| i.define_for_luruju unless JudeMeta.is_defined_for_luruju?(i)} end
+    
+    class JudeInterface
+
+      attr_accessor :if_name, :attributes, :super_if_names, :constants
+      
+      def initialize() @attributes, @super_if_names, @constants = [], [], {} end
+      def super_ifs() @super_if_names.collect{|x|JudeMeta.instance.interfaces[x]} end
+      def module_name() "Jude#{if_name}Methods" end
+      def class_name() "Jude#{if_name}" end
+            
+      def define_for_luruju
+        super_ifs.select{|x|!JudeMeta.is_defined_for_luruju?(x.if_name)}.each{|x|x.define_for_luruju}
+        JudeApi.module_eval ERB.new(module_erb_def).result(binding)
+        JudeApi.module_eval ERB.new(class_erb_def).result(binding)
+        JudeApi.module_eval class_name
+      end
+
+      protected
+      def module_erb_def
+        return <<-EOD
+module <%= module_name %>
+<% super_ifs.each do |super_if| %>
+  include <%= super_if.module_name %>
+<% end %>
+<% attributes.each do |attr| %>
+  attr_accessor :<%= attr %>
+  <%  if /^is_/ =~  attr %>
+  alias_method :<%= attr %>?, :<%= attr %>
+  <% end %>
+<% end %>
+<% constants.each do |key,value| %>
+   <%= key %> = <%= value %>
+<% end %>
+end
+        EOD
+      end
+      
+      def class_erb_def
+        return <<-EOD
+class <%= class_name %>  < JudeBase
+  include <%= module_name %>
+end
+        EOD
+      end
+    end
+  end
+end

data/lib/luruju/luruju_client.rb

@@ -0,0 +1,20 @@
+require 'drb'
+
+DRb.start_service
+
+module Luruju
+  
+  class LurujuClient
+    
+    def initialize() init end
+    def marshal(jude_file, options={}) @drb_object.marshal jude_file, options end
+    def shutdown_server() @drb_object.shutdown end
+    def self.shutdown_server() new.shutdown_server end
+    protected
+    def init
+      @drb_object = DRbObject.new_with_uri "druby://127.0.0.1:#{Luruju.config.drb_port}"
+    end    
+    
+  end
+
+end

data/lib/luruju/prepare.rb

@@ -0,0 +1,16 @@
+
+def luruju_bin(file) File.join File.dirname(__FILE__),'..','..','bin', file end
+
+def am_i_jruby?
+  require "java"
+  self.class.method_defined? :include_class
+rescue LoadError
+  false
+end
+
+def am_i_cruby?() !am_i_jruby? end
+def ruby_vm_name() am_i_jruby? ? 'jruby' : 'cruby' end
+
+Inflector.inflections do |inflect| 
+  inflect.irregular 'schema', 'schemata' 
+end

data/lib/luruju/server/luruju_server.rb

@@ -0,0 +1,33 @@
+require 'drb'
+raise 'Use Jruby for LuRuJu Server!!' unless am_i_jruby?
+
+$SAFE = 1
+
+module Luruju
+
+  class LurujuServer
+
+    def marshal(jude_file, options={})
+      puts "start loadding #{jude_file} #{options}"
+      JudeApiLoader.marshal jude_file, options
+    rescue
+      p $!
+      pp $!.backtrace
+      return $!
+    ensure
+      puts "end loading"
+    end
+
+    def shutdown() 
+      puts "try shutdown."
+      DRb.stop_service
+      nil
+    end
+
+  end
+end
+url = "druby://127.0.0.1:#{Luruju.config.drb_port}"
+DRb.start_service(url, Luruju::LurujuServer.new)
+puts "start LuRuJu Server URL=#{url}"
+DRb.thread.join
+puts "shutdown LuRuJu Server ..."

data/lib/luruju/version.rb

@@ -1,8 +1,6 @@
 module Luruju #:nodoc:
   module VERSION #:nodoc:
-    MAJOR = 0
-    MINOR = 1
-    TINY  = 0
+    MAJOR, MINOR, TINY = 0, 2, 0
     STRING = [MAJOR, MINOR, TINY].join('.')
   end
-end
+end

data/lib/tasks/luruju.rb

@@ -0,0 +1,5 @@
+$VERBOSE = nil
+require 'rubygems'
+require 'luruju'
+
+Dir["#{File.dirname(__FILE__)}/*.rake"].each { |ext| load ext }

data/lib/tasks/server.rake

@@ -0,0 +1,21 @@
+namespace :luruju do
+  
+  namespace :server do
+    desc "Start up LuRuJu Server"
+    task :start do
+      if am_i_jruby?
+	require 'luruju/server/luruju_server'
+      else
+	IO.popen("jruby -S rake luruju:server:start", "r+") do |io| 
+	  io.each_line { |line| puts line}
+        end
+      end
+    end
+    
+    desc "Stop LuRuJu Server"    
+    task :stop do
+      Luruju::LurujuClient.shutdown_server
+    end
+  end
+  
+end

data/test/abstract_unit.rb

@@ -6,31 +6,46 @@ require 'fileutils'
 
 class Test::Unit::TestCase 
   
-  java_class_path = java.lang.System.getProperty "java.class.path"
-  jude_product = "community-5.0.2" if java_class_path.include? "Community"
-  jude_product = "professional-5.1" if java_class_path.include? "Professional"
+  if am_i_jruby?
+    java_class_path = java.lang.System.getProperty "java.class.path"
+    jude_product = "community-5.0.2" if java_class_path.include? "Community"
+    jude_product = "professional-5.1" if java_class_path.include? "Professional"
+  else
+    jude_product = "community-5.0.2"
+  end
+  
   TEST_JUDE_DIR = File.dirname(__FILE__) + '/jude/' + jude_product
   
   include Luruju
   
+  @@test_jude_model_dir = {}
+
+  def self.test_jude_model_dir(dir_sym) @@test_jude_model_dir[self] = dir_sym.to_s end
+  
   def setup
-    #   JudeApi.constants.each {|c| JudeApi.remove_const(c)}
+    Luruju::Configuration.install
+  end
+  
+  def teardown
+    Luruju::Configuration.install
   end
   
   protected
-  def jude_api_load jude_file
-    jude_path = "#{TEST_JUDE_DIR}/#{@@test_jude_model_dir}/#{jude_file}.jude"
-    FileUtils.cp jude_path, "c:/#{jude_file}.jude"
-    Luruju::JudeApiLoader.load "c:/#{jude_file}.jude"
+  def jude_api_load jude_file, options={}
+    jude_path = "#{jude_dir}/#{jude_file}.jude"
+    Luruju::JudeApiLoader.load jude_path, options
   end
   
-  def self.test_jude_model_dir dir_sym
-    @@test_jude_model_dir = dir_sym.to_s
+  def jude_dir()
+    if @@test_jude_model_dir[self.class]
+      "#{TEST_JUDE_DIR}/#{@@test_jude_model_dir[self.class]}"
+    else
+      File.dirname(__FILE__) + '/jude/'
+    end
   end
   
 end
 
-
 class Object
   def jude_methods
     self.class.ancestors.inject(self.methods) do |result,item|
@@ -39,4 +54,3 @@ class Object
     end.sort
   end
 end
-