strobe 0.0.2.1 → 0.1.0.beta.1

data/bin/strobe

@@ -1,4 +1,4 @@
 #!/usr/bin/env ruby
 require 'strobe'
 
-Strobe::CLI.start
+Strobe::CLI::Main.start(ARGV)

data/lib/strobe/association.rb

@@ -43,7 +43,7 @@ module Strobe
 
         ruby << " return @__#{name} if @__#{name}"
         ruby << " return nil unless self[:#{name}_id]"
-        ruby << " @__#{name} = #{target_name}.get( self[:#{name}_id] )"
+        ruby << " @__#{name} = #{target_name}.get!( self[:#{name}_id] )"
 
       end
 
@@ -80,6 +80,7 @@ module Strobe
       end
 
       ruby <<   "end"
+
       ruby.join("\n")
     end
   end

data/lib/strobe/cli/main.rb

@@ -0,0 +1,167 @@
+module Strobe
+  class CLI::Main < CLI
+
+    action "users", 'manage users' do |*args|
+      argv = $ARGV[1..-1]
+      argv = [ 'list' ] + argv if args.empty?
+      CLI::Users.start(argv)
+    end
+
+    action "signup", "signup for a new Strobe account" do
+      resource Signup.new :account => { :name => 'default' }
+
+      if settings[:token]
+        say "This computer is already registered with a Strobe account."
+        unless agree "Signup anyway? [Yn] "
+          say "exiting..."
+          exit
+        end
+      end
+
+      until_success do
+        say "Please fill out the following information."
+
+        ask :invitation
+        ask :email, :into => "user.email"
+
+        group :validate => "user.password" do
+          password :password,              :into => "user.password"
+          password :password_confirmation, :into => "password_confirmation"
+        end
+
+        save do
+          settings[:token] = resource['user.authentication_token']
+          settings.authenticate!
+          say "Your account was created successfully."
+        end
+      end
+    end
+
+    action "login", "register this computer with an existing Strobe account" do
+      resource Me.new
+
+      until_success do
+        say "Please enter your Strobe username and password."
+
+        ask      :email,    :into => "user.email"
+        password :password, :into => "user.password"
+
+        save do
+          settings[:token] = resource['user.authentication_token']
+          settings.authenticate!
+          say "The computer has been registered with the account."
+        end
+      end
+    end
+
+    application_path_option
+    method_option :staging, :type => :boolean, :banner => "deploy to a staging environment"
+    action "deploy", "deploy your application to Strobe" do
+      ensure_computer_is_registered
+
+      if application_id = config[:application_id]
+        resource Application.get! application_id, :lazy => true
+      else
+        resource Account.first.applications.new
+      end
+
+      resource[:path] = determine_application_root
+
+      unless resource.persisted?
+        say "Please fill out the following information."
+
+        ask :name
+
+        save do
+          config[:application_id] ||= resource[:id]
+        end
+      end
+
+      host = resource.deploy! :environment => options[:staging] && 'staging'
+      say "The application has successfully been deployed and is available at #{host}"
+    end
+
+    action "applications", "list all of your applications" do
+      empty = "You do not have any applications. Try deploying one with `strobe deploy`."
+      table Resources::Application.all, :empty => empty do |t|
+        t.column :id
+        t.column :name
+        t.column :url
+      end
+    end
+
+    method_option "url",  :type => :string
+    application_path_option
+    action "set", "update the settings for the application" do
+      resource get_application
+      resource['url'] = options['url']
+
+      save do
+        say "The application is now running at #{resource[:url]}"
+      end
+    end
+
+    application_path_option
+    action "delete", "delete a specific application" do
+      resource get_application
+
+      say "Deleting application '#{resource[:name]}'"
+
+      unless agree "Are you sure? [Yn] "
+        say "Aborting..."
+        exit
+      end
+
+      delete do
+        config.delete
+        say "The application has been deleted"
+      end
+    end
+
+    application_path_option
+    method_option "id", :type => :numeric, :banner => "The ID of the remote application"
+    action "register", "registers a local application with an existing Strobe application" do
+      if config[:application_id] && app = Application.get(config[:application_id])
+        say "The directory is already registered with the application `#{app[:name]}`"
+        unless agree "Continue? [Yn] "
+          say "Aborting..."
+        end
+        config.delete
+      end
+
+      application = Application.get! options[:id]
+      config[:application_id] = application[:id]
+      say "You can now deploy to #{application[:name]} (http://#{application[:url]})"
+    end
+
+  private
+
+    def determine_application_root
+      if File.exist?("#{path}/tmp/build")
+        return "#{path}/tmp/build"
+      end
+
+      path
+    end
+
+    def ensure_computer_is_registered
+      unless settings[:token]
+        say "This computer is not yet registered with a Strobe account."
+
+        choose do |m|
+          m.choice(:login)  { invoke :login  }
+          m.choice(:signup) { invoke :signup }
+        end
+      end
+    end
+
+    def get_application(opts = {})
+      unless id = config[:application_id]
+        error "No application found. Are you currently in the correct directory?"
+        exit 1
+      end
+
+      Application.get!(id, opts)
+    end
+  end
+end

