luruju 0.1.0 → 0.2.0

data/Rakefile

@@ -7,6 +7,12 @@ require 'rake/gempackagetask'
 # TODO require 'rake/contrib/rubyforgepublisher'
 require File.join(File.dirname(__FILE__), 'lib', 'luruju', 'version')
 
+#require 'tasks/luruju' rescue nil
+
+#config = Luruju::Configuration.install do |config|
+#  config.drb_port = 9999
+#end
+
 PKG_BUILD     = ENV['PKG_BUILD'] ? '.' + ENV['PKG_BUILD'] : ''
 PKG_NAME      = 'luruju'
 PKG_VERSION   = Luruju::VERSION::STRING + PKG_BUILD
@@ -16,34 +22,34 @@ PKG_FILE_NAME = "#{PKG_NAME}-#{PKG_VERSION}"
 Rake::TestTask.new('test') do |t|
   t.libs << "test"
   t.pattern = "test/**/*_test.rb"
- # t.warning = true
+  # t.warning = true
 end
 
 # Create compressed packages
-dist_dirs = [ "lib", "test" ]
+dist_dirs = [ "lib", "test", "bin" ]
 
 spec = Gem::Specification.new do |s|
   s.platform = Gem::Platform::RUBY
   s.name = PKG_NAME
   s.version = PKG_VERSION
   s.summary = "A library for coordinating with Ruby And JUDE."
-# TODO  s.description = %q{}
+  # TODO  s.description = %q{}
 
   s.author = "Shuhei Nomura"
-# TODO  s.email = "david@loudthinking.com"
+  # TODO  s.email = "david@loudthinking.com"
   s.rubyforge_project = PKG_NAME
   s.homepage = "http://luruju.com"
 
   s.has_rdoc = false # TODO
-# TODO  s.extra_rdoc_files = ["README"]
+  # TODO  s.extra_rdoc_files = ["README"]
   s.requirements << 'JUDE Community'
   s.add_dependency('activesupport', '>= 1.4.2' + PKG_BUILD)
   s.require_path = 'lib'
   s.autorequire = 'luruju'
 
   s.files = [ "LICENSE", "Rakefile"]
-# TODO s.files << "CHANGELOG"
-# TODO s.files << "README"
+  # TODO s.files << "CHANGELOG"
+  # TODO s.files << "README"
   dist_dirs.each do |dir|
     s.files = s.files + Dir.glob( "#{dir}/**/*" ).delete_if { |i| (/^\.svn/ =~ i) or (/\~\z/) =~ i }
   end
@@ -53,7 +59,7 @@ end
 Rake::GemPackageTask.new(spec) do |p|
   p.gem_spec = spec
   p.need_tar = true
-  p.need_zip = true
+  p.need_zip = false
 end
 
 task :lines do
@@ -78,4 +84,11 @@ task :lines do
   end
 
   puts "Total: Lines #{total_lines}, LOC #{total_codelines}"
