passifier 0.0.2

data/lib/passifier/pass.rb

@@ -0,0 +1,82 @@
+#!/usr/bin/env ruby
+
+module Passifier
+
+  class Pass
+
+    attr_reader :archive, 
+      :image_files, 
+      :manifest, 
+      :serial_number, 
+      :signature, 
+      :spec
+
+    # @param [String] serial_number An ID for this pass, used as the serial number in pass.json
+    # @param [Hash] spec_hash The pass's spec (pass.json)
+    # @param [Hash] images The pass's image assets
+    #                      ex. { "background.png" => "https://www.google.com/images/srpr/logo3w.png", 
+    #                          "thumbnail.png" => "~/thumb.png" }
+    # @param [Signing] signing A valid signing
+    def initialize(serial_number, spec_hash, images, signing, options = {})
+      @signing = signing
+      @spec = Spec.new(serial_number, spec_hash)
+      @image_files = to_image_files(images)
+      @manifest = Manifest.new(@image_files, signing)
+      @signature = ManifestSignature.new(@manifest, signing)
+    end
+
+    # File objects that should be included in the archive
+    # @return [Array<Spec, Manifest, ManifestSignature, StaticFile, UrlSource>] File objects that will appear in 
+    #                                                                           this pass' archive
+    def files_for_archive
+      [@spec, @manifest, @signature, @image_files].flatten.compact
+    end
+
+    # Create the Archive file for this Pass
+    # @param [String] path The desired path of the Archive
+    # @return [Archive] The complete stored archive
+    def create_archive(path, options = {})
+      @archive = Archive.new(path, @spec.serial_number, files_for_archive)
+      @archive.store(options)
+      @archive
+    end
+    alias_method :generate, :create_archive
+    alias_method :save, :create_archive
+
+    # Convert a Time object to Apple's preferred String time format
+    # @param [Time, Date, DateTime] The time object to convert to a String
+    # @return [String] The converted time object in Apple's preferred format
+    def self.to_apple_datetime(time_with_zone)
+      time_with_zone.strftime("%Y-%m-%dT%H:%M%:z")
+    end
+
+    # Create a Pass and corresponding Archive file
+    # @param [String] path The desired path of the Archive
+    # @param [String] serial_number An ID for this pass, used as the serial number in pass.json
+    # @param [Hash] spec_hash The pass's spec (pass.json)
+    # @param [Hash] images The pass's image assets
+    #                      ex. { "background.png" => "https://www.google.com/images/srpr/logo3w.png", 
+    #                          "thumbnail.png" => "~/thumb.png" }
+    # @param [Signing] signing A valid signing
+    # @return [Archive] The complete stored archive
+    def self.create_archive(path, serial_number, spec_hash, images, signing, options = {})
+      pass = new(serial_number, spec_hash, images, signing, options)
+      pass.create_archive(path, options)
+    end
+
+    protected
+
+    # Convert a list of images to Passifier file objects
+    # @param [Hash] images A Hash of filenames and corresponding file paths or urls
+    # @return [Array<StaticFile, UrlSource>] The resulting StaticFile and/or UrlSource objects
+    def to_image_files(images)
+      images.map do |filename, image| 
+        klass = (image =~ /https?:\/\/[\S]+/) ? UrlSource : StaticFile
+        klass.new(filename, image)
+      end.flatten.compact
+    end
+
+  end
+
+end
+

data/lib/passifier/signing.rb

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+
+module Passifier
+
+  # Class for Pass signing functionality
+  class Signing
+
+    # @param [String] key_pem The key pem file location
+    # @param [String] pass_phrase The key pass phrase
+    # @param [String] certificate_pem The certificate pem file location
+    def initialize(key_pem, pass_phrase, certificate_pem)
+      @certificate = File.read(certificate_pem)
+      @key = File.read(key_pem)
+      @pass_phrase = pass_phrase
+    end
+
+    # Generate a digest of the given content
+    # @param [String] content The content to generate a digest from
+    # @return [String] The resulting digest
+    def sha(content)
+      signed_contents = sign(content)
+      Digest::SHA1.hexdigest(signed_contents)
+    end
+
+    # Sign the given content
+    # @param [String] content The content to generate a signing of
+    # @return [String] The resulting signing
+    def sign(content)
+      key = OpenSSL::PKey::RSA.new(@key, @pass_phrase)
+      certificate = OpenSSL::X509::Certificate.new(@certificate)
+      OpenSSL::PKCS7.sign(certificate, key, content, nil, OpenSSL::PKCS7::BINARY | OpenSSL::PKCS7::NOATTR | OpenSSL::PKCS7::DETACHED).to_der
+    end
+
+  end
+
+end
+
+