data/lib/strobe/cli/settings.rb

@@ -12,11 +12,15 @@ module Strobe
       Pathname.new(root).join(".strobe/#{file}")
     end
 
+    def self.application(root)
+      new application_config_file(root)
+    end
+
     def initialize(filename = self.class.global_config_file)
       @filename = filename
 
       if @filename.exist?
-        @hash = YAML.load(@filename)
+        @hash = YAML.load(@filename) || {}
       else
         @hash = {}
       end
@@ -55,6 +59,10 @@ module Strobe
       end
     end
 
+    def delete
+      FileUtils.rm_f(@filename)
+    end
+
   private
 
     def key(key)

data/lib/strobe/cli/table.rb

@@ -0,0 +1,51 @@
+module Strobe
+  class CLI::Table
+    def initialize(collection, opts = {})
+      @collection = collection
+      @columns    = []
+      @computed   = []
+      @opts       = opts
+    end
+
+    def column(key)
+      @columns << { :key => key, :max => 0 }
+    end
+
+    def to_s
+      @collection.each do |obj|
+        @computed << @columns.map do |col|
+          cell      = obj[ col[:key] ].to_s
+          col[:max] = [ cell.length, col[:max] ].max
+          cell
+        end
+      end
+
+      if @computed.empty?
+        return @opts[:empty] || "Nothing to see here..."
+      end
+
+      str = ""
+
+      @columns.each do |col|
+        str << cell_to_s(col, col[:key].to_s.upcase)
+      end
+
+      str << "\n"
+
+      @computed.each do |cells|
+        cells.each_with_index do |cell, i|
+          str << cell_to_s(@columns[i], cell)
+        end
+        str << "\n"
+      end
+      str
+    end
+
+  private
+
+    def cell_to_s(col, cell)
+      width = [ col[:max], 25 ].max + 5
+      cell.ljust(width)
+    end
+  end
+end

data/lib/strobe/cli/users.rb

@@ -0,0 +1,65 @@
+module Strobe
+  class CLI::Users < CLI
+
+    application_path_option
+    action "list", "list users that have access to this application" do
+      @team = get_current_team!
+      if @team.memberships.any?
+        say "The following users also have access to the application"
+        say
+
+        @team.memberships.each do |m|
+          email = m.user ? m.user[:email] : m[:email]
+          say "  * #{email}"
+        end
+      else
+        say "You are the only user with access to this application"
+      end
+    end
+
+    application_path_option
+    action "add", "give a user access to this application" do |email|
+      @team = get_current_team!
+      @team.memberships.create! :email => email
+
+      say "`#{email}` has been invited to the application"
+    end
+
+    application_path_option
+    action "remove", "remove a user's access from this application" do |email|
+      @team = get_current_team!
+      @team.memberships.each do |m|
+        m.destroy if (m.user ? m.user[:email] : m[:email]) == email
+      end
+
+      say "`#{email}` has been removed from the application"
+    end
+
+  private
+
+    def get_current_team!
+      if team = current_application.teams.first
+        team
+      else
+        # Create a team for the application
+        account = current_application.account
+        name    = "Developers for #{current_application[:name]}"
+        team    = Team.create! :name => name, :account => account
+
+        team.assignments.create! :application => current_application
+        team
+      end
+    end
+
+    def current_application
+      return @current_application if @current_application
+
+      unless id = config[:application_id]
+        error "No application found. Are you currently in the correct directory?"
+        exit 1
+      end
+
+      @current_application = Application.get!(config[:application_id])
+    end
+  end
+end

