physique 0.2.2

data/lib/physique/task_builders/default.rb

@@ -0,0 +1,9 @@
+module Physique
+  class DefaultTasksBuilder < TasksBuilder
+    def build_tasks
+      Rake::Task.define_task :default => [ :test ]
+      Rake::Task.define_task :ci => [ :versionizer, :test ]
+    end
+  end
+end
+

data/lib/physique/task_builders/fluent_migrator.rb

@@ -0,0 +1,227 @@
+require 'physique/project'
+
+module Physique
+  class FluentMigratorConfig
+    self.extend Albacore::ConfigDSL
+    include Albacore::Logging
+
+    # Project name or path
+    attr_path :project
+
+    attr_writer :lang,        # Programming language of the db project
+                :instance,    # Server instance name
+                :name,        # Database name
+                :scripts_dir, # Scripts folder to examine to create tasks
+                :dialect      # Dialect to use for generating SQL
+
+    def initialize
+      @lang = :cs
+      @scripts_dir = '_Scripts'
+    end
+
+    def opts
+      Map.new({
+        exe: @exe,
+        instance: @instance,
+        name: @name,
+        project: @project,
+        project_file: Physique::Project.get_path(@project, @lang),
+        lang: @lang,
+      }).apply(
+        lang: :cs,
+        project_dir: "src/#{@project}",
+        scripts_dir: "src/#{@project}/#{@scripts_dir}"
+      )
+    end
+  end
+
+  class FluentMigratorTasksBuilder < TasksBuilder
+    def build_tasks
+      @options = solution.migrator
+      return if @options.nil?
+
+      add_script_tasks
+      add_default_db_tasks
+      add_migrator_tasks
+      add_workflow_tasks
+      add_new_migration_task
+    end
+
+    private
+
+    def add_script_tasks
+      FileList["#{@options.scripts_dir}/*.sql"].each do |f|
+        namespace :db do
+          task_name = File.basename(f, '.*')
+          task = sqlcmd_task task_name do |s|
+            s.file = f
+            s.server_name = @options.instance
+            s.set_variable 'DATABASE_NAME', @options.name
+          end
+          task.add_description get_script_task_description(task_name, @options.scripts_dir)
+        end
+      end
+    end
+
+    def add_default_db_tasks
+      default_tasks(@options.name).each do |task_name,sql|
+        unless Rake::Task.task_defined? "db:#{task_name.to_s}"
+          namespace :db do
+            task = sqlcmd_task task_name do |s|
+              s.command = sql
+              s.server_name = @options.instance
+              s.set_variable 'DATABASE_NAME', @options.name
+            end
+            task.add_description get_script_task_description(task_name, @options.scripts_dir)
+          end
+        end
+      end
+    end
+
+    def default_tasks(database)
+      { create: "CREATE DATABASE #{database}",
+        drop: "DROP DATABASE #{database}",
+        seed: 'SELECT 1' } # This is a no-op
+    end
+
+    def get_script_task_description(task, dir)
+      well_known_scripts[task.to_sym] || "Executes #{task}.sql in the #{dir} folder."
+    end
+
+    # TODO: Refactor this to combine this with default_tasks
+    def well_known_scripts
+      { create: 'Creates the database',
+        drop: 'Drops the database',
+        seed: 'Seeds the database with test data' }
+    end
+
+    def add_migrator_tasks
+      require 'physique/tasks/fluent_migrator'
+
+      namespace :db do
+        build_task :compile_db do |b|
+          b.target = [ 'Build' ]
+          b.file = solution.migrator.project_file
+          b.prop 'Configuration', solution.compile.configuration
+          b.logging = solution.compile.logging
+        end
+
+        block = lambda &method(:configure_migration)
+
+        # Migrate up
+        task = fluent_migrator_task :migrate => [ :compile_db ], &block.curry.('migrate:up')
+        task.add_description 'Migrate database to the latest version'
+
+        # Migrate down
+        task = fluent_migrator_task :rollback => [ :compile_db ], &block.curry.('rollback')
+        task.add_description 'Rollback the database to the previous version'
+      end
+    end
+
+    def configure_migration(task, config)
+      config.instance = solution.migrator.instance
+      config.database = solution.migrator.name
+      config.task = task
+      config.dll = migration_dll
+      config.exe = locate_tool(tool_in_output_folder || tool_in_nuget_package)
+      config.output_to_file
+    end
+
+    def add_workflow_tasks
+      namespace :db do
+        # Try the migration
+        task = Rake::Task.define_task :try => [ :migrate, :rollback ]
+        task.add_description 'Migrate and then immediately rollback'
+
+        # Setup the database from nothing
+        task = Rake::Task.define_task :setup => [ :create, :migrate, :seed ]
+        task.add_description 'Create the database and run all migrations'
+
+        # Setup the database from nothing
+        task = Rake::Task.define_task :rebuild => [ :drop, :setup ]
+        task.add_description 'Drop and recreate the database'
+      end
+    end
+
+    def migration_dll
+      "#{solution.migrator.project_dir}/bin/#{solution.compile.configuration}/#{solution.migrator.project}.dll"
+    end
+
+    def tool_in_output_folder
+      existing_path "#{solution.migrator.project_dir}/bin/#{solution.compile.configuration}/Migrate.exe"
+    end
+
+    def tool_in_nuget_package
+      existing_path "#{solution.nuget.restore_location}/FluentMigrator.*/tools/Migrate.exe"
+    end
+
+    def existing_path(path)
+      return path if FileList[path].any? { |p| File.exists? p }
+      nil
+    end
+
+    def add_new_migration_task
+      namespace :db do
+        task = Rake::Task.define_task :new_migration, :name, :description do |t, args|
+          name, description = args[:name], args[:description]
+
+          unless name
+            abort [
+              %Q{Usage: rake "#{t.name}[name[,description]]"},
+              desc,
+            ].join "\n\n"
+          end
+
+          project, project_dir, project_file = solution.migrator.project, solution.migrator.project_dir, solution.migrator.project_file
+          version = migration_version
+          migration_file_name = "#{version}_#{name}.cs"
+          migration_content = migration_template(version, name, description, project)
+
+          # Save the new migration file
+          save_file migration_content, "#{project_dir}/Migrations/#{migration_file_name}"
+
+          # Add the new migration file to the project
+          Albacore::Project.new(project_file).tap do |p|
+            p.add_compile_node :Migrations, migration_file_name
+            p.save
+          end
+        end
+        task.add_description 'Creates a new migration file with the specified name'
+      end
+    end
+
+    def migration_version
+      Time.now.utc.strftime('%Y%m%d%H%M%S')
+    end
+
+    def migration_template(version, name, description, project_name)
+      description = ", \"#{description}\"" unless description.nil?
+      return <<TEMPLATE
+using FluentMigrator;
+using FluentMigrator.Runner;
+
+namespace #{project_name}.Migrations
+{
+    [Migration(#{version}#{description})]
+    public class #{name} : Migration
+    {
+        public override void Up()
+        {
+            // Add migration code here
+        }
+
+        public override void Down()
+        {
+            // Add migration rollback code here
+        }
+    }
+}
+TEMPLATE
+    end
+
+    def save_file(content, file_path)
+      raise "#{file_path} already exists, cancelling" if File.exists? file_path
+      File.open(file_path, 'w') { |f| f.write(content) }
+    end
+  end
+end

data/lib/physique/task_builders/nuget.rb

@@ -0,0 +1,45 @@
+module Physique
+  class NugetConfig
+    self.extend Albacore::ConfigDSL
+
+    attr_path :exe,               # Path to nuget executable
+              :restore_location,  # Path where nuget packages will be downloaded
+              :build_location     # Path where nuget packages will be built
+
+    # Disable metadata analysis (sets -NoPackageAnalysis flag)
+    def disable_package_analysis
+      @disable_package_analysis = true
+    end
+
+    def initialize
+      @exe = 'src/.nuget/NuGet.exe'
+      @restore_location = 'src/packages'
+      @build_location = 'build/packages'
+    end
+
+    def opts
+      Map.new({
+        exe: @exe,
+        restore_location: @restore_location,
+        build_location: @build_location,
+        disable_package_analysis: !!@disable_package_analysis
+      })
+    end
+  end
+
+  class NugetTasksBuilder < TasksBuilder
+    def build_tasks
+      add_restore
+    end
+
+    private
+
+    def add_restore
+      task = nugets_restore_task :restore do |r|
+        r.out = solution.nuget.restore_location
+        r.exe = solution.nuget.exe
+      end
+      task.add_description 'Restores all nugets as per the packages.config files'
+    end
+  end
+end

data/lib/physique/task_builders/octopus.rb

@@ -0,0 +1,147 @@
+require 'albacore'
+require 'albacore/nuget_model'
+require 'physique/config'
+
+module Physique
+  class OctopusDeployConfig
+    attr_writer :server,  # The server name of the deployment server
+                :api_key  # The API key of the deployment server
+
+    def initialize
+      @apps = []
+      @alias_tasks = true
+    end
+
+    # Do not alias the tasks without the 'octo' prefix.
+    def no_alias_tasks
+      @alias_tasks = false
+    end
+
+    def deploy_app
+      config = OctopusDeployAppConfig.new
+      yield config
+      @apps << config
+    end
+
+    def opts
+      raise ArgumentError, 'You must specify a server to deploy to' if @server.blank?
+      raise ArgumentError, 'You must specify at least one application to deploy' if @apps.blank?
+
+      Map.new({
+        server: @server,
+        api_key: @api_key,
+        alias_tasks: @alias_tasks,
+        apps: @apps.map { |a| a.opts }
+      })
+    end
+  end
+
+  class OctopusDeployAppConfig < MetadataConfig
+    attr_writer :name,    # The name for the build task
+                :project, # The project to deploy
+                :type,    # The type of app to deploy
+                :lang     # The programming language of the project to deploy
+
+    def initialize
+      super
+      @type = :console
+      @lang = :cs
+    end
+
+    def opts
+      raise ArgumentError, 'You must specify a :project to deploy' if @project.blank?
+      raise ArgumentError, 'You must specify the :type of project to deploy' if @type.blank?
+      raise ArgumentError, "Project :type #{@type} is not supported." unless supported_types.include? @type
+
+      project_file_path = Physique::Project.get_path(@project, @lang)
+      _, project_file = File.split project_file_path
+      project_name = File.basename(project_file, '.*')
+
+      Map.new({
+        type: @type,
+        name: @name || @project,
+        project: project_name,
+        project_file: project_file_path,
+        metadata: @metadata
+      })
+    end
+
+    private
+
+    def supported_types
+      [ :console, :service, :website ]
+    end
+  end
+
+  class OctopusTasksBuilder < TasksBuilder
+    def build_tasks
+      @options = solution.octopus
+      return if @options.nil?
+      return if @options.apps.blank?
+
+      add_octopus_package_tasks
+      add_octopus_publish_tasks
+
+      if @options.alias_tasks
+        add_task_aliases
+      end
+    end
+
+    private
+
+    def add_octopus_package_tasks
+      @options.apps.each do |a|
+        namespace :octo do
+          namespace :package do
+            task = octopus_pack_task a.name => [:versionizer, :test] do |o|
+              ensure_output_location solution.nuget.build_location
+
+              o.project_file = a.project_file
+              o.type = a.type
+              o.configuration = solution.compile.configuration
+              o.exe = solution.nuget.exe
+              o.out = solution.nuget.build_location
+              o.metadata = a.metadata
+            end
+            task.add_description "Package #{a.project} for Octopus deployment"
+          end
+
+          task = Rake::Task.define_task :package => all_octopus_app_tasks('package')
+          task.add_description 'Package all applications'
+        end
+      end
+    end
+
+    def add_octopus_publish_tasks
+      nuget = solution.nuget
+
+      @options.apps.each do |a|
+        namespace :octo do
+          namespace :publish do
+            task = Rake::Task.define_task a.name => [ "package:#{a.name}" ] do
+              package_location = Albacore::Paths.normalise_slashes "#{nuget.build_location}/#{a.project}.#{a.metadata.version}.nupkg"
+              sh "#{nuget.exe} push #{package_location} -ApiKey #{@options.api_key} -Source #{@options.server}"
+            end
+            task.add_description "Publish #{a.project} app to Octopus Server"
+          end
+
+          task = Rake::Task.define_task :publish => all_octopus_app_tasks('publish')
+          task.add_description 'Publish all apps to Octopus Server'
+        end
+      end
+    end
+
+    def all_octopus_app_tasks(task)
+      # It is assumed that this is called within the octo namespace
+      @options.apps.map { |a| "#{task}:#{a.name}" }
+    end
+
+    def add_task_aliases
+      task = Rake::Task.define_task :package => [ 'octo:package' ]
+      task.add_description 'Package all applications'
+
+      task = Rake::Task.define_task :publish => [ 'octo:publish' ]
+      task.add_description 'Publish apps to Octopus Server'
+    end
+  end
+end

data/lib/physique/task_builders/publish_nugets.rb

@@ -0,0 +1,133 @@
+require 'physique/config'
+
+module Physique
+  class PublishNugetsConfig < MetadataConfig
+    attr_writer :project_files, # Project files to include
+                :exclude,       # Project files to exclude
+                :local_path,    # Path to publish locally
+                :feed_url,      # Nuget feed to publish packages
+                :api_key        # Nuget API key
+
+    def initialize
+      super
+      @alias_tasks = true
+    end
+
+    # Do not alias the tasks without the 'nuget' prefix.
+    def no_alias_tasks
+      @alias_tasks = false
+    end
+
+    def symbols_feed_url=(value)
+      @gen_symbols = true
+      @symbols_feed_url = value
+    end
+
+    def opts
+      Map.new(
+        project_files: FileList[project_files_or_default].exclude(exclude_or_default),
+        metadata: @metadata,
+        local_path: @local_path,
+        feed_url: @feed_url,
+        gen_symbols: @gen_symbols,
+        symbols_feed_url: @symbols_feed_url,
+        api_key: @api_key,
+        alias_tasks: @alias_tasks
+      ).apply(
+        local_path: 'C:/Nuget.Local'
+      )
+    end
+
+    def project_files_or_default
+      @project_files || 'src/**/*.{csproj,fsproj,nuspec}'
+    end
+
+    def exclude_or_default
+      @exclude || /Tests/
+    end
+  end
+
+  class PublishNugetsTasksBuilder < TasksBuilder
+    def build_tasks
+      @options = solution.publish_nugets
+      return if @options.nil?
+
+      add_package_nugets_task
+      add_publish_nugets_task
+      add_publish_nugets_local_task
+
+      if @options.alias_tasks
+        add_task_aliases
+      end
+    end
+
+    private
+
+    def add_package_nugets_task
+      namespace :nuget do
+        task = nugets_pack_task :package => [ :versionizer, :test ] do |p|
+          ensure_output_location solution.nuget.build_location
+
+          p.configuration = solution.compile.configuration
+          p.out           = solution.nuget.build_location
+          p.exe           = solution.nuget.exe
+          p.files         = @options.project_files
+          p.gen_symbols   if @options.gen_symbols
+          p.with_metadata do |m|
+            @options.metadata.set_fields.each do |attr|
+              eval "m.#{attr}= @options.metadata.#{attr}"
+            end
+          end
+        end
+        task.add_description 'Package all nugets'
+      end
+    end
+
+    def add_publish_nugets_task
+      namespace :nuget do
+        task = Rake::Task.define_task :publish => [ 'nuget:package' ] do
+          raise ArgumentError, 'You must specify an :api_key to connect to the server' if @options.api_key.blank?
+
+          nuget_project_names.each do |p|
+            sh nuget_publish_command(p, 'nupkg', @options.feed_url)
+
+            if @options.gen_symbols
+              sh nuget_publish_command(p, 'symbols.nupkg', @options.symbols_feed_url)
+            end
+          end
+        end
+        task.add_description 'Publish nuget packages to feed'
+      end
+    end
+
+    def nuget_publish_command(name, extension, feed)
+      "#{solution.nuget.exe} push #{solution.nuget.build_location}/#{name}.#{@options.metadata.version}.#{extension} #{@options.api_key} -Source #{feed}"
+    end
+
+    def add_publish_nugets_local_task
+      local_path = @options.local_path
+
+      namespace :nuget do
+        namespace :publish do
+          task = Rake::Task.define_task :local => [ 'nuget:package' ] do
+            ensure_output_location local_path
+            FileUtils.cp FileList["#{solution.nuget.build_location}/*"], local_path
+          end
+          task.add_description 'Copy nuget packages to local path'
+        end
+      end
+    end
+
+    def nuget_project_names
+      Set.new(@options.project_files.map { |f| Albacore::Project.new f }.map { |p| p.name })
+    end
+
+    def add_task_aliases
+      task = Rake::Task.define_task :package => [ 'nuget:package' ]
+      task.add_description 'Package all nugets'
+
+      task = Rake::Task.define_task :publish => [ 'nuget:publish' ]
+      task.add_description 'Publish nuget packages to feed'
+    end
+  end
+end