bushido 0.0.1

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in bushido.gemspec
+gemspec

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/bin/bushido

@@ -0,0 +1,50 @@
+#!/usr/bin/env ruby
+require './lib/bushido'
+
+options = {}
+
+commands = [:create, :destroy, :reload]
+help_docs = {:create => "bushido create [NAME] - creates a new app"}
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: bushido <command>"
+
+  opts.on("-v", "--[no-]verbose", "Run verbosely") do |v|
+    options[:verbose] = v
+  end
+
+  opts.on("-h", "--help [command]", commands, "Help (this screen)") do |h|
+    if h.nil?
+      puts opts
+      puts "Supported commands: create, names"
+      exit
+    end
+
+    puts help_docs[h]
+    exit
+  end
+
+  opts.on_tail("-V", "--version", "Show version") do
+    puts Bushido::VERSION.join('.')
+    exit
+  end
+end.parse!
+
+command = ARGV.first
+
+if command
+  case command.downcase.to_sym
+  when :reauth  then Bushido::User.reauth
+  when :claim   then Bushido::App.claim(ARGV[1])
+  when :list    then Bushido::App.list()
+  when :create  then Bushido::App.create(ARGV[1])
+  when :show    then Bushido::App.show(ARGV[1])
+  when :start   then Bushido::App.start(ARGV[1])
+  when :stop    then Bushido::App.stop(ARGV[1])
+  when :restart then Bushido::App.restart(ARGV[1])
+  when :update  then Bushido::App.update(ARGV[1])
+  end
+else
+  puts "usage: bushido <command>\n\nSee bushido -h for more detailed instructions"
+  puts "Supported commands: create, names"
+end

data/bushido.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "bushido/version"
+
+Gem::Specification.new do |s|
+  s.name        = "bushido"
+  s.version     = Bushido::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Sean Grove"]
+  s.email       = ["s@bushi.do"]
+  s.homepage    = ""
+  s.summary     = %q{Command-lin interface for bushi.do}
+  s.description = %q{A command line tool to do everything with bushido, from signing up and deploying apps, to claiming, restarting, and updating existing apps}
+
+  s.rubyforge_project = "bushido"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/lib/bushido/app.rb

@@ -0,0 +1,84 @@
+module Bushido
+  class App
+    class << self
+      def create(url)
+        puts "Creating account for #{Bushido::User.email}..."
+
+        post({:app => {:url => url}})
+      end
+
+      def list
+        response = Bushido::Command.get_command("#{Temple}/apps")
+
+        response.each do |app|
+          puts app["app"]['subdomain']
+        end
+      end
+
+      def get(name, params={})
+        url = "#{Temple}/apps/#{name}"
+        Bushido::Command.get_command(url, params)
+      end
+
+      def put(app, command)
+        url = "#{Temple}/apps/#{app}.json"
+        params = {:command => command}
+
+        show_response Bushido::Command.put_command(url, params)
+      end
+
+      def post(params)
+        url = "#{Temple}/apps"
+        show_response Bushido::Command.post_command(url, params)
+      end
+
+      def show_response(response)
+        show_messages response
+        show_errors   response
+      end
+
+      def show_messages(response)
+        if response["messages"]
+          puts "Messages:"
+          response["messages"].each_with_index do |error, counter|
+            puts "\t#{counter + 1}. #{error}"
+          end
+        end
+      end
+
+      def show_errors(response)
+        if response["errors"]
+          puts "Errors:"
+          response["errors"].each_with_index do |error, counter|
+            puts "\t#{counter + 1}. #{error}"
+          end
+        end
+      end
+
+      def show(name)
+        result = get name
+        puts result.inspect
+      end
+
+      def start(name)
+        put name, :start
+      end
+
+      def stop(name)
+        put name, :stop
+      end
+
+      def restart(name)
+        put name, :restart
+      end
+
+      def claim(name)
+        put name, :claim
+      end
+
+      def update(name)
+        put name, :update
+      end
+    end
+  end
+end

data/lib/bushido/command.rb

@@ -0,0 +1,28 @@
+module Bushido
+  class Command
+    class << self
+      def get_command(url, params={})
+        params.merge!({:auth_token => Bushido::User.authentication_token}) if params[:auth_token].nil? unless Bushido::User.authentication_token.nil?
+
+        raw = RestClient.get(url, {:params => params, :accept => :json})
+        response = JSON.parse raw    
+      end
+
+      def post_command(url, params)
+        params.merge!({:auth_token => Bushido::User.authentication_token}) if params[:auth_token].nil? unless Bushido::User.authentication_token.nil?
+
+        raw = RestClient.post(url, params.to_json, :content_type => :json, :accept => :json)
+        response = JSON.parse raw    
+      end
+
+      def put_command(url, params)
+        Bushido::Utils.while_authorized do
+          params.merge!({:auth_token => Bushido::User.authentication_token}) if params[:auth_token].nil? unless Bushido::User.authentication_token.nil?
+
+          raw = RestClient.put(url, params.to_json,  :content_type => :json)
+          response = JSON.parse raw
+        end
+      end
+    end
+  end
+end

data/lib/bushido/user.rb

