ruboto-core 0.1.0 → 0.2.1

data/lib/ruboto/util/build.rb

@@ -27,20 +27,20 @@ module Ruboto
       #   Aborts if the class is not found or if it is not available for
       #   all api levels
       #
-      def get_class_or_interface(klass, force=false)
+      def get_class_or_interface(klass, force=nil)
         element = verify_api.find_class_or_interface(klass, "either")
 
         abort "ERROR: #{klass} not found" unless element
 
-        unless force
-          abort "#{klass} not available in minSdkVersion, added in #{element.attribute('api_added')}; use --force to create it" if
-          element.attribute('api_added') and element.attribute('api_added').to_i > verify_min_sdk.to_i
-          abort "#{klass} deprecated for targetSdkVersion, deprecatrd in #{element.attribute('deprecated')}; use --force to create it" if
-          element.attribute('deprecated') and element.attribute('deprecated').to_i <= verify_target_sdk.to_i
+        unless force == "include"
+          abort "#{klass} not available in minSdkVersion, added in #{element.attribute('api_added')}; use '--force include' to create it" if
+            element.attribute('api_added') and element.attribute('api_added').to_i > verify_min_sdk.to_i
+          abort "#{klass} deprecated for targetSdkVersion, deprecatrd in #{element.attribute('deprecated')}; use '--force include' to create it" if
+            element.attribute('deprecated') and element.attribute('deprecated').to_i <= verify_target_sdk.to_i
         end
 
         abort "#{klass} removed for targetSdkVersion, removed in #{element.attribute('api_removed')}" if
-        element.attribute('api_removed') and element.attribute('api_removed').to_i <= verify_target_sdk.to_i
+          element.attribute('api_removed') and element.attribute('api_removed').to_i <= verify_target_sdk.to_i
 
         element
       end
@@ -48,7 +48,7 @@ module Ruboto
       #
       # check_methods: Checks the methods to see if they are available for all api levels
       #
-      def check_methods(methods, force=false)
+      def check_methods(methods, force=nil)
         min_api = verify_min_sdk.to_i
         target_api = verify_target_sdk.to_i
 
@@ -67,22 +67,29 @@ module Ruboto
           end
         end
 
+        abort = false
         new_methods = methods
-        unless force
+        unless force == "include"
           # Inform and remove methods changed inside the scope of the sdk versions
           new_methods = methods.select do |i|
-            if i.attribute('api_added') and i.attribute('api_added').to_i > min_api
-              puts "Can't create #{i.method_signature} -- added in #{i.attribute('api_added')} -- exclude or force"
+            if i.attribute('api_added') and i.attribute('api_added').to_i > min_api and force == "exclude"
+              false
+            elsif i.attribute('api_added') and i.attribute('api_added').to_i > min_api
+              puts "Can't create #{i.method_signature} -- added in #{i.attribute('api_added')} -- use method_exclude or force exclude"
+              abort = true
+              false
+            elsif i.attribute('deprecated') and i.attribute('deprecated').to_i <= target_api and force == "exclude"
               false
             elsif i.attribute('deprecated') and i.attribute('deprecated').to_i <= target_api
-              puts "Can't create #{i.method_signature} -- deprecated in #{i.attribute('deprecated')} -- exclude or force"
+              puts "Can't create #{i.method_signature} -- deprecated in #{i.attribute('deprecated')} -- use method_exclude or force exclude"
+              abort = true
               false
             else
               true
             end
           end
 
-          abort("Aborting!") if methods.count != new_methods.count
+          abort("Aborting!") if abort
         end
 
         new_methods
@@ -92,7 +99,7 @@ module Ruboto
       # generate_subclass_or_interface: Creates a subclass or interface based on the specifications.
       #
       def generate_subclass_or_interface(params)
-        defaults = {:template => "InheritingClass", :method_base => "all", :method_include => "", :method_exclude => "", :force => false, :implements => ""}
+        defaults = {:template => "InheritingClass", :method_base => "all", :method_include => "", :method_exclude => "", :force => nil, :implements => ""}
         params = defaults.merge(params)
         params[:package] = verify_package unless params[:package]
 
@@ -125,10 +132,10 @@ module Ruboto
       #   on the API specifications.
       #
       def generate_core_classes(params)
