strobe 0.1.6 → 0.2.0.beta.1

data/lib/strobe.rb

@@ -8,18 +8,25 @@ require 'active_support/core_ext/hash/indifferent_access'
 require 'active_support/core_ext/string/inflections'
 
 module Strobe
-  autoload :Association, 'strobe/association'
-  autoload :CLI,         'strobe/cli'
-  autoload :Collection,  'strobe/collection'
-  autoload :Connection,  'strobe/connection'
-  autoload :IdentityMap, 'strobe/identity_map'
-  autoload :Key,         'strobe/key'
-  autoload :Resources,   'strobe/resources'
-  autoload :Validations, 'strobe/validations'
+  autoload :Association,       'strobe/association'
+  autoload :CLI,               'strobe/cli'
+  autoload :Collection,        'strobe/collection'
+  autoload :Config,            'strobe/config'
+  autoload :Connection,        'strobe/connection'
+  autoload :IdentityMap,       'strobe/identity_map'
+  autoload :Key,               'strobe/key'
+  autoload :Resources,         'strobe/resources'
+  autoload :Validations,       'strobe/validations'
+  autoload :ExceptionNotifier, 'strobe/exception_notifier'
+
+  module Addons
+    # Stubb out the Addons module
+  end
 
   module Middleware
-    autoload :Proxy,     'strobe/middleware/proxy'
-    autoload :Rewrite,   'strobe/middleware/rewrite'
+    autoload :Addons,  'strobe/middleware/addons'
+    autoload :Proxy,   'strobe/middleware/proxy'
+    autoload :Rewrite, 'strobe/middleware/rewrite'
   end
 
   module Resource
@@ -30,12 +37,21 @@ module Strobe
 
 
   # Errors
-  class StrobeError           < StandardError ; end
-  class RequestError          < StrobeError   ; end
-  class ResourceNotFoundError < StrobeError   ; end
-  class ServerError           < StrobeError   ; end
-  class UnauthenticatedError  < StrobeError   ; end
-  class ValidationError       < StrobeError   ; end
+  class StrobeError           < StandardError   ; end
+  class ResourceNotFoundError < StrobeError     ; end
+  class UnauthenticatedError  < StrobeError     ; end
+  class ValidationError       < StrobeError     ; end
+
+  class NotifiableError < StrobeError
+    attr_reader :data
+    def initialize(message = nil, data = nil)
+      super(message)
+      @data = data
+    end
+  end
+
+  class RequestError          < NotifiableError ; end
+  class ServerError           < NotifiableError ; end
 
   def self.connection
     @connection

data/lib/strobe/addons/social.rb

