strobe 0.0.1

data/features/support/strobe.rb

@@ -0,0 +1,57 @@
+require "excon"
+require "timeout"
+require "thor"
+require "child_labor"
+
+class Strobe
+  module Spec
+    module CLIExecution
+      def strobe(command, &block)
+        run("strobe #{command}", &block)
+      end
+
+      def run(command)
+        merged_env = env.merge("HOME" => system_home, "STROBE_URL" => "http://localhost:3000/")
+        env_string = merged_env.inject([]) { |env_str,env| env_str << %{#{env.first}="#{env.last}"} }
+
+        self.task  = ChildLabor.subprocess("cd #{dir} && #{env_string.join(" ")} #{command}")
+
+        if block_given?
+          yield task
+          task.terminate unless task.terminated?
+          task.wait unless task.terminated?
+        end
+      end
+
+      def task
+        Thread.current[:task]
+      end
+
+      def task=(child)
+        Thread.current[:task] = child
+      end
+
+      def out
+        task.read
+      end
+
+      def err
+        task.read_stderr
+      end
+
+      def out_until_block
+        # read 1 first so we wait until the process is done processing the last write
+        chars  = task.stdout.read(1)
+
+        loop do
+          chars << task.stdout.read_nonblock(1000)
+          sleep 0.05
+        end
+      rescue Errno::EAGAIN, EOFError
+        @last_out = chars
+      end
+    end
+  end
+end
+
+World(Strobe::Spec::CLIExecution)

data/lib/strobe.rb

@@ -0,0 +1,118 @@
+require "pathname"
+require "yaml"
+
+class Strobe
+  class << self
+
+    # this isn't currently needed, but why start with globals when you could
+    # just as easily start with a singleton instance, which may be helpful
+    # later
+    def main
+      @main ||= new
+    end
+
+    def ui
+      main.ui
+    end
+
+    def ui=(ui)
+      main.ui = ui
+    end
+
+    def root
+      main.root
+    end
+
+    def app_root
+      main.app_root
+    end
+
+    def account
+      main.account
+    end
+
+    def settings
+      main.settings
+    end
+
+    def config_dir
+      main.config_dir
+    end
+
+    def local_config_dir
+      main.local_config_dir
+    end
+  end
+
+  attr_writer :ui
+
+  def ui
+    @ui ||= UI::Basic.new
+  end
+
+  def root
+    sproutcore = "#{app_root}/tmp/build"
+    File.directory?(sproutcore) ? sproutcore : app_root
+  end
+
+  def app_root
+    @app_root ||= Pathname.new(Dir.pwd)
+  end
+
+  def config_dir
+    @config_dir ||= begin
+      dir = Pathname.new(File.join(Strobe.user_home, ".strobe"))
+      FileUtils.mkdir_p(dir) unless dir.exist?
+      dir
+    end
+  end
+
+  def local_config_dir
+    @local_config_dir ||= begin
+      dir = Pathname.new(File.join(app_root, ".strobe"))
+      FileUtils.mkdir_p(dir) unless dir.exist?
+      dir
+    end
+  end
+
+  def settings
+    @settings ||= Settings.new
+  end
+
+  autoload :Account,  "strobe/account"
+  autoload :CLI,      "strobe/cli"
+  autoload :Deploy,   "strobe/deploy"
+  autoload :Error,    "strobe/errors"
+  autoload :HTTP,     "strobe/http"
+  autoload :Server,   "strobe/server"
+  autoload :Settings, "strobe/settings"
+  autoload :UI,       "strobe/ui"
+  autoload :User,     "strobe/user"
+  autoload :Version,  "strobe/version"
+
+  # ERRORS
+  autoload :AccountError,     "strobe/errors"
+  autoload :ApplicationError, "strobe/errors"
+
+private
+  # sadly, copied from Rubygems
+  def self.user_home
+    unless RUBY_VERSION > '1.9' then
+      ['HOME', 'USERPROFILE'].each do |homekey|
+        return File.expand_path(ENV[homekey]) if ENV[homekey]
+      end
+
+      if ENV['HOMEDRIVE'] && ENV['HOMEPATH'] then
+        return File.expand_path("#{ENV['HOMEDRIVE']}#{ENV['HOMEPATH']}")
+      end
+    end
+
+    File.expand_path "~"
+  rescue
+    if File::ALT_SEPARATOR then
+      "C:/"
+    else
+      "/"
+    end
+  end
+end

data/lib/strobe/account.rb

@@ -0,0 +1,67 @@
+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/cli.rb

@@ -0,0 +1,78 @@
+require "thor"
+
+class Strobe
+  class CLI < Thor
+    check_unknown_options!
+
+    class_option "no-color", :type => :boolean, :banner => "Disable colorization in output"
+    class_option "path",     :type => :string,  :banner => "The path to your application"
+
+    def initialize(*)
+      super
+
+      opts = {"path" => Strobe.root}.merge(options)
+      self.options = Thor::CoreExt::HashWithIndifferentAccess.new(opts)
+
+      use_shell = options["no-color"] ? Thor::Shell::Basic.new : shell
+      Strobe.ui = UI::Shell.new(use_shell)
+    end
+
+    desc "signup", "sign up for a new Strobe account"
+    def signup
+      Account.signup
+    end
+
+    desc "deploy", "deploy your application to Strobe"
+    def deploy
+      Deploy.new(options[:path]).deploy
+    end
+
+    desc "preview", "preview your application locally"
+    def preview
+      Server.new(options[:path]).start
+    end
+
+    def help(command)
+      case command
+      when "gemfile" then command = "gemfile.5"
+      when nil       then command = "bundle"
+      else command = "bundle-#{cli}"
+      end
+
+      root = File.expand_path("../man", __FILE__)
+
+      if manpages.include?(command)
+        if have_groff?
+          groff   = "groff -Wall -mtty-char -mandoc -Tascii"
+          pager   = ENV['MANPAGER'] || ENV['PAGER'] || 'more'
+
+          Kernel.exec "#{groff} #{root}/#{command} | #{pager}"
+        else
+          puts File.read("#{root}/#{command}.txt")
+        end
+      else
+        super
+      end
+    end
+
+  private
+    def manpages
+      man_root = File.expand_path("../man", __FILE__)
+      return [] unless File.directory?(man_root)
+
+      man_pages = []
+      Dir["#{man_root}/*"].each do |file|
+        base = File.basename(file)
+        next if base.include?(".")
+        man_pages << base
+      end
+      man_pages
+    end
+
+    def have_groff?
+      `which groff 2>#{NULL}`
+      $? == 0
+    end
+  end
+end
+

data/lib/strobe/deploy.rb

@@ -0,0 +1,131 @@
+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