-        %w(android.view.View.OnClickListener android.widget.AdapterView.OnItemClickListener).each do |i|
+        %w(android.view.View.OnClickListener android.widget.AdapterView.OnItemClickListener android.widget.AdapterView.OnItemSelectedListener).each do |i|
           name = i.split(".")[-1]
           if(params[:class] == name or params[:class] == "all")
-            generate_subclass_or_interface({:package => "org.ruboto.callbacks", :class => i, :name => "Ruboto#{name}"})
+            generate_subclass_or_interface({:package => "org.ruboto.callbacks", :class => i, :name => "Ruboto#{name}", :force => params[:force]})
           end
         end
 
@@ -139,8 +146,7 @@ module Ruboto
         %w(android.app.Activity android.app.Service android.content.BroadcastReceiver android.view.View).each do |i|
           name = i.split(".")[-1]
           if(params[:class] == name or params[:class] == "all")
-            generate_subclass_or_interface(
-            hash.merge({:template => name == "View" ? "InheritingClass" : "Ruboto#{name}", :class => i, :name => "Ruboto#{name}"}))
+            generate_subclass_or_interface(hash.merge({:template => name == "View" ? "InheritingClass" : "Ruboto#{name}", :class => i, :name => "Ruboto#{name}"}))
           end
         end
 
@@ -160,24 +166,29 @@ module Ruboto
       #
 
       def generate_inheriting_file(klass, name, package, script_name, dest='.', filename = name)
-        file = File.join(dest, "src/#{package.gsub('.', '/')}", "#{filename}.java")
+        file = File.expand_path File.join(dest, "src/#{package.gsub('.', '/')}", "#{filename}.java")
         text = File.read(File.join(Ruboto::ASSETS, "src/Inheriting#{klass}.java"))
         File.open(file, 'w') do |f|
           f << text.gsub("THE_PACKAGE", package).gsub("Inheriting#{klass}", name).gsub("start.rb", script_name)
         end
+        puts "Added file #{file}."
 
         sample_source = File.read(File.join(Ruboto::ASSETS, "samples/sample_#{underscore klass}.rb")).gsub("THE_PACKAGE", package).gsub("Sample#{klass}", name).gsub("start.rb", script_name)
         FileUtils.mkdir_p File.join(dest, 'assets/scripts')
-        File.open File.join(dest, "assets/scripts/#{script_name}"), "a" do |f|
+        script_file = File.expand_path("assets/scripts/#{script_name}", dest)
+        File.open script_file, "a" do |f|
           f << sample_source
         end
+        puts "Added file #{script_file}."
 
         sample_test_source = File.read(File.join(Ruboto::ASSETS, "samples/sample_#{underscore klass}_test.rb")).gsub("THE_PACKAGE", package).gsub("Sample#{klass}", name)
         FileUtils.mkdir_p File.join(dest, 'test/assets/scripts')
-        File.open File.join(dest, "test/assets/scripts/#{script_name.chomp('.rb')}_test.rb"), "a" do |f|
+        test_file = File.expand_path("test/assets/scripts/#{script_name.chomp('.rb')}_test.rb", dest)
+        File.open test_file, "a" do |f|
           f << sample_test_source
         end
+        puts "Added file #{test_file}."
       end
     end
   end
-end
+end

data/lib/ruboto/util/update.rb

@@ -1,23 +1,99 @@
 module Ruboto
   module Util
     module Update
+      include Build
       ###########################################################################
       #
       # Updating components
       #
