wooga_wooget 2.1.1

data/lib/wooget/cli.rb

@@ -0,0 +1,293 @@
+require 'thor'
+require 'fileutils'
+require 'json'
+require 'pathname'
+require 'activesupport/json_encoder'
+module Wooget
+  class CLI < Thor
+    include Thor::Actions
+    class_option :verbose, :desc => "Spit out tons of logging info", :aliases => "-v", :type => :boolean
+    class_option :quiet, :desc => "Suppress stdout", :aliases => "-q", :type => :boolean, default: false
+    class_option :path, desc: "Path to the project you want to install things into", default: Dir.pwd
+
+
+    def initialize *args
+      super
+
+      Wooget.log.level = Logger::Severity::DEBUG if self.options[:verbose]
+      Wooget.repos[:default] = self.options[:repo] if self.options[:repo]
+    end
+
+    desc "create PACKAGE_NAME", "create a new package"
+    option :visual_studio, desc: "Should visual studio files (.csproj .sln) be generated?", type: :boolean, default: true
+    option :tests, desc: "Should test project be generated?", type: :boolean, default: true
+    option :author, desc: "name to use for author field of nupkg"
+
+    def create package_name
+      proj = Project.new
+      proj.create package_name, options
+    end
+
+    desc "build", "build the packages in the current dir"
+    option :version, desc:"Version number to prepend to release notes", type: :string, required: true
+    option :output, desc: "Dir to place built packages", type: :string, default: "bin"
+    option :release_notes, desc: "Release notes to include in the package", type: :string, default: ""
+    option :native, desc: "Invoke native build functionality", type: :boolean, default: true
+    def build
+      package_release_checks
+
+      p "Preinstall before build"
+      invoke "install", [], quiet:true, path:get_path
+
+      p "Running tests"
+      invoke "test", [], path:get_path
+
+      #templates refs have to be relative to the working dir / project root for paket.exe
+      path = Pathname.new(options[:path])
+      templates = Dir.glob(File.join(options[:path],"**/*paket.template"))
+      templates.map! { |t| Pathname.new(t).relative_path_from(path).to_s}
+
+      build_options = {
+          output_dir: options[:output],
+          version:options[:version],
+          release_notes: options[:release_notes],
+          templates: templates,
+          path: options[:path],
+          native: options[:native]
+      }
+
+      built_packages = invoke "wooget:packager:build", [], build_options
+
+      p "#{built_packages.join " & "} built to #{File.expand_path File.join(options[:path],options[:output])}" if built_packages
+    end
+
+    option :repo, desc: "Which repo to use"
+    option :push, desc: "Should built package be pushed to repo", default: true, type: :boolean
+    option :confirm, desc: "Ask for confirmation before pushing", default: true, type: :boolean
+    option :output, desc: "Dir to place built packages", type: :string, default: "bin"
+    option :git, desc: "Use git functionality", type: :boolean, default: true
+    option :native, desc: "Invoke native build functionality", type: :boolean, default: true
+    desc "release", "release package in current dir"
+
+    def release
+      package_release_checks
+
+      released_packages = invoke "wooget:packager:release", [], options
+
+      p "#{released_packages.join " & "} released successfully" if released_packages
+    end
+
+    option :repo, desc: "Which repo to use"
+    option :push, desc: "Should built package be pushed to repo", default: true, type: :boolean
+    option :confirm, desc: "Ask for confirmation before pushing", default: true, type: :boolean
+    option :output, desc: "Dir to place built packages", type: :string, default: "bin"
+    option :git, desc: "Use git functionality", type: :boolean, default: true
+    option :native, desc: "Invoke native build functionality", type: :boolean, default: true
+    desc "prerelease", "prerelease package in current dir"
+
+    def prerelease
+      package_release_checks
+
+      released_packages = invoke "wooget:packager:prerelease", [], options
+
+      p "#{released_packages.join " & "} prereleased successfully" if released_packages
+    end
+
+    desc "test", "run package tests in mono"
+
+    def test
+      unless Util.is_a_wooget_package_dir(options[:path]) and Dir.exists?(File.join(options[:path],"tests"))
+        Wooget.log.error "Can't find a wooget package dir with tests at #{options[:path]}"
+        return
+      end
+
+      slns = Dir.glob(File.join(options[:path],"/**/*.sln"))
+      sln = slns.select{ |d| not Wooget::Util.is_a_unity_project_dir(File.dirname(d))}.first
+
+      if sln.nil? or sln.empty?
+        Wooget.log.error "Can't find sln file for building test artifacts"
+        return
+      end
+
+      nunit = Dir.glob(File.join(options[:path],"/**/nunit-console.exe")).first
+      if nunit.nil? or nunit.empty?
+        Wooget.log.error "Can't find nunit-console for running tests"
+        return
+      end
+
+
+      Dir.mktmpdir do |tmp_dir|
+        p "Building test assembly.."
+        stdout, status = Util.run_cmd("xbuild #{File.expand_path(sln)}  /t:Rebuild  /p:RestorePackages='False' /p:Configuration='Release' /p:OutDir='#{tmp_dir}/'") { |log| Wooget.no_status_log log}
+        raise BuildError, stdout.join unless status == 0
+
+        Dir[File.join(tmp_dir, "*Tests*.dll")].each do |assembly|
+          _, status = Util.run_cmd("mono #{nunit} #{assembly} -nologo -labels -noshadow") { |log| p log}
+          p "Exit Status - #{status}"
+        end
+      end
+    end
+
+    desc "paket ARGS", "call bundled version of paket and pass args"
+
+    def paket *args
+      Wooget::Paket.execute(args.join(" "))
+    end
+
+    desc "paket_unity3d ARGS", "call bundled version of paket.unity3d and pass args"
+
+    def paket_unity3d *args
+      Wooget::Paket.unity3d_execute(args.join(" "))
+    end
+
+    option :force, desc: "Forces the download and reinstallation of all packages.", aliases: "-f", type: :boolean, default: false
+    desc "install", "install packages into this unity project"
+    def install package=nil
+      load_config
+
+      if Util.is_a_unity_project_dir(options[:path]) or Util.is_a_wooget_package_dir(options[:path])
+        if package and Util.is_a_unity_project_dir(options[:path])
+          invoke "wooget:unity:install", [package], options
+        end
+
+        Paket.install options
+      else
+        abort "Project not found at #{options[:path]}"
+      end
+      p "Installed!"
+    end
+
+    option :force, desc: "Forces the download and reinstallation of all packages.", aliases: "-f", type: :boolean, default: false
+    desc "update", "update packages into this unity project"
+    def update package=nil
+      load_config
+
+      if Util.is_a_unity_project_dir(options[:path]) or Util.is_a_wooget_package_dir(options[:path])
+        Paket.update package, options
+      else
+        abort "Project not found at #{options[:path]}"
+      end
+      p "Updated!"
+    end
+
+    desc "bootstrap", "setup environment / project for wooget usage"
+    def bootstrap
+      assert_dependencies
+      p "Dependencies OK"
+      load_config
+      p "Config OK"
+
+      if Util.is_a_unity_project_dir options[:path]
+        p "Unity project detected - Checking setup"
+        invoke "wooget:unity:bootstrap", [], options
+      end
+    end
+
+    option :repos, desc: "Which repos to list", type: :array, default: ["main", "universe","legacy","public"]
+    option :format, desc: "What format to output results", type: :string, enum: ["shell","json"], default: "shell"
+    option :show_binary, desc: "Display binary packages in output", type: :boolean, default: false
+    desc "list", "list available packages + version"
+    def list package_id=nil
+      load_config
+
+      if package_id
+        p PackageListFormatter.format_package package_list_by_repo, options[:format], package_id
+      else
+        p PackageListFormatter.format_list package_list_by_repo, options[:format], options[:show_binary]
+      end
+    end
+
+    option :repos, desc: "Which repos to search", type: :array, default: ["main", "universe","legacy"]
+    option :format, desc: "What format to output results", type: :string, enum: ["shell","json"], default: "shell"
+    option :show_binary, desc: "Display binary packages in output", type: :boolean, default: false
+    desc "search", "search packages by a regex"
+    def search pattern
+      load_config
+
+      packages_by_repo = package_list_by_repo pattern
+      p PackageListFormatter.format_list packages_by_repo, options[:format], options[:show_binary]
+    end
+
+    private
+    def package_list_by_repo(match_pattern=nil)
+      packages_by_repo = {}
+      packages_by_repo_lock = Mutex.new
+
+      threads = options[:repos].map do |repo|
+        Thread.new do
+          url = Wooget.repos[repo] || Wooget.repos[repo.to_sym]
+          raise RepoError, "Can't find a repository with name '#{repo}' in the configuration" unless url
+
+          nuget = Nuget.new
+          packages = nuget.invoke "packages", [], repo_url:url
+          packages = packages.select { |pkg| pkg.package_id.downcase.match(match_pattern.downcase) } unless match_pattern.nil?
+          packages_by_repo_lock.synchronize { packages_by_repo[repo] = packages}
+        end
+      end
+
+      threads.each {|t| t.join}
+			packages_by_repo
+    end
+
+
+    no_commands do
+      def load_config
+        config_location = File.expand_path(File.join("~", ".wooget"))
+        unless File.exists? config_location
+          Wooget.log.info "Creating default config at #{config_location}"
+
+          default_config = File.expand_path(File.join(File.dirname(__FILE__), "template", "wooget_conf.json"))
+          FileUtils.cp(default_config, config_location)
+        end
+
+        config = JSON.parse(File.read(config_location), symbolize_names: true)
+
+        Wooget.credentials.merge! config[:credentials]
+        Wooget.repos.merge! config[:repos]
+
+        if config[:repos][:default]
+          Wooget.repos[:default] = config[:repos][:default]
+        end
+
+        #set default repo to whatever was passed on commandline (if anything)
+        if options[:repo]
+          overridden_repo = Wooget.repos[options[:repo]] || Wooget.repos[options[:repo].to_sym]
+          abort "Repo '#{options[:repo]}' not found in conf - options are #{Wooget.repos.keys.join(", ")}" unless overridden_repo
+
+          Wooget.repos[:default] = overridden_repo
+        end
+
+        Wooget.log.debug "Acting as #{Wooget.credentials[:username]}"
+        Wooget.log.debug "Default repo is #{Wooget.repo}"
+      end
+    end
+
+    private
+
+
+    def assert_package_dir
+      abort "#{ get_path} doesn't appear to be a wooget package dir" unless Util.is_a_wooget_package_dir  get_path
+    end
+
+    def get_path
+      path = Pathname.new(options[:path])
+      path.absolute? ? path : File.join(Dir.pwd, options[:path])
+    end
+
+    def assert_dependencies
+      %w( mono ).each do |dep|
+        `type #{dep}`
+        abort "Couldn't find #{dep} - please install!" unless $?.exitstatus == 0
+      end
+    end
+
+    def package_release_checks
+      assert_package_dir
+      load_config
+    end
+
+    def p msg
+      say msg unless options[:quiet]
+    end
+  end
+end