data/lib/strobe/cli.rb

@@ -1,65 +1,201 @@
 require 'thor'
 require 'pathname'
 require 'fileutils'
+require 'highline'
 
 module Strobe
   class CLI < Thor
-    autoload :Action,   'strobe/cli/action'
-    autoload :Settings, 'strobe/cli/settings'
+    autoload :Main,        'strobe/cli/main'
+    autoload :Settings,    'strobe/cli/settings'
+    autoload :Table,       'strobe/cli/table'
+    autoload :Users,       'strobe/cli/users'
 
-    def self.start(*)
-      super
+    include Resources
+
+    class_option "backtrace", :type => :boolean
+
+    def self.start(args)
+      $ARGV = args
+      IdentityMap.wrap do
+        super
+      end
     rescue Strobe::StrobeError => e
-      raise if $STROBE_BACKTRACE
+      raise if $ARGV.include?('--backtrace')
       abort "[ERROR] #{e.message}"
     end
 
-    class_option "backtrace", :type => :boolean, :banner => "Show a backtrace in case of an exception"
+    def self.action(name, *args, &blk)
+      @haxliases ||= []
+      @haxliases << name.to_s
+      desc name, *args
+      define_method("__hax__#{name}", &blk)
+      map name => "__hax__#{name}"
+    end
+
+    def self.__haxlias(name)
+      @haxliases ||= []
+
+      return name if Class === name
+
+      if @haxliases.include?(name.to_s)
+        "__hax__#{name}"
+      else
+        name
+      end
+    end
+
+    def self.application_path_option
+      method_option :path, :type => :string, :banner => "Path to your application"
+    end
 
     def initialize(*)
       super
 
-      $STROBE_BACKTRACE = true if options[:backtrace]
-      _settings.connect!
+      @resource = nil
+      @highline = HighLine.new
+
+      # State
+      @in_group = false
+      @success  = false
+
+      settings.connect!
     end
 
-    # Load the CLI actions
-    require "strobe/cli/actions"
+  private
 
-    desc "signup", "signup for a new Strobe account"
-    def signup
-      _run :signup
+    def path
+      options[:path] || Dir.pwd
     end
 
-    desc "login", "register this computer with an existing Strobe account"
-    def login
-      _run :login
+    def config
+      @config ||= Settings.application(path)
     end
 
-    desc "deploy", "deploy your application to Strobe"
-    method_option "path", :type => :string, :banner => "The path to the application"
-    def deploy
-      path   = options[:path] || Dir.pwd
-      file   = ENV['STROBE_CONFIG'] || 'config'
-      config = Settings.new(Pathname.new(path).join(".strobe/#{file}"))
+    def invoke(action, *args)
+      action = self.class.__haxlias(action)
+      super
+    end
 
-      _run :deploy, :config => config, :path => path
+    def resource(resource = nil)
+      @resource = resource if resource
+      @resource
     end
 
-  private
+    def settings
+      @settings ||= Settings.new
+    end
 
-    def _init_application
-      path = options[:path]
-      dir  = Pathname.new(path).join(".strobe")
-      FileUtils.mkdir_p dir
+    def until_success(&blk)
+      until @success
+        retval = blk.call
+      end
+      @success = false
+      retval
     end
 
-    def _run(name, opts = {})
-      Action.run name, _settings, opts
+    def save(opts = {})
+      if resource.save
+        @success = true
+        yield
+      else
+        display_errors
+      end
     end
 
