albacore 2.8.0 → 3.0.0.pre.alpha

data/lib/albacore/paths.rb

@@ -93,6 +93,7 @@ module Paths
     def extname
       @inner.extname
     end
+
     def ==(o)
       trace { "#{self} ==( #{o} )" }
       (o.respond_to? :p) && o.p == p

data/lib/albacore/project.rb

@@ -4,24 +4,93 @@ require 'albacore/semver'
 require 'albacore/package_repo'
 require 'albacore/paket'
 require 'pathname'
-module Albacore
 
+module Albacore
   # error raised from Project#output_path if the given configuration wasn't
   # found
   class ConfigurationNotFoundError < ::StandardError
   end
 
-  # a project encapsulates the properties from a xxproj file.
+  class OutputArtifact
+    EXECUTABLE = :executable
+    LIBRARY = :dll
+    XMLDOC = :xmldoc
+    SYMBOLS = :symbols
+
+    # E.g. "bin/Debug/lib.dll"
+    # E.g. "bin/Debug/net461/lib.dll"
+    # E.g. "bin/Debug/net461/lib.xml"
+    # E.g. "bin/Debug/net461/lib.dll.pdb"
+    # E.g. "bin/Debug/net461/prog.exe"
+    attr_reader :path
+
+    # E.g. "lib.dll"
+    # E.g. "prog.exe"
+    attr_reader :filename
+
+    # E.g. :dll
+    attr_reader :sort
+
+    # E.g. ".txt"
+    attr_reader :ext
+
+    # Create a new OutputArtifact
+    def initialize path, sort
+      @path, @sort = path, sort
+      @ext = File.extname path
+      @filename = File.basename path
+    end
+
+    # Is the file a DLL file?
+    def library?
+      sort == ::LIBRARY
+    end
+
+    # Is the file a DLL file?
+    def dll?
+      library?
+    end
+
+    # Is the file an executable?
+    def executable?
+      sort == ::EXECUTABLE
+    end
+
+    # Is the file a documentation file?
+    def xmldoc?
+      sort == ::XMLDOC
+    end
+
+    # Is the file a symbol file?
+    def symbols?
+      sort == ::SYMBOLS
+    end
+
+    def ==(o)
+      @path == o.path && @sort == o.sort
+    end
+
+    alias_method :eql?, :==
+  end
+
+  # A project encapsulates the properties from a xxproj file.
   class Project
     include Logging
 
-    attr_reader :proj_path_base, :proj_filename, :proj_xml_node
+    attr_reader \
+      :proj_path_base,
+      :proj_filename,
+      :ext,
+      :proj_filename_noext,
+      :proj_xml_node
 
     def initialize proj_path
       raise ArgumentError, 'project path does not exist' unless File.exists? proj_path.to_s
       proj_path                       = proj_path.to_s unless proj_path.is_a? String
       @proj_xml_node                  = Nokogiri.XML(open(proj_path))
       @proj_path_base, @proj_filename = File.split proj_path
+      @ext = File.extname @proj_filename
+      @proj_filename_noext = File.basename @proj_filename, ext
       sanity_checks
     end
 
@@ -44,15 +113,20 @@ module Albacore
     # the title of the nuspec and, if Id is not specified, also the id of the
     # nuspec.
     def name
-      (read_property 'Name') || asmname
+      read_property('Name') || asmname || proj_filename_noext
     end
 
     # The same as #name
     alias_method :title, :name
 
+    # The project is a .Net Core project.
+    def netcore?
+      ! @proj_xml_node.css('Project').attr('Sdk').nil?
+    end
+
     # get the assembly name specified in the project file
     def asmname
-      read_property 'AssemblyName'
+      read_property('AssemblyName') || proj_filename_noext
     end
 
     # Get the root namespace of the project
@@ -79,42 +153,131 @@ module Albacore
       read_property 'License'
     end
 