@@ -0,0 +1,130 @@
+require 'oauth'
+
+module Strobe
+  module Addons
+    class Social
+      TWITTER_URL = "http://api.twitter.com"
+      REQUEST_TOKEN_SECRETS = {}
+      ACCESS_TOKEN_SECRETS  = {}
+
+      def initialize(settings)
+        @settings        = settings
+        @cookie_key      = "twitter_access_token"
+        @consumer_key    = settings['social.twitter.consumer_key']
+        @consumer_secret = settings['social.twitter.consumer_secret']
+
+        unless @consumer_key
+          raise "Social addon requires `social.twitter.consumer_key` configuration"
+        end
+
+        unless @consumer_secret
+          raise "Social addon requires `social.twitter.consumer_secret` configuration"
+        end
+
+        @consumer = OAuth::Consumer.new(@consumer_key, @consumer_secret, :site => TWITTER_URL)
+      end
+
+      def call(env)
+        dup._call(env)
+      end
+
+      def _call(env)
+        @request = Rack::Request.new(env)
+
+        case env["PATH_INFO"]
+        when "/twitter/authenticate"
+          get_request_token
+        when "/twitter/callback"
+          get_access_token
+        when %r[^/twitter(.*)$]
+          proxy
+        else
+          msg = "Not found"
+          [404, {"Content-Length" => msg.bytesize.to_s}, [msg]]
+        end
+      end
+
+    private
+
+      def get_request_token
+        request_token = @consumer.get_request_token(:oauth_callback => callback_url)
+        REQUEST_TOKEN_SECRETS[request_token.token] = request_token.secret
+
+        response = Rack::Response.new
+        response.redirect(request_token.authorize_url(:oauth_callback => callback_url))
+        response.finish
+      end
+
+      def get_access_token
+        response = Rack::Response.new
+
+        oauth_token    = @request.params["oauth_token"]
+        oauth_verifier = @request.params["oauth_verifier"]
+        request_token  = REQUEST_TOKEN_SECRETS[oauth_token]
+
+        if oauth_token && request_token
+          request_token = OAuth::RequestToken.new(@consumer, oauth_token, request_token)
+          access_token = request_token.get_access_token(:oauth_verifier => oauth_verifier)
+          ACCESS_TOKEN_SECRETS[access_token.token] = access_token.secret
+
+          response.body = ['<html><head><script>window.opener?window.close():(window.location = "/")</script></head></html>']
+          response.set_cookie(@cookie_key, :value => access_token.token, :path => "/")
+          response.finish
+        else
+          msg = "Could not match oauth response with an oauth request. Was the server restarted?\n"
+          [404, {"Content-Type" => "text/plain", "Content-Length" => msg.bytesize.to_s}, msg]
+        end
+      end
+
+      def proxy
+        token         = @request.cookies[@cookie_key]
+        access_token  = OAuth::AccessToken.new(@consumer, token, ACCESS_TOKEN_SECRETS[token])
+
+        request_method  = @request.request_method.to_s.upcase
+        request_path    = @request.fullpath.sub(%r<^/_strobe/social/twitter>, "")
+        request_body    = @request.body.read
+        request_headers = {}
+        request_headers["Content-Type"] = @request.content_type if @request.content_type.present?
+        request_headers["Content-Length"] = @request.content_length if @request.content_length.present?
+
+        http = Net::HTTP.new(URI.parse(TWITTER_URL).host, URI.parse(TWITTER_URL).port)
+        oauth_request = Net::HTTPGenericRequest.new(request_method, request_body.present?, request_method != "HEAD", request_path, request_headers)
+        oauth_request.body = request_body if request_body.present?
+        oauth_request.oauth!(http, @consumer, access_token)
+
+        response_headers = {}
+
+        response_headers["Authorization"] = oauth_request["Authorization"]
+        response_headers["X-Strobe-Forward-Headers"] = "Authorization"
+
+        response_headers["X-Strobe-Location"] = URI.join(TWITTER_URL, request_path).to_s
+        response_headers["X-Strobe-Redirect-Method"] = request_method
+
+        if oauth_request["Content-Type"].present?
+          response_headers["X-Strobe-Forward-Headers"] += ",Content-Type"
+          response_headers["Content-Type"] = oauth_request["Content-Type"]
+        end
+
+        if oauth_request["Content-Length"].present?
+          response_headers["X-Strobe-Forward-Headers"] += ",Content-Length"
+          response_headers["Content-Length"] = oauth_request["Content-Length"]
+        end
+
+        [302, response_headers, [request_body]]
+      end
+
+      def root_url
+        url_for("")
+      end
+
+      def callback_url
+        url_for("/twitter/callback")
+      end
+
+      def url_for(path)
+        # host_with_port returns http://localhost:9293 in tests
+        "#{@request.scheme}://#{@request.host_with_port.sub(%r<^https?://>, "")}#{@request.script_name}#{path}"
+      end
+    end
+  end
+end

data/lib/strobe/cli.rb

@@ -24,9 +24,15 @@ module Strobe
       IdentityMap.wrap do
         super
       end
-    rescue Strobe::StrobeError => e
+    rescue NotifiableError => e
       raise if $ARGV.include?('--backtrace')
-      abort "[ERROR] #{e.message}"
+      STDERR.puts "[ERROR] #{e.message}"
+      ExceptionNotifier.notify(e, :action => args.join(" "))
+      abort
+    rescue StrobeError => e
+      raise if $ARGV.include?('--backtrace')
+      STDERR.puts "[ERROR] #{e.message}"
+      abort
     rescue Interrupt
       abort  "\nQuitting..."
     end
@@ -34,7 +40,12 @@ module Strobe
     def self.action(name, *args, &blk)
       @haxliases ||= []
       @haxliases << name.to_s
-      usage = self == Users ? "users #{name}" : name
+      options = args.last if args.last.is_a?(Hash)
+      usage = if options && options[:usage]
+        options[:usage]
+      else
+        self == Users ? "users #{name}" : name
+      end
       desc usage, *args
       define_method("__hax__#{name}", &blk)
       map name => "__hax__#{name}"
@@ -75,12 +86,13 @@ module Strobe
       options[:path] || Dir.pwd
     end
 
-    def config(app = nil)
-      if app
-        @config = settings.configs.find { |c| c[:application_id] = app[:id] }
-      end
+    def config
+      return @config if @config
+      @config = Config.new_or_stub(path) || Config.stub!(path)
+    end
 
-      @config ||= Settings.application(path)
+    def settings
+      @settings ||= Settings.for(path)
     end
 
     def invoke(action, *args)
