spaceship 0.0.1 → 0.0.2

data/lib/spaceship.rb

@@ -1,6 +1,72 @@
-require "spaceship/version"
-require "spaceship/ship"
+require 'spaceship/version'
+require 'spaceship/base'
+require 'spaceship/client'
+require 'spaceship/profile_types'
+require 'spaceship/app'
+require 'spaceship/certificate'
+require 'spaceship/device'
+require 'spaceship/provisioning_profile'
+require 'spaceship/launcher'
 
 module Spaceship
-  # Your code goes here...
+  # Use this to just setup the configuration attribute and set it later somewhere else
+  class << self
+    # This client stores the default client when using the lazy syntax
+    # Spaceship.app instead of using the spaceship launcher
+    attr_accessor :client
+
+    # Authenticates with Apple's web services. This method has to be called once
+    # to generate a valid session. The session will automatically be used from then
+    # on.
+    # 
+    # This method will automatically use the username from the Appfile (if available)
+    # and fetch the password from the Keychain (if available)
+    # 
+    # @param user (String) (optional): The username (usually the email address)
+    # @param password (String) (optional): The password
+    # 
+    # @raise InvalidUserCredentialsError: raised if authentication failed
+    # 
+    # @return (Spaceship::Client) The client the login method was called for
+    def login(user = nil, password = nil)
+      @client = Client.login(user, password)
+    end
+
+    # Open up the team selection for the user (if necessary).
+    # 
+    # If the user is in multiple teams, a team selection is shown.
+    # The user can then select a team by entering the number
+    # 
+    # Additionally, the team ID is shown next to each team name
+    # so that the user can use the environment variable `FASTLANE_TEAM_ID`
+    # for future user.
+    # 
+    # @return (String) The ID of the select team. You also get the value if 
+    #   the user is only in one team.
+    def select_team
+      @client.select_team
+    end
+
+    # Helper methods for managing multiple instances of spaceship
+
+    # @return (Class) Access the apps for the spaceship
+    def app
+      Spaceship::App.set_client(@client)
+    end
+
+    # @return (Class) Access the devices for the spaceship
+    def device
+      Spaceship::Device.set_client(@client)
+    end
+
+    # @return (Class) Access the certificates for the spaceship
+    def certificate
+      Spaceship::Certificate.set_client(@client)
+    end
+
+    # @return (Class) Access the provisioning profiles for the spaceship
+    def provisioning_profile
+      Spaceship::ProvisioningProfile.set_client(@client)
+    end
+  end
 end

data/lib/spaceship/app.rb

@@ -0,0 +1,96 @@
+module Spaceship
+  # Represents an App ID from the Developer Portal
+  class App < Base
+
+    # @return (String) The identifier of this app, provided by the Dev Portal
+    # @example 
+    #   "RGAWZGXSAA"
+    attr_accessor :app_id
+
+    # @return (String) The name you provided for this app
+    # @example
+    #   "Spaceship"
+    attr_accessor :name
+
+    # @return (String) the supported platform of this app
+    # @example 
+    #   "ios"
+    attr_accessor :platform
+
+    # Prefix provided by the Dev Portal
+    # @example 
+    #   "5A997XSHK2"
+    attr_accessor :prefix
+
+    # @return (String) The bundle_id (app identifier) of your app
+    # @example 
+    #   "com.krausefx.app"
+    attr_accessor :bundle_id
+
+    # @return (Bool) Is this app a wildcard app (e.g. com.krausefx.*)
+    attr_accessor :is_wildcard
+
+    # @return (Bool) Development Push Enabled?
+    attr_accessor :dev_push_enabled
+
+    # @return (Bool) Production Push Enabled?
+    attr_accessor :prod_push_enabled
+
+    attr_mapping(
+      'appIdId' => :app_id,
+      'name' => :name,
+      'appIdPlatform' => :platform,
+      'prefix' => :prefix,
+      'identifier' => :bundle_id,
+      'isWildCard' => :is_wildcard,
+      'isDevPushEnabled' => :dev_push_enabled,
+      'isProdPushEnabled' => :prod_push_enabled
+    )
+
+    class << self
+      # Create a new object based on a hash.
+      # This is used to create a new object based on the server response.
+      def factory(attrs)
+        self.new(attrs)
+      end
+
+      # @return (Array) Returns all apps available for this account
+      def all
+        client.apps.map { |app| self.factory(app) }
+      end
+
+      # Creates a new App ID on the Apple Dev Portal
+      # 
+      # if bundle_id ends with '*' then it is a wildcard id otherwise, it is an explicit id
+      # @param bundle_id [String] the bundle id (app_identifier) of the app associated with this provisioning profile
+      # @param name [String] the name of the App
+      # @return (App) The app you just created
+      def create!(bundle_id: bundle_id, name: name)
+        if bundle_id.end_with?('*')
+          type = :wildcard
+        else
+          type = :explicit
+        end
+
+        new_app = client.create_app!(type, name, bundle_id)
+        self.new(new_app)
+      end
+
+      # Find a specific App ID based on the bundle_id
+      # @return (App) The app you're looking for. This is nil if the app can't be found.
+      def find(bundle_id)
+        all.find do |app|
+          app.bundle_id == bundle_id
+        end
+      end
+    end
+
+    # Delete this App ID. This action will most likely fail if the App ID is already in the store
+    # or there are active profiles
+    # @return (App) The app you just deletd
+    def delete!
+      client.delete_app!(app_id)
+      self
+    end
+  end
+end