-    # the target .NET Framework / .NET Standard version
-    def target_framework
-      read_property 'TargetFrameworkVersion'
+    def xmldoc? conf='Debug', platform='AnyCPU'
+      if netcore?
+        gdf = read_property('GenerateDocumentationFile')
+        !gdf.nil? && gdf == 'true'
+      else
+        ! read_property('DocumentationFile', conf, platform).nil?
+      end
     end
-    
-    # gets the output path of the project given the configuration or raise
-    # an error otherwise
-    def output_path conf
-      try_output_path conf || raise(ConfigurationNotFoundError, "could not find configuration '#{conf}'")
+
+    def symbols? conf='Debug', platform='AnyCPU'
+      read_property('DebugSymbols', conf) == 'true'
     end
 
-    def try_output_path conf
-      default_platform = @proj_xml_node.css('Project PropertyGroup Platform').first.inner_text || 'AnyCPU'
-      path             = @proj_xml_node.css("Project PropertyGroup[Condition*='#{conf}|#{default_platform}'] OutputPath")
-      # path = @proj_xml_node.xpath("//Project/PropertyGroup[matches(@Condition, '#{conf}')]/OutputPath")
+    # OutputArtifact::LIBRARY
+    # OutputArtifact::EXECUTABLE
+    def output_type
+      ot = read_property 'OutputType'
+      case ot
+      when 'Library'
+        OutputArtifact::LIBRARY
+      when 'Exe'
+        OutputArtifact::EXECUTABLE
+      else
+        ot
+      end
+    end
 
-      debug { "#{name}: output path node[#{conf}]: #{ (path.empty? ? 'empty' : path.inspect) } [albacore: project]" }
+    # ".exe"?, ".dll"?
+    def output_file_ext
+      case output_type
+      when OutputArtifact::LIBRARY
+        ".dll"
+      when OutputArtifact::EXECUTABLE
+        ".exe"
+      end
+    end
+
+    def default_platform
+      @proj_xml_node.css('Project PropertyGroup Platform').first.inner_text || 'AnyCPU'
+    end
+
+    def debug_type conf
+      dt = read_property "DebugType", conf
+    end
+
+    # the target .NET Framework / .NET version
+    def target_framework
+      read = read_property('TargetFrameworkVersion')
+      case read
+      when 'v3.5'
+        'net35'
+      when 'v3.5.1'
+        'net351'
+      when 'v4.0'
+        'net40'
+      when 'v4.5'
+        'net45'
+      when 'v4.5.1'
+        'net451'
+      when 'v4.6'
+        'net46'
+      when 'v4.6.1'
+        'net461'
+      when 'v4.6.2'
+        'net462'
+      when 'v5.0'
+        'net50'
+      when 'v5.0.1'
+        'net501'
+      else
+        read
+      end
+    end
 
-      return path.inner_text unless path.empty?
-      nil
+    # Gets the target frameworks as specified by .Net Core syntax
+    def target_frameworks
+      if netcore?
+        tfw = @proj_xml_node.css('Project PropertyGroup TargetFramework').inner_text
+        tfws = @proj_xml_node.css('Project PropertyGroup TargetFrameworks').inner_text
+        nfws = if tfw.nil? || tfw == '' then tfws else tfw end
+        fws = nfws.split(';')
+      else
+        [ target_framework ]
+      end
+    end
+    
+    # Returns OutputArtifact[] or throws an error
+    def outputs conf, fw
+      os = try_outputs(conf, fw)
+      if os.empty?
+        raise(ConfigurationNotFoundError, "could not find configuration '#{conf}'")
+      else
+        os
+      end
     end
 
