spade-packager 0.1.0

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

@@ -0,0 +1,46 @@
+module Spade::Packager::CLI
+  class Owner < Thor
+    default_task :list
+
+    desc "list [PACKAGE]", "Display owners of a package"
+    def list(package)
+      remote = Spade::Packager::Remote.new
+      if remote.logged_in?
+        yaml   = remote.list_owners(package)
+        owners = YAML.load(yaml)
+
+        if owners.is_a?(Array)
+          say "Owners for package: #{package}"
+          owners.each do |owner|
+            say "- #{owner['email']}"
+          end
+        else
+          say owners
+        end
+      else
+        abort LOGIN_MESSAGE
+      end
+    end
+
+    desc "add [PACKAGE] [EMAIL]", "Allow another user to push new versions of your spade package"
+    def add(package, email)
+      remote = Spade::Packager::Remote.new
+      if remote.logged_in?
+        say remote.add_owner(package, email)
+      else
+        abort LOGIN_MESSAGE
+      end
+    end
+
+    desc "remove [PACKAGE] [EMAIL]", "Allow another user to push new versions of your spade package"
+    def remove(package, email)
+      remote = Spade::Packager::Remote.new
+      if remote.logged_in?
+        say remote.remove_owner(package, email)
+      else
+        abort LOGIN_MESSAGE
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,117 @@
+module Spade::Packager::CLI
+  class ProjectGenerator
+    include Thor::Actions
+
+    source_root File.join(TEMPLATES_DIR, 'project')
+
+    attr_reader :name
+
+    def initialize(thor, name, root)
+      @thor, @name, @root = thor, name, root
+
+      self.destination_root = root
+    end
+
+    def run
+      empty_directory '.'
+      FileUtils.cd(destination_root)
+
+      template "LICENSE"
+      template "README.md"
+      template "project.json"
+
+      empty_directory "lib"
+      empty_directory "tests"
+
+      inside "lib" do
+        template "main.js"
+      end
+
+      inside "tests" do
+        template "main-test.js"
+      end
+    end
+
+  private
+
+    def app_const
+      name.gsub(/\W|-/, '_').squeeze('_').gsub(/(?:^|_)(.)/) { $1.upcase }
+    end
+
+    def current_year
+      Time.now.year
+    end
+
+    def source_paths
+      [File.expand_path('../../templates/project', __FILE__)] +
+        @thor.source_paths
+    end
+
+    def respond_to?(*args)
+      super || @thor.respond_to?(*args)
+    end
+
+    def method_missing(name, *args, &blk)
+      @thor.send(name, *args, &blk)
+    end
+  end
+end
+module Spade::CLI
+  class ProjectGenerator
+    include Thor::Actions
+
+    source_root File.expand_path('../../templates/project', __FILE__)
+
+    attr_reader :name
+
+    def initialize(thor, name, root)
+      @thor, @name, @root = thor, name, root
+
+      self.destination_root = root
+    end
+
+    def run
+      empty_directory '.'
+      FileUtils.cd(destination_root)
+
+      template "LICENSE"
+      template "README.md"
+      template "project.json"
+
+      empty_directory "lib"
+      empty_directory "tests"
+
+      inside "lib" do
+        template "main.js"
+      end
+
+      inside "tests" do
+        template "main-test.js"
+      end
+    end
+
+  private
+
+    def app_const
+      name.gsub(/\W|-/, '_').squeeze('_').gsub(/(?:^|_)(.)/) { $1.upcase }
+    end
+
+    def current_year
+      Time.now.year
+    end
+
+    def source_paths
+      [File.expand_path('../../templates/project', __FILE__)] +
+        @thor.source_paths
+    end
+
+    def respond_to?(*args)
+      super || @thor.respond_to?(*args)
+    end
+
+    def method_missing(name, *args, &blk)
+      @thor.send(name, *args, &blk)
+    end
+  end
+end
+

data/lib/spade/packager/credentials.rb

@@ -0,0 +1,38 @@
+module Spade
+  module Packager
+    class Credentials
+      attr_reader :email, :api_key
+
+      def initialize
+        parse
+      end
+
+      def save(email, api_key)
+        @email   = email
+        @api_key = api_key
+        write
+      end
+
+      private
+
+      def write
+        FileUtils.mkdir_p(File.dirname(path))
+        File.open(path, "w") do |file|
+          file.write YAML.dump(:spade_api_key => api_key, :spade_email => email)
+        end
+      end
+
+      def path
+        LibGems.configuration.credentials_path
+      end
+
+      def parse
+        if File.exist?(path)
+          hash     = YAML.load_file(path)
+          @email   = hash[:spade_email]
+          @api_key = hash[:spade_api_key]
+        end
+      end
+    end
+  end
+end