-    def _settings
-      @settings ||= Settings.new
+    def delete(opts = {})
+      if resource.destroy
+        @success = true
+        yield
+      else
+        display_errors
+      end
+    end
+
+    def say(what = nil)
+      puts what
+    end
+
+    def error(what)
+      STDERR.puts "[ERROR] #{what}"
+    end
+
+    def agree(msg, *args)
+      @highline.agree(msg, *args) do |q|
+        next unless STDIN.tty? # For testing
+        q.readline = true
+      end
+    end
+
+    def ask(key, options = {})
+      input key, options do |msg|
+        resp = @highline.ask msg do |q|
+          next unless STDIN.tty? # For testing
+          q.readline = true
+        end
+      end
+    end
+
+    def password(key, options = {})
+      input key, options do |msg|
+        @highline.ask msg do |q|
+          next unless STDIN.tty? # For testing
+          q.echo = '*'
+        end
+      end
+    end
+
+    def choose
+      @highline.choose do |menu|
+        yield menu
+      end
+    end
+
+    def group(options = {}, &blk)
+      case
+      when key = options[:validate]
+        validation_group(key, &blk)
+      else
+        yield if block_given?
+      end
+    end
+
+    def input(key, options)
+      into = options[:into] || key
+
+      validation_group into do
+        msg = (key.to_s.humanize + ': ').ljust(25)
+        resource[into] = yield msg
+      end
+    end
+
+    def validation_group(resource_key)
+      return yield if @in_group
+
+      begin
+        @in_group = true
+        while true
+          yield
+
+          break if resource.valid_attribute?(resource_key)
+
+          display_errors
+        end
+      ensure
+        @in_group = false
+      end
+    end
+
+    def display_errors
+      resource.errors.each do |k, msg|
+        key = k.to_s.split('.').last
+        say "[ERROR] #{key.humanize} #{msg}"
+      end
+    end
+
+    def table(collection, opts = {})
+      table = Table.new(collection, opts)
+      yield table
+      puts table.to_s
     end
   end
 end

data/lib/strobe/collection.rb

@@ -11,6 +11,7 @@ module Strobe
     def to_a
       @to_a ||= begin
         resp = Strobe.connection.get klass.resource_uri, params
+        resp.validate!
 
         if resp.status == 200
           resp.body[klass.resource_name].map do |hash|
@@ -42,6 +43,14 @@ module Strobe
       klass.new(@params.merge(params))
     end
 
+    def create(params = {})
+      klass.create(@params.merge(params))
+    end
+
+    def create!(params = {})
+      klass.create!(@params.merge(params))
+    end
+
     def ==(other)
       if Array === other
         to_a === other
@@ -49,5 +58,9 @@ module Strobe
         super
       end
     end
+
+    def reload!
+      @to_a = nil
+    end
   end
 end

data/lib/strobe/connection.rb

@@ -71,12 +71,15 @@ module Strobe
       end
 
       def validate!
+        msg = body['errors'] && body['errors']['request']
         case status
         when 401
           # TODO Fix this on the server
-          raise UnauthenticatedError, body['errors']
+          raise UnauthenticatedError, msg
         when 404
-          raise ResourceNotFoundError, body['errors']
+          raise ResourceNotFoundError, msg
+        when 500...600
+          raise ServerError, "The server puked :(. Don't worry, the error has been reported."
         end
 
         self
@@ -119,7 +122,7 @@ module Strobe
       request = Net::HTTPGenericRequest.new(
         method.to_s.upcase, !!body, true, path, headers)
 
-      Response.new(http.request(request, body)).validate!
+      Response.new(http.request(request, body))
     end
 
   private

data/lib/strobe/identity_map.rb

@@ -0,0 +1,48 @@
+module Strobe
+  class IdentityMap
+    def self.wrap
+      Thread.current[:__strobe_im] = new
+      yield
+    ensure
+      Thread.current[:__strobe_im] = nil
+    end
+
+    def self.identify(klass, key)
+      return yield unless current && key
+
+      inst = current[klass, key]
+
+      return inst if inst
+
+      current[klass, key] = yield if block_given?
+    end
+
+    def self.forget(klass, key)
+      current && key && current[klass, key] = nil
+    end
+
+    def self.reset!
+      current && current.reset!
+    end
+
+    def self.current
+      Thread.current[:__strobe_im]
+    end
+
+    def initialize
+      reset!
+    end
+
+    def [](klass, key)
+      @map[klass.to_s][klass.key.typecast(key)]
+    end
+
+    def []=(klass, key, val)
+      @map[klass.to_s][klass.key.typecast(key)] = val
+    end
+
+    def reset!
+      @map = Hash.new { |h,k| h[k] = {} }
+    end
+  end
+end