+      def update_test(force = nil)
+        root = Dir.getwd
+        if force || !File.exists?("#{root}/test")
+          name = verify_strings.root.elements['string'].text.gsub(' ', '')
+          puts "\nGenerating Android test project #{name} in #{root}..."
+          system "android create test-project -m #{root} -n #{name}Test -p #{root}/test"
+          FileUtils.rm_rf File.join(root, 'test', 'src', verify_package.split('.'))
+          puts "Done"
+        else
+          puts "Test project already exists.  Use --force to overwrite."
+        end
+
+        Dir.chdir File.join(root, 'test') do
+          test_manifest = REXML::Document.new(File.read('AndroidManifest.xml')).root
+          test_manifest.elements['instrumentation'].attributes['android:name'] = 'org.ruboto.test.InstrumentationTestRunner'
+          File.open("AndroidManifest.xml", 'w'){|f| test_manifest.document.write(f, 4)}
+          instrumentation_property = "test.runner=org.ruboto.test.InstrumentationTestRunner\n"
+          prop_lines = File.readlines('build.properties')
+          File.open('build.properties', 'a'){|f| f << instrumentation_property} unless prop_lines.include?(instrumentation_property)
+          ant_setup_line = /^(\s*<setup\s*\/>)/
+          run_tests_override = <<-EOF
+<!-- BEGIN added by ruboto-core -->
+    <macrodef name="run-tests-helper">
+      <attribute name="emma.enabled" default="false"/>
+      <element name="extra-instrument-args" optional="yes"/>
+      <sequential>
+        <echo>Running tests with failure detection...</echo>
+        <exec executable="${adb}" failonerror="true" outputproperty="tests.output">
+          <arg line="${adb.device.arg}"/>
+          <arg value="shell"/>
+          <arg value="am"/>
+          <arg value="instrument"/>
+          <arg value="-w"/>
+          <arg value="-e"/>
+          <arg value="coverage"/>
+          <arg value="@{emma.enabled}"/>
+          <extra-instrument-args/>
+          <arg value="${manifest.package}/${test.runner}"/>
+        </exec>
+        <echo message="${tests.output}"/>
+        <fail message="Tests failed!!!">
+          <condition>
+            <or>
+              <contains string="${tests.output}" substring="INSTRUMENTATION_RESULT"/>
+              <contains string="${tests.output}" substring="INSTRUMENTATION_FAILED"/>
+              <contains string="${tests.output}" substring="FAILURES"/>
+              <not>
+                <matches string="${tests.output}" pattern="OK \\(\\d+ tests\\)" multiline="true"/>
+              </not>
+            </or>
+          </condition>
+        </fail>
+      </sequential>
+    </macrodef>
+
+    <target name="run-tests-quick" description="Runs tests with previously installed packages">
+      <run-tests-helper />
+    </target>
+<!-- END added by ruboto-core -->
 
-      def update_jruby(force=nil)
+EOF
+          ant_script = File.read('build.xml')
+          # TODO(uwe): Old patches without dlimiter.  Remove when we stop supporting upgrading from ruboto-core 0.2.0 and older.
+          ant_script.gsub!(/\s*<macrodef name="run-tests-helper">.*?<\/macrodef>\s*/m, '')
+          ant_script.gsub!(/\s*<target name="run-tests-quick".*?<\/target>\s*/m, '')
+          # TODO end
+          ant_script.gsub!(/\s*<!-- BEGIN added by ruboto-core -->.*?<!-- END added by ruboto-core -->\s*/m, '')
+          ant_script.gsub!(ant_setup_line, "\\1\n\n#{run_tests_override}")
+          File.open('build.xml', 'w'){|f| f << ant_script}
+        end
+      end
+
+      def update_jruby(force=nil, with_psych=nil)
         jruby_core = Dir.glob("libs/jruby-core-*.jar")[0]
         jruby_stdlib = Dir.glob("libs/jruby-stdlib-*.jar")[0]
-        new_jruby_version = JRubyJars::core_jar_path.split('/')[-1][11..-5]
+        new_jruby_version = JRubyJars::VERSION
 
         unless force
-          abort "cannot find existing jruby jars in libs. Make sure you're in the root directory of your app" if
-          (not jruby_core or not jruby_stdlib)
+          if !jruby_core || !jruby_stdlib
+            puts "Cannot find existing jruby jars in libs. Make sure you're in the root directory of your app."
+            return false
+          end
 
           current_jruby_version = jruby_core ? jruby_core[16..-5] : "None"
-          abort "both jruby versions are #{new_jruby_version}. Nothing to update. Make sure you 'gem update jruby-jars' if there is a new version" if
-          current_jruby_version == new_jruby_version
+          if current_jruby_version == new_jruby_version
+            puts "Both jruby versions are #{new_jruby_version}. Nothing to update. Make sure you 'gem update jruby-jars' if there is a new version."
+            return false
+          end
 
           puts "Current jruby version: #{current_jruby_version}"
           puts "New jruby version: #{new_jruby_version}"
@@ -29,9 +105,63 @@ module Ruboto
         log_action("Copying #{JRubyJars::core_jar_path} to libs") {copier.copy_from_absolute_path JRubyJars::core_jar_path, "libs"}
         log_action("Copying #{JRubyJars::stdlib_jar_path} to libs") {copier.copy_from_absolute_path JRubyJars::stdlib_jar_path, "libs"}
 