@@ -93,10 +105,6 @@ module Strobe
       @resource
     end
 
-    def settings
-      @settings ||= Settings.new
-    end
-
     def until_success(&blk)
       until @success
         retval = blk.call

data/lib/strobe/cli/main.rb

@@ -10,6 +10,30 @@ module Strobe
       end
     end
 
+    method_option "global", :type => :boolean, :banner => "Set option globally (for all applications)"
+    method_option "unset",  :type => :boolean, :banner => "Unset a config option"
+    action "config", "configure strobe", :usage => "config [KEY] [VALUE]" do |key, val = nil|
+      case
+      when val
+        if options[:global]
+          settings.global_set! key, val
+          say "Globally setting `#{key}` to `#{val}`"
+        else
+          settings.set! key, val
+          say "Setting `#{key}` to `#{val}`"
+        end
+      when options[:unset]
+        settings.unset!(key)
+        say "Unsetting `#{key}`"
+      else
+        if val = settings[key]
+          say "#{key}: #{val}"
+        else
+          say "No value for `#{key}`"
+        end
+      end
+    end
+
     action "users", 'manage users' do |*args|
       argv = $ARGV[1..-1]
       argv = [ 'list' ] + argv if args.empty?
@@ -23,6 +47,20 @@ module Strobe
       Launchy.open("http://#{url}")
     end
 
+    action "deploys", "manage deploys" do
+      id = options['application-id'] || config[:application_id]
+      app = Application.new(:id => id)
+      deploys = app.deploys.all
+
+      table deploys do |t|
+        t.column :key    do |d| d[:id][0..7] end
+        t.column :parent do |d| d[:parent] ? d[:parent][0..7] : "" end
+        t.column :name
+        t.column :email
+        t.column :message
+      end
+    end
+
     action "signup", "signup for a new Strobe account" do
       resource Signup.new :account => { :name => 'default' }
 
@@ -46,7 +84,7 @@ module Strobe
         end
 
         save do
-          settings[:token] = resource['user.authentication_token']
+          settings.global_set! :token, resource['user.authentication_token']
           settings.authenticate!
           say "Your account was created successfully."
         end
@@ -63,7 +101,7 @@ module Strobe
         password :password, :into => "user.password"
 
         save do
-          settings[:token] = resource['user.authentication_token']
+          settings.global_set! :token,  resource['user.authentication_token']
           settings.authenticate!
           say "The computer has been registered with the account."
         end
@@ -109,8 +147,11 @@ module Strobe
         ask :application_name, :into => "name"
 
         save do
-          config[:application_id] ||= resource[:id]
-          settings.register_app_path(config.filename)
+          unless config[:application_id]
+            config.set_application_id! resource[:id]
+          end
+
+          settings.register_app_path(path)
         end
       end
 
@@ -159,7 +200,10 @@ module Strobe
       end
 
       delete do
-        config(resource).delete
+        if config = settings.configs.find { |c| c[:application_id] == id.to_i }
+          config.unset_application_id!
+          settings.unregister_app_path config.application_path
+        end
         say "The application has been deleted"
       end
     end
@@ -169,16 +213,14 @@ module Strobe
     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
+        say "Aborting..."
+        exit 1
       end
 
       application = options['application-id'] ? Application.get!(options['application-id']) : pick_application
 
-      config[:application_id] = application[:id]
-      settings.register_app_path(config.filename)
+      config.set_application_id! application[:id]
+      settings.register_app_path(path)
 
       say "You can now deploy to #{application[:name]} (http://#{application[:url]})"
     end

data/lib/strobe/cli/preview.rb

@@ -18,8 +18,10 @@ module Strobe
 
     def preview_html_application
       app = Rack::Static.new lambda { |e| [] }, :urls => [ '/' ], :root => '.'
-      app = Middleware::Rewrite.new(Middleware::Proxy.new(app))
-      Server.start :app => app, :host => '0.0.0.0', :Port => 9292
+      app = Middleware::Rewrite.new(app)
+      app = Middleware::Addons.new(app, :settings => settings, :config => config)
+      app = Middleware::Proxy.new(app)
+      Server.start :app => app, :host => '0.0.0.0', :server => "thin", :Port => 9292
     end
 
     def preview_sproutcore_application

data/lib/strobe/cli/settings.rb

@@ -12,34 +12,71 @@ module Strobe
       Pathname.new(root).join(".strobe/#{file}")
     end
 