data/lib/strobe/key.rb

@@ -0,0 +1,21 @@
+module Strobe
+  class Key
+    attr_reader :property, :type
+
+    def initialize(property, type)
+      @property = property.to_s
+      @type     = type
+    end
+
+    def key_for(obj)
+      typecast(obj[property])
+    end
+
+    def typecast(val)
+      return if val.nil?
+      return val.to_s if type == String
+      return val.to_i if type == Integer
+      raise "Unknown key type `#{type}`"
+    end
+  end
+end

data/lib/strobe/resource/base.rb

@@ -1,4 +1,7 @@
 module Strobe
+  class RequestError    < RuntimeError ; end
+  class ValidationError < RuntimeError ; end
+
   module Resource
     class AssociationValidator < ActiveModel::EachValidator
       def validate_each(record, attr, val)
@@ -71,6 +74,7 @@ module Strobe
 
       def initialize(params = {})
         @response   = nil
+        @params     = with_indifferent_access({})
         self.params = params || {}
       end
 
@@ -93,13 +97,8 @@ module Strobe
       end
 
       def params=(val)
-        params = with_indifferent_access(val)
-
-        extract_on_associations(params).each do |k, v|
-          send("#{k}=", v)
-        end
-
-        @params = params
+        @params = with_indifferent_access({})
+        merge!(val)
         val
       end
 
@@ -131,10 +130,13 @@ module Strobe
         params = with_indifferent_access(params || {})
 
         extract_on_associations(params).each do |k, v|
-          unless inst = send(k)
-            inst = send("#{k}=", {})
+          if Base === v
+            send("#{k}=", v)
+          elsif inst = send(k)
+              inst.merge!(v)
+          else
+            send("#{k}=", v)
           end
-          inst.merge! v
         end
 
         @params.deep_merge! params
@@ -150,8 +152,15 @@ module Strobe
         end
       end
 
+      def save!
+        save or raise ValidationError, "could not validate: #{errors.full_messages}"
+      end
+
       def destroy
-        raise NotImplemented
+        if request { delete }
+          IdentityMap.forget(self.class, key)
+          true
+        end
       end
 
     private
@@ -174,11 +183,24 @@ module Strobe
         @response = yield
         root      = self.class.singular_resource_name
 
+        @response.validate!
+
         if @response.success?
           merge! @response.body[root]
+
+          # register with the IM
+          IdentityMap.identify(self.class, self[:id]) do
+            self
+          end
+
           return true
         elsif @response.status == 422
           errors = @response.body['errors']
+
+          if msg = errors['request']
+            raise RequestError, msg
+          end
+
           errors = errors[root] if errors
           handle_errors(errors) if errors
         else
@@ -201,6 +223,10 @@ module Strobe
         connection.put http_uri, request_params, {}
       end
 
+      def delete
+        connection.delete http_uri
+      end
+
       def handle_errors(errors, key = nil)
         errors.each do |k, v|
           key = key ? "#{key}.#{k}" : k

data/lib/strobe/resource/collection.rb

@@ -7,6 +7,14 @@ module Strobe
       module ClassMethods
         include Enumerable
 
+        def key(property = nil, type = Integer)
+          @key ||= Key.new(:id, Integer)
+
+          return @key unless property
+
+          @key = Key.new(property, type)
+        end
+
         def each
           collection.each { |r| yield r }
         end
@@ -29,21 +37,63 @@ module Strobe
 
         alias all collection
 
-        def get(id, opts = {})
-          inst = new :id => id
-          inst.reload unless opts[:lazy]
+        def new(params = {})
+          inst = IdentityMap.identify(self, key.key_for(params)) do
+            super({})
+          end
+          inst.merge!(params)
           inst
         end