data/lib/spade/packager/local.rb

@@ -0,0 +1,50 @@
+require 'libgems/uninstaller'
+
+module Spade::Packager
+  class Local < Repository
+    def uninstall(package)
+      LibGems::Uninstaller.new(package).uninstall
+      true
+    rescue LibGems::InstallError
+      false
+    end
+
+    def pack(path)
+      package = Spade::Packager::Package.new(creds.email)
+      package.json_path = path
+      if package.valid?
+        silence do
+          LibGems::Builder.new(package.to_spec).build
+        end
+      end
+      package
+    end
+
+    def unpack(path, target)
+      package       = Spade::Packager::Package.new
+      package.spade = path
+      unpack_dir    = File.expand_path(File.join(Dir.pwd, target, package.to_full_name))
+      LibGems::Installer.new(path, :unpack => true).unpack unpack_dir
+      package
+    end
+
+    def installed(packages)
+      specs = LibGems.source_index.search dependency_for(packages)
+
+      specs.map do |spec|
+        [spec.name, spec.version, spec.original_platform]
+      end
+    end
+
+    private
+
+    def silence
+      original_verbose = LibGems.configuration.verbose
+      LibGems.configuration.verbose = false
+      yield
+    ensure
+      LibGems.configuration.verbose = original_verbose
+    end
+  end
+end
+

data/lib/spade/packager/package.rb

@@ -0,0 +1,160 @@
+require 'json'
+
+module Spade::Packager
+  class Package
+    EXT      = "spd"
+    METADATA = %w[keywords licenses engines main bin directories]
+    FIELDS   = %w[name version description author homepage summary]
+    attr_accessor :metadata, :lib_path, :test_path, :errors, :json_path, :attributes, :directories, :dependencies
+    attr_accessor *FIELDS
+
+    def initialize(email = "")
+      @email = email
+    end
+
+    def spade=(path)
+      format = LibGems::Format.from_file_by_path(path)
+      fill_from_gemspec(format.spec)
+    end
+
+    def to_spec
+      return unless valid?
+      LibGems::Specification.new do |spec|
+        spec.name              = name
+        spec.version           = version
+        spec.authors           = [author]
+        spec.email             = @email
+        spec.homepage          = homepage
+        spec.summary           = summary
+        spec.description       = description
+        spec.requirements      = [metadata.to_json]
+        spec.files             = directory_files + ["package.json"]
+        spec.test_files        = glob_files(test_path) if test_path
+        spec.bindir            = bin_path
+        spec.executables       = bin_files.map{|p| File.basename(p) } if bin_path
+        spec.rubyforge_project = "spade"
+        def spec.file_name
+          "#{full_name}.#{EXT}"
+        end
+        dependencies.each{|d,v| spec.add_dependency(d, v) } if dependencies
+      end
+    end
+
+    def as_json(options = {})
+      json = self.metadata.clone
+      FIELDS.each{|key| json[key] = send(key)}
+      json["dependencies"] = self.dependencies
+      json
+    end
+
+    def to_full_name
+      "#{name}-#{version}"
+    end
+
+    def to_ext
+      "#{self.to_full_name}.#{EXT}"
+    end
+
+    def errors
+      @errors ||= []
+    end
+
+    def validate
+      validate_fields && validate_version && validate_paths
+    end
+
+    def valid?
+      read && parse && validate
+    end
+
+    private
+
+    def directory_files
+      directories.values.map{|dir| glob_files(dir) }.flatten
+    end
+
+    def bin_files
+      if @attributes["bin"]
+        @attributes["bin"].values
+      else
+        []
+      end
+    end
+
+    def bin_path
+      @directories["bin"] || "bin"
+    end
+
+    def lib_path
+      @directories["lib"]
+    end
+
+    def test_path
+      @directories["test"]
+    end
+
+    def parse
+      FIELDS.each do |field|
+        send("#{field}=", @attributes[field])
+      end
+
+      self.dependencies = @attributes["dependencies"] || {}
+      self.directories = @attributes["directories"] || {}
+      self.metadata    = Hash[*@attributes.select { |k, v| METADATA.include?(k) }.flatten(1)]
+    end
+
+    def read
+      @attributes = JSON.parse(File.read(@json_path))
+    rescue *[JSON::ParserError, Errno::EACCES, Errno::ENOENT] => ex
+      add_error "There was a problem parsing package.json: #{ex.message}"
+    end
+
+    def validate_paths
+      %w[lib test].all? do |directory|
+        path = send("#{directory}_path")
+        if path.nil? || File.directory?(File.join(Dir.pwd, path))
+          true
+        else
+          add_error "'#{path}' specified for #{directory} directory, is not a directory"
+        end
+      end
+    end
+
+    def validate_version
+      LibGems::Version.new(version)
+      true
+    rescue ArgumentError => ex
+      add_error ex.to_s
+    end
+
+    def validate_fields
+      %w[name description summary homepage author version directories].all? do |field|
+        value = send(field)
+        if value.nil? || value.size.zero?
+          add_error "Package requires a '#{field}' field"
+        else
+          true
+        end
+      end
+    end
+
+    def add_error(message)
+      self.errors << message
+      false
+    end
+
+    def glob_files(path)
+      Dir[File.join(path, "**", "*")].reject{|f| File.directory?(f) }
+    end
+
+    def fill_from_gemspec(spec)
+      FIELDS.each{|field| send("#{field}=", spec.send(field).to_s) }
+
+      self.dependencies = {}
+      spec.dependencies.each{|d| self.dependencies[d.name] = d.requirement.to_s }
+
+      self.metadata = JSON.parse(spec.requirements.first)
+    end
+  end
+end
+