data/lib/wooget/nuget.rb

@@ -0,0 +1,96 @@
+require 'ostruct'
+require 'oga'
+require 'curb'
+
+module Wooget
+  class Nuget < Thor
+    option :repo_url, desc: "url to the repo", required: true
+    desc "packages", "get packages for a repo"
+
+    def packages
+      Wooget.log.info "Fetching package list for #{options[:repo_url]} ..."
+
+      url = ""
+      if options[:repo_url] == Wooget.repos[:public]
+        url = "https://packages.nuget.org/api/v2/Search?searchTerm=%27wooget%27"
+      else
+        url = options[:repo_url] + '/Search?$orderby=Id&$filter=IsLatestVersion&searchterm='
+      end
+
+      c = Curl::Easy.new(url)
+      c.username = Wooget.credentials[:username]
+      c.password = Wooget.credentials[:password]
+
+      c.perform
+
+      Nuget.from_xml c.body_str
+    end
+
+    def self.from_xml file
+      if file.is_a? String and File.exists? file
+        file = File.open(file)
+      end
+
+      doc = Oga.parse_xml(file)
+
+      entries = doc.css "entry"
+      entries.map do |e|
+        id = e.at_css("title").text()
+        url = e.at_css("id").text()
+        props_xml = e.at_css("properties").children
+        properties = props_xml.inject({}) do |hsh, node|
+          hsh[node.name] = node.text() if node.respond_to? :name
+          hsh
+        end
+
+        Package.new id, url, properties
+      end
+    end
+  end
+
+  class Package
+    attr_reader :properties, :url, :package_id
+
+    attr_reader :id, :version, :normalized_version, :authors, :copyright, :created, :dependencies, :description, :download_count
+    attr_reader :gallery_details_url, :icon_url, :is_latest_version, :is_absolute_latest_version, :is_prerelease, :language, :last_updated
+    attr_reader :published, :package_hash, :package_hash_algorithm, :package_size, :project_url, :report_abuse_url, :release_notes
+    attr_reader :require_license_acceptance, :license_url, :summary, :tags
+
+    attr_accessor :has_binary, :is_binary
+
+    def initialize package_id, url, properties
+      @package_id = package_id
+      @url = url
+      @properties = properties || {}
+
+      apply_properties
+    end
+
+    #
+    # discern between source and binary packages
+    def self.process_binary_packages(packages)
+      packages.each do |package|
+        package.is_binary = (package.package_id =~ /Binary/ or packages.any? { |p| p.package_id == package.package_id + ".Source" })
+        package.has_binary = packages.any? do |p|
+          (p.package_id != package.package_id and p.package_id == package.package_id.chomp(".Source"))\
+            or p.package_id == package.package_id + ".Binary"
+        end
+      end
+    end
+
+    private
+
+    def apply_properties
+      @properties.each do |k, v|
+        if self.respond_to? "#{k.snake_case}".to_sym
+
+          v = true if v == "true"
+          v = false if v == "false"
+
+          instance_variable_set "@#{k.snake_case}".to_sym, v
+        end
+      end
+      @dependencies = @dependencies.split("|") if @dependencies
+    end
+  end
+end

