spade-packager 0.1.0

data/.gitignore

@@ -0,0 +1,2 @@
+tmp
+devbin

data/.gitmodules

@@ -0,0 +1,6 @@
+[submodule "packages/optparse"]
+	path = packages/optparse
+	url = https://github.com/qrush/optparse-js.git
+[submodule "packages/coffee-script"]
+	path = packages/coffee-script
+	url = https://github.com/charlesjolley/coffee-script.git

data/bin/spadepkg

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+lib = File.expand_path(File.dirname(__FILE__) + '/../lib')
+$:.unshift(lib) if File.exists?(lib)
+
+require 'spade/packager'
+
+Spade::Packager::CLI::Base.start
+

data/lib/libgems_ext.rb

@@ -0,0 +1,8 @@
+require 'libgems_ext/libgems'
+require 'libgems_ext/config_file'
+require 'libgems_ext/dependency_installer'
+require 'libgems_ext/installer'
+require 'libgems_ext/spec_fetcher'
+
+# Reload from new paths
+LibGems.load_configuration

data/lib/libgems_ext/config_file.rb

@@ -0,0 +1,33 @@
+require 'libgems/config_file'
+
+module LibGems
+  class ConfigFile
+
+    # Duplicate, with slight work-arounds, but needed for SYSTEM_WIDE_CONFIG_FILE
+    system_config_path =
+      if defined?(Win32API) # Already required in original version
+        CSIDL_COMMON_APPDATA = 0x0023
+        path = 0.chr * 260
+        if RUBY_VERSION > '1.9' then
+          SHGetFolderPath = Win32API.new 'shell32', 'SHGetFolderPath', 'PLPLP',
+                                         'L', :stdcall
+          SHGetFolderPath.call nil, CSIDL_COMMON_APPDATA, nil, 1, path
+        else
+          SHGetFolderPath = Win32API.new 'shell32', 'SHGetFolderPath', 'LLLLP',
+                                         'L'
+          SHGetFolderPath.call 0, CSIDL_COMMON_APPDATA, 0, 1, path
+        end
+
+        path.strip
+      else
+        '/etc'
+      end
+
+    remove_const(:SYSTEM_WIDE_CONFIG_FILE)
+    SYSTEM_WIDE_CONFIG_FILE = File.join system_config_path, 'spaderc'
+
+    def credentials_path
+      File.join(LibGems.user_dir, "credentials")
+    end
+  end
+end

data/lib/libgems_ext/dependency_installer.rb

