pepijnve-ivy4r 0.12.11

data/lib/ivy/artifactproperty.rb

@@ -0,0 +1,34 @@
+require 'ivy/target'
+
+module Ivy
+  class Artifactproperty < Ivy::Target
+    def parameter
+      [
+        Parameter.new(:name, true),
+        Parameter.new(:value, true),
+        Parameter.new(:conf, false),
+        Parameter.new(:haltonfailure, false),
+        Parameter.new(:validate, false),
+        Parameter.new(:overwrite, false),
+        Parameter.new(:settingsRef, false),
+      ]
+    end
+
+    protected
+    def before_hook
+      @cached_property_names = ant_properties.map {|key, value| key }
+    end
+
+    def after_hook
+      @cached_property_names = nil
+    end
+
+    def execute_ivy
+      call_nested :ivy_artifactproperty => params
+    end
+
+    def create_return_values
+      ant_properties.reject { |key, value| @cached_property_names.member? key }
+    end
+  end
+end

data/lib/ivy/artifactreport.rb

@@ -0,0 +1,24 @@
+require 'ivy/target'
+
+module Ivy
+  class Artifactreport < Ivy::Target
+    def parameter
+      [
+        Parameter.new(:tofile, true),
+        Parameter.new(:pattern, false),
+        Parameter.new(:conf, false),
+        Parameter.new(:haltonfailure, false),
+        Parameter.new(:settingsRef, false)
+      ]
+    end
+
+    protected
+    def execute_ivy
+      call_nested :ivy_artifactreport => params
+    end
+
+    def create_return_values
+      IO.read(params[:tofile])
+    end
+  end
+end

data/lib/ivy/buildlist.rb

@@ -0,0 +1,37 @@
+require 'ivy/target'
+
+module Ivy
+  class Buildlist < Ivy::Target
+    def parameter
+      [
+        Parameter.new(:reference, false),
+        Parameter.new(:nested, true),
+        Parameter.new(:ivyfilepath, false),
+        Parameter.new(:root, false),
+        Parameter.new(:excluderoot, false),
+        Parameter.new(:leaf, false),
+        Parameter.new(:onlydirectdep, false),
+        Parameter.new(:delimiter, false),
+        Parameter.new(:excludeleaf, false),
+        Parameter.new(:haltonerror, false),
+        Parameter.new(:skipbuildwithoutivy, false),
+        Parameter.new(:onMissingDescriptor, false),
+        Parameter.new(:reverse, false),
+        Parameter.new(:restartFrom, false),
+        Parameter.new(:settingsRef, false)
+      ]
+    end
+
+    protected
+    def execute_ivy
+      params[:reference] = "path-#{rand.to_s}" unless params[:reference]
+      call_nested :ivy_buildlist => params
+    end
+
+    def create_return_values
+      path = ant_references.find { |current| params[:reference] == current[0] }[1]
+      raise "Could not get path for params #{params.inspect}" unless path && path.respond_to?(:list)
+      path.list.map {|a| a.to_s }
+    end
+  end
+end

data/lib/ivy/buildnumber.rb

@@ -0,0 +1,34 @@
+require 'ivy/target'
+
+module Ivy
+  class Buildnumber < Ivy::Target
+    def parameter
+      [
+        Parameter.new(:organisation, true),
+        Parameter.new(:module, true),
+        Parameter.new(:branch, false),
+        Parameter.new(:revision, false),
+        Parameter.new(:default, false),
+        Parameter.new(:defaultBuildNumber, false),
+        Parameter.new(:revSep, false),
+        Parameter.new(:prefix, false),
+        Parameter.new(:settingsRef, false),
+        Parameter.new(:resolver, false)
+      ]
+    end
+
+    def result_property_values
+      [
+        ResultValue.new("ivy.revision", nil),
+        ResultValue.new("ivy.new.revision", nil),
+        ResultValue.new("ivy.build.number", nil),
+        ResultValue.new("ivy.new.build.number", nil)
+      ]
+    end
+
+    protected
+    def execute_ivy
+      call_nested :ivy_buildnumber => params
+    end
+  end
+end