-    # This is the output path if the project file doesn't have a configured
-    # 'Configuration' condition like all default project files have that come
-    # from Visual Studio/Xamarin Studio.
-    def fallback_output_path
-      fallback  = @proj_xml_node.css("Project PropertyGroup OutputPath").first
-      condition = fallback.parent['Condition'] || 'No \'Condition\' specified'
-      warn "chose an OutputPath in: '#{self}' for Configuration: <#{condition}> [albacore: project]"
-      fallback.inner_text
+    def try_outputs conf, fw
+      outputs = []
+      if netcore? then
+        outputs << OutputArtifact.new("bin/#{conf}/#{fw}/#{asmname}#{output_file_ext}", output_type)
+        outputs << OutputArtifact.new("bin/#{conf}/#{fw}/#{asmname}.xml", OutputArtifact::XMLDOC) if xmldoc?
+      else
+        path = read_property 'OutputPath', conf, default_platform
+        if path != ''
+          full_path = Albacore::Paths.join(path, "#{asmname}#{output_file_ext}").to_s
+          outputs << OutputArtifact.new(full_path, output_type)
+        end
+
+        if xmldoc? conf, default_platform
+          xml_full_path = read_property 'DocumentationFile', conf
+          outputs << OutputArtifact.new(xml_full_path, OutputArtifact::XMLDOC)
+        end
+
+        if symbols? conf, default_platform
+          pdb_full_path = Albacore::Paths.join(path, "#{asmname}.pdb").to_s
+          outputs << OutputArtifact.new(pdb_full_path, OutputArtifact::SYMBOLS)
+        end
+      end
+      outputs
     end
 
     # Gets the relative location (to the project base path) of the dll
     # that it will output
-    def output_dll conf
-      Paths.join(output_path(conf) || fallback_output_path, "#{asmname}.dll")
+    def output_dll conf, fw
+      output_paths(conf, fw).keep_if { |o| o.library? }.first
     end
 
     # find the NodeList reference list
@@ -227,8 +390,6 @@ module Albacore
       p
     end
 
-
-
     # Reads assembly version information
     # Returns 1.0.0.0 if AssemblyVersion is not found
     # @return string
@@ -242,11 +403,11 @@ module Albacore
       rescue
         '1.0.0.0'
       end
-
     end
 
 
-    private
+  private
+
     def nuget_packages
       return nil unless has_packages_config?
       doc = Nokogiri.XML(open(package_config))
@@ -262,9 +423,27 @@ module Albacore
 
     def all_paket_deps
       return @all_paket_deps if @all_paket_deps
-      arr             = File.open('paket.lock', 'r') do |io|
-        Albacore::Paket.parse_paket_lock(io.readlines.map(&:chomp))
+
+      path = if File.exists?('paket.lock') then
+          'paket.lock'
+        else
+          File.join(@proj_path_base, "paket.lock")
+        end
+
+      arr = File.open(path, 'r') do |io|
+        lines = io.readlines.map(&:chomp)
+        Albacore::Paket.parse_paket_lock(lines)
+          .map { |depid, dep|
+            [ depid,
+              target_frameworks.map { |fw|
+                dep2 = OpenStruct.new dep
+                dep2[:target_framework] = fw
+                dep2
+              }
+            ]
+          }
       end
+
       @all_paket_deps = Hash[arr]
     end
 
@@ -275,7 +454,8 @@ module Albacore
 
       if has_paket_refs?
         File.open paket_refs, 'r' do |io|
-          io.readlines.map(&:chomp).compact.each do |line|
+          lines = io.readlines.map(&:chomp)
+          lines.compact.each do |line|
             paket_package_by_id! line, all_refs, 'referenced'
           end
         end
@@ -283,20 +463,21 @@ module Albacore
 
       if has_paket_deps?
         File.open paket_deps, 'r' do |io|
-          io.readlines.map(&:chomp).compact.each do |line|
+          lines = io.readlines.map(&:chomp)
+          Albacore::Paket.parse_dependencies_file(lines).each do |line|
             paket_package_by_id! line, all_refs, 'dependent'
           end
         end
       end
 
