jenkins-plugin-runtime 0.1.10 → 0.1.11

data/lib/jenkins/model/build.rb

@@ -18,6 +18,26 @@ module Jenkins
 
       def initialize(native = nil)
         @native = native
+        @variables = {}
+      end
+
+      # Gets a build value. Each build stores a map of key,value
+      # pairs which can be used by each build step in the pipeline
+      #
+      # @param [String|Symbol] key
+      # @return [Object] value
+      def [](key)
+        @variables[key.to_s]
+      end
+
+      # Sets a build value. Each build has a map of key,value
+      # pairs which allow build steps to share information
+      #
+      # @param [String|Symbol] key
+      # @param [Object] value
+      # @return [Object] value
+      def []=(key, value)
+        @variables[key.to_s] = value
       end
 
       def workspace

data/lib/jenkins/model/descriptor.rb

@@ -55,8 +55,15 @@ module Jenkins
         @impl.new
       end
 
+      # compute the path name of views for this class
       def name_to_path
-        @impl.name.split('::').join('/')
+        # camel case to underscore conversion taken from ActiveSupport::Inflector::underscore,
+        # which is MIT-licensed.
+        @impl.name.split('::').join('/').gsub(/::/, '/').
+            gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').
+            gsub(/([a-z\d])([A-Z])/, '\1_\2').
+            tr("-", "_").
+            downcase
       end
     end
 

data/lib/jenkins/plugin.rb

@@ -152,8 +152,8 @@ module Jenkins
     #
     # @param [Object] internal the object on the Ruby side of the link
     # @param [java.lang.Object] external the object on the Java side of the link
-    def link(internal, external)
-      @proxies.link internal, external
+    def linkout(internal, external)
+      @proxies.linkout internal, external
     end
 
     def load_models

data/lib/jenkins/plugin/proxies.rb

@@ -5,7 +5,7 @@ module Jenkins
 
     ExportError = Class.new(StandardError)
     ImportError = Class.new(StandardError)
-    NativeJavaObject = Struct.new(:native)
+    OpaqueJavaObject = Struct.new(:native)
 
     # Maps JRuby objects part of the idomatic Ruby API
     # to a plain Java object representation and vice-versa.
@@ -49,20 +49,20 @@ module Jenkins
       # @param [Object] object the object to bring in from the outside
       # @return the best representation of that object for this plugin
       def import(object)
-        if ref = @ext2int[object]
-          return ref.get() if ref.get()
+        if proxy = deref(@ext2int, object)
+          return proxy
         end
         cls = object.class
         while cls do
           if internal_class = @@extcls2intcls[cls]
             internal = internal_class.new(object)
-            link(internal, object)
+            linkin(internal, object)
             return internal
           end
           cls = cls.superclass
         end
-        internal = NativeJavaObject.new(object)
-        link(internal, object)
+        internal = OpaqueJavaObject.new(object)
+        linkin(internal, object)
         return internal
       end
 
@@ -73,35 +73,73 @@ module Jenkins
       # @return [java.lang.Object] the Java wrapper that provides an interface to `object`
       # @throw [ExportError] if no suitable Java representation can be found
       def export(object)
-        if ref = @int2ext[object]
-          return ref.get() if ref.get()
+        if proxy = deref(@int2ext, object)
+          return proxy
         end
 
         cls = object.class
         while cls do
-          if proxy_class = @@intcls2extcls[cls]
-            proxy = proxy_class.new(@plugin, object)
-            link(object, proxy)
-            return proxy
+          if external_class = @@intcls2extcls[cls]
+            external = external_class.new(@plugin, object)
+            linkout(object, external)
+            return external
           end
           cls = cls.superclass
         end
         raise ExportError, "unable to find suitable Java Proxy for #{object.inspect}"
       end
 