data/lib/wooget/paket.rb

@@ -0,0 +1,81 @@
+module Wooget
+  class Paket
+    @@paket_path = File.expand_path(File.join(__FILE__, "..", "third_party", "paket.exe"))
+    @@unity3d_path = File.expand_path(File.join(__FILE__, "..", "third_party", "paket.unity3d.exe"))
+
+    def self.execute args
+      cmd = "mono #{ @@paket_path} #{args}"
+      Wooget.log.debug "Running #{cmd}"
+
+      exec cmd
+    end
+
+    def self.unity3d_execute args
+      cmd = "mono #{@@unity3d_path} #{args}"
+      Wooget.log.debug "Running #{cmd}"
+
+      exec cmd
+    end
+
+    def self.install options={}
+      options[:path] ||= Dir.pwd
+
+      commands = ["#{env_vars} mono #{@@paket_path} install #{"--force" if options[:force]}"]
+      commands << "#{env_vars} mono #{@@unity3d_path} install" if Util.is_a_unity_project_dir(options[:path])
+
+      commands.each do |cmd|
+        reason, exitstatus = Util.run_cmd(cmd, options[:path]) { |log| Wooget.no_status_log log }
+        unless exitstatus == 0
+          Wooget.log.error "Install failed:\n #{reason}"
+          break
+        end
+      end
+    end
+
+    def self.update package=nil, options={}
+      options[:path] ||= Dir.pwd
+
+      commands = ["#{env_vars} mono #{@@paket_path} update #{"nuget #{package}" if package} #{"--force" if options[:force]}"]
+      commands << "#{env_vars} mono #{@@unity3d_path} install" if Util.is_a_unity_project_dir(options[:path])
+
+      commands.each do |cmd|
+        reason, exitstatus = Util.run_cmd(cmd, options[:path]) { |log| Wooget.no_status_log log }
+        unless exitstatus == 0
+          Wooget.log.error "Update failed:\n #{reason}"
+          break
+        end
+      end
+    end
+
+    def self.env_vars
+      "USERNAME=#{Wooget.credentials[:username]} PASSWORD=#{Wooget.credentials[:password]}"
+    end
+
+    def self.installed? project_path, package
+      abort "Not a valid paket dir - #{project_path}" unless Util.is_a_unity_project_dir(project_path) or Util.is_a_wooget_package_dir(project_path)
+
+      lock_file = File.join(project_path, "paket.lock")
+      return false unless File.exists? lock_file
+
+      File.open(lock_file).read.lines.any? { |l| l =~ /\s*#{package}\s+/ }
+    end
+
+    def self.should_generate_unity3d_references? path=Dir.pwd
+      #if the references file doesnt exist, or it does exist and
+      # it contains the automanage tag then we can rewrite it
+      auto_manage_tag = "[!automanage!]"
+      !File.exists?(File.join(path, "paket.unity3d.references")) or (Util.file_contains? File.join(path, "paket.dependencies"), auto_manage_tag)
+    end
+
+    def self.pack options
+      pack_cmd = "#{env_vars} mono #{@@paket_path} pack output #{options[:output]} version #{options[:version]} releaseNotes \"#{options[:release_notes]}\""
+      Util.run_cmd(pack_cmd, options[:path] || Dir.pwd) { |log| Wooget.no_status_log log }
+    end
+
+    def self.push auth, url, package
+      push_cmd = "#{env_vars} nugetkey=#{auth} mono #{@@paket_path} push url #{url} file #{package}"
+      Util.run_cmd(push_cmd) { |log| Wooget.no_status_log log }
+    end
+
+  end
+end