-        reconfigure_jruby_libs
+        reconfigure_jruby_libs(new_jruby_version, with_psych)
 
         puts "JRuby version is now: #{new_jruby_version}"
+        true
+      end
+
+      def update_assets(force = nil)
+        puts "\nCopying files:"
+        copier = Ruboto::Util::AssetCopier.new Ruboto::ASSETS, '.'
+
+        %w{Rakefile .gitignore assets res test}.each do |f|
+          log_action(f) {copier.copy f}
+        end
+      end
+
+      def update_classes(force = nil)
+        copier = Ruboto::Util::AssetCopier.new Ruboto::ASSETS, '.'
+        log_action("Ruboto java classes"){copier.copy "src/org/ruboto/*.java", "src/org/ruboto"}
+        log_action("Ruboto java test classes"){copier.copy "src/org/ruboto/test/*.java", "test/src/org/ruboto/test"}
+      end
+
+      def update_manifest(min_sdk, target, force = false)
+        log_action("\nAdding activities (RubotoActivity and RubotoDialog) and SDK versions to the manifest") do
+          if sdk_element = verify_manifest.elements['uses-sdk']
+            min_sdk ||= sdk_element.attributes["android:minSdkVersion"]
+            target ||= sdk_element.attributes["android:targetSdkVersion"]
+          end
+          if min_sdk.to_i >= 11
+            verify_manifest.elements['application'].attributes['android:hardwareAccelerated'] ||= 'true'
+          end
+          app_element = verify_manifest.elements['application']
+          if app_element.elements["activity[@android:name='org.ruboto.RubotoActivity']"]
+            puts 'found activity tag'
+          else
+            app_element.add_element 'activity', {"android:name" => "org.ruboto.RubotoActivity"}
+          end
+          if app_element.elements["activity[@android:name='org.ruboto.RubotoDialog']"]
+            puts 'found dialog tag'
+          else
+            app_element.add_element 'activity', {"android:name" => "org.ruboto.RubotoDialog", "android:theme" => "@android:style/Theme.Dialog"}
+          end
+          if sdk_element
+            sdk_element.attributes["android:minSdkVersion"] = min_sdk
+            sdk_element.attributes["android:targetSdkVersion"] = target
+          else
+            verify_manifest.add_element 'uses-sdk', {"android:minSdkVersion" => min_sdk, "android:targetSdkVersion" => target}
+          end
+          # # <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
+          # unless sdcard_permission_element = verify_manifest.elements["uses-permission[@android:name='android.permission.WRITE_EXTERNAL_STORAGE']"]
+          #   verify_manifest.add_element 'uses-permission', {"android:name" => 'android.permission.WRITE_EXTERNAL_STORAGE'}
+          # end
+          save_manifest
+        end
+      end
+
+      def update_core_classes(force = nil)
+        generate_core_classes(:class => "all", :method_base => "on", :method_include => "", :method_exclude => "", :force => force, :implements => "")
       end
 
       def update_ruboto(force=nil)
@@ -47,13 +177,16 @@ module Ruboto
           puts "New version: #{from_text[/\$RUBOTO_VERSION = (\d+)/, 1]}"
           puts "Old version: #{to_text ? to_text[/\$RUBOTO_VERSION = (\d+)/, 1] : 'none'}"
 
-          abort "The ruboto.rb verion has not changed. Use --force to force update." if
-          from_text[/\$RUBOTO_VERSION = (\d+)/, 1] == to_text[/\$RUBOTO_VERSION = (\d+)/, 1]
+          if from_text[/\$RUBOTO_VERSION = (\d+)/, 1] == to_text[/\$RUBOTO_VERSION = (\d+)/, 1]
+            puts "The ruboto.rb version has not changed. Use --force to force update."
+            return false
+          end
         end
 
-        log_action("Copying ruboto.rb and setting the package name") do
-          File.open(to, 'w') {|f| f << from_text.gsub("THE_PACKAGE", verify_package).gsub("ACTIVITY_NAME", verify_activity)}
+        log_action("Copying ruboto.rb") do
+          File.open(to, 'w') {|f| f << from_text}
         end
+        true
       end
 
       #
@@ -61,42 +194,79 @@ module Ruboto
       #   - removes unneeded code from jruby-core
       #   - moves ruby stdlib to the root of the ruby-stdlib jar
       #
