ruby-maven 3.0.3.0.28.4

data/lib/ruby/maven/tools/gem_project.rb

@@ -0,0 +1,387 @@
+require File.join(File.dirname(File.dirname(__FILE__)), 'model', 'model.rb')
+require File.join(File.dirname(__FILE__), 'gemfile_lock.rb')
+require File.join(File.dirname(__FILE__), 'versions.rb')
+
+module Maven
+  module Tools
+    class GemProject < Maven::Model::Project
+      tags :dummy
+
+      def initialize(artifact_id = dir_name, version = "0.0.0", &block)
+        super("rubygems", artifact_id, version, &block)
+        packaging "gem"
+      end
+
+      def loaded_files
+        @files ||= []
+      end
+
+      def current_file
+        loaded_files.last
+      end
+
+      def dump_loaded_file_list
+        if loaded_files.size > 0
+          basedir = File.dirname(loaded_files[0])
+          File.open(loaded_files[0] + ".files", 'w') do |f|
+            loaded_files.each { |i| f.puts i.sub(/^#{basedir}./, '') }
+          end
+        end
+      end
+
+      def add_param(config, name, list, default = [])
+        if list.is_a? Array
+          config[name] = list.join(",").to_s unless (list || []) == default
+        else
+          # list == nil => (list || []) == default is true
+          config[name] = list.to_s unless (list || []) == default
+        end
+      end
+      private :add_param
+
+      def load_gemspec(specfile)
+        require 'rubygems'
+        if specfile.is_a? ::Gem::Specification 
+          spec = specfile
+        else
+          spec = ::Gem::Specification.load(specfile)
+          loaded_files << File.expand_path(specfile)
+        end
+        raise "file not found '#{specfile}'" unless spec
+        @is_gemspec = loaded_files.size == 0
+        artifact_id spec.name
+        version spec.version
+        name spec.summary || "#{self.artifact_id} - gem"
+        description spec.description if spec.description
+        url spec.homepage if spec.homepage
+        (spec.email || []).zip(spec.authors || []).map do |email, author|
+          self.developers.new(author, email)
+        end
+
+        #  TODO work with collection of licenses - there can be more than one !!!
+        (spec.licenses + spec.files.select {|file| file.to_s =~ /license|gpl/i }).each do |license|
+          # TODO make this better, i.e. detect the right license name from the file itself
+          self.licenses.new(license)
+        end
+
+        config = {}
+        add_param(config, "autorequire", spec.autorequire)
+        add_param(config, "defaultExecutable", spec.default_executable)
+        add_param(config, "testFiles", spec.test_files)
+        #has_rdoc always gives true => makes not sense to keep it then
+        #add_param(config, "hasRdoc", spec.has_rdoc)
+        add_param(config, "extraRdocFiles", spec.extra_rdoc_files)
+        add_param(config, "rdocOptions", spec.rdoc_options)
+        add_param(config, "requirePaths", spec.require_paths, ["lib"])
+        add_param(config, "rubyforgeProject", spec.rubyforge_project)
+        add_param(config, "requiredRubygemsVersion", 
+                  spec.required_rubygems_version && spec.required_rubygems_version != ">= 0" ? "<![CDATA[#{spec.required_rubygems_version}]]>" : nil)
+        add_param(config, "bindir", spec.bindir, "bin")
+        add_param(config, "requiredRubyVersion", 
+                  spec.required_ruby_version && spec.required_ruby_version != ">= 0" ? "<![CDATA[#{spec.required_ruby_version}]]>" : nil)
+        add_param(config, "postInstallMessage", 
+                  spec.post_install_message ? "<![CDATA[#{spec.post_install_message}]]>" : nil)
+        add_param(config, "executables", spec.executables)
+        add_param(config, "extensions", spec.extensions)
+        add_param(config, "platform", spec.platform, 'ruby')
+
+        # # TODO maybe calculate extra files
+        # files = spec.files.dup
+        # (Dir['lib/**/*'] + Dir['spec/**/*'] + Dir['features/**/*'] + Dir['test/**/*'] + spec.licenses + spec.extra_rdoc_files).each do |f|
+        #   files.delete(f)
+        #   if f =~ /^.\//
+        #     files.delete(f.sub(/^.\//, ''))
+        #   else
+        #     files.delete("./#{f}")
+        #   end
+        # end
+        #add_param(config, "extraFiles", files)
+        add_param(config, "files", spec.files)
+        
+        plugin('gem').with(config) if config.size > 0
+
+        spec.dependencies.each do |dep|
+          scope = 
+            case dep.type
+            when :runtime
+              "compile"
+            when :development
+              "test"
+            else
+              warn "unknown scope: #{dep.type}"
+              "compile"
+            end
+
+          versions = dep.requirement.requirements.collect do |req|
+            req.to_s
+          end
+          gem(dep.name, versions).scope = scope
+        end
+
+        spec.requirements.each do |req|
+          begin
+            eval req
+          rescue => e
+            # TODO requirements is a list !!!
+            add_param(config, "requirements", req)
+            warn e
+          rescue SyntaxError => e
+            # TODO requirements is a list !!!
+            add_param(config, "requirements", req)
+          end
+        end
+      end
+
+      def load(file)
+        file = file.path if file.is_a?(File)
+        if File.exists? file
+          content = File.read(file)
+          loaded_files << file
+          if @lock.nil?
+            @lock = GemfileLock.new(file + ".lock")
+            if @lock.size == 0
+              @lock = nil
+            else
+              loaded_files << file + ".lock"
+              @lock.hull.each do |dep|
+                dependency_management.gem dep
+              end
+            end
+          end
+          eval content
+        else
+          self
+        end
+      end
+
+      def dir_name
+        File.basename(File.expand_path("."))
+      end
+      private :dir_name
+
+      def add_defaults(args = {})
+        versions = VERSIONS
+        versions = versions.merge(args) if args
+
+        name "#{dir_name} - gem" unless name
+        
+        packaging "gem" unless packaging
+
+        repository("rubygems-releases").url = "http://rubygems-proxy.torquebox.org/releases" unless repository("rubygems-releases").url
+        
+        has_prerelease = dependencies.detect { |d| d.type.to_sym == :gem && d.version =~ /[a-zA-Z]/ }
+
+        repository("rubygems-prereleases").url = "http://rubygems-proxy.torquebox.org/prereleases" if has_prerelease && !repository("rubygems-prereleases").url
+
+        if !jar?("org.jruby:jruby-complete") && !jar?("org.jruby:jruby-core") && versions[:jruby_version]
+          minor = versions[:jruby_version].sub(/[0-9]*\./, '').sub(/\..*/, '')
+
+          #TODO once jruby-core pom is working !!!
+          if minor.to_i > 55 #TODO fix minor minimum version
+            jar("org.jruby:jruby-core", versions[:jruby_version])
+            jar("org.jruby:jruby-stdlib", versions[:jruby_version])
+            # override deps which works
+            jar("jline:jline", '0.9.94') if versions[:jruby_version] =~ /1.6.[1-2]/
+            jar("org.jruby.extras:jffi", '1.0.8', 'native') if versions[:jruby_version] =~ /1.6.[0-2]/
+            jar("org.jruby.extras:jaffl", '0.5.10') if versions[:jruby_version] =~ /1.6.[0-2]/
+          else
+            jar("org.jruby:jruby-complete", versions[:jruby_version]) 
+          end
+        end
+
+        # TODO go through all plugins to find out any SNAPSHOT version !!
+        if versions[:jruby_plugins] =~ /-SNAPSHOT$/ || properties['jruby.plugins.version'] =~ /-SNAPSHOT$/
+          plugin_repository("sonatype-snapshots") do |nexus|
+            nexus.url = "http://oss.sonatype.org/content/repositories/snapshots"
+            nexus.releases(:enabled => false)
+            nexus.snapshots(:enabled => true)
+          end
+        end
+
+        if packaging =~ /gem/ || plugin?(:gem)
+          gem = plugin(:gem)
+          gem.version = "${jruby.plugins.version}" unless gem.version
+          gem.extensions = true if packaging =~ /gem/
+        end
+
+        if plugin?(:bundler)
+          plugin_repository("rubygems-releases").url = "http://rubygems-proxy.torquebox.org/releases" unless plugin_repository("rubygems-releases").url
+          bundler = plugin(:bundler)
+          bundler.version = "${jruby.plugins.version}" unless bundler.version
+          bundler.executions.goals << "install"
+          unless gem?(:bundler)
+            gem("bundler")
+          end
+        end
+
+        if versions[:jruby_plugins]
+          #add_test_plugin(nil, "test")
+          add_test_plugin("rspec", "spec")
+          add_test_plugin("cucumber", "features")
+        end
+
+        self.properties = {
+          "project.build.sourceEncoding" => "UTF-8", 
+          "gem.home" => "${project.build.directory}/rubygems", 
+          "gem.path" => "${project.build.directory}/rubygems",
+          "jruby.plugins.version" => versions[:jruby_plugins]
+        }.merge(self.properties)
+      end
+
+      def add_test_plugin(name, test_dir)
+        unless plugin?(name)
+          has_gem = name.nil? ? true : gem?(name)
+          if has_gem && File.exists?(test_dir)
+            plugin(name || 'runit', "${jruby.plugins.version}").execution.goals << "test" 
+          end
+        else
+          pl = plugin(name || 'runit')
+          pl.version = "${jruby.plugins.version}" unless pl.version
+        end
+      end
+      private :add_test_plugin
+
+      def stack
+        @stack ||= [[:default]]
+      end
+      private :stack
+        
+      def group(*args, &block)
+        stack << args
+        block.call if block
+        stack.pop
+      end
+
+      def gemspec(name = nil)
+        if name
+          load_gemspec(File.join(File.dirname(current_file), name))
+        else
+          Dir[File.join(File.dirname(current_file), "*.gemspec")].each do |file|
+            load_gemspec(file)
+          end
+        end
+      end
+
+      def source(*args)
+        warn "ignore source #{args}" if !(args[0].to_s =~ /^https?:\/\/rubygems.org/) && args[0] != :rubygems
+      end
+
+      def path(*args)
+      end
+
+      def git(*args)
+      end
+
+      def is_jruby_platform(*args)
+        args.detect { |a| :jruby == a.to_sym }
+      end
+      private :is_jruby_platform
+
+      def platforms(*args, &block)
+        if is_jruby_platform(*args)
+          block.call
+        end
+      end
+
+      def gem(*args, &block)
+        dep = nil
+        if args.last.is_a?(Hash)
+          options = args.delete(args.last)
+          unless options.key?(:git) || options.key?(:path)
+            if options[:platforms].nil? || is_jruby_platform(*(options[:platforms] || []))
+              group = options[:group] || options[:groups]
+              if group
+                [group].flatten.each do |g|
+                  if dep
+                    profile(g).dependencies << dep
+                  else
+                    dep = profile(g).gem(args, &block)
+                  end
+                end
+              else
+                self.gem(args, &block)
+              end
+            end
+          end
+        else
+          stack.last.each do |c|
+            if c == :default
+              if @lock.nil?
+                dep = add_gem(args, &block)
+              else
+                dep = add_gem(args[0], &block)
+
+                # add its dependencies as well to have the version
+                # determine by the dependencyManagement
+                @lock.dependency_hull(args[0]).map.each do |d|
+                  add_gem d[0], nil
+                end
+              end
+            else
+              if @lock.nil?
+                if dep
+                  profile(c).dependencies << dep
+                else
+                  dep = profile(c).gem(args, &block)
+                end
+              else
+                if dep
+                  profile(c).dependencies << dep
+                else
+                  dep = profile(c).gem(args[0], nil, &block)
+                end
+                # add its dependencies as well to have the version
+                # determine by the dependencyManagement
+                @lock.dependency_hull(args[0]).map.each do |d|
+                  profile(c).gem d[0], nil unless gem? d[0]
+                end
+              end
+            end
+          end
+        end
+        if dep && !@is_gemspec
+          project = self
+          
+          # first collect the missing deps it any
+          bundler_deps = []
+          #plugin(:bundler) do |bundler|
+          # use a dep with version so just create it from the args
+          bundler_deps << args unless project.dependencies.member? dep
+            
+          #TODO this should be done after all deps are in place - otherwise it depends on order how bundler gets setup
+          if @lock
+            # add its dependencies as well to have the version
+            # determine by the dependencyManagement
+            @lock.dependency_hull(dep.artifact_id).map.each do |d|
+              bundler_deps << d unless project.gem? d[0]
+            end
+          end
+          #end
+          
+          # now add the deps to bundler plugin
+          # avoid to setup bundler if it has no deps
+          if bundler_deps.size > 0 
+            plugin(:bundler) do |bundler|
+              bundler_deps.each do |d|
+                bundler.gem(d)
+              end
+            end
+          end
+        end
+        dep
+      end
+    end
+  end
+end
+
+if $0 == __FILE__
+  proj = Maven::Tools::GemProject.new("test_gem")
+  if ARGV[0] =~ /\.gemspec$/
+    proj.load_gemspec(ARGV[0])
+  else
+    proj.load(ARGV[0] || 'Gemfile')
+  end
+  proj.load(ARGV[1] || 'Mavenfile')
+  proj.add_defaults
+  puts proj.to_xml
+end

data/lib/ruby/maven/tools/gemfile_lock.rb

@@ -0,0 +1,67 @@
+module Maven
+  module Tools
+    class GemfileLock < Hash
+     
+      class Dependency
+        attr_accessor :name, :version, :dependencies
+        def initialize(line, deps = {})
+          @name = line.sub(/\ .*/,'')
+          @version =  line.sub(/.*\(/, '').sub(/\).*/, '').sub(/-java$/, '')
+          @dependencies = deps
+        end
+        
+        def add(line)
+          dependencies[line.sub(/\ .*/,'')] = line.sub(/.*\(/, '').sub(/\).*/, '')
+        end
+      end
+    
+      def initialize(file)
+        current = nil
+        f = file.is_a?(File) ? file.path: file
+        if File.exists? f
+          File.readlines(f).each do |line|
+            if line =~ /^    [^ ]/
+              line.strip!
+              current = Dependency.new(line)
+              self[current.name] = current
+            elsif line =~ /^      [^ ]/
+              line.strip!
+              current.add(line) if current
+            end
+          end
+        end
+      end
+
+      def recurse(result, dep)
+        result[dep] = self[dep].version if self[dep] && !result.key?(dep)
+        if d = self[dep]
+          d.dependencies.each do |name, version|
+            unless result.key? name
+              result[name] = self[name].nil?? version : self[name].version
+              recurse(result, name)
+            end
+          end
+        end
+      end
+
+      def dependency_hull(deps = [])
+        deps = deps.is_a?(Array) ? deps : [deps]
+        result = {}
+        deps.each do |dep|
+          recurse(result, dep)
+        end
+        result
+      end
+
+      def hull
+        dependency_hull(keys)
+      end
+    end
+  end
+end
+
+if $0 == __FILE__
+  lockfile = Maven::Tools::GemfileLock.new(File.new(ARGV[0] || 'Gemfile.lock'))
+  p lockfile
+  p lockfile.dependency_hull("rails")
+end

data/lib/ruby/maven/tools/pom_generator.rb

@@ -0,0 +1,61 @@
+require File.join(File.dirname(__FILE__), 'rails_project.rb')
+module Maven
+  module Tools
+    class PomGenerator
+      def read_rails(filename, plugin_version = nil, jruby_version = nil)
+        proj = Maven::Tools::RailsProject.new
+        proj.load(filename.to_s)
+        proj.load(File.join(File.dirname(filename.to_s), 'Mavenfile'))
+        proj.add_defaults(versions(plugin_version, jruby_version))
+        proj.dump_loaded_file_list
+        proj.to_xml
+      end
+
+      def read_gemfile(filename, plugin_version = nil, jruby_version = nil)
+        dir = File.dirname(filename)
+        proj = 
+          if File.exists? File.join( dir, 'config', 'application.rb' )
+            Maven::Tools::RailsProject.new
+          else
+            Maven::Tools::GemProject.new
+          end
+        proj.load(filename.to_s)
+        proj.load(File.join(File.dirname(filename.to_s), 'Mavenfile'))
+        proj.add_defaults(versions(plugin_version, jruby_version))
+        proj.dump_loaded_file_list
+        proj.to_xml
+      end
+
+      def read_gemspec(filename, plugin_version = nil, jruby_version = nil)
+        proj = Maven::Tools::GemProject.new
+        proj.load_gemspec(filename.to_s)
+        proj.load(File.join(File.dirname(filename.to_s), 'Mavenfile'))
+        proj.add_defaults(versions(plugin_version, jruby_version))
+        proj.dump_loaded_file_list
+        proj.to_xml
+      end
+
+      private
+
+      def versions(plugin_version, jruby_version)
+        result = {}
+        result[:jruby_plugins] = plugin_version if plugin_version
+        result[:jruby_version] = jruby_version if jruby_version
+        result
+      end
+    end
+  end
+end
+
+generator = Maven::Tools::PomGenerator.new
+
+case ARGV.size
+when 2
+  puts generator.send("read_#{ARGV[0]}".to_sym, ARGV[1])
+when 3
+  puts generator.send("read_#{ARGV[0]}".to_sym, ARGV[1], ARGV[2])
+when 4
+  puts generator.send("read_#{ARGV[0]}".to_sym, ARGV[1], ARGV[2], ARGV[3])
+else
+  generator
+end

data/lib/ruby/maven/tools/rails_project.rb

@@ -0,0 +1,147 @@
+require File.join(File.dirname(__FILE__), 'gem_project.rb')
+module Maven
+  module Tools
+    class RailsProject < GemProject
+      tags :dummy
+
+      def initialize(name = dir_name, &block)
+        super(name, &block)
+        group_id "rails"
+        packaging "war"
+      end
+      
+      def add_defaults(args = {})
+        self.name = "#{dir_name} - rails application" unless name
+        
+        # setup bundler plugin
+        plugin(:bundler)
+
+        s_args = args.dup
+        s_args.delete(:jruby_plugins)
+        super(s_args)
+
+        versions = VERSIONS.merge(args)
+        
+        rails_gem = dependencies.detect { |d| d.type.to_sym == :gem && d.artifact_id.to_s =~ /^rail.*s$/ } # allow rails or railties
+
+        if rails_gem && rails_gem.version =~ /^3.1./
+          versions[:jruby_rack] = '1.1.0.dev'
+        end
+
+        jar("org.jruby.rack:jruby-rack", versions[:jruby_rack]) unless jar?("org.jruby.rack:jruby-rack")
+
+        self.properties = {
+          "jetty.version" => versions[:jetty_plugin],
+          "rails.env" => "development",
+          "gem.includeRubygemsInTestResources" => false
+        }.merge(self.properties)
+
+        plugin(:rails3) do |rails|
+          rails.version = "${jruby.plugins.version}" unless rails.version
+          rails.in_phase(:validate).execute_goal(:initialize)#.goals << "initialize"
+        end
+
+        plugin(:war, versions[:war_plugin]) unless plugin?(:war)
+        plugin(:war).with({
+            :webResources => Maven::Model::NamedArray.new(:resource) do |l|
+              l << { :directory => "public" }
+              l << { 
+                :directory => ".",
+                :targetPath => "WEB-INF",
+                :includes => ['app/**', 'config/**', 'lib/**', 'vendor/**', 'Gemfile']
+              }
+              l << {
+                :directory => '${gem.path}',
+                :targetPath => 'WEB-INF/gems',
+                :includes => ['gems/**', 'specifications/**']
+              }
+              l << {
+                :directory => '${gem.path}-bundler-maven-plugin',
+                :targetPath => 'WEB-INF/gems',
+                :includes => ['specifications/**']
+              }
+            end
+          })
+
+        profile(:development).activation.by_default
+        profile(:test).activation.property("rails.env", "test")
+        profile(:production) do |prod|   
+          prod.activation.property("rails.env", "production")
+          prod.properties = { 
+            "gem.home" => "${project.build.directory}/rubygems-production", 
+            "gem.path" => "${project.build.directory}/rubygems-production" 
+          }.merge(prod.properties)
+        end
+
+        profile(:war).plugin("org.mortbay.jetty:jetty-maven-plugin",
+                             "${jetty.version}")
+         
+        profile(:run) do |run|
+          overrideDescriptor = '${project.build.directory}/jetty/override-${rails.env}-web.xml'
+          run.activation.by_default
+          run.plugin("org.mortbay.jetty:jetty-maven-plugin",
+                       "${jetty.version}").with({
+                :webAppConfig => {
+                  :overrideDescriptor => overrideDescriptor           
+                },
+                :connectors => <<-XML
+
+                <connector implementation="org.eclipse.jetty.server.nio.SelectChannelConnector">
+                  <port>8080</port>
+                </connector>
+                <connector implementation="org.eclipse.jetty.server.ssl.SslSelectChannelConnector">
+                  <port>8443</port>
+                  <keystore>${project.basedir}/src/test/resources/server.keystore</keystore>
+                  <keyPassword>123456</keyPassword>
+                  <password>123456</password>
+                </connector>
+XML
+              })
+        end
+        profile(:executable) do |exec|
+          exec.plugin_repository('kos').url = 'http://opensource.kantega.no/nexus/content/groups/public/'
+          exec.plugin('org.simplericity.jettyconsole:jetty-console-maven-plugin', '1.42').execution do |jetty|
+            jetty.execute_goal(:createconsole)
+            jetty.configuration.comment <<-TEXT
+                  see http://simplericity.com/2009/11/10/1257880778509.html for more info
+                -->
+                <!--
+		  <backgroundImage>${basedir}/src/main/jettyconsole/puffin.jpg</backgroundImage>
+		  <additionalDependencies>
+		    <additionalDependency>
+		      <artifactId>jetty-console-winsrv-plugin</artifactId>
+		    </additionalDependency>
+		    <additionalDependency>
+		      <artifactId>jetty-console-requestlog-plugin</artifactId>
+		    </additionalDependency>
+		    <additionalDependency>
+		      <artifactId>jetty-console-log4j-plugin</artifactId>
+		    </additionalDependency>
+		    <additionalDependency>
+		      <artifactId>jetty-console-jettyxml-plugin</artifactId>
+		    </additionalDependency>
+		    <additionalDependency>
+		      <artifactId>jetty-console-ajp-plugin</artifactId>
+		    </additionalDependency>
+		    <additionalDependency>
+		      <artifactId>jetty-console-gzip-plugin</artifactId>
+		    </additionalDependency>
+		    <additionalDependency>
+		      <artifactId>jetty-console-startstop-plugin</artifactId>
+		    </additionalDependency>
+		  </additionalDependencies>
+TEXT
+          end
+        end
+      end
+    end
+  end
+end
+
+if $0 == __FILE__
+  proj = Maven::Tools::RailsProject.new
+  proj.load(ARGV[0] || 'Gemfile')
+  proj.load(ARGV[1] || 'Mavenfile')
+  proj.add_defaults
+  puts proj.to_xml
+end

data/lib/ruby/maven/tools/versions.rb

@@ -0,0 +1,11 @@
+ module Maven
+  module Tools
+    VERSIONS = { 
+      :jetty_plugin => "7.5.1.v20110908",
+      :jruby_rack => "1.0.10",
+      :war_plugin => "2.1.1",
+      :jruby_plugins => "0.28.4",
+      :jruby_version => "1.6.4",
+    }.freeze
+  end
+end