-    def self.application(root)
-      new application_config_file(root)
+    def self.for(path)
+      new(application_config_file(path), global_config_file)
+    end
+
+    def self.global
+      new(nil, global_config_file)
     end
 
     attr_reader :filename
 
-    def initialize(filename = self.class.global_config_file)
-      @filename = Pathname.new(filename)
+    def initialize(local_filename, global_filename)
+      @local_filename  = Pathname.new(local_filename) if local_filename
+      @global_filename = Pathname.new(global_filename)
 
-      if @filename.exist?
-        @hash = YAML.load_file(@filename)
+      if @local_filename && @local_filename.exist?
+        @local_hash = YAML.load_file(@local_filename)
       end
 
-      @hash = {} unless Hash === @hash
-    end
+      @local_hash = {} unless Hash === @local_hash
+
+      if @global_filename.exist?
+        @global_hash = YAML.load_file(@global_filename)
+      end
 
-    def application_path
-      filename.sub %r[/.strobe/config(\.[a-z]+)?$]i, ''
+      @global_hash = {} unless Hash === @global_hash
     end
 
+    # def application_path
+    #   filename.sub %r[/.strobe/config(\.[a-z]+)?$]i, ''
+    # end
+
     def [](k)
-      ENV[key(k)] || @hash[key(k)]
+      k = key(k)
+      ENV[k] || @local_hash[k] || @global_hash[k]
+    end
+
+    def fetch(k, v)
+      self[k] || v
+    end
+
+    def set!(k, v)
+      @local_hash[key(k)] = v
+      persist! @local_hash, @local_filename
+      v
     end
 
-    def []=(k, val)
-      @hash[key(k)] = val
-      persist!
-      val
+    def global_set!(k, v)
+      @global_hash[key(k)] = v
+      persist! @global_hash, @global_filename
+      v
+    end
+
+    def unset!(k)
+      k = key(k)
+      if @local_hash[k]
+        @local_hash.delete(k)
+        persist! @local_hash, @local_filename
+      end
+
+      if @global_hash[k]
+        @global_hash.delete(k)
+        persist! @global_hash, @global_filename
+      end
+
+      nil
     end
 
     def connection
@@ -59,38 +96,47 @@ module Strobe
       end
     end
 
-    def delete
-      FileUtils.rm_f(@filename)
-    end
-
     def configs
       @configs ||= begin
-        self[:applications] ||= []
-        self[:applications].map do |path|
-          next unless File.file?(path)
-          self.class.new(path)
-        end.compact
+        application_paths.map do |path|
+          Config.new_or_stub(path)
+        end
       end
     end
 
-    def register_app_path(path)
-      self[:applications] ||= []
-      self[:applications] |= [File.expand_path(path.to_s)]
-      self[:applications]  = self[:applications].select do |path|
-        File.file?(path)
+    def application_paths
+      paths = self[:applications] || []
+
+      # Handle legacy application paths
+      # TODO: When it's safe, remove this code
+      paths.map! do |p|
+        if File.file?(p) && p =~ /\.strobe/
+          File.expand_path('../..', p)
+        else
+          p
+        end
+      end
+
+      # TODO: Handle the logacy case where applications points
+      # to a .strobe/config file
+      paths.delete_if do |path|
+        !(File.file?("#{path}/.strobe/config") ||
+          File.file?("#{path}/strobe/config.json"))
       end
 
-      persist!
+      paths
     end
 
-    def unregister_app_path(path)
-      self[:applications] ||= []
-      self[:applications].delete File.expand_path(path.to_s)
-      self[:applications] = self[:applications].select do |path|
-        File.file?(path)
-      end
+    def register_app_path(path)
+      paths  = application_paths
+      paths |= [File.expand_path(path.to_s)]
+      global_set! :applications, paths
+    end
 
-      persist!
+    def unregister_app_path(path)
+      paths = application_paths
+      paths.delete File.expand_path(path.to_s)
+      global_set! :applications, paths
     end
 
   private
@@ -99,11 +145,18 @@ module Strobe
       "STROBE_#{key}".upcase
     end
 
-    def persist!
-      # Persist the setting
-      FileUtils.mkdir_p(@filename.dirname)
-      File.open(@filename, "wb") do |file|
-        file.puts @hash.to_yaml
+    def persist!(hash, filename)
+      FileUtils.mkdir_p(filename.dirname)
+      File.open(filename, "wb") do |file|
+        file.puts hash.to_yaml
+      end
+    end
+
+    def check_app_paths
+      self[:applications] ||= []
+      self[:applications] = self[:applications].select do |path|
+        File.file?("#{path}/.strobe") ||
+          File.file?("#{path}/strobe/config.json")
       end
     end
   end