data/lib/ivy/cachepath.rb

@@ -0,0 +1,30 @@
+require 'ivy/target'
+
+module Ivy
+  class Cachepath < Ivy::Target
+    def parameter
+      [
+        Parameter.new(:pathid, true),
+        Parameter.new(:conf, false),
+        Parameter.new(:inline, false),
+        Parameter.new(:organisation, false),
+        Parameter.new(:module, false),
+        Parameter.new(:revision, false),
+        Parameter.new(:branch, false),
+        Parameter.new(:type, false),
+        Parameter.new(:settingsRef, false),
+      ]
+    end
+
+    def create_return_values
+      path = ant_references.find { |current| current[0] == params[:pathid] }[1]
+      raise "Could not get path for confs: #{params.inspect}" unless path && path.respond_to?(:list)
+      path.list.map {|a| a.to_s }
+    end
+
+    protected
+    def execute_ivy
+      call_nested :ivy_cachepath => params
+    end
+  end
+end

data/lib/ivy/cleancache.rb

@@ -0,0 +1,20 @@
+require 'ivy/target'
+
+module Ivy
+  class Cleancache < Ivy::Target
+    def parameter
+      [
+        Parameter.new(:settingsRef, false)
+      ]
+    end
+
+    protected
+    def execute_ivy
+      call_nested :ivy_cleancache => params
+    end
+    
+    def create_return_values
+      nil
+    end
+  end
+end

data/lib/ivy/configure.rb

