usergrid_iron 0.0.1

data/lib/usergrid/core/entity.rb

@@ -0,0 +1,59 @@
+# also allows hash or dot notation for entity properties
+module Usergrid
+  class Entity < Resource
+
+    def initialize(url, api_url, options={}, response=nil, index=nil)
+      super url, api_url, options, response
+      @index = index
+    end
+
+    def data
+      get unless response
+      @index ? response.entities_data[@index] : response.entity_data
+    end
+
+    def data?
+      !!response
+    end
+
+    def resource
+      Resource.new url, api_url, options
+    end
+
+    def [](k)
+      data[k]
+    end
+
+    def []=(k,v)
+      data[k] = v
+    end
+
+    def collection
+      Collection.new url[0..url[0..-2].rindex('/')-1], api_url, options
+    end
+
+    def save
+      self.put data
+    end
+
+    def to_s
+      "resource: #{url}\ndata: #{data.pretty_inspect}"
+    end
+
+    private
+
+    def method_missing(method, *args, &block)
+      if data.respond_to?(method)
+        data.send(method, *args, &block)
+      elsif method[-1] == '=' && args.size == 1
+        data[method[0..-2]] = args[0]
+      else
+        super method, args, block
+      end
+    end
+
+    def respond_to?(method)
+      super.respond_to?(method) || data.respond_to?(method)
+    end
+  end
+end

data/lib/usergrid/core/management.rb

@@ -0,0 +1,37 @@
+module Usergrid
+  class Management < Resource
+
+    def initialize(api_url, options)
+      url = concat_urls(api_url, 'management')
+      super url, api_url, options
+    end
+
+    # one way: cannot delete organizations
+    def create_organization(organization, username, name, email, password)
+      data = { organization: organization,
+               username: username,
+               name: name,
+               email: email,
+               password: password }
+      self['organizations'].post data
+    end
+
+    def organizations
+      self[__method__].get
+    end
+
+    def organization(organization)
+      url = self["organizations/#{organization}"].url
+      Organization.new url, api_url, options
+    end
+
+    def users
+      self['users'].get
+    end
+
+    def user(name_or_uuid)
+      self["users/#{name_or_uuid}"].get
+    end
+
+  end
+end

data/lib/usergrid/core/organization.rb

@@ -0,0 +1,51 @@
+require 'uri'
+module Usergrid
+  class Organization < Resource
+
+    def initialize(url, api_url, options)
+      super url, api_url, options
+    end
+
+    def name
+      URI(url).path.split('/').last
+    end
+
+    def create_application(name)
+      self['applications'].post({ name: name })
+      application name
+    end
+
+    def applications(query=nil)
+      resource = self[__method__]
+      response = query ? resource.query(query) : resource.get
+      response.data['data'].collect do |k|
+        application concat_urls(api_url, k)
+      end
+    end
+
+    def application(name_or_uuid)
+      Usergrid::Application.new concat_urls(api_url, "#{name}/#{name_or_uuid}"), api_url, options
+    end
+
+    def users(query=nil)
+      self[__method__].query(query)
+    end
+
+    def user(user)
+      management.user(user)
+    end
+
+    def feed(query=nil)
+      self[__method__].query(query)
+    end
+
+    def credentials
+      self[__method__].get
+    end
+
+    def generate_credentials
+      self['credentials'].post nil
+    end
+
+  end
+end

data/lib/usergrid/core/resource.rb