data/lib/spade/packager/remote.rb

@@ -0,0 +1,98 @@
+module Spade::Packager
+  class Remote < Repository
+    include LibGems::UserInteraction
+
+    def login(email, password)
+      response = raw_request :get, "api/v1/api_key" do |req|
+        req.basic_auth email, password
+      end
+
+      case response
+      when Net::HTTPSuccess
+        creds.save(email, response.body)
+        true
+      else
+        false
+      end
+    end
+
+    def push(package)
+      begin
+        body = LibGems.read_binary package
+        LibGems::Format.from_file_by_path(package)
+      rescue Exception => ex
+        return "There was a problem opening your package.\n#{ex.class}: #{ex.to_s}"
+      end
+
+      request :post, "api/v1/gems" do |req|
+        req.body = body
+        req.add_field "Content-Length", body.size
+        req.add_field "Content-Type",   "application/octet-stream"
+        req.add_field "Authorization",  creds.api_key
+      end
+    end
+
+    def yank(package, version)
+      request :delete, "api/v1/gems/yank" do |req|
+        req.set_form_data 'gem_name' => package, 'version' => version
+        req.add_field "Authorization", creds.api_key
+      end
+    end
+
+    def unyank(package, version)
+      request :put, "api/v1/gems/unyank" do |req|
+        req.set_form_data 'gem_name' => package, 'version' => version
+        req.add_field "Authorization", creds.api_key
+      end
+    end
+
+    def add_owner(package, email)
+      request :post, "api/v1/gems/#{package}/owners" do |req|
+        req.set_form_data 'email' => email
+        req.add_field "Authorization", creds.api_key
+      end
+    end
+
+    def remove_owner(package, email)
+      request :delete, "api/v1/gems/#{package}/owners" do |req|
+        req.set_form_data 'email' => email
+        req.add_field "Authorization", creds.api_key
+      end
+    end
+
+    def list_owners(package)
+      request :get, "api/v1/gems/#{package}/owners.yaml" do |req|
+        req.add_field "Authorization", creds.api_key
+      end
+    end
+
+    def list_packages(packages, all, prerelease)
+      fetcher = LibGems::SpecFetcher.fetcher
+      fetcher.find_matching(dependency_for(packages), all, false, prerelease).map(&:first)
+    end
+
+    def install(package, version, prerelease)
+      inst = LibGems::DependencyInstaller.new(:prerelease => prerelease)
+      inst.install package, LibGems::Requirement.new([version])
+      inst.installed_gems
+    end
+
+    private
+
+    def raw_request(method, path, &block)
+      require 'net/http'
+      host = ENV['SPADE_HOST'] || LibGems.host
+      uri = URI.parse "#{host}/#{path}"
+
+      request_method = Net::HTTP.const_get method.to_s.capitalize
+
+      LibGems::RemoteFetcher.fetcher.request(uri, request_method, &block)
+    end
+
+    def request(method, path, &block)
+      response = raw_request(method, path, &block)
+      response.body
+    end
+  end
+end
+