+
+        def create(params = {})
+          new(params).tap { |inst| inst.save }
+        end
+
+        def create!(params = {})
+          new(params).tap { |inst| inst.save! }
+        end
+
+        def get(id, opts = {})
+          return nil unless id
+
+          IdentityMap.identify self, id do
+            inst = new :id => id
+            break inst if opts[:lazy]
+            inst.reload(opts) && inst
+          end
+        end
+
+        def get!(id, opts = {})
+          raise ResourceNotFoundError, "can not find resource will nil key" unless id
+
+          IdentityMap.identify self, id do
+            inst = new :id => id
+            inst.reload!
+            inst
+          end
+        end
       end
 
       def id
-        self[:id]
+        raise NotImplementedError
       end
 
-      def reload
-        resp = Strobe.connection.get "#{self.class.resource_uri}/#{id}"
-        self.params = resp.body[self.class.singular_resource_name]
-        self
+      def key
+        self.class.key.key_for(self)
+      end
+
+      def reload!(opts = {})
+        reload(opts.merge(:validate => true))
+      end
+
+      def reload(opts = {})
+        resp = Strobe.connection.get "#{self.class.resource_uri}/#{key}"
+        resp.validate! if opts[:validate]
+
+        if resp.success?
+          self.params = resp.body[self.class.singular_resource_name]
+          self
+        end
       end
     end
   end

data/lib/strobe/resources/account.rb

@@ -3,8 +3,9 @@ module Strobe
     class Account
       include Resource::Collection
 
-      has n, :users
       has n, :applications
+      has n, :users
+      has n, :teams
 
       validates "name", :presence => true
     end

data/lib/strobe/resources/application.rb

@@ -12,17 +12,21 @@ module Strobe
 
       filter :path
 
-      validates "account", "name", "url", :presence => true
+      validates "account", "name", :presence => true
 
-      def deploy!(path = nil)
-        self['path'] = path if path
+      def deploy!(opts = {})
+        self['path'] = opts[:path] if opts[:path]
+        environment  = opts[:environment]
 
         validate_for_deploy or return
 
         request do
+          qs       = "?environment=#{environment}" if environment
           packfile = build_packfile
-          connection.put("#{http_uri}/deploy", packfile.to_s, packfile.headers)
+          connection.put("#{http_uri}/deploy#{qs}", packfile.to_s, packfile.headers)
         end
+
+        [ environment, self['url'] ].compact.join('.')
       end
 
     private

data/lib/strobe/resources/assignment.rb

@@ -0,0 +1,12 @@
+module Strobe
+  module Resources
+    class Assignment
+      include Resource::Collection
+
+      has 1, :team
+      has 1, :application
+
+      validates :team, :application, :presence => true
+    end
+  end
+end

data/lib/strobe/resources/membership.rb

@@ -0,0 +1,13 @@
+module Strobe
+  module Resources
+    class Membership
+      include Resource::Collection
+
+      has 1, :team
+      has 1, :user
+
+      validates :team,  :presence => true
+      validates :email, :presence => true, :email => true
+    end
+  end
+end

data/lib/strobe/resources/team.rb

@@ -6,8 +6,10 @@ module Strobe
       has 1, :account
       has n, :users
       has n, :applications
+      has n, :assignments
+      has n, :memberships
 
-      validates :name, :presence => true
+      validates :account, :name, :presence => true
     end
   end
 end

data/lib/strobe/resources/user.rb

@@ -3,6 +3,8 @@ module Strobe
     class User
       include Resource::Collection
 
+      key :email, String
+
       has n, :accounts
 
       validates "email", :presence => true, :email => true

data/lib/strobe/validations.rb

@@ -67,11 +67,15 @@ module Strobe
     def valid_for_given_attributes?
       errors.clear
 
-      ran = []
+      ran  = []
+      keys = []
 
       _validators.each do |attr, validators|
         validators.each do |v|
           next if !key?(attr) && v.skippable?
+
+          keys |= [attr.to_s]
+
           next if ran.include?(v)
 
           v.validate(self)