+end
+
+task :install_localhost => [:repackage] do
+  %x{gem uninstall luruju}
+  %x{gem install pkg/#{PKG_FILE_NAME}.gem -l}
+  %x{jruby -S gem uninstall luruju}
+  %x{jruby -S gem install pkg/#{PKG_FILE_NAME}.gem -l}
 end

data/bin/access_jruby_with_command.rb

@@ -0,0 +1,5 @@
+require 'rubygems'
+require 'luruju'
+require 'cgi'
+jude_file, options = ARGV[0], Marshal.load(Base64.decode64(ARGV[1..-1].join("\n")+"\n"))
+print Luruju::JudeApiLoader.marshal(jude_file, options)

data/lib/luruju.rb

@@ -1,19 +1,15 @@
 $:.unshift(File.dirname(__FILE__)) unless
-  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+$:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
 
-unless defined?(ActiveSupport)
-  begin
-    $:.unshift(File.dirname(__FILE__) + "/../../activesupport/lib")  
-    require 'active_support'  
-  rescue LoadError
-    require 'rubygems'
-    require 'active_support'
-  end
-end
-
-require  'luruju/easy_breakpoint'
-require  'luruju/customize_inflector'
-require  'luruju/jude_api_loader'
-require  'luruju/dynamic_method'
-require  'luruju/jude_api/jude_base'
+require 'rubygems'
+require 'active_support'
 
+require 'luruju/prepare'
+require 'luruju/enjoy_ruby'
+require 'luruju/configuration'
+require 'luruju/jude_meta'
+require 'luruju/luruju_client'
+require 'luruju/jude_api_loader'
+require "luruju/jude_api_loader_in_#{ruby_vm_name}"
+require 'luruju/dto'
+require 'luruju/jude_api/jude_base'

data/lib/luruju/configuration.rb

@@ -0,0 +1,11 @@
+module Luruju
+  
+  class Configuration
+
+    include Configuratable
+    define_config :access_jruby_with, :default => :drb, :validate => lambda{|val|[:drb,:command].include?(val)}
+    define_config :drb_port, :default => 3937, :validate => lambda{|val|val.to_i > 0}
+    define_config :use_jude_cache, :default => true, :validate => lambda{|val|[true,false].include?(val)}
+  end
+
+end

data/lib/luruju/dto.rb

@@ -0,0 +1,8 @@
+module Luruju
+  class DtoBetweenCrubyAndJruby
+    attr_accessor :meta, :model, :exception
+    def initialize(model, exception=nil) 
+      @meta, @model, @exception = JudeMeta.instance, model, exception
+    end
+  end
+end

data/lib/luruju/enjoy_ruby.rb

@@ -0,0 +1,186 @@
+
+module Luruju
+  
+  module DynamicMethod
+    
+    class IsNotMyRole < StandardError ; end
+    
+    def method_missing method, *args, &b
+      methods.select{|m|/^dyna_.*/ =~ m.to_s}.sort.each do |dyna_method|
+        return send(dyna_method, method, *args, &b) rescue IsNotMyRole
+      end
+      super method, *args, &b
+    end
+    
+  end
+  
+  module MethodWrappable
+    
+    def self.included(base) base.extend ClassMethods end
+    
+    module ClassMethods
+      
+      @@wrapped_class_methods = []
+
+      def wrap_class_method *names
+	@@wrapped_class_methods += names
+        names.each { |name|  do_wrap_class_method name rescue NameError }
+      end
+      
+      def singleton_method_added(name)
+	return if /^original_/ =~ name.to_s
+	file, line, method = caller[1].match(/^(.+?):(\d+)(?::in `(.*?)')?/).captures
+	return if file == __FILE__ and ["do_wrap_class_method","singleton_method_added"].include?(method) 
+	do_wrap_class_method(name) if @@wrapped_class_methods.include? name.to_sym
+      ensure
+	super
+      end
+
+      def do_wrap_class_method name
+	self.module_eval <<-EOD
+	  class << self
+	    alias :original_#{name.to_s} :#{name.to_s}
+	    def #{name.to_s} *args
+	      bucket_brigade methods.select{|x|/^wrap_#{name}/=~x}.sort!.push("original_#{name.to_s}"), *args
+	    end
+	  end
+	EOD
+      end
+      
+      def bucket_brigade wraps, *args
+        current = wraps.shift
+        send(current, *args) do |*args|
+	  wraps.empty? ? send(current, *args) : bucket_brigade(wraps, *args)
+        end
+      end
+      
+    end
+
+  end
+  
+  module Configuratable
+    
+    def self.included base
+      base.parent.class_eval <<-EOD
+	@@config = nil
+	def self.config() @@config || #{base.name}.default end
+	def self.config=(config) @@config = config end
+      EOD
+      base.class_eval <<-EOD
+	@@default_configurations = {}
+	def self.default() new end   
+	def self.uninstall() parent.config = nil end
+	def self.install(config=default, &block)
+	  return parent.config = config unless block_given?
+	  parent.config = new {|config|yield config}
+        end
+	def self.define_config key, options={}
+	  @@default_configurations[key] = Config.new(key, options[:default], options[:validate])
+	end
+	def initialize
+	  @configrations = {}
+	  @@default_configurations.each{|key, value| @configrations[key] = value.dup}
+	  yield self if block_given?
+	end
+	def self.singleton_method_added name
+	  return unless name.to_s.match(/default_(.+)$/)
+	  key = $1.to_sym
+	  return unless @@default_configurations[key]
+	  @@default_configurations[key].default = method(name).call
+	end
+      EOD
+    end
+    
+    class Config
+      attr_accessor :key, :default, :value
+      def initialize(key, default=nil, validate=nil) 
+	@key, @default, @validate = key, default, validate
+      end
+      def value() @value.nil? ? @default : @value end
+      def value=(value)
+	if @validate
+	  raise ArgumentError.new("invarid value[#{value}]. key[#{key}]") unless @validate.call(value)	  
+        end
+	@value = value
+      end
+    end
+    
+    def method_missing method, *args
+      return @configrations[method].value if @configrations.key? method.to_sym
+      if args.size == 1
+	sym = method.to_s.match(/^(.+?)=$/).captures[0].to_sym
+	return @configrations[sym].value = args[0] if @configrations.key? sym
+      end
+      super
+    end
+
+  end
+  
+end
+
+require 'pp'
+
+#eval(easy_breakpoint)
+module Kernel
+  
+  def easy_breakpoint 
+    <<-EOS
+      puts 'easy-breakpoint>'
+      input = STDIN.readline.chop!
+      unless input == "stop"
+        begin
+          eval(input)
+        rescue => e
+          p e
+          pp e.backtrace
+        end
+        eval easy_breakpoint
+      end
+    EOS
+  end
+  
+end
+
+__END__
+
+class Hoge
+  
+  include Luruju::MethodWrappable
+
+  wrap_class_method :hoge
+  
+  def self.hoge arg1, arg2
+    p "hoge call #{arg1} #{arg2}"
+    "A"
+  end
+
+  def aaa
+  end
+  
+  def self.wrap_hoge_aaa arg1, arg2
+    p "wrap enter aaa #{arg1} #{arg2}"
+    rtn = yield arg1, arg2
+    p "wrap leave aaa #{arg1} #{arg2}"
+    rtn + "B"
+  end
+
+  def self.wrap_hoge_bbb arg1, arg2
+    p "wrap enter bbb #{arg1} #{arg2}"
+    rtn = yield arg1, arg2
+    p "wrap leave bbb #{arg1} #{arg2}"
+    rtn + "C"
+  end
+
+end
+
+begin
+  result = Hoge.hoge "x", "y"
+rescue LocalJumpError
+  p $!
+  p $!.reason
+  p $!.exit_value
+  require "pp"
+  pp $!.backtrace
+end
+
+p result

data/lib/luruju/jude_api/add_dynamic_method.rb

@@ -25,9 +25,10 @@ module Luruju
       end
       
       def dyna_is_kind_of? method, *args
-        raise IsNotMyRole unless /^kind_of_(.+?)\?$/ =~ method.to_s
-        return self.kind_of?(eval("JudeApi::#{$1.classify.jude_module}")) rescue
-        false
+        raise IsNotMyRole unless /^kind_of_([^?]+?)\?$/ =~ method.to_s
+	c = "JudeApi::Jude#{$1.classify}Methods"
+	c = 'JudeApi::JudeClassMethods' if c == 'JudeApi::JudeClasMethods'
+        return self.kind_of?(eval(c)) rescue false
       end
 
       def dyna_owned_elements method, *args
@@ -44,6 +45,11 @@ module Luruju
         send(method.to_s.pluralize.to_sym, *args)[0]
       end
       
+      def dyna_search method, *args, &block
+	raise IsNotMyRole unless /^search_(.+?)$/ =~ method.to_s
+	JudeBase.search search{|x|x.send("kind_of_#{$1.singularize}?")}, *args, &block
+      end
+      
     end
   end
 end

data/lib/luruju/jude_api/jude_base.rb

@@ -1,2 +1,90 @@
 require  'luruju/jude_api/add_dynamic_method'
-require  'luruju/jude_api/add_method'
+
+module Luruju
+
+  module JudeApi
+    
+    class JudeBase
+      
+      attr_writer :tagged
+      attr_reader :members
+      
+      def initialize(members) @members = members end
+      
+      def search options={}, &block
+	JudeBase.search members, options, &block
+      end
+      
+      def tagged
+        return @tagged if @tagged
+        @tagged = HashWithIndifferentAccess.new
+        tagged_values.each {|x| @tagged[x.key.to_sym] = x.value}
+        @tagged
+      end
+      
+      def self.search members, options={}
+	members.collect do |member|
+	  if options.key?(:name)
+	    next unless member.is_a?(JudeNamedElementMethods)
+	    next unless member.name == options[:name]
+          end
+	  next if options.key?(:id) and member.id != options[:id]
+	  if block_given?
+	    next unless yield(member)
+          end
+	  member
+        end.compact
+      end
+      
+      def inspect() "<#{self.class}: id=#{self.instance_eval('@id')}>" end
+      
+    end
+    
+    module JudeNamedElementAddMethod
+      def inspect() "<#{self.class}: name=#{self.name} id=#{self.instance_eval('@id')}>" end
+    end
+    
+    module JudeErAttributeAddMethod
+      def constraint(constraint_name) constraints.find{|x|constraint_name == x.name} end
+    end
+    
+    module JudeModelAddMethod
+      attr_accessor :mtime
+    end
+    
+    module JudeClassAddMethod
+      def default?
+	return unless owner
+	return unless owner.kind_of_element?
+	return unless owner.owner
+	['lang', 'util'].include?(owner.name) and owner.owner.name == 'java'
+      end
+      
+      def super_classes() generalizations.collect{|g|g.super_type} end 
+      def sub_classes() specializations.collect{|s|s.sub_type} end 
+      
+    end
+
+    module JudeAttributeAddMethod
+      def broad_aggregate?() is_aggregate? or is_composite? end
+      def not_broad_aggregate?() !broad_aggregate? end
+      def contra() association.attributes.find{|b|b != self} end
+    end    
+    
+  end
+
+end
+
+class Class
+  
+  alias :include_except_luruju :include
+  
+  def include *included
+    return include_except_luruju(*included) unless self.ancestors.include?(Luruju::JudeApi::JudeBase)
+    if Luruju::JudeApi.constants.include? "#{self.name}AddMethod".split("::").last
+      included[0].send :include, eval("#{self.name}AddMethod")
+    end
+    include_except_luruju(*included)
+  end
+
+end

data/lib/luruju/jude_api_loader.rb

@@ -1,164 +1,13 @@
-require  'java'
-
 module Luruju
-  
-  JUDEAPI_PHEAD = 'com.change_vision.jude.api.inf'
-  include_class "#{JUDEAPI_PHEAD}.project.ProjectAccessorFactory"
-  
-  class JudeApiLoader
-
-    def self.load jude_file
-      project_accessor = ProjectAccessorFactory.getProjectAccessor
-      project_accessor.open jude_file
-      getter = project_accessor.getClass.getDeclaredMethod "getProject", nil
-      new.build project_accessor, getter 
-    ensure
-      project_accessor.close rescue Exception
-    end
-
-    def initialize
-      @already_builded = {}
-    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      
-      if is_jude_class? java_return_class
-        return build_judeapi(java_obj)
-      elsif java_return_class.isArray
-        return build_array(java_obj, java_getter)
-      else
-        return java_obj
-      end
-    end
-
-    def build_array java_obj, java_getter
-      
-      comp_type =  java_getter.getReturnType.getComponentType
-      
-      if is_jude_class? comp_type
-        jude_objects = Array.new
-        java_obj.each {|i| jude_objects << build_judeapi(i) }
-        return jude_objects
-      else
-        return java_obj.to_a
-      end
-    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_class = JudeApi.module_eval java_if.getSimpleName.jude_class
-      jude_object = jude_class.new
-      
-      @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 self.define_jude_class class_id
-      judeapi_class_name = class_id.to_s.jude_class
-      JudeApi.module_eval "class #{judeapi_class_name} < JudeBase ; end"
-      judeapi_class = JudeApi.module_eval judeapi_class_name
-      judeapi_module_name = class_id.to_s.jude_module
-      judeapi_module = JudeApi.module_eval judeapi_module_name
-      judeapi_class.send :include, judeapi_module 
-      judeapi_class
-    end
-    
-    def self.define_jude_module module_id
-      
-      java_if = java.lang.Class.forName "#{JUDEAPI_PHEAD}.model.#{module_id.to_s.java_if}"
-      judeapi_module_name = java_if.getSimpleName.jude_module
-      JudeApi.module_eval "module #{judeapi_module_name} ; end"
-      judeapi_module = JudeApi.module_eval judeapi_module_name
-      java_if.getGenericInterfaces().each do |generic_if|
-        JudeApi.module_eval generic_if.getSimpleName.jude_class
-        judeapi_module.send :include, JudeApi.module_eval(generic_if.getSimpleName.jude_module)
-      end
-      
-      java_if.getDeclaredMethods.each do |method|
-        next if method.getGenericParameterTypes.length > 0
-        java_method_name = method.getName
-        attr_name = java_method_name.sub(/^(get)/,'').underscore
-        judeapi_module.module_eval "attr_accessor :#{attr_name}"
-        if /^is_/ =~  attr_name
-          judeapi_module.send :alias_method, 
-            "#{attr_name}?".to_sym, attr_name.to_sym
-        end
-      end
-
-      java_if.getDeclaredFields.each do |f|
-        judeapi_module.module_eval "#{f.getName} = #{f.get(nil)}"
-      end      
-      judeapi_module
-    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
-
-class String
-  
-  def is_jude_class?
-    /^Jude/ =~ self and not /Methods$/ =~ self
+  class ProjectNotFoundException < Exception #:nodoc:
   end
-
-  def is_jude_module?
-    /^Jude/ =~ self and /Methods$/ =~ self
+  class ProjectLockedException < Exception #:nodoc:
   end
-  
-  def jude_class
-    'Jude' + sub(/^(I|Jude)/,'').sub(/ER/, "Er").sub(/Methods$/, '')
+  class UnexpectedNativeException < Exception #:nodoc:
   end
-
-  def jude_module
-    'Jude' + sub(/^(I|Jude)/,'').sub(/ER/, "Er") + "Methods"
-  end
-  
-  def java_if
-    sub(/^(I|Jude)/,'I').sub(/Er/, "ER").sub(/Methods$/, '')
+  class JudeApiLoader
+    include MethodWrappable
+    wrap_class_method :load
   end
-
 end
-
-class Module
-  
-  alias :const_missing_except_luruju :const_missing
-  
-  def const_missing class_id   
-    return  const_missing_except_luruju(class_id) unless self ==  Luruju::JudeApi
-    return Luruju::JudeApiLoader::define_jude_class(class_id)  if class_id.to_s.is_jude_class?
-    return Luruju::JudeApiLoader::define_jude_module(class_id)  if class_id.to_s.is_jude_module?
-    raise NameError
-  end
-
-end
+require 'luruju/jude_api_loader_for_cache'