strobe 0.0.1 → 0.0.2

data/lib/strobe/account.rb

@@ -1,67 +0,0 @@
-require "excon"
-require "json"
-
-class Strobe
-  class Account
-    def self.signup_or_login
-      Strobe.ui.info          "You aren't logged in with a Strobe user on this machine"
-      Strobe.ui.info          "  1. Create a new Strobe user"
-      Strobe.ui.info          "  2. Log in with an existing Strobe user"
-      option = Strobe.ui.ask  "Please select an option: "
-
-      case option
-      when "1"
-        signup
-      when "2"
-        login
-      end
-    end
-
-    def self.signup
-      while true
-        email, pass = ask_for_login
-        passc = Strobe.ui.password "Repeat Password: "
-        break if pass == passc
-
-        Strobe.ui.info "The password and confirmation do not match. Please try again."
-      end
-
-      response = HTTP.new.signup(email, pass)
-      persist_details(*response)
-
-      Strobe.ui.info "Your account was created successfully."
-    end
-
-    def self.login
-      email, pass = ask_for_login
-
-      response = HTTP.new.login(email, pass)
-      persist_details(*response)
-
-      Strobe.ui.info "You are now logged in as #{email}"
-    end
-
-    # we don't need the account for anything yet, so leave it
-    def initialize(json)
-    end
-
-  private
-    def self.ask_for_login
-      Strobe.ui.info "Please enter your Strobe username and password."
-
-      email = Strobe.ui.ask      "Email:           "
-      pass  = Strobe.ui.password "Password:        "
-      return email, pass
-    end
-
-    def self.persist_details(user, account = nil, errors = nil)
-      if account && errors
-        raise Strobe::AccountError, "Account creation failed. Please try again.\n#{errors}"
-      elsif errors
-        raise Strobe::AccountError, "Log in failed. Please try again.\n#{errors}"
-      else
-        Strobe.settings[:token] = user.token
-      end
-    end
-  end
-end

data/lib/strobe/deploy.rb