@@ -79,6 +83,10 @@ module Strobe
         end
       end
 
+      errors.keys.each do |k|
+        errors.delete(k) unless keys.include?(k.to_s)
+      end
+
       errors.empty?
     end
 

data/lib/strobe.rb

@@ -12,6 +12,8 @@ module Strobe
   autoload :CLI,         'strobe/cli'
   autoload :Collection,  'strobe/collection'
   autoload :Connection,  'strobe/connection'
+  autoload :IdentityMap, 'strobe/identity_map'
+  autoload :Key,         'strobe/key'
   autoload :Validations, 'strobe/validations'
 
   module Resource
@@ -24,7 +26,9 @@ module Strobe
   module Resources
     autoload :Account,     'strobe/resources/account'
     autoload :Application, 'strobe/resources/application'
+    autoload :Assignment,  'strobe/resources/assignment'
     autoload :Me,          'strobe/resources/me'
+    autoload :Membership,  'strobe/resources/membership'
     autoload :Signup,      'strobe/resources/signup'
     autoload :Team,        'strobe/resources/team'
     autoload :User,        'strobe/resources/user'
@@ -34,6 +38,7 @@ module Strobe
   class StrobeError           < StandardError ; end
   class UnauthenticatedError  < StrobeError   ; end
   class ResourceNotFoundError < StrobeError   ; end
+  class ServerError           < StrobeError   ; end
 
   def self.connection
     @connection

metadata

@@ -1,13 +1,14 @@
 --- !ruby/object:Gem::Specification 
 name: strobe
 version: !ruby/object:Gem::Version 
-  prerelease: false
+  prerelease: true
   segments: 
   - 0
+  - 1
   - 0
-  - 2
+  - beta
   - 1
-  version: 0.0.2.1
+  version: 0.1.0.beta.1
 platform: ruby
 authors: 
 - Yehuda Katz
@@ -16,7 +17,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-12-15 00:00:00 -08:00
+date: 2011-01-02 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -106,18 +107,23 @@ extra_rdoc_files: []
 
 files: 
 - lib/strobe/association.rb
-- lib/strobe/cli/action.rb
-- lib/strobe/cli/actions.rb
+- lib/strobe/cli/main.rb
 - lib/strobe/cli/settings.rb
+- lib/strobe/cli/table.rb
+- lib/strobe/cli/users.rb
 - lib/strobe/cli.rb
 - lib/strobe/collection.rb
 - lib/strobe/connection.rb
+- lib/strobe/identity_map.rb
+- lib/strobe/key.rb
 - lib/strobe/resource/base.rb
 - lib/strobe/resource/collection.rb
 - lib/strobe/resource/singleton.rb
 - lib/strobe/resources/account.rb
 - lib/strobe/resources/application.rb
+- lib/strobe/resources/assignment.rb
 - lib/strobe/resources/me.rb
+- lib/strobe/resources/membership.rb
 - lib/strobe/resources/signup.rb
 - lib/strobe/resources/team.rb
 - lib/strobe/resources/user.rb

data/lib/strobe/cli/action.rb

