klaas1979-ivy4r 0.1.0

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,23 @@
+require 'ivy/target'
+
+module Ivy
+  class Makepom < Ivy::Target
+    def parameter
+      [
+        Parameter.new(:ivyfile, true),
+        Parameter.new(:pomfile, true),
+        Parameter.new(:nested, true),
+        Parameter.new(:settingsRef, 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,122 @@
+require 'facets'
+
+module Ivy
+
+  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
+  class Target
+    attr_reader :params
+
+    def initialize(ant)
+      @ant = ant
+    end
+
+    # Executes this ivy target with given parameters returning a result where appropriate
+    def execute(*params)
+      @params = {}
+      params.pop.each { |key, value| @params[key] = value } if Hash === params.last
+      params.each { |key| @params[key] = true }
+
+      validate
+      before_hook
+      execute_ivy
+      create_return_values
+    ensure
+      after_hook
+    end
+
+    protected
+    
+    # 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 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.to_h(:multi)
+      result.update_values do |v|
+        case v.size
+        when 0
+          nil
+        when 1
+          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
+      @ant.project.properties
+    end
+
+    def ant_references
+      @ant.project.references
+    end
+  end
+  
+end

data/lib/ivy/targets.rb

@@ -0,0 +1,49 @@
+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/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

data/lib/ivy4r.rb

@@ -0,0 +1,176 @@
+require 'antwrap'
+require 'ivy/targets'
+
+class Ivy4r
+  VERSION = '0.1.0'
+
+  # Set the ant home directory to load ant classes from if no custom __antwrap__ is provided
+  attr_accessor :ant_home
+
+  # Defines the directory to load ivy libs and its dependencies from
+  attr_accessor :lib_dir
+
+  attr_accessor :project_dir
+
+  # To provide a custom __antwrap__ to use instead of default one
+  attr_writer :ant
+
+  def initialize(*opts)
+    @ant = opts[0] if opts.size == 1
+    raise "To many parameters to create Ivy4r use none, or 1 to set ANT!" if opts.size > 1
+  end
+
+  # Calls the __cleancache__ ivy target with given parameters.
+  def cleancache(*params)
+    Ivy::Cleancache.new(ant).execute(*params)
+  end
+
+  # Calls the __settings__ ivy target with given parameters.
+  def settings(*params)
+    Ivy::Settings.new(ant).execute(*params)
+  end
+
+  # Calls the __configure__ ivy target with given parameters.
+  def configure(*params)
+    Ivy::Configure.new(ant).execute(*params)
+  end
+
+  # Calls the __info__ ivy target with given parameters and returns info as hash.
+  def info(*params)
+    Ivy::Info.new(ant).execute(*params)
+  end
+
+  # Calls the __buildnumber__ ivy target with given parameters and returns info as hash.
+  def buildnumber(*params)
+    Ivy::Buildnumber.new(ant).execute(*params)
+  end
+
+  # Calls the __listmodules__ ivy target with given parameters and returns info as hash.
+  def listmodules(*params) #:nodoc:
+    Ivy::Listmodules.new(ant).execute(*params)
+  end
+
+  # Calls the __makepom__ ivy target with given parameters and returns pom content.
+  def makepom(*params)
+    Ivy::Makepom.new(ant).execute(*params)
+  end
+
+  # Calls the __resolve__ ivy target with given parameters and returns info as hash.
+  def resolve(*params)
+    Ivy::Resolve.new(ant).execute(*params)
+  end
+
+  # Calls the __retrieve__ ivy target with given parameters.
+  def retrieve(*params)
+    Ivy::Retrieve.new(ant).execute(*params)
+  end
+
+  # Calls the __publish__ ivy target with given parameters.
+  def publish(*params)
+    Ivy::Publish.new(ant).execute(*params)
+  end
+
+  # Calls the __cachepath__ ivy target with given parameters and returns
+  # array containing absolute file paths to all artifacts contained in result
+  def cachepath(*params)
+    Ivy::Cachepath.new(ant).execute(*params)
+  end
+
+  # Calls the __findrevision__ ivy target with given parameters and returns
+  # array containing absolute file paths to all artifacts contained in result
+  def findrevision(*params)
+    Ivy::Findrevision.new(ant).execute(*params)
+  end
+
+  # Calls the __artifactproperty__ ivy target with given parameters and returns
+  # map with all defined properties
+  def artifactproperty(*params)
+    Ivy::Artifactproperty.new(ant).execute(*params)
+  end
+    
+  # Calls the __buildlist__ ivy target with given parameters and returns
+  # the resulting buildlist
+  def buildlist(*params)
+    Ivy::Buildlist.new(ant).execute(*params)
+  end
+
+  # Calls the __artifactreport__ ivy target with given parameters and returns
+  # the created xml.
+  def artifactreport(*params)
+    Ivy::Artifactreport.new(ant).execute(*params)
+  end
+
+  # Calls the __report__ ivy target with given parameters
+  def report(*params)
+    Ivy::Report.new(ant).execute(*params)
+  end
+
+  # Used to get or set an ant properties
+  # [set] <tt>property['name'] = value</tt> sets the ant property with name to given value no overwrite
+  # [get] <tt>property[matcher]/tt> gets property that is equal via case equality operator (+===+)
+  def property
+    AntPropertyHelper.new(ant_properties)
+  end
+
+  # Returns the __antwrap__ instance to use for all internal calls creates a default
+  # instance if no instance has been set before.
+  def ant
+    @ant ||= ::Antwrap::AntProject.new(:ant_home => ant_home, :name => "ivy-ant",
+      :basedir => Dir.pwd, :declarative => true)
+    init(@ant) if should_init?
+    @ant
+  end
+
+  private
+  def should_init?
+    @init_done.nil? || @init_done == false
+  end
+
+  def init(ant)
+    @init_done = true
+    ant.property :name => 'ivy.project.dir', :value => project_dir
+    ant.path :id => 'ivy.lib.path' do
+      ant.fileset :dir => lib_dir, :includes => '*.jar'
+    end
+
+    ant.typedef :name => "ivy_settings", :classname => "org.apache.ivy.ant.IvyAntSettings", :classpathref => "ivy.lib.path", :loaderRef => 'ivy.lib.path.loader', :loaderRef => 'ivy.lib.path.loader'
+    ant.taskdef :name => "ivy_configure", :classname => "org.apache.ivy.ant.IvyConfigure", :classpathref => "ivy.lib.path", :loaderRef => 'ivy.lib.path.loader'
+    ant.taskdef :name => "ivy_resolve", :classname => "org.apache.ivy.ant.IvyResolve", :classpathref => "ivy.lib.path", :loaderRef => 'ivy.lib.path.loader'
+    ant.taskdef :name => "ivy_retrieve", :classname => "org.apache.ivy.ant.IvyRetrieve", :classpathref => "ivy.lib.path", :loaderRef => 'ivy.lib.path.loader'
+    ant.taskdef :name => "ivy_deliver", :classname => "org.apache.ivy.ant.IvyDeliver", :classpathref => "ivy.lib.path", :loaderRef => 'ivy.lib.path.loader'
+    ant.taskdef :name => "ivy_publish", :classname => "org.apache.ivy.ant.IvyPublish", :classpathref => "ivy.lib.path", :loaderRef => 'ivy.lib.path.loader'
+    ant.taskdef :name => "ivy_extract", :classname => "org.apache.ivy.ant.IvyExtractFromSources", :classpathref => "ivy.lib.path", :loaderRef => 'ivy.lib.path.loader'
+    ant.taskdef :name => "ivy_cachepath", :classname => "org.apache.ivy.ant.IvyCachePath", :classpathref => "ivy.lib.path", :loaderRef => 'ivy.lib.path.loader'
+    ant.taskdef :name => "ivy_cachefileset", :classname => "org.apache.ivy.ant.IvyCacheFileset", :classpathref => "ivy.lib.path", :loaderRef => 'ivy.lib.path.loader'
+    ant.taskdef :name => "ivy_report", :classname => "org.apache.ivy.ant.IvyReport", :classpathref => "ivy.lib.path", :loaderRef => 'ivy.lib.path.loader'
+    ant.taskdef :name => "ivy_repreport", :classname => "org.apache.ivy.ant.IvyRepositoryReport", :classpathref => "ivy.lib.path", :loaderRef => 'ivy.lib.path.loader'
+    ant.taskdef :name => "ivy_var", :classname => "org.apache.ivy.ant.IvyVar", :classpathref => "ivy.lib.path", :loaderRef => 'ivy.lib.path.loader'
+    ant.taskdef :name => "ivy_check", :classname => "org.apache.ivy.ant.IvyCheck", :classpathref => "ivy.lib.path", :loaderRef => 'ivy.lib.path.loader'
+    ant.taskdef :name => "ivy_artifactproperty", :classname => "org.apache.ivy.ant.IvyArtifactProperty", :classpathref => "ivy.lib.path", :loaderRef => 'ivy.lib.path.loader'
+    ant.taskdef :name => "ivy_buildlist", :classname => "org.apache.ivy.ant.IvyBuildList", :classpathref => "ivy.lib.path", :loaderRef => 'ivy.lib.path.loader'
+    ant.taskdef :name => "ivy_install", :classname => "org.apache.ivy.ant.IvyInstall", :classpathref => "ivy.lib.path", :loaderRef => 'ivy.lib.path.loader'
+    ant.taskdef :name => "ivy_convertpom", :classname => "org.apache.ivy.ant.IvyConvertPom", :classpathref => "ivy.lib.path", :loaderRef => 'ivy.lib.path.loader'
+    ant.taskdef :name => "ivy_makepom", :classname => "org.apache.ivy.ant.IvyMakePom", :classpathref => "ivy.lib.path", :loaderRef => 'ivy.lib.path.loader'
+    ant.taskdef :name => "ivy_artifactreport", :classname => "org.apache.ivy.ant.IvyArtifactReport", :classpathref => "ivy.lib.path", :loaderRef => 'ivy.lib.path.loader'
+    ant.taskdef :name => "ivy_info", :classname => "org.apache.ivy.ant.IvyInfo", :classpathref => "ivy.lib.path", :loaderRef => 'ivy.lib.path.loader'
+    ant.taskdef :name => "ivy_addpath", :classname => "org.apache.ivy.ant.AddPathTask", :classpathref => "ivy.lib.path", :loaderRef => 'ivy.lib.path.loader'
+    ant.taskdef :name => "ivy_listmodules", :classname => "org.apache.ivy.ant.IvyListModules", :classpathref => "ivy.lib.path", :loaderRef => 'ivy.lib.path.loader'
+    ant.taskdef :name => "ivy_findrevision", :classname => "org.apache.ivy.ant.IvyFindRevision", :classpathref => "ivy.lib.path", :loaderRef => 'ivy.lib.path.loader'
+    ant.taskdef :name => "ivy_buildnumber", :classname => "org.apache.ivy.ant.IvyBuildNumber", :classpathref => "ivy.lib.path", :loaderRef => 'ivy.lib.path.loader'
+    ant.taskdef :name => "ivy_cleancache", :classname => "org.apache.ivy.ant.IvyCleanCache", :classpathref => "ivy.lib.path", :loaderRef => 'ivy.lib.path.loader'
+  end
+
+  def ant_properties
+    ant.project.properties
+  end
+end
+
+AntPropertyHelper = Struct.new(:ant_properties) do #:nodoc:
+  def []=(name, value) #:nodoc:
+    ant_properties[name] = value
+  end
+
+  def [](matcher) #:nodoc:
+    ant_properties.find {|p| matcher === p[0] }[1]
+  end
+end