strobe 0.0.1 → 0.0.2

data/lib/strobe/cli/actions.rb

@@ -0,0 +1,103 @@
+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
+        end
+
+        save do
+          config[:application_id] ||= resource[:id]
+          say "The application has successfully been deployed and is available at #{resource[:url]}"
+        end
+      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

data/lib/strobe/cli/settings.rb

@@ -0,0 +1,62 @@
+require 'yaml'
+
+module Strobe
+  class CLI::Settings
+    def self.global_config_file
+      Pathname.new(Strobe.user_home).join(".strobe/config")
+    end
+
+    def self.application_config_file(root)
+      Pathname.new(root).join(".strobe/config")
+    end
+
+    def initialize(filename = self.class.global_config_file)
+      @filename = filename
+
+      if @filename.exist?
+        @hash = YAML.load(@filename)
+      else
+        @hash = {}
+      end
+    end
+
+    def [](k)
+      ENV[key(k)] || @hash[key(k)]
+    end
+
+    def []=(k, val)
+      @hash[key(k)] = val
+
+      # Persist the setting
+      FileUtils.mkdir_p(@filename.dirname)
+      File.open(@filename, "wb") do |file|
+        file.puts @hash.to_yaml
+      end
+
+      val
+    end
+
+    def connection
+      return @connection if @connection
+      host = self[:url] || "http://api.strobeapp.com/"
+      @connection = Connection.new(host)
+    end
+
+    def connect!
+      Strobe.connection = connection
+      authenticate!
+    end
+
+    def authenticate!
+      if token = self[:token]
+        connection.authenticate_with_token(token)
+      end
+    end
+
+  private
+
+    def key(key)
+      "STROBE_#{key}".upcase
+    end
+  end
+end

data/lib/strobe/collection.rb

@@ -0,0 +1,53 @@
+module Strobe
+  class Collection
+    include Enumerable
+
+    attr_reader :klass, :params
+
+    def initialize(klass, params = {})
+      @klass, @params = klass, params
+    end
+
+    def to_a
+      @to_a ||= begin
+        resp = Strobe.connection.get klass.resource_uri, params
+
+        if resp.status == 200
+          resp.body[klass.resource_name].map do |hash|
+            klass.new(hash)
+          end
+        else
+          raise "Something went wrong"
+        end
+      end
+    end
+
+    def each
+      to_a.each { |r| yield r }
+    end
+
+    def all
+      self
+    end
+
+    def [](index)
+      to_a[index]
+    end
+
+    def length
+      to_a.length
+    end
+
+    def new(params = {})
+      klass.new(@params.merge(params))
+    end
+
+    def ==(other)
+      if Array === other
+        to_a === other
+      else
+        super
+      end
+    end
+  end
+end

data/lib/strobe/connection.rb

@@ -0,0 +1,91 @@
+require 'base64'
+require 'faraday'
+
+module Strobe
+  class Connection
+    attr_reader :url
+
+    def initialize(url)
+      @url      = url
+      @user     = nil
+      @password = nil
+    end
+
+    def authenticate_with_token(token)
+      authenticate_with_user_and_password(token, '')
+    end
+
+    def authenticate_with_user_and_password(user, password)
+      @json_connection = nil
+      @reg_connection  = nil
+      @user, @password = user, password
+    end
+
+    def get(*args)
+      request :get, *args
+    end
+
+    def post(*args)
+      request :post, *args
+    end
+
+    def put(*args)
+      request :put, *args
+    end
+
+    def delete(*args)
+      request :delete, *args
+    end
+
+    def request(method, path, body = '', headers = {})
+      connection = case headers['Content-Type']
+      when /^multipart\/form-data;/ then reg_connection
+      else json_connection
+      end
+
+      resp = connection.run_request method, path, body, headers
+
+      case resp.status
+      when 401
+        # TODO Fix this on the server
+        raise UnauthenticatedError, resp.body['errors']
+      when 404
+        raise ResourceNotFoundError, resp.body['errors']
+      end
+
+      resp
+    end
+
+  private
+
+    def authorization_header
+      auth = Base64.encode64("#{@user}:#{@password}")
+      auth.gsub!("\n", "")
+
+      "Basic #{auth}"
+    end
+
+    def authorize?
+      @user
+    end
+
+    def json_connection
+      @json_connection ||= Faraday::Connection.new(:url => @url) do |b|
+        b.use Faraday::Request::ActiveSupportJson
+        b.use Faraday::Adapter::NetHttp
+        b.use Faraday::Response::ActiveSupportJson
+        b.options[:timeout]        = 30
+        b.headers['authorization'] = authorization_header if authorize?
+      end
+    end
+
+    def reg_connection
+      @reg_connection ||= Faraday::Connection.new(:url => @url) do |b|
+        b.use Faraday::Adapter::NetHttp
+        b.use Faraday::Response::ActiveSupportJson
+        b.options[:timeout]        = 30
+        b.headers['authorization'] = authorization_header if authorize?
+      end
+    end
+  end
+end

data/lib/strobe/resource/base.rb