-
-      def reconfigure_jruby_libs
+      def reconfigure_jruby_libs(jruby_core_version, with_psych=nil)
         jruby_core = JRubyJars::core_jar_path.split('/')[-1]
-        log_action("Removing unneeded classes from #{jruby_core}") do
-          Dir.mkdir "libs/tmp"
-          Dir.chdir "libs/tmp"
-          FileUtils.move "../#{jruby_core}", "."
-          `jar -xf #{jruby_core}`
-          File.delete jruby_core
-          ['cext', 'jni', 'org/jruby/ant', 'org/jruby/compiler/ir', 'org/jruby/demo', 'org/jruby/embed/bsf',
-            'org/jruby/embed/jsr223', 'org/jruby/ext/ffi','org/jruby/javasupport/bsf'
-            ].each {|i| FileUtils.remove_dir i, true}
-            `jar -cf ../#{jruby_core} .`
-            Dir.chdir "../.."
-            FileUtils.remove_dir "libs/tmp", true
+        Dir.chdir 'libs' do
+          log_action("Removing unneeded classes from #{jruby_core}") do
+            Dir.mkdir "tmp"
+            Dir.chdir "tmp" do
+              FileUtils.move "../#{jruby_core}", "."
+              `jar -xf #{jruby_core}`
+              File.delete jruby_core
+              invalid_libs = ['cext', 'jni', 'org/jruby/ant', 'org/jruby/compiler/ir', 'org/jruby/demo', 'org/jruby/embed/bsf',
+                'org/jruby/embed/jsr223', 'org/jruby/ext/ffi','org/jruby/javasupport/bsf'
+              ]
+              if jruby_core_version == '1.6.2'
+                puts 'Retaining FFI for JRuby 1.6.2'
+                invalid_libs.delete('org/jruby/ext/ffi')
+              end
+              invalid_libs.each {|i| FileUtils.remove_dir i, true}
+              `jar -cf ../#{jruby_core} .`
+            end
+            FileUtils.remove_dir "tmp", true
           end
 
           jruby_stdlib = JRubyJars::stdlib_jar_path.split('/')[-1]
           log_action("Reformatting #{jruby_stdlib}") do
-            Dir.mkdir "libs/tmp"
-            Dir.chdir "libs/tmp"
-            FileUtils.move "../#{jruby_stdlib}", "."
-            `jar -xf #{jruby_stdlib}`
-            File.delete jruby_stdlib
-            FileUtils.move "META-INF/jruby.home/lib/ruby/1.8", ".."
-            Dir["META-INF/jruby.home/lib/ruby/site_ruby/1.8/*"].each do |f|
-              next if File.basename(f) =~ /^..?$/
-              FileUtils.move f, "../1.8/" + File.basename(f)
+            Dir.mkdir "tmp"
+            Dir.chdir "tmp" do
+              FileUtils.move "../#{jruby_stdlib}", "."
+              `jar -xf #{jruby_stdlib}`
+              File.delete jruby_stdlib
+
+              FileUtils.move "META-INF/jruby.home/lib/ruby/1.8", ".."
+              Dir["META-INF/jruby.home/lib/ruby/site_ruby/1.8/*"].each do |f|
+                next if File.basename(f) =~ /^..?$/
+                FileUtils.move f, "../1.8/" + File.basename(f)
+              end
+              Dir["META-INF/jruby.home/lib/ruby/site_ruby/shared/*"].each do |f|
+                next if File.basename(f) =~ /^..?$/
+                FileUtils.move f, "../1.8/" + File.basename(f)
+              end
+            end
+            Dir.chdir "1.8" do
+              `jar -cf ../#{jruby_stdlib} .`
+            end
+          end
+
+          psych_jar = "psych.jar"
+          psych_already_present = File.exists? psych_jar
+          FileUtils.rm_f psych_jar
+
+          if with_psych || with_psych.nil? && psych_already_present
+            log_action("Adding psych #{File.basename psych_jar}") do
+              psych_dir = 'psych'
+              FileUtils.move "tmp/META-INF/jruby.home/lib/ruby/1.9", psych_dir
+              Dir.chdir psych_dir do
+                psych_files = Dir["**/*"]
+                puts if psych_files.any?
+                psych_files.each do |f|
+                  next if File.basename(f) =~ /^..?$/
+                  if File.exists? "../1.8/#{f}"
+                    puts "Removing duplicate #{f}"
+                    FileUtils.rm_f f
+                  end
+                end
+                `jar -cf ../#{psych_jar} .`
+              end
+              FileUtils.remove_dir psych_dir, true
             end