-      ##
-      # Link a plugin-local Ruby object to an external Java object such that they will
-      # be subsituted for one another when passing values back and forth between Jenkins
-      # and this plugin. An example of this is associating the Ruby Jenkins::Launcher object
-      # with an equivalent
+
+      # Forms an incoming reference to an internal Ruby object from an
+      # external Java object. These two objects will be referentially
+      # equivalent whenever they are passed back and forth between the Ruby
+      # plugin and the Jenkins runtime.
+      #
+      # The fact that this reference is "in" means
+      # that GC-wise, the internal Ruby object depends on the external
+      # Java object. In other words, it will not be garbage collected
+      # until the Java object is.
+      #
+      # This behavior is important for things like AbstractBuild objects. We
+      # don't want our Ruby `Build` object that corresponds to it to be GC'd
+      # until the `hudson.model.AbstractBuild` it represents is itself
+      # collected. That allows us to maintain state on the Ruby object, and know
+      # that the same state will be accessible wherever.
+      #
+      # Only weak refereces are maintained to the external Java object.
       #
       # @param [Object] internal the object on the Ruby side of the link
       # @param [java.lang.Object] external the object on the Java side of the link
-      def link(internal, external)
+      def linkin(internal, external)
         @int2ext.put(internal, java.lang.ref.WeakReference.new(external))
+        @ext2int.put(external, internal)
+      end
+
+      # Forms an outgoing reference from an internal Ruby object to an
+      # external Java object. These two objects will be referentially
+      # equivalent whenever they are passed back and forth between the Ruby
+      # plugin and the Jenkins runtime.
+      #
+      # The fact that this reference goes "out" means
+      # that GC-wise, the external Java object depends on the internal
+      # Ruby object. In other words, The Java object will not be garbage
+      # collected until the local Ruby object is.
+      #
+      # Only weak refereces are maintained to the internal Ruby object.
+      #
+      # @param [Object] internal the object on the Ruby side of the link
+      # @param [java.lang.Object] external the object on the Java side of the link
+      def linkout(internal, external)
+        @int2ext.put(internal, external)
         @ext2int.put(external, java.lang.ref.WeakReference.new(internal))
       end
 
+      def deref(reflist, object)
+        if ref = reflist[object]
+          ref.is_a?(java.lang.ref.Reference) ? ref.get() : ref
+        end
+      end
+
       ##
       # Associated the the Ruby class `internal_class` with the Java class `external_class`.
       #

data/lib/jenkins/plugin/proxies/build_wrapper.rb

@@ -15,11 +15,10 @@ module Jenkins
         include Jenkins::Plugin::Proxy
 
         def setUp(build, launcher, listener)
-          env = {}
-          @object.setup(import(build), import(launcher), import(listener), env)
-          EnvironmentWrapper.new(self, @plugin, @object, env)
+          @object.setup(import(build), import(launcher), import(listener))
+          EnvironmentWrapper.new(self, @plugin, @object)
         rescue Jenkins::Model::Build::Halt
-            nil
+          nil
         end
 
         def getDescriptor
@@ -35,15 +34,14 @@ module Jenkins
 
       class EnvironmentWrapper < Java.hudson.tasks.BuildWrapper::Environment
 
-        def initialize(build_wrapper, plugin, impl, env)
+        def initialize(build_wrapper, plugin, impl)
           super(build_wrapper)
           @plugin = plugin
           @impl = impl
-          @env = env
         end
 
         def tearDown(build, listener)
-          @impl.teardown(@plugin.import(build), @plugin.import(listener), @env)
+          @impl.teardown(@plugin.import(build), @plugin.import(listener))
           true
         rescue Jenkins::Model::Build::Halt
           false

data/lib/jenkins/plugin/proxy.rb

@@ -56,7 +56,7 @@ module Jenkins
         # so that they remain referentially equivalent.
         def read_completed
           @plugin = Java.jenkins.model.Jenkins.getInstance().getPlugin(@pluginid).getNativeRubyPlugin()
-          @plugin.link @object, self
+          @plugin.linkout @object, self
         end
 
       end

data/lib/jenkins/plugin/runtime/version.rb

@@ -1,7 +1,7 @@
 module Jenkins
   class Plugin
     module Runtime