data/lib/passifier/spec.rb

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+
+module Passifier
+
+  # Pass specification, representing the pass.json file
+  class Spec
+
+    attr_reader :hash, :serial_number
+    alias_method :to_hash, :hash
+
+    # @param [String] serial_number An ID for this Spec, used in the pass.json file as the Serial Number
+    # @param [Hash] hash The pass.json contents as a hash
+    def initialize(serial_number, hash)
+      @serial_number = serial_number
+      @hash = hash
+    end
+
+    # The contents of the pass.json file
+    # @return [String] The pass.json contents as a String
+    def to_json
+      to_hash.to_json
+    end
+    alias_method :content, :to_json
+
+    def filename
+      "pass.json"
+    end
+
+  end
+
+end

data/lib/passifier/static_file.rb

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+
+module Passifier
+
+  # A single local static file asset
+  class StaticFile
+
+    attr_reader :content, :name, :path
+    alias_method :filename, :name
+
+    # @param [String, Symbol] name The name of the asset
+    # @param [String] path_to_file The local path to the asset file
+    def initialize(name, path_to_file)
+      @name = name
+      @path = path_to_file
+      @content = File.open(@path, 'rb') {|file| file.read }
+    end
+
+  end
+
+end
+
+
+

data/lib/passifier/storage.rb

@@ -0,0 +1,94 @@
+#!/usr/bin/env ruby
+
+module Passifier
+
+  # Disk storage for a pass
+  class Storage
+
+    attr_reader :assets, :scratch_directory
+
+    # @param [String] scratch directory The directory to use for file storage
+    # @param [Array<Object>] assets The file assets to store
+    def initialize(scratch_directory, assets)
+      @assets = [assets].flatten
+      @scratch_directory = scratch_directory
+    end
+
+    # Path to the stored version
+    # @param [String] filename The filename to return the path for
+    # @return [String] The full path to the file with the passed-in filename
+    def path(filename)
+      "#{@scratch_directory}/#{filename}"
+    end
+
+    # Store the files for a group of pass assets
+    # @param [Array<Object>] The pass asset objects to store files for
+    def store
+      ensure_directory_exists
+      @assets.each { |asset| write_file(asset) }
+    end
+
+    # Create a zip archive given a filename for the archive and a set of pass assets
+    # @param [String] zip_path The desired output path
+    # @return [String] The full path of the resulting zip archive
+    def zip(zip_path)
+      remove_zip(zip_path) # ensure that older version is deleted if it exists
+      Zip::ZipFile.open(zip_path, Zip::ZipFile::CREATE) do |zipfile|
+        @assets.each do |asset| 
+          zipfile.add(asset.filename, path(asset.filename))
+        end
+      end
+      zip_path
+    end
+
+    # Clean up temp files
+    def cleanup
+      remove_temp_files
+      remove_directory
+    end
+
+    # Remove a zip archive
+    # @param [String] zip_path The path of the archive to delete
+    def remove_zip(zip_path)
+      File.delete(zip_path) if File.exists?(zip_path)
+    end
+
+    protected
+
+    # Store the file for the given pass asset to disk
+    # @param [Object] asset Store the file for the given pass asset
+    def write_file(asset)
+      File.open(path(asset.filename), 'w') do |file| 
+        file.write(asset.content) if asset.respond_to?(:content)
+      end
+    end
+
+    def remove_directory(directory = nil)
+      directory ||= @scratch_directory
+      Dir.rmdir(directory) if File.exists?(directory) && File.directory?(directory)
+    end
+
+    # Remove assets (created by Passifier::Storage#store)
+    def remove_temp_files
+      @assets.map do |asset|
+        path = path(asset.filename)
+        File.delete(path) if File.exists?(path)
+      end
+    end
+
+    def ensure_directory_exists(directory = nil)
+      directory ||= @scratch_directory
+      last_directory = ""
+      tree = directory.split("/")
+      tree.each do |directory|
+        dir = "#{last_directory}#{directory}"
+        Dir.mkdir(dir) unless File.exists?(dir) || dir == ""
+        last_directory = "#{dir}/"
+      end
+      last_directory
+    end
+
+  end
+
+end
+

data/lib/passifier/url_source.rb

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+
+module Passifier
+
+  # Asset derived from a url
+  # Used to pull in the background images
+  class UrlSource
+
+    attr_reader :content, :name, :url
+    alias_method :filename, :name
+
+    # @param [String, Symbol] name The name of the asset
+    # @param [String] url The url to request the asset content from
+    def initialize(name, url)
+      @name = name
+      @url = url
+      populate_content
+    end
+
+    private
+
+    def populate_content
+      uri = URI(@url)
+      res = Net::HTTP.get_response(uri)
+      @content = res.body   
+    end
+
+  end
+
+end

data/test/helper.rb