@@ -0,0 +1,150 @@
+require 'libgems/dependency_installer'
+
+module LibGems
+  class DependencyInstaller
+
+    # Had to overwrite this all just to change the match from /gem$/ to /spd$/
+    # TODO: Consider whether extension should be settable in LibGems
+    def find_spec_by_name_and_version(gem_name,
+                                      version = LibGems::Requirement.default,
+                                      prerelease = false)
+      spec_and_source = nil
+
+      glob = if File::ALT_SEPARATOR then
+               gem_name.gsub File::ALT_SEPARATOR, File::SEPARATOR
+             else
+               gem_name
+             end
+
+      local_gems = Dir["#{glob}*"].sort.reverse
+
+      unless local_gems.empty? then
+        local_gems.each do |gem_file|
+          next unless gem_file =~ /spd$/
+          begin
+            spec = LibGems::Format.from_file_by_path(gem_file).spec
+            spec_and_source = [spec, gem_file]
+            break
+          rescue SystemCallError, LibGems::Package::FormatError
+          end
+        end
+      end
+
+      if spec_and_source.nil? then
+        dep = LibGems::Dependency.new gem_name, version
+        dep.prerelease = true if prerelease
+        spec_and_sources = find_gems_with_sources(dep).reverse
+
+        spec_and_source = spec_and_sources.find { |spec, source|
+          LibGems::Platform.match spec.platform
+        }
+      end
+
+      if spec_and_source.nil? then
+        raise LibGems::GemNotFoundException.new(
+          "Could not find a valid spd '#{gem_name}' (#{version}) locally or in a repository",
+          gem_name, version, @errors)
+      end
+
+      @specs_and_sources = [spec_and_source]
+    end
+
+    # Overwrite this to use our custom installer
+    def install dep_or_name, version = LibGems::Requirement.default
+      LibGems.with_rubygems_compat do
+        if String === dep_or_name then
+          find_spec_by_name_and_version dep_or_name, version, @prerelease
+        else
+          dep_or_name.prerelease = @prerelease
+          @specs_and_sources = [find_gems_with_sources(dep_or_name).last]
+        end
+
+        @installed_gems = []
+
+        gather_dependencies
+
+        @gems_to_install.each do |spec|
+          last = spec == @gems_to_install.last
+          # HACK is this test for full_name acceptable?
+          next if @source_index.any? { |n,_| n == spec.full_name } and not last
+
+          # TODO: make this sorta_verbose so other users can benefit from it
+          say "Installing spd #{spec.full_name}" if LibGems.configuration.really_verbose
+
+          _, source_uri = @specs_and_sources.assoc spec
+          begin
+            local_gem_path = LibGems::RemoteFetcher.fetcher.download spec, source_uri,
+                                                                 @cache_dir
+          rescue LibGems::RemoteFetcher::FetchError
+            next if @force
+            raise
+          end
+
+          inst = LibGems::Installer.new local_gem_path,
+                                    :bin_dir             => @bin_dir,
+                                    :development         => @development,
+                                    :env_shebang         => @env_shebang,
+                                    :force               => @force,
+                                    :format_executable   => @format_executable,
+                                    :ignore_dependencies => @ignore_dependencies,
+                                    :install_dir         => @install_dir,
+                                    :security_policy     => @security_policy,
+                                    :source_index        => @source_index,
+                                    :user_install        => @user_install,
+                                    :wrappers            => @wrappers
+
+          spec = inst.install
+
+          @installed_gems << spec
+        end
+
+        @installed_gems
+      end
+    end
+
+    def find_gems_with_sources(dep)
+      # Reset the errors
+      @errors = nil
+      gems_and_sources = []
+
+      if @domain == :both or @domain == :local then
+        Dir[File.join(Dir.pwd, "#{dep.name}-[0-9]*.spd")].each do |gem_file|
+          spec = LibGems::Format.from_file_by_path(gem_file).spec
+          gems_and_sources << [spec, gem_file] if spec.name == dep.name
+        end
+      end
+
+      if @domain == :both or @domain == :remote then
+        begin
+          requirements = dep.requirement.requirements.map do |req, ver|
+            req
+          end
+
+          all = !dep.prerelease? &&
+                # we only need latest if there's one requirement and it is
+                # guaranteed to match the newest specs
+                (requirements.length > 1 or
+                  (requirements.first != ">=" and requirements.first != ">"))
+
+          found, @errors = LibGems::SpecFetcher.fetcher.fetch_with_errors dep, all, true, dep.prerelease?
+
+          gems_and_sources.push(*found)
+
+        rescue LibGems::RemoteFetcher::FetchError => e
+          if LibGems.configuration.really_verbose then
+            say "Error fetching remote data:\t\t#{e.message}"
+            say "Falling back to local-only install"
+          end
+          @domain = :local
+        end
+      end
+
+      gems_and_sources.sort_by do |gem, source|
+        [gem, source =~ /^http:\/\// ? 0 : 1] # local gems win
+      end
+    end
+
+  end
+end
+
+

data/lib/libgems_ext/installer.rb

@@ -0,0 +1,39 @@
+require 'libgems/installer'
+
+module LibGems
+  class Installer
+
+    def app_script_text(bin_file_name)
+      <<-TEXT
+#{shebang bin_file_name}
+#
+# This file was generated by Spade.
+#
+# The application '#{@spec.name}' is installed as part of an spd, and
+# this file is here to facilitate running it.
+#
+
+version = "#{LibGems::Requirement.default}"
+
+if ARGV.first =~ /^_(.*)_$/ and LibGems::Version.correct? $1 then
+  version = $1
+  ARGV.shift
+end
+
+gem '#{@spec.name}', version
+
+path = LibGems.bin_path('#{@spec.name}', '#{bin_file_name}', version)
+shebang = File.open(path){|f| f.readline }
+
+if shebang =~ /^\#\!.*ruby/
+  load path
+else
+  exec path, *ARGV
+end
+TEXT
+    end
+
+  end
+end
+
+

data/lib/libgems_ext/libgems.rb

@@ -0,0 +1,39 @@
+require 'libgems'
+
+module LibGems
+  def self.default_sources
+    %w[https://sproutcutter.heroku.com/]
+  end
+
+  def self.host
+    @host ||= "https://sproutcutter.heroku.com"
+  end
+
+  def self.default_dir
+    File.join LibGems.user_home, Spade::SPADE_DIR
+  end
+
+  def self.user_dir
+    File.join LibGems.user_home, Spade::SPADE_DIR
+  end
+
+  def self.config_file
+    File.join LibGems.user_home, '.spaderc'
+  end
+
+  def self.path
+    @gem_path ||= nil
+
+    unless @gem_path then
+      paths = [ENV['SPADE_PATH'] || LibGems.configuration.path || default_path]
+      set_paths paths.compact.join(File::PATH_SEPARATOR)
+    end
+
+    @gem_path
+  end
+
+  def self.dir
+    set_home(ENV['SPADE_HOME'] || LibGems.configuration.home || default_dir) unless @gem_home
+    @gem_home
+  end
+end

data/lib/libgems_ext/spec_fetcher.rb

@@ -0,0 +1,11 @@
+require 'libgems/spec_fetcher'
+
+module LibGems
+  class SpecFetcher
+    alias :orig_initialize :initialize
+    def initialize(*args)
+      orig_initialize(*args)
+      @dir = File.join LibGems.dir, 'specs'
+    end
+  end
+end

data/lib/spade-packager.rb

@@ -0,0 +1 @@
+require 'spade/packager'

data/lib/spade/packager.rb

@@ -0,0 +1,18 @@
+require 'spade/core'
+require 'libgems'
+require 'libgems_ext'
+
+module Spade
+  module Packager
+    TEMPLATES_DIR = File.expand_path("../../../templates", __FILE__)
+
+    autoload :CLI,                  'spade/packager/cli'
+    autoload :Credentials,          'spade/packager/credentials'
+    autoload :Local,                'spade/packager/local'
+    autoload :Package,              'spade/packager/package'
+    autoload :Remote,               'spade/packager/remote'
+    autoload :Repository,           'spade/packager/repository'
+    autoload :Version,              'spade/packager/version'
+  end
+end
+

data/lib/spade/packager/cli.rb

@@ -0,0 +1,9 @@
+module Spade
+  module Packager
+    module CLI
+      autoload :Base,             'spade/packager/cli/base'
+      autoload :Owner,            'spade/packager/cli/owner'
+      autoload :ProjectGenerator, 'spade/packager/cli/project_generator'
+    end
+  end
+end

data/lib/spade/packager/cli/base.rb

@@ -0,0 +1,196 @@
+require 'thor'
+require 'highline'
+
+module Spade
+  module Packager
+    module CLI
+      LOGIN_MESSAGE = "Please login first with `spade login`."
+
+      class Base < Thor
+
+        class_option :verbose, :type => :boolean, :default => false,
+          :aliases => ['-V'],
+          :desc => 'Show additional debug information while running'
+
+        desc "owner", "Manage users for a package"
+        subcommand "owner", Spade::Packager::CLI::Owner
+
+        desc "install [PACKAGE]", "Installs one or many spade packages"
+        method_option :version,    :type => :string,  :default => ">= 0", :aliases => ['-v'],    :desc => 'Specify a version to install'
+        method_option :prerelease, :type => :boolean, :default => false,  :aliases => ['--pre'], :desc => 'Install a prerelease version'
+        def install(*packages)
+          report_arity_error("install") and return if packages.size.zero?
+
+          begin
+            packages.each do |package|
+              installed = Spade::Packager::Remote.new.install(package, options[:version], options[:prerelease])
+              installed.each do |spec|
+                say "Successfully installed #{spec.full_name}"
+              end
+            end
+          rescue LibGems::InstallError => e
+            abort "Install error: #{e}"
+          rescue LibGems::GemNotFoundException => e
+            abort "Can't find package #{e.name} #{e.version} available for install"
+          rescue Errno::EACCES, LibGems::FilePermissionError => e
+            abort e.message
+          end
+        end
+
+        desc "installed [PACKAGE]", "Shows what spade packages are installed"
+        def installed(*packages)
+          local = Spade::Packager::Local.new
+          index = local.installed(packages)
+          print_specs(packages, index)
+        end
+
+        desc "uninstall [PACKAGE]", "Uninstalls one or many packages"
+        def uninstall(*packages)
+          local = Spade::Packager::Local.new
+          if packages.size > 0
+            packages.each do |package|
+              if !local.uninstall(package)
+                abort %{No packages installed named "#{package}"}
+              end
+            end
+          else
+            report_arity_error('uninstall')
+          end
+        end
+
+        desc "login", "Log in with your Spade credentials"
+        def login
+          highline = HighLine.new
+          say "Enter your Spade credentials."
+
+          begin
+            email = highline.ask "\nEmail:" do |q|
+              next unless STDIN.tty?
+              q.readline = true
+            end
+
+            password = highline.ask "\nPassword:" do |q|
+              next unless STDIN.tty?
+              q.echo = "*"
+            end
+          rescue Interrupt => ex
+            abort "Cancelled login."
+          end
+
+          say "\nLogging in as #{email}..."
+
+          if Spade::Packager::Remote.new.login(email, password)
+            say "Logged in!"
+          else
+            say "Incorrect email or password."
+            login
+          end
+        end
+
+        desc "push", "Distribute your spade package"
+        def push(package)
+          remote = Spade::Packager::Remote.new
+          if remote.logged_in?
+            say remote.push(package)
+          else
+            say LOGIN_MESSAGE
+          end
+        end
+
+        desc "yank", "Remove a specific package version release from SproutCutter"
+        method_option :version, :type => :string,  :default => nil,   :aliases => ['-v'],    :desc => 'Specify a version to yank'
+        method_option :undo,    :type => :boolean, :default => false,                        :desc => 'Unyank package'
+        def yank(package)
+          if options[:version]
+            remote = Spade::Packager::Remote.new
+            if remote.logged_in?
+              if options[:undo]
+                say remote.unyank(package, options[:version])
+              else
+                say remote.yank(package, options[:version])
+              end
+            else
+              say LOGIN_MESSAGE
+            end
+          else
+            say "Version required"
+          end
+        end
+
+        desc "list", "View available packages for download"
+        method_option :all,        :type => :boolean, :default => false, :aliases => ['-a'],    :desc => 'List all versions available'
+        method_option :prerelease, :type => :boolean, :default => false, :aliases => ['--pre'], :desc => 'List prerelease versions available'
+        def list(*packages)
+          remote = Spade::Packager::Remote.new
+          index  = remote.list_packages(packages, options[:all], options[:prerelease])
+          print_specs(packages, index)
+        end
+
+        desc "new [NAME]", "Generate a new project skeleton"
+        def new(name)
+          ProjectGenerator.new(self,
+            name, File.expand_path(name)).run
+        end
+
+        desc "build", "Build a spade package from a package.json"
+        def build
+          local = Spade::Packager::Local.new
+          if local.logged_in?
+            package = local.pack("package.json")
+            if package.errors.empty?
+              puts "Successfully built package: #{package.to_ext}"
+            else
+              failure_message = "Spade encountered the following problems building your package:"
+              package.errors.each do |error|
+                failure_message << "\n* #{error}"
+              end
+              abort failure_message
+            end
+          else
+            abort LOGIN_MESSAGE
+          end
+        end
+
+        desc "unpack [PACKAGE]", "Extract files from a spade package"
+        method_option :target, :type => :string, :default => ".", :aliases => ['-t'], :desc => 'Unpack to given directory'
+        def unpack(*paths)
+          local = Spade::Packager::Local.new
+
+          paths.each do |path|
+            begin
+              package     = local.unpack(path, options[:target])
+              unpack_path = File.expand_path(File.join(Dir.pwd, options[:target], package.to_full_name))
+              puts "Unpacked spade into: #{unpack_path}"
+            rescue Errno::EACCES, LibGems::FilePermissionError => ex
+              abort "There was a problem unpacking #{path}:\n#{ex.message}"
+            end
+          end
+        end
+
+        private
+
+          def report_arity_error(name)
+            self.class.handle_argument_error(self.class.tasks[name], nil)
+          end
+
+          def print_specs(packages, index)
+            spades = {}
+
+            index.each do |(name, version, platform)|
+              spades[name] ||= []
+              spades[name] << version
+            end
+
+            if spades.size.zero?
+              abort %{No packages found matching "#{packages.join('", "')}".}
+            else
+              spades.each do |name, versions|
+                puts "#{name} (#{versions.sort.reverse.join(", ")})"
+              end
+            end
+          end
+
+      end
+    end
+  end
+end