@@ -0,0 +1,235 @@
+module Strobe
+  module Resource
+    class AssociationValidator < ActiveModel::EachValidator
+      def validate_each(record, attr, val)
+        if inst = record.send(attr)
+          inst.valid?
+          inst.errors.each do |key, msg|
+            record.errors.add("#{attr}.#{key}", msg)
+          end
+        end
+      end
+    end
+
+    module Base
+      extend  ActiveSupport::Concern
+      include Validations
+
+      included do
+        extend ActiveModel::Callbacks
+        define_model_callbacks :save, :create, :update, :destroy
+      end
+
+      module ClassMethods
+        def n
+          :n
+        end
+
+        def has(cardinality, name, options = {})
+          assoc = Association.new(self, cardinality, name, options)
+
+          class_eval(assoc.reader)
+          class_eval(assoc.writer)
+
+          if assoc.include?
+            validates_with AssociationValidator, :attributes => [name]
+          end
+
+          associations[assoc.name] = assoc
+        end
+
+        def filter(*params)
+          @filter ||= []
+
+          return @filter if params.empty?
+
+          @filter |= params.map { |p| p.to_s }
+        end
+
+        def associations
+          @associations ||= {}
+        end
+
+        def base_const_name
+          name.gsub(/^Strobe::Resources::/, '')
+        end
+
+        def resource_name
+          raise NotImplementedError, 'Implemented in a subclass'
+        end
+
+        def singular_resource_name
+          raise NotImplementedError, 'Implemented in a subclass'
+        end
+
+        def uri_prefix
+          @uri_prefix ||= "/#{resource_name}"
+        end
+      end
+
+      attr_reader :response
+
+      def initialize(params = {})
+        @response   = nil
+        self.params = params || {}
+      end
+
+      def persisted?
+        self[:id]
+      end
+
+      # TODO: Make this legit
+      def key?(key)
+        params.key?(key)
+      end
+
+      def params
+        @params.dup.tap do |params|
+          self.class.associations.each do |name, assoc|
+            next unless assoc.include? and inst = send(name)
+            params.deep_merge! name => inst.params
+          end
+        end
+      end
+
+      def params=(val)
+        params = with_indifferent_access(val)
+
+        extract_on_associations(params).each do |k, v|
+          send("#{k}=", v)
+        end
+
+        @params = params
+        val
+      end
+
+      def [](key)
+        if Array === key
+          parts = key
+        else
+          parts = key.to_s.split('.')
+        end
+
+        if self.class.associations.key?(parts.first.to_sym)
+          return unless inst = send(parts.first)
+          return inst if parts.length == 1
+          inst[parts[1..-1]]
+        else
+          parts.inject(params) do |param, key|
+            param[key]
+          end
+        end
+      end
+
+      def []=(key, val)
+        merge!(key.to_s.split('.').reverse.inject(val) do |param, key|
+          { key => param }
+        end)
+      end
+
+      def merge!(params)
+        params = with_indifferent_access(params || {})
+
+        extract_on_associations(params).each do |k, v|
+          unless inst = send(k)
+            inst = send("#{k}=", {})
+          end
+          inst.merge! v
+        end
+
+        @params.deep_merge! params
+      end
+
+      def persisted?
+        self[:id]
+      end
+
+      def save
+        if valid?
+          root      = self.class.singular_resource_name
+          @response = self["id"] ? update : create
+
+          if @response.success?
+            merge! @response.body[root]
+            return true
+          elsif @response.status == 422
+            errors = @response.body['errors']
+            errors = errors[root] if errors
+            handle_errors(errors) if errors
+          else
+            raise "Something went wrong"
+          end
+
+          false
+        end
+      end
+
+      def destroy
+        raise NotImplemented
+      end
+
+    private
+
+      def connection
+        Strobe.connection
+      end
+
+      def http_verb
+        persisted? ? :put : :post
+      end
+
+      def http_uri
+        uri = self.class.uri_prefix
+        uri = "#{uri}/#{self[:id]}" if self[:id]
+        uri
+      end
+
+      def request_params
+        filter = self.class.filter
+        { self.class.singular_resource_name => params.except(*filter) }
+      end
+
+      def create
+        connection.post http_uri, request_params, {}
+      end
+
+      def update
+        connection.put http_uri, request_params, {}
+      end
+
+      def handle_errors(errors, key = nil)
+        errors.each do |k, v|
+          key = key ? "#{key}.#{k}" : k
+          case v
+          when Hash
+            handle_errors(v, key)
+          else
+            self.errors.add(key, v)
+          end
+        end
+      end
+
+      def with_indifferent_access(val)
+        case val
+        when Hash
+          h = HashWithIndifferentAccess.new
+          val.each { |k, v| h[k] = with_indifferent_access(v) }
+          h
+        when Array
+          val.map { |elem| with_indifferent_access(elem) }
+        else
+          val
+        end
+      end
+
+      def extract_on_associations(params)
+        {}.tap do |ret|
+          self.class.associations.keys.each do |key|
+            next unless params.key?(key)
+            ret[key] = params.delete(key)
+          end
+        end
+      end
+    end
+  end
+end