-      all_refs
+      all_refs.uniq
     end
 
     def paket_package_by_id! id, arr, ref_type
-      pkg = all_paket_deps[id]
-      if pkg
+      pkgs = all_paket_deps[id]
+      if ! pkgs.nil? && pkgs.length > 0
         debug { "found #{ref_type} package '#{id}' [project: paket_packages]" }
-        arr << pkg
+        arr.concat(pkgs)
       else
         warn { "found #{ref_type} package '#{id}' not in paket.lock [project: paket_packages]" }
       end
@@ -306,9 +487,11 @@ module Albacore
       warn { "project '#{@proj_filename}' has no name" } unless name
     end
 
-    def read_property prop_name
-      txt = @proj_xml_node.css("Project PropertyGroup #{prop_name}").inner_text
-      txt.length == 0 ? nil : txt.strip
+    def read_property prop_name, conf='Debug', platform='AnyCPU'
+      specific = @proj_xml_node.css("Project PropertyGroup[Condition*='#{conf}|#{platform}'] #{prop_name}")
+      chosen = if specific.empty? then @proj_xml_node.css("Project PropertyGroup #{prop_name}") else specific end
+      first = chosen.first
+      if first.nil? then nil else first.inner_text end
     end
 
     # find the node of pkg_id

data/lib/albacore/task_types/nugets_pack.rb

@@ -1,478 +1,126 @@
 require 'rake'
-require 'nokogiri'
-require 'fileutils'
-require 'pathname'
 require 'albacore'
-require 'albacore/paths'
+require 'albacore/package'
 require 'albacore/cmd_config'
 require 'albacore/config_dsl'
 require 'albacore/cross_platform_cmd'
 require 'albacore/project'
 require 'albacore/logging'
 require 'albacore/nuget_model'
-require 'albacore/task_types/nugets'
 
 module Albacore
   module NugetsPack