data/lib/spaceship/base.rb

@@ -0,0 +1,86 @@
+module Spaceship
+  class Base
+    class << self
+      attr_accessor :client
+
+      def client
+        @client || Spaceship.client
+      end
+
+      #set client and return self for chaining
+      def set_client(client)
+        self.client = client
+        self
+      end
+
+      ##
+      # bang method since it changes the parameter in-place
+      def remap_keys!(attrs)
+        return if attr_mapping.nil?
+
+        attr_mapping.each do |from, to|
+          attrs[to] = attrs.delete(from)
+        end
+      end
+
+      def attr_mapping(attr_map = nil)
+        if attr_map
+          @attr_mapping = attr_map
+        else
+          @attr_mapping ||= ancestors[1].attr_mapping rescue nil
+        end
+      end
+
+      ##
+      # Call a method to return a subclass constant.
+      #
+      # If `method_sym` is an underscored name of a class,
+      # return the class with the current client passed into it.
+      # If the method does not match, NoMethodError is raised.
+      #
+      # Example:
+      #
+      #   Certificate.production_push
+      #   #=> Certificate::ProductionPush
+      #
+      #   ProvisioningProfile.ad_hoc
+      #   #=> ProvisioningProfile::AdHoc
+      #
+      #   ProvisioningProfile.some_other_method
+      #   #=> NoMethodError: undefined method `some_other_method' for ProvisioningProfile
+      def method_missing(method_sym, *args, &block)
+        module_name = method_sym.to_s
+        module_name.sub!(/^[a-z\d]/) { $&.upcase }
+        module_name.gsub!(/(?:_|(\/))([a-z\d])/) { $2.upcase }
+        const_name = "#{self.name}::#{module_name}"
+        # if const_defined?(const_name)
+          klass = const_get(const_name)
+          klass.set_client(@client)
+        # else
+        #   super
+        # end
+      end
+    end
+
+    def initialize(attrs = {})
+      self.class.remap_keys!(attrs)
+      attrs.each do |key, val|
+        self.send("#{key}=", val) if respond_to?("#{key}=")
+      end
+      @client = self.class.client
+    end
+
+    def client
+      @client
+    end
+
+    def inspect
+      inspectables = instance_variables - [:@client]
+      inspect_vars = inspectables.map do |ivar|
+         val = instance_variable_get(ivar)
+         "#{ivar}=#{val.inspect}"
+      end
+      "\n#<#{self.class.name}\n\t#{inspect_vars.join("\n\t")}>"
+    end
+  end
+end

data/lib/spaceship/certificate.rb