@@ -1,131 +0,0 @@
-require "excon"
-require "json"
-require "mime/types"
-require "active_support/secure_random"
-
-cache_manifest = MIME::Type.new("text/cache-manifest") { |m| m.extensions = %w(manifest) }
-MIME::Types.add(cache_manifest)
-
-class Strobe
-  class Deploy
-    def initialize(path)
-      @path       = path
-      @connection, @method = Strobe.settings.app_connection_and_method
-    end
-
-    def deploy
-      Strobe::Account.signup_or_login unless Strobe.settings[:token]
-
-      application, errors = HTTP.new.deploy(multipart)
-
-      if errors
-        raise Strobe::ApplicationError, "Application creation failed. Please try again.\n#{errors}"
-      else
-        # Update this every time for now, in case the app has changed
-        # on the server. This assumes that the server returns JSON
-        Strobe.settings.set_local(:application, application)
-        Strobe.ui.confirm "Your app was successfully deployed on #{application["url"]}"
-      end
-    end
-
-    def multipart
-      Multipart.new do |m|
-        if application = Strobe.settings[:application]
-          name = application["name"]
-          url  = application["url"]
-        else
-          name = Strobe.ui.ask "Please enter your application's name: "
-          url  = Strobe.ui.ask "URL to deploy to:                     "
-        end
-
-        m.name name
-        m.url  url
-
-        Dir["#{@path}/**/*"].each do |file|
-          next unless File.file?(file)
-
-          filename = file.sub(/^#{@path}/, '')
-          mime_type = MIME::Types.type_for(file).first
-          m.file filename, mime_type ? mime_type.to_s : "application/octet-stream", File.read(file)
-        end
-
-        apps = []
-
-        Dir["#{@path}/static/*"].each do |app|
-          next if File.file?(app)
-
-          dir   = File.basename(app)
-          index = Dir["#{app}/*/*/index.html"].first
-
-          next if !index || !File.file?(index)
-
-          index = File.read(index)
-          apps << index
-
-          m.file "#{dir}/index.html", "text/html", index
-        end
-
-        m.file "index.html", "text/html", apps.first if apps.size == 1
-      end
-    end
-
-    class Multipart
-      def initialize
-        @name  = nil
-        @url   = nil
-        @files = []
-        yield self if block_given?
-      end
-
-      def name(name)
-        @name = name
-      end
-
-      def url(url)
-        @url = url
-      end
-
-      def file(path, content_type, body)
-        @files << [path, content_type, body]
-      end
-
-      def headers
-        { "Content-Type" => %[multipart/form-data; boundary="#{boundary}"] }
-      end
-
-      def body
-        b  = "--#{boundary}\r\n"
-        b << part("metadata", "application/json", metadata)
-        b << "--#{boundary}\r\n"
-
-        @files.each do |path, type, body|
-          b << part("files[]", type, body)
-          b << "--#{boundary}\r\n"
-        end
-
-        b
-      end
-
-    private
-
-      def boundary
-        @boundary ||= ActiveSupport::SecureRandom.hex(25)
-      end
-
-      def metadata
-        hash =     { "name" => @name, "url" => @url }
-        hash.merge!( "paths" => @files.map { |path,*| path } )
-        hash.to_json
-      end
-
-      def part(name, type, body)
-        b = ""
-        b << %[Content-Disposition: form-data; name="#{name}"; filename="array"\r\n]
-        b << %[Content-Type: #{type}\r\n]
-        b << %[\r\n]
-        b << body
-        b << %[\r\n]
-      end
-    end
-  end
-end

data/lib/strobe/errors.rb

@@ -1,12 +0,0 @@
-class Strobe
-  class Error < StandardError; end
-
-  def self.Error(code)
-    Class.new(Error) do
-      define_method(:status_code) { code }
-    end
-  end
-
-  class AccountError     < Error(2); end
-  class ApplicationError < Error(3); end
-end

data/lib/strobe/http.rb

@@ -1,94 +0,0 @@
-class Strobe
-  class HTTP
-    def signup(email, pass)
-      body = {
-        :account => {:name => "default"},
-        :user => {:email => email, :password => pass}
-      }.to_json
-
-      response = http_request(
-        "POST",
-        Strobe.settings.url("accounts"),
-        {"Content-Type" => "application/json"},
-        body
-      )
-
-      # user, account, error
-
-      json = JSON.parse(response.body)
-
-      if error = json["error"]
-        return nil, nil, error_messages(error)
-      else
-        user    = json["user"]    && User.new(json["user"])
-        account = json["account"] ? Account.new(json["account"]) : true
-        errors  = json["errors"]  && error_messages(json["errors"])
-        return user, account, errors
-      end
-    end
-
-    def login(email, pass)
-      response = http_request(
-        "GET",
-        Strobe.settings.url("account"),
-        {"Content-Type" => "application/json"}.merge(auth_header(email, pass))
-      )
-
-      json = JSON.parse(response.body)
-
-      if error = json["error"]
-        return nil, nil, "The email and password were invalid"
-      else
-        user   = json["user"]   && User.new(json["user"])
-        errors = json["errors"] && error_messages(json["errors"])
-        return user, nil, errors
-      end
-    end
-
-    def deploy(deployment)
-      connection, method = Strobe.settings.app_connection_and_method
-
-      response   = connection.request(
-        :method  => method,
-        :headers => auth_header.merge(deployment.headers),
-        :body    => deployment.body.force_encoding("BINARY")
-      )
-
-      json = JSON.parse(response.body)
-
-      if error = json["error"]
-        return nil, error
-      else
-        application = json["application"]
-        errors      = json["errors"] && error_messages(json["errors"])
-        return application, errors
-      end
-    end
-
-  private
-    def http_request(method, uri, headers = {}, body = nil)
-      connection = Excon::Connection.new(uri)
-      connection.request(:method => method, :headers => headers, :body => body)
-    end
-
-    def auth_header(username=Strobe.settings[:token], password=nil)
-      header = "Basic " << ["#{username}:#{password}"].pack("m")
-      header.gsub!(/\n/, '')
-      {"Authorization" => header}
-    end
-
-    def error_messages(errors)
-      messages = []
-      errors.each do |k, v|
-        if v
-          v.each do |field, error|
-            messages << "  * #{field} #{error}"
-          end
-        else
-          messages << "  * #{k}"
-        end
-      end
-      messages.join("\n")
-    end
-  end
-end

data/lib/strobe/server.rb

@@ -1,13 +0,0 @@
-require "rack"
-
-class Strobe
-  class Server < ::Rack::Server
-    def initialize(path = nil)
-      @path = path
-    end
-
-    def app
-      Rack::Directory.new(@path)
-    end
-  end
-end

data/lib/strobe/settings.rb

@@ -1,56 +0,0 @@
-require "excon"
-
-class Strobe
-  class Settings
-    def initialize
-      @location   = ENV["STROBE_SETTINGS"]   || Strobe.config_dir.join("config")
-      @local      = ENV["STROBE_APP_CONFIG"] || Strobe.local_config_dir.join("config")
-      @hash       = File.file?(@location) ? YAML.load(@location) : {}
-      @local_hash = File.file?(@local)    ? YAML.load(@local)    : {}
-    end
-
-    def [](key)
-      ENV[key_for(key)] || @local_hash[key_for(key)] || @hash[key_for(key)]
-    end
-
-    def []=(key, value)
-      @hash[key_for(key)] = value
-      File.open(@location, "wb") { |file| file.puts @hash.to_yaml }
-      value
-    end
-
-    def set_local(key, value)
-      @local_hash[key_for(key)] = value
-      File.open(@local, "wb") { |file| file.puts @local_hash.to_yaml }
-    end
-
-    def url(path)
-      self["url"] ||= "http://api.strobeapp.com/"
-      self["url"] + path
-    end
-
-    def auth_header(username=self[:token], password=nil)
-      header = "Basic " << ["#{username}:#{password}"].pack("m")
-      header.gsub!(/\n/, '')
-      {"Authorization" => header}
-    end
-
-    def app_connection_and_method
-      app_url = url("applications")
-
-      if application = self[:application]
-        app_url << "/#{application["id"]}"
-        method = "PUT"
-      else
-        method = "POST"
-      end
-
-      return Excon::Connection.new(app_url), method
-    end
-
-  private
-    def key_for(key)
-      "STROBE_#{key.to_s.upcase}"
-    end
-  end
-end

data/lib/strobe/ui.rb

@@ -1,81 +0,0 @@
-require "highline"
-
-class Strobe
-  module UI
-    class Basic
-      def debug(msg)
-        puts msg
-      end
-
-      def info(msg)
-        puts msg
-      end
-
-      def confirm(msg)
-        puts msg
-      end
-
-      def warn(msg)
-        puts msg
-      end
-
-      def error(msg)
-        puts msg
-      end
-
-      def highline
-        @highline ||= HighLine.new
-      end
-
-      def password(message)
-        highline.ask(message) do |q|
-          next unless STDIN.tty?
-          q.echo = "*"
-        end
-      rescue EOFError
-        ''
-      end
-
-      def ask(message)
-        highline.ask(message) do |q|
-          next unless STDIN.tty?
-          q.readline = true
-        end
-      rescue EOFError
-        ''
-      end
-    end
-
-    class Shell < Basic
-      def initialize(shell)
-        @shell = shell
-        @quiet = false
-      end
-
-      def debug(msg)
-        @shell.say(msg) if ENV['DEBUG'] && !@quiet
-      end
-
-      def info(msg)
-        @shell.say(msg) if !@quiet
-      end
-
-      def confirm(msg)
-        @shell.say(msg, :green) if !@quiet
-      end
-
-      def warn(msg)
-        @shell.say(msg, :yellow)
-      end
-
-      def error(msg)
-        @shell.say(msg, :red)
-      end
-
-      def be_quiet!
-        @quiet = true
-      end
-    end
-  end
-end
-