-            Dir.chdir "../1.8"
-            FileUtils.remove_dir "../tmp", true
-            `jar -cf ../#{jruby_stdlib} .`
-            Dir.chdir "../.."
-            FileUtils.remove_dir "libs/1.8", true
           end
+
+          FileUtils.remove_dir "tmp", true
+          FileUtils.remove_dir "1.8", true
         end
       end
     end
-  end
+  end
+end

data/lib/ruboto/util/verify.rb

@@ -14,6 +14,10 @@ module Ruboto
         @manifest ||= REXML::Document.new(File.read('AndroidManifest.xml')).root
       end
 
+      def save_manifest
+        File.open("AndroidManifest.xml", 'w') {|f| verify_manifest.document.write(f, 4)}
+      end
+      
       def verify_package
         verify_manifest
         @package ||= @manifest.attribute('package').value

data/lib/ruboto/util/xml_element.rb

@@ -158,35 +158,45 @@ module Ruboto
         args = ""
         if params.size > 3
           args = ", args"
-          rv << "IRubyObject[] args = {" + params.map{|i| "JavaUtil.convertJavaToRuby(getRuby(), #{i[0]})"}.join(", ") + "};"
+          rv << "Object[] args = {" + params.map{|i| i[0]}.join(", ") + "};"
         elsif params.size > 0
-          args = ", " + params.map{|i| "JavaUtil.convertJavaToRuby(getRuby(), #{i[0]})"}.join(", ")
+          args = ", " + params.map{|i| i[0]}.join(", ")
         end
 
         return_cast = ""
-        if attribute("return") and (attribute("return").include?(".") or attribute("return") == "int[]")
-          return_cast = "return (#{attribute("return")})"
-        elsif attribute("return") and attribute("return") == "int"
-          return_cast = "return (Integer)"
-        elsif attribute("return") and attribute("return") != "void"
-          return_cast = "return (#{attribute("return").capitalize})"
-        end
-        return_cast = return_cast.gsub("&lt;", "<").gsub("&gt;", ">")
-
         convert_return = ""
-        if attribute("return") and attribute("return") != "void"
-          convert_return = ".toJava(#{attribute("return")}.class)"
+        if attribute("return") && attribute("return") != "void"
+          if (attribute("return").include?(".") or attribute("return") == "int[]")
+            return_class = attribute("return")
+          elsif attribute("return") == 'int'
+            return_class = 'Integer'
+          else
+            return_class = attribute("return").capitalize
+          end
+          return_cast = "return (#{return_class.gsub("&lt;", "<").gsub("&gt;", ">")}) " if return_class
+          convert_return = ", #{return_class}.class"
         end
 
-        rv << "#{return_cast}RuntimeHelpers.invoke(getRuby().getCurrentContext(), callbackProcs[#{constant_string}], \"call\" #{args})#{convert_return};"
+        if return_class == 'Integer'
+          # TODO(uwe): This is a fix for JRUBY-5937  Remove when the issue is fixed.
+          rv << "#{return_cast}((Number)getRuby().callMethod(callbackProcs[#{constant_string}], \"call\" #{args}#{convert_return})).intValue();"
+          # TODO end
+        else
+        rv << "#{return_cast}getRuby().callMethod(callbackProcs[#{constant_string}], \"call\" #{args}#{convert_return});"
+        end
         rv
       end
 
       def method_definition
-        method_call((attribute("return") ? attribute("return") : "void"), attribute("name"), parameters,
-        if_else("callbackProcs[#{constant_string}] != null",
-        [super_string] + try_catch(ruby_call, ["re.printStackTrace();", default_return]),
-        [super_return])).indent.join("\n")
+        method_call(
+          (attribute("return") ? attribute("return") : "void"),
+          attribute("name"), parameters,
+          if_else(
+              "callbackProcs[#{constant_string}] != null",
+              [super_string] + try_catch(ruby_call, ["re.printStackTrace();", default_return]),
+              [super_return]
+          )
+        ).indent.join("\n")
       end
 
       def constructor_definition(class_name)