@@ -1,131 +0,0 @@
-require 'highline'
-
-module Strobe
-  class CLI::Action
-    def self.run(action, settings, options = {})
-      success = false
-      klass   = action.to_s.classify + 'Action'
-      klass   = CLI::Actions.const_get(klass)
-
-      until success == true
-        action = klass.new(settings, options)
-        action.steps
-        success = !action.restart
-      end
-    end
-
-    include Resources
-
-    attr_reader :actions, :settings, :restart, :options
-
-    def initialize(settings, options)
-      @settings = settings
-      @options  = options
-      @highline = HighLine.new
-      @resource = nil
-
-      # State
-      @in_group = false
-      @restart  = false
-    end
-
-    def resource(resource = nil)
-      @resource = resource if resource
-      @resource
-    end
-
-    def say(what)
-      puts what
-    end
-
-    def agree(msg, *args)
-      @highline.agree(msg, *args) do |q|
-        next unless STDIN.tty? # For testing
-        q.readline = true
-      end
-    end
-
-    def ask(key, options = {})
-      input key, options do |msg|
-        resp = @highline.ask msg do |q|
-          next unless STDIN.tty? # For testing
-          q.readline = true
-        end
-      end
-    end
-
-    def password(key, options = {})
-      input key, options do |msg|
-        @highline.ask msg do |q|
-          next unless STDIN.tty? # For testing
-          q.echo = '*'
-        end
-      end
-    end
-
-    def choose
-      @highline.choose do |menu|
-        yield menu
-      end
-    end
-
-    def group(options = {}, &blk)
-      case
-      when key = options[:validate]
-        validation_group(key, &blk)
-      else
-        yield if block_given?
-      end
-    end
-
-    def save(opts = {})
-      if resource.save
-        yield
-      else
-        display_errors
-        if opts[:on_error] == :restart
-          @restart = true
-        end
-      end
-    end
-
-    def run(action, opts = {})
-      CLI::Action.run(action, settings, opts)
-    end
-
-  private
-
-    def input(key, options)
-      into = options[:into] || key
-
-      validation_group into do
-        msg = (key.to_s.humanize + ': ').ljust(25)
-        resource[into] = yield msg
-      end
-    end
-
-    def validation_group(resource_key)
-      return yield if @in_group
-
-      begin
-        @in_group = true
-        while true
-          yield
-
-          break if resource.valid_attribute?(resource_key)
-
-          display_errors
-        end
-      ensure
-        @in_group = false
-      end
-    end
-
-    def display_errors
-      resource.errors.each do |k, msg|
-        key = k.to_s.split('.').last
-        say "[ERROR] #{key.humanize} #{msg}"
-      end
-    end
-  end
-end

data/lib/strobe/cli/actions.rb

@@ -1,104 +0,0 @@
-module Strobe
-  module CLI::Actions
-    class SignupAction < CLI::Action
-      def steps
-        resource Signup.new :account => { :name => 'default' }
-
-        if settings[:token]
-          say "This computer is already registered with a Strobe account."
-          unless agree "Signup anyway? [Yn] "
-            say "exiting..."
-            exit
-          end
-        end
-
-        say "Please fill out the following information."
-
-        ask :invitation
-        ask :email, :into => "user.email"
-
-        group :validate => "user.password" do
-          password :password,              :into => "user.password"
-          password :password_confirmation, :into => "password_confirmation"
-        end
-
-        save :on_error => :restart do
-          settings[:token] = resource['user.authentication_token']
-          settings.authenticate!
-          say "Your account was created successfully."
-        end
-      end
-    end
-
-    class LoginAction < CLI::Action
-      def steps
-        resource Me.new
-
-        say "Please enter your Strobe username and password."
-
-        ask      :email,    :into => "user.email"
-        password :password, :into => "user.password"
-
-        save :on_error => :restart do
-          settings[:token] = resource['user.authentication_token']
-          settings.authenticate!
-          say "The computer has been registered with the account."
-        end
-      end
-    end
-
-    class DeployAction < CLI::Action
-      def steps
-        ensure_computer_is_registered
-
-        config = options[:config]
-        path   = determine_path
-
-        if application_id = config[:application_id]
-          resource Application.get application_id, :lazy => true
-        else
-          resource Account.first.applications.new
-        end
-
-        resource[:path] = path
-
-        unless resource.persisted?
-          say "Please fill out the following information."
-
-          ask :name
-          ask :url
-
-          save do
-            config[:application_id] ||= resource[:id]
-          end
-        end
-
-        resource.deploy!
-        say "The application has successfully been deployed and is available at #{resource[:url]}"
-      end
-
-    private
-
-      def determine_path
-        path = options[:path]
-
-        if File.exist?("#{path}/tmp/build")
-          return "#{path}/tmp/build"
-        end
-
-        path
-      end
-
-      def ensure_computer_is_registered
-        unless settings[:token]
-          say "This computer is not yet registered with a Strobe account."
-
-          choose do |m|
-            m.choice(:login)  { run :login  }
-            m.choice(:signup) { run :signup }
-          end
-        end
-      end
-    end
-  end
-end