@@ -0,0 +1,120 @@
+module Bushido
+  class User
+    class << self
+      def account
+        load_config || {}
+      end
+
+      def load_config
+        begin
+          return JSON.parse(File.open(File.expand_path("~/.bushido/config.json"), 'r') { |l| l.read })
+        rescue Errno::ENOENT
+        end
+      end
+
+      def load_account
+        begin
+          @account = JSON.parse(File.open(File.expand_path("~/.bushido/config.json"), 'r') { |l| l.read })
+        rescue Errno::ENOENT
+          @account = retrieve_account
+        end
+      end
+
+      def reauth
+        retrieve_account
+      end
+
+      def update_account(account)
+        print "Storing account information..."
+        File.open(File.expand_path("~/.bushido/config.json"), 'w') { |f| f.write(account.to_json) }
+        puts " Done!"
+      end
+
+      def retrieve_account
+        credentials = self.prompt_for_credentials
+
+        raw = RestClient.get "#{Bushido::Temple}/users/verify.json", {:params => {:email => credentials[:email], :password => credentials[:password]}, :accept => :json}
+
+        begin
+          result = JSON.parse(raw)
+        rescue
+          puts "Our servers didn't respond properly while trying to retrieve the account, this seems to be an issue on our end. Please email us at support@bushi.do to clear this up."
+          exit 1
+        end
+
+        if result["authentication_token"] and result["error"].nil?
+          update_account({:email => credentials[:email], :authentication_token => result["authentication_token"]})
+          return {:email => credentials[:email], :authentication_token => result["authentication_token"]}
+        else
+          puts result["error"]
+          if result["error_type"] == "verification_failure"
+            puts ""
+            print "If this is your first time using Bushido, would you like to create an account using the email and password you just entered?\n[y/n]"
+            if $stdin.gets.chomp == "y"
+              self.create_account(credentials)
+            else
+              exit 1
+            end
+          end
+        end
+      end
+
+      def create_account(credentials)
+        # GET instead of POST because of AuthenticityToken issues. Deal with it later.
+        begin 
+          raw = RestClient.get "#{Bushido::Temple}/users/create.json", {:params => {:email => credentials[:email], :password => credentials[:password], :accept => :json}}
+        rescue RestClient::UnprocessableEntity
+          puts "We ran into an error registering, either our site is down or that name is registered."
+          exit 1
+        end
+
+        begin
+          result = JSON.parse(raw)
+          #puts result.inspect
+          #puts "----------------------------------------------------------------------"
+        rescue JSON::ParserError
+          puts "Our servers didn't respond properly while trying to create an account, this seems to be an issue on our end. Please email us at support@bushi.do to clear this up."
+          exit 1
+        end
+
+        if result["errors"]
+          puts "There were some errors registering: "
+          
+          result["errors"].each_pair { |field, error| puts "  #{field.capitalize} #{error}" }
+          exit 1
+        end
+
+        update_account result
+        return credentials
+      end
+
+      def authentication_token
+        account["authentication_token"]
+      end
+
+      def email
+        account["email"]
+      end
+
+      def prompt_for_credentials(confirm=false)
+        result = {
+          :email => self.prompt_for_email,
+          :password => self.prompt_for_password
+        }
+
+        result.merge!({:password_confirmation => self.prompt_for_password(" Confirm: ")}) if confirm
+
+        return result
+      end
+
+      def prompt_for_email
+        print " Email: "
+        email = $stdin.gets.chomp
+      end
+
+      def prompt_for_password(prompt=" Password:")
+        ask(prompt) { |q| q.echo = false }
+      end
+    end
+  end
+end

data/lib/bushido/utils.rb

@@ -0,0 +1,14 @@
+module Bushido
+  class Utils
+    class << self
+      def while_authorized(&block)
+        if Bushido::User.authentication_token.nil? or Bushido::User.email.nil?
+          puts "Please authorized before attempting that command. You can run `bushido reauth` to update your credentials."
+          exit 1
+        else
+          yield
+        end
+      end
+    end
+  end
+end

data/lib/bushido/version.rb

@@ -0,0 +1,3 @@
+module Bushido
+  VERSION = "0.0.1"
+end

data/lib/bushido.rb

@@ -0,0 +1,15 @@
+module Bushido
+  require 'rubygems'
+  require 'optparse'
+  require 'rest-client'
+  require 'json'
+  require 'highline/import'
+
+  require "./lib/bushido/user"
+  require "./lib/bushido/utils"
+  require "./lib/bushido/command"
+  require "./lib/bushido/app"
+
+
+  Temple = ENV["HOST"] || "http://nok.tea.sh/"
+end

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification 
+name: bushido
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Sean Grove
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-01-26 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: A command line tool to do everything with bushido, from signing up and deploying apps, to claiming, restarting, and updating existing apps
+email: 
+- s@bushi.do
+executables: 
+- bushido
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Gemfile
+- Rakefile
+- bin/bushido
+- bushido.gemspec
+- lib/bushido.rb
+- lib/bushido/app.rb
+- lib/bushido/command.rb
+- lib/bushido/user.rb
+- lib/bushido/utils.rb
+- lib/bushido/version.rb
+has_rdoc: true
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: bushido
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Command-lin interface for bushi.do
+test_files: []
+