@@ -0,0 +1,270 @@
+require 'openssl'
+
+module Spaceship
+  # Represents a certificate from the Apple Developer Portal.
+  # 
+  # This can either be a code signing identity or a push profile
+  class Certificate < Base
+    # @return (String) The ID given from the developer portal. You'll probably not need it.
+    # @example 
+    #   "P577TH3PAA"
+    attr_accessor :id
+
+    # @return (String) The name of the certificate
+    # @example Company
+    #   "SunApps GmbH"
+    # @example Push Profile
+    #   "com.krausefx.app"
+    attr_accessor :name
+
+    # @return (String) Status of the certificate
+    # @example 
+    #   "Issued"
+    attr_accessor :status
+
+    # @return (Date) The date and time when the certificate was created
+    # @example 
+    #   2015-04-01 21:24:00 UTC
+    attr_accessor :created
+
+    # @return (Date) The date and time when the certificate will expire
+    # @example 
+    #   2016-04-01 21:24:00 UTC
+    attr_accessor :expires
+    
+    # @return (String) The owner type that defines if it's a push profile
+    #  or a code signing identity
+    # 
+    # @example Code Signing Identity
+    #   "team"
+    # @example Push Certificate
+    #   "bundle"
+    attr_accessor :owner_type
+
+    # @return (String) The name of the owner
+    # 
+    # @example Code Signing Identity (usually the company name)
+    #   "SunApps Gmbh"
+    # @example Push Certificate (the name of your App ID)
+    #   "Awesome App"
+    attr_accessor :owner_name
+
+    # @return (String) The ID of the owner, that can be used to 
+    #  fetch more information
+    # @example
+    #   "75B83SPLAA"
+    attr_accessor :owner_id
+
+    # Indicates the type of this certificate
+    # which is automatically used to determine the class of 
+    # the certificate. Available values listed in CERTIFICATE_TYPE_IDS
+    # @return (String) The type of the certificate
+    # @example Production Certificate
+    #   "R58UK2EWSO"
+    # @example Development Certificate
+    #   "5QPB9NHCEI"
+    attr_accessor :type_display_id
+
+    attr_mapping({
+      'certificateId' => :id,
+      'name' => :name,
+      'statusString' => :status,
+      'dateCreated' => :created,
+      'expirationDate' => :expires,
+      'ownerType' => :owner_type,
+      'ownerName' => :owner_name,
+      'ownerId' => :owner_id,
+      'certificateTypeDisplayId' => :type_display_id
+    })
+
+    #####################################################
+    # Certs are not associated with apps
+    #####################################################
+
+    # A development code signing certificate used for development environment
+    class Development < Certificate; end
+
+    # A production code signing certificate used for distribution environment
+    class Production < Certificate; end
+
+    # An In House code signing certificate used for enterprise distributions
+    class InHouse < Certificate; end
+
+    #####################################################
+    # Certs that are specific for one app
+    #####################################################
+
+    # Abstract class for push certificates. Check out the subclasses
+    # DevelopmentPush, ProductionPush, WebsitePush and VoipPush
+    class PushCertificate < Certificate; end
+
+    # A push notification certificate for development environment
+    class DevelopmentPush < PushCertificate; end
+
+    # A push notification certificate for production environment
+    class ProductionPush < PushCertificate; end
+
+    # A push notification certificate for websites
+    class WebsitePush < PushCertificate; end
+
+    # A push notification certificate for the VOIP environment
+    class VoipPush < PushCertificate; end
+
+    # Passbook certificate
+    class Passbook < Certificate; end
+
+    # ApplePay certificate
+    class ApplePay < Certificate; end
+
+    CERTIFICATE_TYPE_IDS = {
+      "5QPB9NHCEI" => Development,
+      "R58UK2EWSO" => Production,
+      "9RQEK7MSXA" => InHouse,
+      "LA30L5BJEU" => Certificate,
+      "BKLRAVXMGM" => DevelopmentPush,
+      "3BQKVH9I2X" => ProductionPush,
+      "Y3B2F3TYSI" => Passbook,
+      "3T2ZP62QW8" => WebsitePush,
+      "E5D663CMZW" => WebsitePush,
+      "4APLUP237T" => ApplePay
+    }
+
+    #class methods
+    class << self
+      # Create a new code signing request that can be used to 
+      # generate a new certificate
+      # @example
+      #  Create a new certificate signing request
+      #  csr, pkey = Spaceship.certificate.create_certificate_signing_request
+      # 
+      #  # Use the signing request to create a new distribution certificate
+      #  Spaceship.certificate.production.create!(csr: csr)
+      def create_certificate_signing_request
+        key = OpenSSL::PKey::RSA.new 2048
+        csr = OpenSSL::X509::Request.new
+        csr.version = 0
+        csr.subject = OpenSSL::X509::Name.new([
+          ['CN', 'PEM', OpenSSL::ASN1::UTF8STRING]
+        ])
+        csr.public_key = key.public_key
+        csr.sign(key, OpenSSL::Digest::SHA1.new)
+        return [csr, key]
+      end
+
+      # Create a new object based on a hash.
+      # This is used to create a new object based on the server response.
+      def factory(attrs)
+        # Example:
+        # => {"name"=>"iOS Distribution: SunApps GmbH",
+        #  "certificateId"=>"XC5PH8DAAA",
+        #  "serialNumber"=>"797E732CCE8B7AAA",
+        #  "status"=>"Issued",
+        #  "statusCode"=>0,
+        #  "expirationDate"=>#<DateTime: 2015-11-25T22:45:50+00:00 ((2457352j,81950s,0n),+0s,2299161j)>,
+        #  "certificatePlatform"=>"ios",
+        #  "certificateType"=>
+        #   {"certificateTypeDisplayId"=>"R58UK2EAAA",
+        #    "name"=>"iOS Distribution",
+        #    "platform"=>"ios",
+        #    "permissionType"=>"distribution",
+        #    "distributionType"=>"store",
+        #    "distributionMethod"=>"app",
+        #    "ownerType"=>"team",
+        #    "daysOverlap"=>364,
+        #    "maxActive"=>2}}
+
+        if attrs['certificateType']
+          # On some accounts this is nested, so we need to flatten it
+          attrs.merge!(attrs['certificateType'])
+          attrs.delete('certificateType')
+        end
+
+        # Parse the dates
+        attrs['expirationDate'] = (Time.parse(attrs['expirationDate']) rescue attrs['expirationDate'])
+        attrs['dateCreated'] = (Time.parse(attrs['dateCreated']) rescue attrs['dateCreated'])
+
+        # Here we go
+        klass = CERTIFICATE_TYPE_IDS[attrs['certificateTypeDisplayId']]
+        klass ||= Certificate
+        klass.client = @client
+        klass.new(attrs)
+      end
+
+      # @return (Array) Returns all certificates of this account.
+      #  If this is called from a subclass of Certificate, this will
+      #  only include certificates matching the current type.
+      def all
+        if (self == Certificate) # are we the base-class?
+          types = CERTIFICATE_TYPE_IDS.keys
+        else
+          types = [CERTIFICATE_TYPE_IDS.key(self)]
+        end
+
+        client.certificates(types).map do |cert|
+          factory(cert)
+        end
+      end
+
+      # @return (Certificate) Find a certificate based on the ID of the certificate. 
+      def find(certificate_id)
+        all.find do |c|
+          c.id == certificate_id
+        end
+      end
+
+      # Generate a new certificate based on a code certificate signing request
+      # @param csr (required): The certificate signing request to use. Get one using 
+      #   `create_certificate_signing_request`
+      # @param bundle_id (String) (optional): The app identifier this certificate is for.
+      #  This value is only needed if you create a push profile. For normal code signing
+      #  certificates, you must only pass a certificate signing request.
+      # @example 
+      #  # Create a new certificate signing request
+      #  csr, pkey = Spaceship::Certificate.create_certificate_signing_request
+      #  
+      #  # Use the signing request to create a new distribution certificate
+      #  Spaceship::Certificate::Production.create!(csr: csr)
+      # @return (Device): The newly created device
+      def create!(csr: csr, bundle_id: nil)
+        type = CERTIFICATE_TYPE_IDS.key(self)
+
+        # look up the app_id by the bundle_id
+        if bundle_id
+          app = Spaceship::App.find(bundle_id)
+          raise "Could not find app with bundle id '#{bundle_id}'" unless app
+          app_id = app.app_id
+        end
+
+        # if this succeeds, we need to save the .cer and the private key in keychain access or wherever they go in linux
+        response = client.create_certificate!(type, csr.to_pem, app_id)
+        # munge the response to make it work for the factory
+        response['certificateTypeDisplayId'] = response['certificateType']['certificateTypeDisplayId']
+        self.new(response)
+      end
+    end
+
+    # instance methods
+
+    # @return (String) Download the raw data of the certificate without parsing
+    def download_raw
+      client.download_certificate(id, type_display_id)
+    end
+
+    # @return (OpenSSL::X509::Certificate) Downloads and parses the certificate
+    def download
+      OpenSSL::X509::Certificate.new(download_raw)
+    end
+
+    # Revoke the certificate. You shouldn't use this method probably.
+    def revoke!
+      client.revoke_certificate!(id, type_display_id)
+    end
+
+    # @return (Bool): Is this certificate a push profile for apps? 
+    def is_push?
+      # does display_type_id match push?
+      [Client::ProfileTypes::Push.development, Client::ProfileTypes::Push.production].include?(type_display_id)
+    end
+
+  end
+end