pepijnve-ivy4r 0.12.11

data/lib/ivy/listmodules.rb

@@ -0,0 +1,35 @@
+require 'ivy/target'
+
+module Ivy
+  class Listmodules < Ivy::Target
+    def parameter
+      [
+        Parameter.new(:organisation, true),
+        Parameter.new(:module, true),
+        Parameter.new(:branch, false),
+        Parameter.new(:revision, true),
+        Parameter.new(:matcher, false),
+        Parameter.new(:property, true),
+        Parameter.new(:value, true),
+        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_listmodules => params
+    end
+
+    def create_return_values
+      ant_properties.reject { |key, value| @cached_property_names.member? key }
+    end
+  end
+end

data/lib/ivy/makepom.rb

@@ -0,0 +1,30 @@
+require 'ivy/target'
+
+module Ivy
+  class Makepom < Ivy::Target
+    def parameter
+      [
+        Parameter.new(:ivyfile, true),
+        Parameter.new(:pomfile, true),
+        Parameter.new(:templatefile, false),
+        Parameter.new(:artifactName, false),
+        Parameter.new(:artifactPackaging, false),
+        Parameter.new(:conf, false),
+        Parameter.new(:settingsRef, false),
+        Parameter.new(:printIvyInfo, false),
+        Parameter.new(:headerFile, false),
+        Parameter.new(:description, false),
+        Parameter.new(:nested, false)
+      ]
+    end
+
+    protected
+    def execute_ivy
+      call_nested :ivy_makepom => params
+    end
+
+    def create_return_values
+      IO.read(params[:pomfile])
+    end
+  end
+end

data/lib/ivy/publish.rb

@@ -0,0 +1,37 @@
+require 'ivy/target'
+
+module Ivy
+  class Publish < Ivy::Target
+    def parameter
+      [
+        Parameter.new(:artifactspattern, false),
+        Parameter.new(:resolver, true),
+        Parameter.new(:pubrevision, false),
+        Parameter.new(:pubbranch, false),
+        Parameter.new(:forcedeliver, false),
+        Parameter.new(:update, false),
+        Parameter.new(:validate, false),
+        Parameter.new(:replacedynamicrev, false),
+        Parameter.new(:publishivy, false),
+        Parameter.new(:conf, false),
+        Parameter.new(:overwrite, false),
+        Parameter.new(:warnonmissing, false),
+        Parameter.new(:srcivypattern, false),
+        Parameter.new(:srcivypattern, false),
+        Parameter.new(:pubdate, false),
+        Parameter.new(:status, false),
+        Parameter.new(:delivertarget, false),
+        Parameter.new(:settingsRef, false)
+      ]
+    end
+    
+    protected
+    def execute_ivy
+      call_nested :ivy_publish => params
+    end
+
+    def create_return_values
+      nil
+    end
+  end
+end

data/lib/ivy/report.rb

@@ -0,0 +1,33 @@
+require 'ivy/target'
+
+module Ivy
+  class Report < Ivy::Target
+    def parameter
+      [
+        Parameter.new(:todir, false),
+        Parameter.new(:nested, false),
+        Parameter.new(:outputpattern, false),
+        Parameter.new(:xsl, false),
+        Parameter.new(:xml, false),
+        Parameter.new(:graph, false),
+        Parameter.new(:dot, false),
+        Parameter.new(:conf, false),
+        Parameter.new(:organisation, false),
+        Parameter.new(:module, false),
+        Parameter.new(:validate, false),
+        Parameter.new(:xslfile, false),
+        Parameter.new(:settingsRef, false),
+        Parameter.new(:resolveId, false)
+      ]
+    end
+
+    protected
+    def execute_ivy
+      call_nested :ivy_report => params
+    end
+
+    def create_return_values
+      nil
+    end
+  end
+end

data/lib/ivy/resolve.rb

@@ -0,0 +1,44 @@
+require 'ivy/target'
+
+module Ivy
+  class Resolve < Ivy::Target
+    def parameter
+      [
+        Parameter.new(:file, false),
+        Parameter.new(:conf, false),
+        Parameter.new(:refresh, false),
+        Parameter.new(:resolveMode, false),
+        Parameter.new(:inline, false),
+        Parameter.new(:keep, false),
+        Parameter.new(:organisation, false),
+        Parameter.new(:module, false),
+        Parameter.new(:revision, false),
+        Parameter.new(:branch, false),
+        Parameter.new(:type, false),
+        Parameter.new(:haltonfailure, false),
+        Parameter.new(:failureproperty, false),
+        Parameter.new(:transitive, false),
+        Parameter.new(:showprogress, false),
+        Parameter.new(:validate, false),
+        Parameter.new(:settingsRef, false),
+        Parameter.new(:resolveId, false),
+        Parameter.new(:log, false)
+      ]
+    end
+
+    def result_property_values
+      property = params[:resolveId] ? ".#{params[:resolveId]}" : ''
+      [
+        ResultValue.new("ivy.organisation#{property}", nil),
+        ResultValue.new("ivy.module#{property}", nil),
+        ResultValue.new("ivy.revision#{property}", nil),
+        ResultValue.new("ivy.resolved.configurations#{property}", Ivy::COMMA_SPLITTER)
+      ]
+    end
+
+    protected
+    def execute_ivy
+      call_nested :ivy_resolve => params
+    end
+  end
+end

data/lib/ivy/retrieve.rb

@@ -0,0 +1,27 @@
+require 'ivy/target'
+
+module Ivy
+  class Retrieve < Ivy::Target
+    def parameter
+      [
+        Parameter.new(:pattern, false),
+        Parameter.new(:ivypattern, false),
+        Parameter.new(:conf, false),
+        Parameter.new(:sync, false),
+        Parameter.new(:type, false),
+        Parameter.new(:symlink, false),
+        Parameter.new(:settingsRef, false),
+        Parameter.new(:log, false)
+      ]
+    end
+
+    protected
+    def execute_ivy
+      call_nested :ivy_retrieve => params
+    end
+
+    def create_return_values
+      nil
+    end
+  end
+end

data/lib/ivy/settings.rb

@@ -0,0 +1,15 @@
+require 'ivy/configure'
+
+module Ivy
+  class Settings < Ivy::Configure
+
+    def create_return_values
+      nil
+    end
+
+    protected
+    def execute_ivy
+      call_nested :ivy_settings => params
+    end
+  end
+end

data/lib/ivy/target.rb

@@ -0,0 +1,162 @@
+require 'digest/md5'
+
+require 'ivy/java/java_object_wrapper'
+
+module Ivy
+
+  # Base class with general logic to call a Ivy ant target
+  class Target
+    attr_reader :params
+
+    def initialize(ant, cache_dir = nil)
+      raise "Cache result directory does not exists '#{cache_dir}'" if cache_dir != nil && !File.directory?(cache_dir)
+      @ant = ant
+      @cache_dir = cache_dir
+    end
+
+    # Executes this ivy target with given parameters returning a result.
+    # __params__ can be a single Hash or an Array with or without a Hash as last value.
+    # every value in array will be converted to string and set to __true__.
+    #
+    # I.e. <tt>[:force, 'validate', {'name' => 'Blub'}]</tt>
+    # results in parameters <tt>{'force'=>true, 'validate' => true, 'name'=>'Blub'}</tt>
+    def execute(*params)
+      @params = {}
+      params.pop.each { |key, value| @params[key] = value } if Hash === params.last
+      params.each { |key| @params[key.to_s] = true }
+      if caching_enabled? && File.exists?(cache_file_path)
+        load_from_yaml
+      else
+        result = execute_target
+        dump_to_yaml(result) if caching_enabled?
+        result
+      end
+    end
+
+  protected
+
+    def caching_enabled?
+      @cache_dir != nil
+    end
+
+    def cache_file_path
+      @cache_file_path ||= File.expand_path(File.join(@cache_dir, Digest::MD5.hexdigest(self.class.to_s + @params.to_s) + '.yaml'))
+    end
+
+    def load_from_yaml
+      File.open(cache_file_path) {|f| YAML::load(f)}
+    end
+
+    def dump_to_yaml(result)
+      File.open(cache_file_path, 'w') {|f| YAML.dump(result, f)}
+    end
+
+    # The bare bone execution of this target without any crosscutting concerns.
+    def execute_target
+      validate
+      before_hook
+      execute_ivy
+      create_return_values
+    ensure
+      after_hook
+    end
+
+    # Validates provided hash of parameters, raises an exception if any mandatory parameter is
+    # missing or an unknown parameter has been provided.
+    def validate
+      unknown = params.keys - symbols(parameter)
+      raise ArgumentError, "Unknown parameters '#{unknown.join(', ')}' for #{self.class}" unless unknown.empty?
+      missing = symbols(mandatory_parameter).find_all { |p| params.keys.member?(p) == false }
+      raise ArgumentError, "Missing mandatory parameters '#{missing.join(', ')}' for #{self.class}" unless missing.empty?
+    end
+
+    # Hook method called after validation but before #execute_ivy
+    # overwrite for special actions needed
+    def before_hook
+    end
+
+    # After hook is always called for #execute_target within +ensure+ block
+    # overwrite for special clean up
+    def after_hook
+    end
+
+    # Helper to call the nested ant targets recursively if nessecary. Must be called within +do+ +end+
+    # block of ant target to work.
+    def call_nested(nested)
+      if nested
+        nested.each do |method, paramlist|
+          [paramlist].flatten.each do |params|
+            if params.member? :nested
+              p = params.dup
+              nest = p.delete(:nested)
+              @ant.send(method, p, &lambda { |*_| call_nested(nest)})
+            else
+              @ant.send(method, params)
+            end
+          end
+        end
+      end
+    end
+
+    # Creates the result for the execution by default it iterates of the ant properties and fetches
+    # all properties that match the result properties for target as a hash. Overwrite to provide
+    # a different result
+    def create_return_values
+      result_properties
+    end
+
+    # Fetches all result properties for called target and returns them as hash
+    def result_properties
+      result = ant_properties.map do |p|
+        rp = result_property_values.find { |rp| rp.matcher === p[0] }
+        rp ? [p[0], rp.parse(p[1])].flatten : nil
+      end.compact.inject({}) do |h,v|
+        k = v.shift
+        h[k] ||= []
+        h[k].concat(v)
+        h
+      end
+      result.each do |k,v|
+        result[k] = case v.size
+        when 0  then nil
+        when 1  then v[0]
+        else v
+        end
+      end
+
+      result
+    end
+
+    def mandatory_parameter
+      parameter.find_all {|p| p.mandatory? }
+    end
+
+    def symbols(params)
+      params.map{|p| p.symbol}
+    end
+
+    def ant_properties
+      Rjb::JavaObjectWrapper.wrap_java_object @ant.project.properties
+    end
+
+    def ant_references
+      Rjb::JavaObjectWrapper.wrap_java_object @ant.project.references
+    end
+  end
+
+
+
+  COMMA_SPLITTER = Proc.new {|value| value.to_s.split(',').map(&:strip)}
+
+  Parameter = Struct.new(:symbol, :mandatory) do
+    def mandatory?
+      mandatory
+    end
+  end
+
+  ResultValue = Struct.new(:matcher, :parser) do
+    def parse(value)
+      parser ? parser.call(value) : value
+    end
+  end
+end

data/lib/ivy/targets.rb

@@ -0,0 +1,50 @@
+require 'ivy/target'
+require 'ivy/info'
+require 'ivy/settings'
+require 'ivy/configure'
+require 'ivy/cleancache'
+require 'ivy/resolve'
+require 'ivy/makepom'
+require 'ivy/cachepath'
+#require 'ivy/listmodules'
+require 'ivy/artifactproperty'
+require 'ivy/artifactreport'
+require 'ivy/findrevision'
+require 'ivy/install'
+require 'ivy/buildnumber'
+require 'ivy/retrieve'
+require 'ivy/publish'
+require 'ivy/report'
+require 'ivy/buildlist'
+
+=begin
+finished
+    * info
+    * settings
+    * configure
+    * cleancache
+    * buildnumber
+    * findrevision
+    * cachepath
+    * artifactreport
+    * resolve
+    * makepom
+    * retrieve
+    * publish
+    * artifactproperty
+    * report
+          o Using yEd to layout report graphs
+    * buildlist
+
+TODO
+    * deliver
+    * install
+    * repreport
+
+not working:
+    * listmodules
+
+makes no sense:
+    * cachefileset
+    * var
+=end