@@ -0,0 +1,159 @@
+require 'rubygems'
+require 'bundler'
+require 'test/unit'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'passifier'
+
+class Test::Unit::TestCase
+end
+
+# So that as few tests as possible will require valid keys and certificates
+# only the Signing test uses the real goods
+class MockSigning
+
+  def sha(content)
+    "sha rite"
+  end
+
+  def sign(content)
+    "****"
+  end
+
+end
+
+module Helper
+
+  extend self
+  include Passifier
+
+  def serial
+    "ARE YOU SERIAL"
+  end
+
+  def spec_hash
+    {
+      "formatVersion" => 1,
+      "passTypeIdentifier" => "pass.example.example",
+      "teamIdentifier" => "ATEAMID",
+      "relevantDate" => "event time***",          
+      "organizationName" => "Example Inc.",
+      "serialNumber" => serial,
+      "description" => "this is a pass",
+      "generic" => {
+        "headerFields" => [
+          {
+            "key" => "date",
+            "label" => "event time***",
+            "value" => "event date***"
+          }
+        ],
+        "primaryFields" => [
+          {
+            "key" => "title",
+            "label" => "",
+            "value" => "This is the pass title!"
+          }
+        ],
+        "secondaryFields" => [
+          {
+            "key" => "host",
+            "label" => "Host",
+            "value" => "paperlesspost.com",
+            "textAlignment" => "PKTextAlignmentRight"
+          }
+        ]
+      }
+    }
+  end
+
+  def zip_path
+    "test/zip.zip"
+  end
+
+  def scratch_directory
+    "test/scratch_directory"
+  end
+
+  def create_archive_through_pass
+    Pass.create_archive(zip_path, serial, spec_hash, new_images, MockSigning.new, :scratch_directory => scratch_directory) 
+  end
+
+  def new_archive
+    Archive.new(zip_path, serial, new_image_files) 
+  end
+
+  def new_pass
+    Pass.new(serial, spec_hash, new_images, MockSigning.new)
+  end
+
+  def new_spec
+    Spec.new(serial, spec_hash)
+  end
+
+  def new_storage
+    Storage.new(scratch_directory, new_image_files)
+  end
+  
+  def new_manifest
+    Manifest.new(new_image_files, MockSigning.new)
+  end
+
+  def new_manifest_signature
+    ManifestSignature.new(new_manifest, MockSigning.new)
+  end
+
+  def new_images     
+    {
+      "background.png" => "test/assets/background.png",
+      "background@2x.png" => "test/assets/background@2x.png",
+      "icon.png" => "test/assets/icon.png",
+      "icon@2x.png" => "test/assets/icon@2x.png",
+      "logo.png" => "http://blog.paperlesspost.com/wp-content/uploads/2012/04/PP_2012-Logo_Registered-2.jpg",
+      "logo@2x.png" => "http://blog.paperlesspost.com/wp-content/uploads/2012/04/PP_2012-Logo_Registered-2.jpg",
+      "thumbnail.png" => "test/assets/thumbnail.png",
+      "thumbnail@2x.png"=> "test/assets/thumbnail@2x.png"
+    }
+  end
+
+  def new_image_files
+    [
+      StaticFile.new("background.png", "test/assets/background.png"),
+      StaticFile.new("background@2x.png", "test/assets/background@2x.png"),
+      StaticFile.new("icon.png", "test/assets/icon.png"),
+      StaticFile.new("icon@2x.png", "test/assets/icon@2x.png"),
+      UrlSource.new("logo.png", "http://blog.paperlesspost.com/wp-content/uploads/2012/04/PP_2012-Logo_Registered-2.jpg"),
+      UrlSource.new("logo@2x.png", "http://blog.paperlesspost.com/wp-content/uploads/2012/04/PP_2012-Logo_Registered-2.jpg"),
+      StaticFile.new("thumbnail.png", "test/assets/thumbnail.png"),
+      StaticFile.new("thumbnail@2x.png", "test/assets/thumbnail@2x.png")
+    ]
+  end
+
+  def new_url_source
+    Passifier::UrlSource.new("background.png", image_url)
+  end
+
+  def new_static_file
+    Passifier::StaticFile.new("background.png", "test/assets/background.png")
+  end
+
+  def image_url
+    "http://blog.paperlesspost.com/wp-content/uploads/2012/04/PP_2012-Logo_Registered-2.jpg"
+  end
+
+  def signing_pass_phrase
+    File.read(TestSigning::PASS_PHRASE_FILE).strip.lstrip
+  end
+
+  def signing_assets_exist?
+    if File.exist?(TestSigning::CERTIFICATE) && File.exist?(TestSigning::KEY) && File.exist?(TestSigning::PASS_PHRASE_FILE)
+      true
+    else
+      warn "** Warning: Skipping Signing tests because .pem files are missing.  See test/passifier/test_signing.rb for more info. "
+      false
+    end
+  end
+
+end
+