@@ -0,0 +1,117 @@
+require 'rest_client'
+
+module Usergrid
+  class Resource < RestClient::Resource
+
+    DEFAULT_API_URL = 'https://api.usergrid.com'
+    TYPE_HEADERS = { :content_type => :json, :accept => :json }
+
+    attr_reader :current_user, :auth_token, :api_url
+
+    def initialize(resource_url=DEFAULT_API_URL, api_url=nil, options={}, response=nil)
+      options[:headers] = TYPE_HEADERS.merge options[:headers] || {}
+      @api_url = api_url || resource_url
+      self.response = response
+      super resource_url, options, &method(:handle_response)
+    end
+
+    # gets user token and automatically set auth header for future requests
+    # precondition: resource must already be set to the correct context (application or management)
+    def login(username, password)
+      params = { grant_type: "password", username: username, password: password }
+      response = self['token'].get({ params: params })
+      self.auth_token = response.data['access_token']
+      user_uuid = response.data['user']['uuid']
+      @current_user = self["/users/#{user_uuid}"].get.entity
+      response
+    end
+
+    # remove auth header for future requests
+    # only affects self and derivative resources
+    def logout
+      self.auth_token = nil
+      @current_user = nil
+    end
+
+    def logged_in?
+      !!@auth_token
+    end
+
+    def management
+      Usergrid::Management.new api_url, options
+    end
+
+    # application defaults to sandbox if none provided
+    def application(organization, application='sandbox')
+      Usergrid::Application.new concat_urls(api_url, "#{organization}/#{application}"), api_url, options
+    end
+
+    def query(query=nil, options={})
+      options = options.merge({ql: query}) if query
+      get({params: options})
+    end
+
+    def entity
+      response.entity
+    end
+
+    def collection
+      Collection.new url, api_url, options, response
+    end
+
+    # overridden to ensure sub resources are instances of this class
+    def [](suburl, &new_block)
+      case
+        when block_given? then Resource.new(concat_urls(url, suburl), api_url, options, &new_block)
+        when block        then Resource.new(concat_urls(url, suburl), api_url, options, &block)
+        else
+          Resource.new(concat_urls(url, suburl), api_url, options)
+      end
+    end
+
+    def api_resource(suburl)
+      Resource.new(concat_urls(api_url, suburl), api_url, options)
+    end
+
+    def get(additional_headers={}, &block)
+      self.response = super additional_headers, &block
+    end
+
+    def post(payload, additional_headers={}, &block)
+      payload = payload.to_json if payload.is_a?(Hash) || payload.is_a?(Array)
+      self.response = super payload, additional_headers, &block
+    end
+
+    def put(payload, additional_headers={}, &block)
+      payload = payload.to_json if payload.is_a?(Hash) || payload.is_a?(Array)
+      self.response = super payload, additional_headers, &block
+    end
+
+    protected
+
+    attr_reader :response
+
+    def response=(response)
+      @response = response
+    end
+
+    def auth_token=(auth_token)
+      @auth_token = auth_token
+      if auth_token
+        @options[:headers].merge!({ Authorization: "Bearer #{auth_token}" })
+      else
+        @options[:headers].delete :Authorization if @options
+      end
+    end
+
+    # add verbose debugging of response body
+    def handle_response(response, request, result, &block)
+      LOG.debug "response.body = #{response}"
+      response = response.return!(request, result, &block)
+      response.resource = self
+      self.response = response
+      response
+    end
+
+  end
+end

data/lib/usergrid/extensions/hash.rb

@@ -0,0 +1,27 @@
+class Hash
+
+  # recursive
+  def add_dot_notation!
+    add_dot_notation_recurse! self
+  end
+
+  # not recursive
+  def symbolize_keys
+    inject({}) do |options, (key, value)|
+      options[(key.to_sym rescue key) || key] = value
+      options
+    end
+  end
+
+  private
+
+  def add_dot_notation_recurse!(_hash)
+    _hash.each do |k,v|
+      getter = k.to_sym; setter = "#{k}=".to_sym
+      _hash.define_singleton_method getter, lambda { _hash[k] } unless _hash.respond_to? getter
+      _hash.define_singleton_method setter, lambda { |v| _hash[k] = v } unless _hash.respond_to? setter
+      add_dot_notation_recurse!(v) if v.is_a? Hash
+      v.each { |e| add_dot_notation_recurse!(e) if e.is_a? Hash } if v.is_a? Array
+    end
+  end
+end

data/lib/usergrid/extensions/response.rb