-      VERSION = "0.1.10"
+      VERSION = "0.1.11"
     end
   end
 end

data/lib/jenkins/tasks/build_wrapper.rb

@@ -17,8 +17,7 @@ module Jenkins
       # @param [Jenkins::Model::Build] build the build about to run
       # @param [Jenkins::Launcher] launcher a launcher for the orderly starting/stopping of processes.
       # @param [Jenkins::Model::Listener] listener channel for interacting with build output console
-      # @param [Hash] env a place to store information needed by #teardown
-      def setup(build, launcher, listener, env)
+      def setup(build, launcher, listener)
 
       end
 
@@ -29,8 +28,7 @@ module Jenkins
       #
       # @param [Jenkins::Model::Build] the build which has completed
       # @param [Jenkins::Model::Listener] listener channel for interacting with build output console
-      # @param [Hash] env contains anything that #setup needs to tell #teardown about
-      def teardown(build, listener, env)
+      def teardown(build, listener)
 
       end
     end

data/spec/jenkins/model/build_spec.rb

@@ -36,4 +36,25 @@ describe Jenkins::Model::Build do
   it "can abort" do
     expect {@build.abort "aborting"}.should raise_error(Java.hudson.AbortException, "aborting")
   end
+
+  describe "hash-y interface" do
+    before do
+      @val = Object.new
+      @build['val'] = @val
+    end
+
+    it "gets" do
+      @build['val'].should be @val
+    end
+
+    it "sets" do
+      @build['val'] = :foo
+      @build['val'].should be :foo
+    end
+
+    it "has symbol/string indifferent access" do
+      @build[:val].should be @val
+    end
+  end
+
 end

data/spec/jenkins/plugin/proxies/build_wrapper_spec.rb

@@ -14,12 +14,12 @@ describe Jenkins::Plugin::Proxies::BuildWrapper do
 
   it "passes in an env file which will be called to " do
     env = nil
-    @object.should_receive(:setup).with(@build, @launcher, @listener, an_instance_of(Hash)) do |*args|
+    @object.should_receive(:setup).with(@build, @launcher, @listener) do |*args|
       env = args.last
     end
     environment = @wrapper.setUp(@jBuild, @jLauncher, @jListener)
 
-    @object.should_receive(:teardown).with(@build, @listener, env)
+    @object.should_receive(:teardown).with(@build, @listener)
     environment.tearDown(@jBuild, @jListener)
   end
 

data/spec/jenkins/plugin/proxies_spec.rb

@@ -50,7 +50,7 @@ describe Jenkins::Plugin::Proxies do
     describe "when a wrapper has already existed" do
       before do
         @proxy = Object.new
-        @proxies.link @object, @proxy
+        @proxies.linkin @object, @proxy
       end
 
       it "finds the same proxy on export" do
@@ -138,7 +138,7 @@ describe Jenkins::Plugin::Proxies do
       @umappable = java.lang.Object.new
       @import = @proxies.import(@umappable)
     end
-    it "maps it do an opaque native java object structure" do
+    it "maps it to an opaque native java object structure" do
       @import.native.should be @umappable
     end
     it "reuses the same opaque proxy on subsequent imports" do

data/spec/jenkins/plugin/proxy_spec.rb

@@ -34,7 +34,7 @@ describe "a class with #{Jenkins::Plugin::Proxy} mixed in" do
     end
 
     it "reconstructs the @plugin field" do
-      @plugin.should_receive(:link).with(@impl, @proxy)
+      @plugin.should_receive(:linkout).with(@impl, @proxy)
       @proxy.read_completed
       @proxy.plugin.should be(@plugin)
     end

metadata

@@ -2,7 +2,7 @@
 name: jenkins-plugin-runtime
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.1.10
+  version: 0.1.11
 platform: ruby
 authors: 
   - Charles Lowell
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-10-26 00:00:00 -05:00
+date: 2011-10-31 00:00:00 -05:00
 default_executable: 
 dependencies: 
   - !ruby/object:Gem::Dependency