@@ -0,0 +1,29 @@
+require 'ivy/target'
+
+module Ivy
+  class Configure < Ivy::Target
+    def parameter
+      [
+        Parameter.new(:id, false),
+        Parameter.new(:file, false),
+        Parameter.new(:url, false),
+        Parameter.new(:host, false),
+        Parameter.new(:realm,false),
+        Parameter.new(:username, false),
+        Parameter.new(:passwd, false)
+      ]
+    end
+
+    def result_property_values
+      property = params[:id] || 'ivy.instance'
+      [
+        ResultValue.new(/.*\.#{property}/, nil)
+      ]
+    end
+
+    protected
+    def execute_ivy
+      call_nested :ivy_configure => params
+    end
+  end
+end

data/lib/ivy/findrevision.rb

@@ -0,0 +1,34 @@
+require 'ivy/target'
+
+module Ivy
+  class Findrevision < Ivy::Target
+    def parameter
+      [
+        Parameter.new(:organisation, true),
+        Parameter.new(:module, true),
+        Parameter.new(:branch, false),
+        Parameter.new(:revision, true),
+        Parameter.new(:property, false),
+        Parameter.new(:settingsRef, false)
+      ]
+    end
+
+    def result_property_values
+      property = params[:property] || 'ivy.revision'
+      [
+        ResultValue.new("#{property}", nil)
+      ]
+    end
+
+    protected
+    def execute_ivy
+      call_nested :ivy_findrevision => params
+    end
+
+    def create_return_values
+      values = result_properties.values
+      raise "Could not retrieve revision for '#{params.inspect}'" if values.size > 1
+      values.size == 1 ? values[0] : nil
+    end
+  end
+end

data/lib/ivy/info.rb

@@ -0,0 +1,36 @@
+require 'ivy/target'
+
+module Ivy
+  class Info < Ivy::Target
+    def parameter
+      [
+        Parameter.new(:file, true),
+        Parameter.new(:organisation, false),
+        Parameter.new(:module, false),
+        Parameter.new(:branch, false),
+        Parameter.new(:revision, false),
+        Parameter.new(:property, false),
+        Parameter.new(:settingsRef, false)
+      ]
+    end
+
+    def result_property_values
+      property = params[:property] || 'ivy'
+      [
+        ResultValue.new("#{property}.organisation", nil),
+        ResultValue.new("#{property}.module", nil),
+        ResultValue.new("#{property}.branch", nil),
+        ResultValue.new("#{property}.revision", nil),
+        ResultValue.new("#{property}.status", nil),
+        ResultValue.new(/#{property}.extra\..*/, nil),
+        ResultValue.new("#{property}.configurations", Ivy::COMMA_SPLITTER),
+        ResultValue.new("#{property}.public.configurations", Ivy::COMMA_SPLITTER)
+      ]
+    end
+
+    protected
+    def execute_ivy
+      call_nested :ivy_info => params
+    end
+  end
+end

data/lib/ivy/install.rb

@@ -0,0 +1,33 @@
+require 'ivy/target'
+
+module Ivy
+  class Install < Ivy::Target
+    def parameter
+      [
+        Parameter.new(:from, true),
+        Parameter.new(:to, true),
+        Parameter.new(:organisation, true),
+        Parameter.new(:module, true),
+        Parameter.new(:branch, false),
+        Parameter.new(:revision, true),
+        Parameter.new(:type, false),
+        Parameter.new(:validate, false),
+        Parameter.new(:overwrite, false),
+        Parameter.new(:transitive, false),
+        Parameter.new(:matcher, false),
+        Parameter.new(:settingsRef, false),
+        Parameter.new(:haltonfailure, false)
+      ]
+    end
+    
+    protected
+    def execute_ivy
+      call_nested :ivy_install => params
+    end
+
+    def create_return_values
+      nil
+    end
+
+  end
+end

data/lib/ivy/java/all_version_matcher.rb

@@ -0,0 +1,31 @@
+module Ivy
+  # Matcher that accepts all versions of the same module as a match, i.e.
+  # only checking that the module is the same.
+  class IvyAllVersionMatcher
+    include Java::OrgApacheIvyPluginsVersion::VersionMatcher
+
+    def is_dynamic(askedMrid)
+      false
+    end
+
+    def accept(askedMrid, foundMrid)
+      true
+    end
+
+    def need_module_descriptor(askedMrid, foundMrid)
+      false
+    end
+
+    def accept(askedMrid, foundMD)
+      true
+    end
+
+    def compare(askedMrid, foundMrid, staticComparator)
+      0
+    end
+
+    def getName
+      self.class
+    end
+  end
+end

data/lib/ivy/java/java_object_wrapper.rb

@@ -0,0 +1,160 @@
+# Extenions to the {Ruby-Java Bridge}[http://rjb.rubyforge.org/] module that
+# add a generic Java object wrapper class for transparent access of java objects
+# from ruby using RJB.
+#
+# This file was part of the Stanford Parser Ruby Wrapper by William Patrick McNeill.
+# Only a few modifications have been done to make it compatible with ivy4r and the
+# Java Ant objects that are accessed.
+module Rjb
+  class JavaObjectWrapper
+    include Enumerable
+    
+    # The underlying Java object.
+    attr_reader :java_object
+    
+    # Initialize with a Java object <em>obj</em>.  If <em>obj</em> is a
+    # String, treat it as a Java class name and instantiate it.  Otherwise,
+    # treat <em>obj</em> as an instance of a Java object.
+    def initialize(obj, *args)
+      @java_object = obj.class == String ? Rjb::import(obj).send(:new, *args) : obj
+    end
+    
+    # Enumerate all the items in the object using its iterator.  If the object
+    # has no iterator, this function yields nothing.
+    def each
+      if @java_object.getClass.getMethods.any? {|m| m.getName == "iterator"}
+        i = @java_object.iterator
+        while i.hasNext
+          yield wrap_java_object(i.next)
+        end
+      end
+    end # each
+    
+    # Reflect unhandled method calls to the underlying Java object and wrap
+    # the return value in the appropriate Ruby object.
+    def method_missing(m, *args)
+      begin
+        JavaObjectWrapper.wrap_java_object(@java_object.send(m, *args))
+      rescue RuntimeError => e
+        # The instance method failed.  See if this is a static method.
+        if not e.message.match(/^Fail: unknown method name/).nil?
+          getClass.send(m, *args)
+        end
+      end
+    end
+    
+    # Checks if underlying java object responds to method prior using standard respond_to? method.
+    def respond_to?(sym)
+      java = @java_object.getClass.getMethods.any? {|m| m.getName == sym.to_s} || super.respond_to?(sym)
+    end
+    
+    # Show the classname of the underlying Java object.
+    def inspect
+      "<#{@java_object._classname}>"
+    end
+    
+    # Use the underlying Java object's stringification.
+    def to_s
+      toString
+    end
+    
+    # All wrapping is done at class level and not at instance level this deviates from the base
+    # implementation
+    class << self
+      # Convert a value returned by a call to the underlying Java object to the
+      # appropriate Ruby object.
+      #
+      # If the value is a JavaObjectWrapper, convert it using a protected
+      # function with the name wrap_ followed by the underlying object's
+      # classname with the Java path delimiters converted to underscores. For
+      # example, a <tt>java.util.ArrayList</tt> would be converted by a function
+      # called wrap_java_util_ArrayList.
+      #
+      # If the value lacks the appropriate converter function, wrap it in a
+      # generic JavaObjectWrapper.
+      #
+      # If the value is not a JavaObjectWrapper, return it unchanged.
+      #
+      # This function is called recursively for every element in an Array.
+      def wrap_java_object(object)
+        if object.kind_of?(Array)
+          object.collect {|item| wrap_java_object(item)}
+        elsif object.respond_to?(:_classname)
+          # Ruby-Java Bridge Java objects all have a _classname member
+          find_converter(object) || JavaObjectWrapper.new(object)
+        else
+          object
+        end
+      end
+      
+      protected
+      # Checks if any class in objects class hierachy or interface of class has a converter method defined
+      # if converter exists returns converted object.
+      def find_converter(object)
+        classnames_to_check(object).each do |name|
+          wrapper = wrapper_name(name)
+          if respond_to?(wrapper, true)
+            return send(wrapper, object)
+          end
+        end
+        
+        nil
+      end
+      
+      # Returns all java classnames that should be checked for an adequate mapper for given object.
+      def classnames_to_check(object)
+        names = []
+        clazz = object.getClass
+        while clazz
+          names << clazz.getName
+          clazz.getInterfaces.each {|i| names << i.getName}
+          clazz = clazz.getSuperclass
+        end
+        
+        names.uniq
+      end
+      
+      # Returns the wrapper name for given java classname.
+      def wrapper_name(java_classname)
+        ("convert_" + java_classname.gsub(/\./, "_")).downcase.to_sym
+      end
+      
+      # Convert <tt>java.util.List</tt> objects to Ruby Array objects.
+      def convert_java_util_list(object)
+        array_list = []
+        object.size.times do
+          |i| array_list << wrap_java_object(object.get(i))
+        end
+        array_list
+      end
+      
+      # Convert <tt>java.util.Set</tt> objects to Ruby array object with no duplicates.
+      def convert_java_util_set(object)
+        set = []
+        i = object.iterator
+        while i.hasNext
+          set << wrap_java_object(i.next)
+        end
+        set.uniq
+      end
+      
+      # Convert <tt>java.util.Map</tt> objects to Ruby Hash object.
+      def convert_java_util_map(object)
+        hash = {}
+        i = object.entrySet.iterator
+        while i.hasNext
+          entry = i.next
+          hash[wrap_java_object(entry.getKey)] = wrap_java_object(entry.getValue)
+        end
+        hash
+      end
+      
+      # Convert <tt>java.lang.String</tt> objects to Ruby String.
+      def convert_java_lang_string(object)
+        object.toString
+      end
+      
+    end
+  end
+  
+end