-    # the nuget command
-    class Cmd
-      include CrossPlatformCmd
-
-      # executable => the nuget executable
-      def initialize executable, *args
-        opts = Map.options args
-        raise ArgumentError, 'out is nil' if opts.getopt(:out).nil?
-
-        @work_dir   = opts.getopt :work_dir, default: nil
-        @executable = executable
-        @parameters = [%W{Pack -OutputDirectory #{opts.get(:out)}}].flatten
-        @opts = opts
-
-        mono_command unless opts.get(:mono_opt_out)
-      end
-
-      # run nuget on the nuspec to create a new package
-      # returns: a tuple-array of the package and the symbol package
-      #   of which the symbol package is nil if it was not generated
-      def execute nuspec_file, nuspec_symbols_file = nil
-        debug "NugetsPack::Cmd#execute, opts: #{@opts} [nugets pack: cmd]"
-        original_pars = @parameters.dup
-
-        pars = original_pars.dup
-        pars << nuspec_file
-        pars << '-NoPackageAnalysis' unless @opts.get :package_analysis
-        pkg = get_nuget_path_of do
-          system @executable, pars, :work_dir => @work_dir
-        end
-
-        debug "package at '#{pkg}'"
-
-        # if the symbols flag is set and there's a symbols file specified
-        # then run NuGet.exe to generate the .symbols.nupkg file
-        if nuspec_symbols_file
-          pars = original_pars.dup
-          pars << '-Symbols'
-          pars << nuspec_symbols_file
-          spkg = with_subterfuge pkg do
-            get_nuget_path_of do
-              system @executable, pars, :work_dir => @work_dir
-            end
-          end
-
-          debug "symbol package at '#{spkg}'"
-
-          [pkg, spkg]
-        else
-          info "symbols not configured for generation, use Config#gen_symbols to do so [nugets pack: cmd]"
-          [pkg, nil]
-        end
-      end
-
-      private
-
-      # regexpes the package path from the output
-      def get_nuget_path_of
-        out = yield
-        out.match(/Successfully created package '([:\s\p{Word}\\\/\d\.\-]+\.symbols\.nupkg)'./iu) if out.respond_to? :match
-        trace "Got symbols return value: '#{out}', matched: '#{$1}'" if $1
-        return $1 if $1
-
-        out.match(/Successfully created package '([:\s\p{Word}\\\/\d\.\-]+\.nupkg)'./iu)if out.respond_to? :match
-        trace "Got NOT-symbols return value: '#{out}', matched: '#{$1}'"
-
-        unless $1
-          args = ARGV.inject("") { |state, arg| state + " " + '"' + arg + '"' }
-          warn do
-            %{Couldn't match package, please run
-     bundle exec rake DEBUG=true #{args} --trace
-and report a bug to albacore with the full output. Here's the nuget process output:
---- START OUTPUT ---
-#{out}
---- END OUTPUT ---
-}
-          end
-        end
-
-        $1
-      end
-
-      # hide the original like a ninja while NuGet whimpers in a corner
-      def with_subterfuge pkg
-        FileUtils.mv pkg, "#{pkg}.tmp" if pkg && File.exists?(pkg)
-        res = yield
-        FileUtils.mv "#{pkg}.tmp", pkg if pkg && File.exists?("#{pkg}.tmp")
-        res
-      end
-    end
 
-    # This tasktype allows you to quickly package project files to nuget
-    # packages.
-    #
-    # Point files to the project files, that should be in MsBuild XML.
-    #
-    # Examples
-    #
-    #  nugets_pack :pack => ['build/pkg', :versioning] do |p|
-    #    p.files   = FileList['src/**/*.csproj']
-    #    p.out     = 'build/pkg'
-    #    p.exe     = 'buildsupport/NuGet.exe'
-    #    p.with_metadata do |m|
-    #      m.version = ENV['NUGET_VERSION']
-    #    end
-    #    p.gen_symbols
-    #    p.no_project_dependencies
-    #  end
     class Config
       include CmdConfig
-      self.extend ConfigDSL
-
-      # the output directory to place the newfangled nugets in
-      attr_path :out
-
-      # the .net target (e.g. net40, mono20, mono3, etc)
-      attr_writer :target
-
-      # sets the files to search
-      attr_writer :files
-
-      # sets the nuspec file
-      attr_writer :nuspec
-
-
-      # sets the MsBuild configuration that is used to produce the output into
-      # <OutputPath>...</OutputPath>
-      attr_writer :configuration
 
       def initialize
-        @package = Albacore::NugetModel::Package.new
-        @target  = ''
-        @symbols = false
-        @project_dependencies = true
-        @nuget_dependencies = true
-        @package_analysis = true
-        @leave_nuspec = false
-        @mono_opt_out = false
-        fill_required
-      end
-
-      def mono_opt_out
-        @mono_opt_out = true
+        @symbols = true
+        @transitive = true
+        @pin = false
+        @exe = '.paket/paket.exe'
+        @files = []
+        @metadata = Albacore::NugetModel::Metadata.new
       end
 
-      def with_metadata &block
-        yield @package.metadata
-      end
+      attr_accessor :configuration
+      attr_accessor :exe
+      attr_accessor :output
+      attr_accessor :files
+      attr_accessor :metadata
 
-      # configure the package with a block
-      def with_package &block
-        yield @package
+      def not_symbols
+        @symbols = false
       end
 
-      # generate symbols for the nugets: just call this method to
-      # enable generation
-      def gen_symbols
-        @symbols = true
+      def symbols?
+        @symbols
       end
 
-      # leave the nuspec behind, don't delete it after generating it
-      #
-      def leave_nuspec
-        @leave_nuspec = true
+      def not_transitive
+        @transitive = false
       end
 
-      # call this if you want to cancel 'smart' scanning of the *proj
-      # file for its dependencies
-      def no_project_dependencies
-        @project_dependencies = false
+      def transitive?
+        @transitive
       end
 
-      # call this if you want to cancel inclusion of package dependencies
-      # when creating the nuspec file
-      def no_nuget_dependencies
-        @nuget_dependencies = false
+      def pin
+        @pin = true
       end
 
-      # call this if you want to disable NuGet's package analysis
-      # when creating the nupkg file
-      def no_package_analysis
-        @package_analysis = false
+      def pin?
+        @pin
       end
 
-      def nuget_gem_exe
-        @exe = Albacore::Nugets::find_nuget_gem_exe
+      def method_missing(m, *args, &block)
+        @metadata.send(m, *args, &block)
       end
 
-      # gets the options specified for the task, used from the task
-      def opts
-        files = @files.respond_to?(:each) ? @files : [@files]
-
-        unless @nuspec
-          [:authors, :description, :version].each do |required|
-            warn "metadata##{required} is missing from nugets_pack [nugets pack: config]" if @package.metadata.send(required) == 'MISSING'
-          end
+      def validate
+        if configuration.nil?
+          raise '"configuration" is a required property'
         end
-
-        Map.new({
-          :out           => @out,
-          :nuspec        => @nuspec,
-          :exe           => @exe,
-          :symbols       => @symbols,
-          :package       => @package,
-          :target        => @target,
-          :files         => files,
-          :configuration => @configuration,
-          :project_dependencies => @project_dependencies,
-          :nuget_dependencies => @nuget_dependencies,
-          :package_analysis => @package_analysis,
-          :mono_opt_out     => @mono_opt_out,
-          :original_path => FileUtils.pwd,
-          :leave_nuspec  => @leave_nuspec
-        })
-      end
-
-      private
-
-      def fill_required
-        # see http://docs.nuget.org/docs/reference/nuspec-reference
-        with_metadata do |m|
-          m.authors = m.description = m.version = 'MISSING'
+        if version.nil?
+          raise '"version" is a required property'
         end
       end
     end
 
-    # a task that handles the generation of nugets from projects or nuspecs.
-    class ProjectTask
-      include Logging
-
-      def initialize opts, &before_execute
-
-        unless opts.get(:nuspec)
-          raise ArgumentError, 'opts is not a map' unless opts.is_a? Map
-          raise ArgumentError, 'no files given' unless opts.get(:files).length > 0
-        end
+    class Cmd
+      include CrossPlatformCmd
 
-        @opts           = opts.apply :out => '.'
-        @files          = opts.get :files
-        @before_execute = before_execute
+      def initialize config
+        @executable = config.exe
+        @config = config
       end
 
       def execute
-        unless @opts.get(:nuspec)
-          knowns = compute_knowns
-          @files.each do |p|
-            proj, n, ns = generate_nuspec p, knowns
-            execute_inner! proj, n, ns
-          end
-        else
-          create_nuget! "#{Dir.pwd}", @opts.get(:nuspec)
-        end
-      end
-
-      def path_to path, cwd
-        if (Pathname.new path).absolute?
-           return path
-        else
-           return File.expand_path( File.join(@opts.get(:original_path), path), cwd )
-        end
-      end
-
-      # generate all nuspecs
-      def generate_nuspecs
-        nuspecs = {}
-        knowns = compute_knowns
-        @files.each do |p|
-          proj, n, ns = generate_nuspec p, knowns
-          nuspecs[proj.name] = OpenStruct.new({:proj => proj, :nuspec => n, :nuspec_symbols => ns })
+        @config.validate
+        invocations(@config).each do |parameters|
+          system @executable, parameters, clr_command: true
         end
-        nuspecs
       end
 
-      private
-
-      # Computes the known *Ids* of the projects; as Name = Title when creating nugets.
-      def compute_knowns
-        Set.new(@files.map { |f| Albacore::Project.new f }.map { |p| p.id })
-      end
-
-      def generate_nuspec p, knowns
-        proj = Albacore::Project.new p
-        nuspec, nuspec_symbols = create_nuspec proj, knowns
-        [proj, nuspec, nuspec_symbols]
-      end
-
-      # execute, for each project file
-      def execute_inner! proj, nuspec, nuspec_symbols
-        nuspec_path = write_nuspec! proj, nuspec, false
-        nuspec_symbols_path = write_nuspec! proj, nuspec_symbols, true if nuspec_symbols
-
-        create_nuget! proj.proj_path_base, nuspec_path, nuspec_symbols_path
-      rescue => e
-        err (e.inspect)
-        raise $!
-      ensure
-        trace do
-          %{
- PROJECT #{proj.name} nuspec:
-#{nuspec.to_xml}
- PROJECT #{proj.name} symbol nuspec:
-#{if nuspec_symbols then nuspec_symbols.to_xml else 'NO SYMBOLS' end}}
-        end
-
-        # now remove them all
-        [nuspec_path, nuspec_symbols_path].each{|n| cleanup_nuspec n}
-      end
-
-      ## Creating
-
-      def create_nuspec proj, knowns
-        version = @opts.get(:package).metadata.version
-        framework_dependencies = @opts.get(:package).metadata.framework_assemblies
-        project_dependencies = @opts.get(:project_dependencies, true)
-        nuget_dependencies = @opts.get(:nuget_dependencies, true)
-        target = if '' == @opts.get(:target) then proj.target_framework else @opts.get :target end
-        if target.start_with? 'v'
-          target = "net#{target[1..target.size].gsub('.', '')}"
-        end
-
-        trace "creating NON-SYMBOL package for '#{proj.name}', targeting '#{target}' [nugets pack: task]"
-        nuspec = Albacore::NugetModel::Package.from_xxproj proj,
-          symbols:        false,
-          verify_files:   true,
-          dotnet_version: target,
-          known_projects: knowns,
-          version:        version,
-          configuration:  (@opts.get(:configuration)),
-          project_dependencies: project_dependencies,
-          nuget_dependencies: nuget_dependencies,
-          framework_dependencies: framework_dependencies
-
-        # take data from package as configured in Rakefile, choosing what is in
-        # Rakefile over what is in projfile.
-        nuspec = nuspec.merge_with @opts.get(:package)
-        trace { "nuspec: #{nuspec.to_s} [nugets pack: task]" }
-
-        if @opts.get(:symbols)
-          trace { "creating SYMBOL package for '#{proj.name}' [nugets pack: task]" }
-          nuspec_symbols = Albacore::NugetModel::Package.from_xxproj proj,
-            symbols:        true,
-            verify_files:   true,
-            dotnet_version: target,
-            known_projects: knowns,
-            version:        version,
-            configuration:  (@opts.get(:configuration)),
-            project_dependencies: project_dependencies,
-            nuget_dependencies: nuget_dependencies,
-            framework_dependencies: framework_dependencies
-
-          nuspec_symbols = nuspec_symbols.merge_with @opts.get(:package)
-          trace { "nuspec symbols: #{nuspec_symbols.to_s} [nugets pack: task]" }
-
-          [nuspec, nuspec_symbols]
+    private
+      def defaults config
+        parameters = []
+        parameters = %w|pack|
+        parameters << config.output unless config.output.nil?
+        parameters << '--version' unless config.version.nil?
+        parameters << config.version unless config.version.nil?
+        parameters << '--build-config'
+        parameters << config.configuration
+        parameters << '--include-referenced-projects' if config.transitive?
+        parameters << '--symbols' if config.symbols?
+        parameters << '--project-url' if config.project_url
+        parameters << config.project_url if config.project_url
+        parameters
+      end
+
+      def invocations config
+        if config.files.empty?
+          [ defaults(config) ]
         else
-          trace { "skipping SYMBOL package for #{proj.name} [nugets pack: task]" }
-          [nuspec, nil]
-        end
-      end
-
-      def write_nuspec! proj, nuspec, symbols
-        raise ArgumentError, "no nuspect metadata id, project at path: #{proj.proj_path_base}, nuspec: #{nuspec.inspect}" unless nuspec.metadata.id
-        nuspec_path = File.join(proj.proj_path_base, nuspec.metadata.id + "#{ symbols ? '.symbols' : '' }.nuspec")
-
-        File.write(nuspec_path, nuspec.to_xml)
-
-        nuspec_path
-      end
+          config.files.map do |file|
+            proj = Albacore::Project.new file
+            package = Albacore::NugetModel::Package.from_xxproj proj,
+              configuration: config.configuration,
+              metadata: config.metadata
 
-      def create_nuget! cwd, nuspec, nuspec_symbols = nil
-        # create the command
-        exe = path_to(@opts.get(:exe), cwd)
-        out = path_to(@opts.get(:out), cwd)
-        nuspec = path_to nuspec, cwd
-        nuspec_symbols = path_to nuspec_symbols, cwd if nuspec_symbols
+            path = File.join(proj.proj_path_base, "paket.template")
 
-        cmd = Albacore::NugetsPack::Cmd.new exe,
-                work_dir:         cwd,
-                out:              out,
-                package_analysis: @opts.get(:package_analysis),
-                mono_opt_out:     @opts.get(:mono_opt_out)
-
-
-        # run any concerns that modify the command
-        @before_execute.call cmd if @before_execute
-
-        debug { "generating nuspec at #{nuspec}, and symbols (possibly) at '#{nuspec_symbols}' [nugets pack: task]" }
-
-        # run the command for the file
-        pkg, spkg = cmd.execute nuspec, nuspec_symbols
-
-        publish_artifact nuspec, pkg
-        publish_artifact nuspec_symbols, spkg if spkg && nuspec_symbols
-      end
-
-      ## Cleaning up after generation
-
-      def cleanup_nuspec nuspec
-        return if nuspec.nil? or not File.exists? nuspec
-        return if @opts.get :leave_nuspec, false
-        File.delete nuspec
-      end
-
-      def publish_artifact nuspec, nuget
-        Albacore.publish :artifact, OpenStruct.new(
-          :nuspec   => nuspec,
-          :nupkg    => nuget,
-          :location => nuget
-        )
-      end
-
-      def self.accept? f
-        File.extname(f).downcase != '.nuspec'
-      end
-    end
-
-    # generate a nuget from a nuspec
-    class NuspecTask
-      include Logging
-
-      def initialize command_line, config, nuspec
-        @config = config
-        @nuspec = nuspec
-        # is a NuspecPack::Cmd
-        @command_line = command_line
-      end
+            File.open(path, 'w') do |template|
+              template.write package.to_template
+            end
 
-      def read_version_from_nuspec
-        begin
-          nuspec_file = File.open(@nuspec)
-          xml = Nokogiri::XML(nuspec_file)
-          nuspec_file.close
-          nodes = xml.xpath('.//metadata/version')
-          raise "No <version/> found" if nodes.empty?
-          nodes.first.text()
-        rescue => error
-          err "Error reading package version from file: #{error}"
-          raise
+            parameters = defaults config
+            parameters << '--template'
+            parameters << path
+            [ parameters ]
+          end
         end
       end
-
-      def execute
-        version = read_version_from_nuspec
-        filename = File.basename(@nuspec, File.extname(@nuspec))
-
-        @command_line.execute @nuspec
-
-        path = File.join(@config.opts.get(:out), "#{filename}.#{version}.nupkg")
-
-        Albacore.publish :artifact, OpenStruct.new(
-          :nuspec   => @nuspec,
-          :nupkg    => path,
-          :location => path
-        )
-      end
-
-      def self.accept? file
-        File.extname(file).downcase == '.nuspec'
-      end
     end
   end
-end
+end