@@ -0,0 +1,64 @@
+module RestClient
+  module Response
+
+    def resource=(resource)
+      @resource = resource
+    end
+
+    def resource
+      @resource
+    end
+
+    def data
+      @data = JSON.parse(self).add_dot_notation! unless @data
+      @data
+    end
+
+    def collection
+      resource.collection
+    end
+
+    def multiple_entities?
+      entities_data = data['entities'] || data['data'] || data['messages']
+      entities_data.is_a? Array
+    end
+
+    def entities_data
+      return @entities_data if @entities_data
+      entities_data = data['entities'] || data['data'] || data['messages']
+      raise "unable to determine entities from: #{data}" unless entities_data.is_a?(Array)
+      entities_data.each do |e|
+        e['uri'] = resource.concat_urls(data['uri'], e['uuid']) if e['uuid']
+      end
+      @entities_data = entities_data
+    end
+
+    def entities
+      return @entities if @entities
+      index = -1
+      @entities = entities_data.collect do |e|
+        Usergrid::Entity.new e['uri'], resource.api_url, resource.options, self, index+=1
+      end
+    end
+
+    def entity_data
+      if multiple_entities?
+        entities_data.first
+      elsif data['data']
+        d = data['data']
+        d['uri'] = @resource.url
+        d
+      elsif data['organization']
+        d = data['organization']
+        d['uri'] = @resource.url
+        d
+      else
+        entities_data.first
+      end
+    end
+
+    def entity
+      Usergrid::Entity.new entity_data['uri'], resource.api_url, resource.options, self
+    end
+  end
+end

data/lib/usergrid/version.rb

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

data/spec/spec_helper.rb

@@ -0,0 +1,77 @@
+require 'simplecov'
+
+require 'rspec'
+require 'yaml'
+require 'securerandom'
+require_relative '../lib/usergrid'
+
+LOG = Logger.new(STDOUT)
+RestClient.log=LOG
+
+SimpleCov.at_exit do
+  SimpleCov.result.format!
+  #index = File.join(SimpleCov.coverage_path, 'index.html')
+  #`open #{index}` if File.exists?(index)
+end
+SimpleCov.start
+
+SPEC_SETTINGS = YAML::load_file(File.join File.dirname(__FILE__), 'spec_settings.yaml')
+
+# ensure we are correctly setup (management login & organization)
+management = Usergrid::Resource.new(SPEC_SETTINGS[:api_url]).management
+management.login SPEC_SETTINGS[:management][:username], SPEC_SETTINGS[:management][:password]
+
+begin
+  management.create_organization(SPEC_SETTINGS[:organization][:name],
+                                 SPEC_SETTINGS[:organization][:username],
+                                 SPEC_SETTINGS[:organization][:username],
+                                 "#{SPEC_SETTINGS[:organization][:username]}@email.com",
+                                 SPEC_SETTINGS[:organization][:password])
+  LOG.info "created organization with user #{SPEC_SETTINGS[:organization][:username]}@email.com"
+rescue
+  if JSON($!.response)['error'] == "duplicate_unique_property_exists"
+    LOG.debug "test organization exists"
+  else
+    raise $!
+  end
+end
+
+def app_endpoint
+  "#{SPEC_SETTINGS[:organization][:name]}/#{SPEC_SETTINGS[:application][:name]}"
+end
+
+def org_endpoint
+  "#{SPEC_SETTINGS[:organization][:name]}"
+end
+
+def create_random_application
+  management = login_management
+  organization = management.organization SPEC_SETTINGS[:organization][:name]
+
+  app_name = "_test_app_#{SecureRandom.hex}"
+  organization.create_application app_name
+  management.application SPEC_SETTINGS[:organization][:name], app_name
+end
+
+def delete_application(application)
+  management = login_management
+  application.auth_token = management.auth_token
+  application.delete
+end
+
+def create_random_user(application, login=false)
+  random = SecureRandom.hex
+  user_hash = {username: "username_#{random}",
+               name:     "#{random} name",
+               email:    "#{random}@email.com",
+               password: random}
+  entity = application['users'].post(user_hash).entity
+  application.login user_hash[:username], user_hash[:password] if login
+  entity
+end
+
+def login_management
+  management = Usergrid::Resource.new(SPEC_SETTINGS[:api_url]).management
+  management.login SPEC_SETTINGS[:organization][:username], SPEC_SETTINGS[:organization][:password]
+  management
+end