glitter 1.0.0 → 2.0.0.alpha1

data/.gitignore

@@ -3,4 +3,7 @@ bin/Glitterfile
 *.gem
 .bundle
 Gemfile.lock
-pkg/*
+pkg/*
+tmp
+.env
+.rbenv-version

data/README.md

@@ -1,72 +1,88 @@
 # About Glitter
 
-Glitter is an easy way to publish Mac software updates to an Amazon S3 bucket using the Sparkle framework (http://sparkle.andymatuschak.org/). It was created at Poll Everywhere to eliminate the need maintaining additional server infrastructure for rolling out Mac desktop software updates. 
+Glitter is an easy way to publish native application software updates to an Amazon S3 bucket. It was created at Poll Everywhere to eliminate the need maintaining additional server infrastructure for rolling out native desktop software updates. Glitter works with various "Sparkle" frameworks including:
 
-It should also be noted that Glitter uses HTTPS S3 URLs to eliminate the need for the maintiance of public/private keys for Sparkle, which further simplifies the publishing process.
+* Sparkle - http://sparkle.andymatuschak.org/
+* NetSparkle - http://netsparkle.codeplex.com/
 
-# Getting started
-
-1.  Install the gem
-
-        $ gem install glitter
-
-2.  Generate a Glitterfile in your project directory
+Glitter also supports the concepts of release channels, which makes it possible to have development, nightly, staging, beta, or production releases all from the command line interface. Release channels make it easier for developers to collaborate with customers and product owners about product features.
 
-        $ glitter init .
+# Getting started
 
-3.  Edit the Glitterfile
+1.  Install the gem.
 
-        # After you configure this file, deploy your app with `glitter push`
-        name          "My App"
-        version       "1.0.0" # Don't forget, its ruby! This could read a version from a plist file
-        archive       "my_app.zip"
-        
-        s3 {
-          bucket_name       "my_app"
-          access_key        "access"
-          secret_access_key "sekret"
-          # Set this to true to use an EU style bucket which uses a subdomain
-          # subdomain_bucket  true
-        }
+    ```sh
+    $ gem install glitter
+    ```
 
-4. Publish your app to the web
+2. Publish your app to the web.
 
-        $ glitter push -m 'Added some really cool stuff to the mix!'
-        Pushing app my-app-1.0.0.zip
-        Asset pushed to https://s3.amazonaws.com/my_app/my-app-1.0.0.zip
-        Updated head https://s3.amazonaws.com/my_app/my-app-head.zip to https://s3.amazonaws.com/my_app/my-app-1.0.0.zip
-        Updated https://s3.amazonaws.com/my_app/appcast.xml
+    ```sh
+    $ AWS_ACCESS_KEY_ID=secret_access_key \
+        AWS_SECRET_ACCESS_KEY=access_key_id \
+        AWS_BUCKET_NAME=my-app-bucket \
+        glitter push my-app.dmg -v 1.2.5 -c "mac-edge" \
+        -m 'Added some really cool stuff to the mix!'
+    
+    Pushing app my-app.dmg to https://s3.amazonaws.com/mac-edge/1.2.5/my-app.dmg
+    Updated head https://s3.amazonaws.com/mac-edge/my-app.dmg to https://s3.amazonaws.com/mac-edge/1.2.5/my-app.dmg
+    ```
 
-5.  Distribute the link to your app
+3.  Distribute the link to your app.
 
-    https://s3.amazonaws.com/my_app/my-app-head.zip is the "current" version of your application and a history is maintained with https://s3.amazonaws.com/my_app/my-app-1.0.0.zip assets. You'll probably want to link to the "head" asset of your app and keep the older builds around for troubleshooting purposes.
+    https://s3.amazonaws.com/mac-edge/my-app.dmg is the "current" version of your application and a history is maintained with https://s3.amazonaws.com/mac-edge/1.2.5/my-app.dmg assets. You'll probably want to link to the "head" asset of your app and keep the older builds around for troubleshooting purposes.
     
     If you want a vanity URL to distribte your app, setup a redirect like this in nginx:
     
-        rewrite ^/my-app.zip$ https://s3.amazonaws.com/my_app/my-app-head.zip;
+        rewrite ^/my-app.zip$ https://s3.amazonaws.com/mac-edge/my-app.dmg;
     
     Now send your users to mydomain.com/my-app.zip and they'll get the latest version of your app. I don't recommend using a CNAME with your application because it won't work with Amazon's HTTPS servers and you'll have to jump through some hoops to sign your app distributions with a DSA signature. Not worth it in my opinion.
 
-That's it!
+# Contribute
+
+Want to hack on glitter? Awesome! You'll need to setup an S3 bucket and run specs with the `AWS_URL` env var specified:
+
+```sh
+$ AWS_ACCESS_KEY_ID=secret_access_key \
+    AWS_SECRET_ACCESS_KEY=access_key_id \
+    AWS_BUCKET_NAME=my-app-bucket \
+    bundle exec rspec
+```
+
+Prefer to use Foreman? Create a `.env` file in the root of the project, then paste:
+
+```sh
+AWS_ACCESS_KEY_ID=secret_access_key
+AWS_SECRET_ACCESS_KEY=access_key_id
+AWS_BUCKET_NAME=my-app-bucket
+```
+
+and run specs via:
+
+```sh
+foreman run bundle exec rspec
+```
+
+Pretty sweet eh? That's it!
 
 # License
 
-    Copyright (C) 2011 by Brad Gessler
-
-    Permission is hereby granted, free of charge, to any person obtaining a copy
-    of this software and associated documentation files (the "Software"), to deal
-    in the Software without restriction, including without limitation the rights
-    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-    copies of the Software, and to permit persons to whom the Software is
-    furnished to do so, subject to the following conditions:
-
-    The above copyright notice and this permission notice shall be included in
-    all copies or substantial portions of the Software.
-
-    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-    THE SOFTWARE.
+Copyright (C) 2011 by Brad Gessler
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/lib/glitter.rb

@@ -1,209 +1,16 @@
-require 's3'
-require 'thor'
-require 'erb'
+require 'glitter/version'
 
 module Glitter
-  # This mix-in Creates a DSL for configuring a class.
-  module Configurable
-    def self.included(base)
-      base.send :extend,  ClassMethods
-      base.send :include, InstanceMethods
-    end
-
-    module InstanceMethods
-      def configure(path=nil,&block)
-        path ? instance_eval(File.read(path), path) : instance_eval(&block)
-        self
-      end
-    end
-
-    module ClassMethods
-      def attr_configurable(*attrs)
-        attrs.each do |attr|
-          class_eval %(
-            attr_writer :#{attr}
-            attr_overloaded :#{attr})
-        end
-      end
-
-      def attr_overloaded(*attrs)
-        attrs.each do |attr|
-          class_eval(%{
-            def #{attr}(val=nil)
-              val ? instance_variable_set('@#{attr}', val) : instance_variable_get('@#{attr}')
-            end})
-        end
-      end
-
-      def configure(*args, &block)
-        new.configure(*args, &block)
-      end
-    end
+  ExistingReleaseError = Class.new(RuntimeError)
+  
+  # Relative paths for glitter. Mostly our templating engines use this.
+  def self.path(*segments)
+    File.join File.expand_path('../glitter', __FILE__), *segments
   end
 
-  # The App class that a release uses to deploy
-  class App
-    TemplatePath = File.expand_path('../glitter/templates/Glitterfile', __FILE__).to_s.freeze
-    RssTemplate = File.expand_path('../glitter/templates/rss.xml.erb', __FILE__).to_s.freeze
-    AppcastXml = 'appcast.xml'
-
-    include Configurable
-    attr_configurable :name, :version, :short_version_string, :release_notes_link, :notes, :archive, :s3
-
-    class S3
-      include Configurable
-      attr_configurable :bucket_name, :access_key, :secret_access_key, :subdomain_bucket
-
-      def url_for(path)
-        if subdomain_bucket
-          "https://#{bucket_name}.s3.amazonaws.com/#{path}"
-        else
-          "https://s3.amazonaws.com/#{bucket_name}/#{path}"
-        end
-      end
-
-      def service
-        @service ||= ::S3::Service.new(:access_key_id => access_key, :secret_access_key => secret_access_key, :use_ssl => true)
-      end
-
-      def bucket
-        service.buckets.find(bucket_name)
-      end
-    end
-
-    def s3(&block)
-      @s3 ||= S3.configure(&block)
-    end
-
-    class Appcast
-      ObjectName = 'appcast.xml'
-      
-      attr_reader :app
-
-      def initialize(app)
-        @app = app
-      end
-
-      def url
-        app.s3.url_for ObjectName
-      end
-
-      def push
-        object.content = rss
-        object.save
-      end
-
-      def rss
-        @rss ||= ERB.new(File.read(RssTemplate)).result(binding)
-      end
-
-    private
-      def object
-        @object ||= app.s3.bucket.objects.build(ObjectName)
-      end
-    end
-
-    def appcast
-      @appcast ||= Appcast.new(self)
-    end
-
-    def latest
-      assets[version]
-    end
-
-    def assets
-      @assets ||= Hash.new do |hash,key|
-        hash[key] = Asset.new do |r|
-          r.version = key
-          r.short_version_string = short_version_string
-          r.release_notes_link = release_notes_link
-          r.notes = notes
-          r.app = self
-        end
-      end
-    end
-  end
-
-  class Asset
-    attr_accessor :app, :version, :short_version_string, :release_notes_link, :notes, :published_at, :object
-
-    def initialize
-      @published_at = Time.now
-      yield self if block_given?
-    end
-
-    def name
-      "#{app.name} #{version}"
-    end
-
-    def object_name
-      "#{name.gsub(/\s/,'-').downcase}#{File.extname(file.path)}"
-    end
-
-    def object
-      @object ||= app.s3.bucket.objects.build(object_name)
-    end
-
-    def url
-      app.s3.url_for object_name
-    end
-
-    def push
-      object.content = file
-      object.save
-      self
-    end
-
-    # Sets this asset as the head on the S3 bucket
-    def head
-      @head ||= self.class.new do |a|
-        a.app = app
-        a.version = "head"
-        a.short_version_string = short_version_string
-        a.release_notes_link = release_notes_link
-        a.notes = app.notes
-        a.published_at = published_at
-        a.object = object.copy(:key => a.object_name)
-      end
-    end
-
-    def file
-      File.new(app.archive)
-    end
-  end
-
-  # Command line interface for cutting glitter builds
-  class CLI < Thor
-    desc "init PATH", "Generate a Glitterfile for the path"
-    def init(path)
-      glitterfile_path = File.join(path, 'Glitterfile')
-      puts "Writing new Glitterfile to #{File.expand_path glitterfile_path}"
-
-      File.open glitterfile_path, 'w+' do |file|
-        file.write File.read(App::TemplatePath)
-      end
-    end
-
-    desc "push", "pushes a build to S3 with release notes."
-    method_option :release_notes, :type => :string, :aliases => "-m"
-    def push
-      puts "Pushing app #{app.latest.object_name}"
-      # Push the latest release with release notes
-      puts "Notes are the following"
-      puts app.notes
-      #app.latest.notes = options[:release_notes] if options[:release_notes]
-      app.latest.push
-      puts "Asset pushed to #{app.latest.url}"
-      app.latest.head # Sets this release as the head.
-      puts "Updated head #{app.latest.head.url} to #{app.latest.url}"
-      # Update the appcast file
-      app.appcast.push
-      puts "Updated #{app.appcast.url}"
-    end
-
-  private
-    def app
-      @config ||= App.configure('./Glitterfile')
-    end
-  end
+  autoload :Configurable, Glitter.path('configurable')
+  autoload :Channel,      Glitter.path('channel')
+  autoload :Release,      Glitter.path('release')
+  autoload :Server,       Glitter.path('server')
+  autoload :CLI,          Glitter.path('cli')
 end

data/lib/glitter/channel.rb

@@ -0,0 +1,19 @@
+module Glitter
+  # A Channel is where multiple releases are pushed and incremented monotonically. 
+  # Sparkle enabled native applications should be pointed at the head of a channel.
+  class Channel
+    attr_reader :name, :server
+
+    def initialize(name, server)
+      @name, @server = name, server
+    end
+
+    def release(&block)
+      Release.new(self, &block)
+    end
+
+    def versions
+      server.channel_versions[name]
+    end
+  end
+end

data/lib/glitter/cli.rb

@@ -0,0 +1,26 @@
+require 'thor'
+
+module Glitter
+  # Command line interface for cutting glitter builds
+  class CLI < Thor
+    desc "push", "pushes a build to a channel with release notes."
+    method_option :notes, :type => :string, :aliases => "-n"
+    method_option :version, :type => :string, :aliases => "-v"
+    method_option :channel, :type => :string, :aliases => "-c"
+
+    def push(executable_path)
+      server = Server.new.channel(options.channel)
+      release = Release::Sparkle.new(server, options.version)
+      release.notes = options.notes
+      release.executable = File.open executable_path
+      release.push.head
+    end
+
+    # desc "yank", "remove a build from a release channel"
+    # method_option :version, :type => :string, :aliases => "-v"
+    # method_option :channel, :type => :string, :aliases => "-c"
+    # def yank
+    # end
+
+  end
+end

data/lib/glitter/configurable.rb

@@ -0,0 +1,46 @@
+module Glitter
+  # This mix-in Creates a DSL for configuring a class so that we don't have to litter
+  # our application with `self.attr = "val"` all over the place or from config files.
+  module Configurable
+    def self.included(base)
+      base.send :extend,  ClassMethods
+      base.send :include, InstanceMethods
+    end
+
+    module InstanceMethods
+      def configure(path=nil,&block)
+        if path
+          # Read the config file up in thar.
+          instance_eval(File.read(path), path)
+        else
+          # Figure out how we want to call this thing.
+          block.arity.zero? ? instance_eval(&block) : block.call(self)
+        end
+        self
+      end
+    end
+
+    module ClassMethods
+      def attr_configurable(*attrs)
+        attrs.each do |attr|
+          class_eval %(
+            attr_writer :#{attr}
+            attr_overloaded :#{attr})
+        end
+      end
+
+      def attr_overloaded(*attrs)
+        attrs.each do |attr|
+          class_eval(%{
+            def #{attr}(val=nil)
+              val ? instance_variable_set('@#{attr}', val) : instance_variable_get('@#{attr}')
+            end})
+        end
+      end
+
+      def configure(*args, &block)
+        new.configure(*args, &block)
+      end
+    end
+  end
+end

data/lib/glitter/release.rb

@@ -0,0 +1,118 @@
+require 'erb'
+require 'logger'
+
+module Glitter
+  module Release
+    # Break apart an S3 bucket key by /:channel/:version/:object-key
+    def self.object_segments(key)
+      if match = key.match(/\/?(.+)\/(.+)\/(.+)/)
+        match.captures
+      end
+    end
+
+    class Base
+      attr_reader :channel, :version, :logger
+
+      # Initialize a release and yield the block for configuration.
+      def initialize(channel, version, logger = Logger.new($stdout), &block)
+        @channel, @version, @logger = channel, version, logger
+        block.call self if block_given?
+        self
+      end
+
+      # Push assets up to the S3 bucket path `/:channel/:version/*`.
+      def push
+        raise ExistingReleaseError.new("Existing build at version #{version}. Increment the version and push again.") if version_exists?
+        logger.info "Pushing version #{version} to #{channel.name}"
+        assets.each do |key, object|
+          logger.info " PUT #{key} to #{object.url}"
+          object.save
+        end
+        logger.info "Version #{version} to #{channel.name} pushed!"
+        self
+      end
+
+      # Promote the release as the head releae. This copies the contents of the release to `/:channel/*`.
+      def head
+        logger.info "Promoting version #{version} to HEAD"
+        assets.map do |_, object|
+          channel, _, key = Release.object_segments(object.key)
+          object = object.copy key: File.join(channel, key)
+          logger.info " Copying #{key} to #{object.url}"
+          object.save
+        end
+        logger.info "Version #{version} promoted to HEAD!"
+      end
+
+      # Registry of assets that are S3 objects. The key is `/:channel/:version/:object-key`. The hash returns an S3 object.
+      def assets
+        @assets ||= Hash.new { |h,k| h[k] = channel.server.bucket.objects.build object_key(k) } # /win-dev/1.1/appcast.xml
+      end
+
+    private
+      # Figure out if the version already exists on the remote bucket.
+      def version_exists?
+        channel.versions.include? version
+      end
+
+      # Build a key that we'll use to store these objects into S3.
+      def object_key(*segments)
+        File.join(channel.name, version, segments)
+      end
+    end
+
+    # A release consists of a binary asset, notes, a monotonically increasing version number, and 
+    # lives inside of a channel.
+    class Sparkle < Base
+      attr_accessor :notes, :executable, :filename
+      attr_writer   :published_at
+
+      # Yeah, lets publish this shiz NOW.
+      def published_at
+        @published_at ||= Time.now
+      end
+
+      # Generate assets and push 
+      def push
+        notes_asset
+        appcast_asset
+        executable_asset
+        super
+      end
+
+    private
+      # Generates an HTML file of the release notes.
+      def notes_asset
+        assets['notes.html'].tap do |a|
+          a.content = render_template 'notes.html.erb'
+          a.content_type = 'text/html'
+        end
+      end
+
+      # Generates the XML appcast file needed to publish zie document
+      def appcast_asset
+        assets['appcast.xml'].tap do |a|
+          a.content = render_template 'appcast.xml.erb'
+          a.content_type = 'application/xml'
+        end
+      end
+
+      # Package up the installer executable and add to the release.
+      def executable_asset
+        assets[executable_key].tap do |a|
+          a.content = executable
+          a.content_type = 'application/octet-stream'
+        end
+      end
+
+      def executable_key
+        File.basename(executable)
+      end
+
+      def render_template(path)
+        ERB.new(File.read(Glitter.path('templates', path))).result(self.send(:binding))
+      end
+    end
+
+  end
+end

data/lib/glitter/server.rb

@@ -0,0 +1,41 @@
+require 's3'
+require 'uri'
+
+# Glitter servers currently work with Amazon S3 buckets. They contain multiple channels which
+# contain multiple releases of software.
+module Glitter
+  class Server
+    attr_reader :access_key_id, :secret_access_key, :bucket_name
+
+    def initialize(access_key_id = ENV['AWS_ACCESS_KEY_ID'], secret_access_key = ENV['AWS_SECRET_ACCESS_KEY'], bucket_name = ENV['AWS_BUCKET_NAME'])
+      @access_key_id, @secret_access_key, @bucket_name = access_key_id, secret_access_key, bucket_name
+    end
+
+    def channel(name)
+      channels[name]
+    end
+
+    def bucket
+      @bucket ||= s3.buckets.find bucket_name
+    end
+
+    # Iterate through the objects in S3 and return a hash of channels containing their
+    # respective released versions.
+    def channel_versions
+      bucket.objects.inject Hash.new { |h,k| h[k] = Set.new } do |hash, object|
+        channel, version, _ = Release.object_segments(URI(object.url).path)
+        hash[channel].add(version) if channel and version
+        hash
+      end
+    end
+    
+  private
+    def channels
+      Hash.new { |h,k| h[k] = Channel.new(k, self) }
+    end
+
+    def s3
+      @s3 ||= ::S3::Service.new(:access_key_id => access_key_id, :secret_access_key => secret_access_key, :use_ssl => true)
+    end
+  end
+end

data/lib/glitter/templates/appcast.xml.erb

@@ -0,0 +1,21 @@
+<?xml version="1.0"?>
+<rss xmlns:sparkle="http://www.andymatuschak.org/xml-namespaces/sparkle" xmlns:dc="http://purl.org/dc/elements/1.1/" version="2.0">
+  <channel>
+    <title><%= channel.name %></title>
+    <link><%= executable_asset.url %></link>
+    <description>Software updates for <%= channel.name %></description>
+    <language>en</language>
+    <item>
+      <title>Version <%= version %></title>
+      <sparkle:releaseNotesLink><%= notes_asset.url %></sparkle:releaseNotesLink>
+      <description>
+        <![CDATA[
+          <%= notes %>
+        ]]>
+      </description>
+      <pubDate><%= published_at.strftime("%a, %d %b %Y %H:%M:%S %z") %></pubDate>
+      <enclosure url="<%= executable_asset.url %>" sparkle:version="<%= version %>" sparkle:shortVersionString="<%= version %>" length="<%= executable.size %>" type="application/octet-stream" />
+      <sparkle:releaseNotesLink><%= notes %></sparkle:releaseNotesLink>
+    </item>
+  </channel>
+</rss>

data/lib/glitter/templates/notes.html.erb

@@ -0,0 +1,24 @@
+<html lang="en-us">
+    <head>
+        <meta charset="utf-8">
+        <title><%= version %></title>
+        <style>
+          body {
+            font-family: sans-serif;
+            font-size: 11.5pt;
+            padding: 0.5em;
+          }
+          body > * {
+            margin-bottom: 0.5em;
+          }
+          h1 {
+            font-size: 1em;
+            font-weight: bold;
+          }
+        </style>
+    </head>
+    <body class="release">
+      <h1 class="version"><%= version %></h1>
+      <p class="notes"><%= notes %></p>
+    </body>
+</html>

data/lib/glitter/version.rb

@@ -1,3 +1,3 @@
 module Glitter
-  VERSION = "1.0.0"
+  VERSION = "2.0.0.alpha1"
 end

data/spec/lib/glitter_spec.rb

@@ -1,112 +1,15 @@
 require 'spec_helper'
 require 'rexml/document'
 
-describe Glitter::App do
-  before(:all) do
-    @app = Glitter::App.configure do
-      name          "My App"
-      version       "1.0.0"
-      short_version_string "1.0"
-      release_notes_link "http://www.google.com"
-      archive       "lib/glitter.rb"
-      
-      s3 {
-        bucket_name       "my_app"
-        access_key        "access"
-        secret_access_key "sekret"
-      }
-    end
-
-    # Leave this in this order to test sorting.    
-    @app.assets["3.0"].notes = "I'm the newest and greatest of them all. 3.0 I am!"
-    @app.assets["1.0"].notes = "Hi dude, 1.0"
-    @app.assets["2.0"].notes = "I'm way better than 2.0"
-  end
-
-  it "should have latest" do
-    @app.latest.version.should eql("1.0.0")
-  end
-
-  # TODO this should be speced out better using moching.
-  it "should have head" do
-    @app.latest.should respond_to(:head)
-  end
-
-  it "should generate rss" do
-    REXML::Document.new(@app.appcast.rss).root.attributes["sparkle"].should eql('http://www.andymatuschak.org/xml-namespaces/sparkle')
-  end
-
-  shared_examples_for "configuration" do
-    it "should read name" do
-      @config.name.should eql("My App")
-    end
-
-    it "should read version" do
-      @config.version.should eql("1.0.0")
-    end
-
-    it "should read short_version_string" do
-      @config.short_version_string.should eql("1.0")
-    end
-
-    it "should read release_notes_link" do
-      @config.release_notes_link.should eql("http://www.google.com")
-    end
-
-    it "should read archive" do
-      @config.archive.should eql("my_app.zip")
-    end
-
-    it "should read notes" do
-      @config.notes.should eql("notes go here")
-    end
-    
-    context "s3" do
-      it "should read bucket_name" do
-        @config.s3.bucket_name.should eql("my_app")
-      end
-
-      it "should read access_key" do
-        @config.s3.access_key.should eql("access")
-      end
-
-      it "should read secret_access_key" do
-        @config.s3.secret_access_key.should eql("sekret")
-      end
-    end
-
-    it "should have a valid Glitterfile template path" do
-      File.exists?(Glitter::App::TemplatePath).should be_true
-    end
-  end
-  
-  context "block configuration" do
-    before(:all) do
-      @config = Glitter::App.configure do
-        name          "My App"
-        version       "1.0.0"
-        short_version_string  "1.0"
-        release_notes_link  "http://www.google.com"
-        archive       "my_app.zip"
-        notes         "notes go here"
-
-        s3 {
-          bucket_name       "my_app"
-          access_key        "access"
-          secret_access_key "sekret"
-        }
-      end
-    end
-    
-    it_should_behave_like "configuration"
+describe Glitter do
+  let(:server) do
+    Glitter::Server.new
   end
 
-  context "file configuration" do
-    before(:all) do
-      @config = Glitter::App.configure File.expand_path('../../../lib/glitter/templates/Glitterfile', __FILE__)
-    end
-    
-    it_should_behave_like "configuration"
+  it "should release to channel" do
+    Glitter::Release::Sparkle.new server.channel('test-channel'), "1.1.2-#{rand}" do |r|
+      r.executable = File.open(__FILE__)
+      r.notes = %[Did you know that its #{Time.now}? Wait, you can only answer yes to that question.]
+    end.push.head
   end
-  
 end

metadata

@@ -1,19 +1,19 @@
 --- !ruby/object:Gem::Specification
 name: glitter
 version: !ruby/object:Gem::Version
-  version: 1.0.0
-  prerelease: 
+  version: 2.0.0.alpha1
+  prerelease: 6
 platform: ruby
 authors:
 - Brad Gessler, Thomas Hanley
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-08-19 00:00:00.000000000 Z
+date: 2013-04-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: s3
-  requirement: &70135839126620 !ruby/object:Gem::Requirement
+  requirement: &70321671996660 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70135839126620
+  version_requirements: *70321671996660
 - !ruby/object:Gem::Dependency
   name: haml
-  requirement: &70135839126100 !ruby/object:Gem::Requirement
+  requirement: &70321671996200 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70135839126100
+  version_requirements: *70321671996200
 - !ruby/object:Gem::Dependency
   name: thor
-  requirement: &70135839152220 !ruby/object:Gem::Requirement
+  requirement: &70321671995640 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,7 +43,7 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70135839152220
+  version_requirements: *70321671995640
 description: Glitter makes it easy to publish software updates via the Sparkle framework
   by using S3 buckets.
 email:
@@ -61,8 +61,13 @@ files:
 - bin/glitter
 - glitter.gemspec
 - lib/glitter.rb
-- lib/glitter/templates/Glitterfile
-- lib/glitter/templates/rss.xml.erb
+- lib/glitter/channel.rb
+- lib/glitter/cli.rb
+- lib/glitter/configurable.rb
+- lib/glitter/release.rb
+- lib/glitter/server.rb
+- lib/glitter/templates/appcast.xml.erb
+- lib/glitter/templates/notes.html.erb
 - lib/glitter/version.rb
 - spec/lib/glitter_spec.rb
 - spec/spec_helper.rb
@@ -81,12 +86,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
-  - - ! '>='
+  - - ! '>'
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: glitter
-rubygems_version: 1.8.11
+rubygems_version: 1.8.3
 signing_key: 
 specification_version: 3
 summary: Publish Mac software updates with the Sparkle framework and Amazon S3.

data/lib/glitter/templates/Glitterfile

@@ -1,13 +0,0 @@
-# After you configure this file, deploy your app with `glitter push`
-name          "My App"
-version       "1.0.0"
-short_version_string "1.0"
-release_notes_link "http://www.google.com"
-archive       "my_app.zip"
-notes         "notes go here"
-
-s3 {
-  bucket_name       "my_app"
-  access_key        "access"
-  secret_access_key "sekret"
-}

data/lib/glitter/templates/rss.xml.erb

@@ -1,22 +0,0 @@
-<rss xmlns:sparkle="http://www.andymatuschak.org/xml-namespaces/sparkle" xmlns:dc="http://purl.org/dc/elements/1.1/" version="2.0">
-<channel>
-<title><%= app.name %></title>
-<link><%= app.appcast.url %></link>
-<description>Software updates for <%= app.name %></description>
-<language>en</language>
-<% app.assets.each do |version, asset| %>
-<item>
-  <title>Version <%= asset.short_version_string %></title>
-  <description>
-    <![CDATA[
-      <h2>New Features</h2>
-      <p><%= app.notes %></p>
-    ]]>
-  </description>
-  <pubDate><%= asset.published_at.strftime("%a, %d %b %Y %H:%M:%S %z") %></pubDate>
-  <enclosure url="<%= asset.url %>" sparkle:version="<%= version %>" sparkle:shortVersionString="<%= asset.short_version_string %>" length="<%= asset.file.stat.size %>" type="application/octet-stream" />
-  <sparkle:releaseNotesLink><%= asset.release_notes_link %></sparkle:releaseNotesLink>
-</item>
-<% end %>
-</channel>
-</rss>