stormpath-sdk 1.0.0.beta.4 → 1.0.0.beta.5

data/.gitignore

@@ -11,3 +11,4 @@ spec/fixtures/vcr_cassettes
 Guardfile
 tmp/*
 *.gem
+.bundle/

data/CHANGES.md

@@ -1,6 +1,21 @@
 stormpath-sdk-ruby Changelog
 ============================
 
+Version 1.0.0.beta.5
+--------------------
+
+Released on March 3, 2014
+
+- Added the Custom Data resource
+- Added CustomDataStorage module
+- Specify an AccountStore during authentication
+- Added AccountStatus module (specialization of the Status module)
+- Added Status spec
+- Added AccountMemberships
+- Added GroupMemberships spec
+- Send only dirty properties to the API
+- Fixed REDIRECTS_LIMIT issue
+
 Version 1.0.0.beta.4
 --------------------
 

data/README.md

@@ -1,4 +1,4 @@
-[![Build Status](https://api.travis-ci.org/stormpath/stormpath-sdk-ruby.png?branch=master)](https://travis-ci.org/stormpath/stormpath-sdk-ruby)
+[![Build Status](https://api.travis-ci.org/stormpath/stormpath-sdk-ruby.png?branch=master,development)](https://travis-ci.org/stormpath/stormpath-sdk-ruby)
 
 # Stormpath Ruby SDK
 
@@ -416,7 +416,7 @@ Group membership can be created by:
 * Explicitly creating a group membership resource with your client:
 
   ```ruby
-  group_memebership = client.group_memberships.create group, account
+  group_membership = client.group_memberships.create group: group, account: account
   ```
 
 * Using the <code>add_group</code> method on the account instance:
@@ -428,11 +428,43 @@ Group membership can be created by:
 * Using the <code>add_account</code> method on the group instance:
 
   ```ruby
-  group.add_group account
+  group.add_account account
   ```
 
 You will need to reload the account or group resource after these
 operations to ensure they've picked up the changes.
+### Add Custom Data to Accounts or Groups
+
+Account and Group resources have predefined fields that are useful to many applications, but you are likely to have your own custom data that you need to associate with an account or group as well.
+
+For this reason, both the account and group resources support a linked custom_data resource that you can use for your own needs.
+
+*Set Custom Data*
+```ruby
+account =  Stormpath::Resource::Account.new({ email: "test@example.com", given_name: 'Ruby SDK', password: 'P@$$w0rd', surname: 'SDK',})
+
+account.custom_data["rank"] = "Captain"
+account.custom_data["birth_date"] = "2305-07-13"
+account.custom_data["birth_place"] = "La Barre, France"
+
+ directory.create_account account
+```
+
+Notice how we did not call account.custom_data.save - creating the account (or updating it later via save) will automatically persist the account's customData resource. The account 'knows' that the custom data resource has been changed and it will propogate those changes automatically when you persist the account.
+
+Groups work the same way - you can save a group and it's custom data resource will be saved as well.
+
+*Delete a specific Custom Data field*
+```ruby
+account.custom_data["birth_date"] #=> "2305-07-13"
+account.custom_data.delete("birth_date")
+account.custom_data.save
+```
+
+*Delete all Custom Data*
+```ruby
+account.custom_data.delete
+```
 
 ## Testing
 

data/lib/stormpath-sdk.rb

@@ -25,28 +25,27 @@ module Stormpath
   module Resource
     autoload :Expansion, 'stormpath-sdk/resource/expansion'
     autoload :Status, 'stormpath-sdk/resource/status'
+    autoload :AccountStatus, 'stormpath-sdk/resource/account_status'
     autoload :Utils, 'stormpath-sdk/resource/utils'
     autoload :Associations, 'stormpath-sdk/resource/associations'
     autoload :Base, 'stormpath-sdk/resource/base'
     autoload :Error, 'stormpath-sdk/resource/error'
     autoload :Instance, 'stormpath-sdk/resource/instance'
     autoload :Collection, 'stormpath-sdk/resource/collection'
+    autoload :CustomData, 'stormpath-sdk/resource/custom_data'
+    autoload :CustomDataStorage, 'stormpath-sdk/resource/custom_data_storage'
+    autoload :CustomDataHashMethods, 'stormpath-sdk/resource/custom_data_hash_methods'
     autoload :Tenant, 'stormpath-sdk/resource/tenant'
     autoload :Application, 'stormpath-sdk/resource/application'
-    autoload :Applications, 'stormpath-sdk/resource/applications'
     autoload :Directory, 'stormpath-sdk/resource/directory'
-    autoload :Directories, 'stormpath-sdk/resource/directories'
     autoload :Account, 'stormpath-sdk/resource/account'
-    autoload :Accounts, 'stormpath-sdk/resource/accounts'
     autoload :AccountStore, 'stormpath-sdk/resource/account_store'
     autoload :AccountStoreMapping, 'stormpath-sdk/resource/account_store_mapping'
     autoload :Group, 'stormpath-sdk/resource/group'
-    autoload :Groups, 'stormpath-sdk/resource/groups'
     autoload :EmailVerificationToken, 'stormpath-sdk/resource/email_verification_token'
     autoload :GroupMembership, 'stormpath-sdk/resource/group_membership'
-    autoload :GroupMemberships, 'stormpath-sdk/resource/group_memberships'
+    autoload :AccountMembership, 'stormpath-sdk/resource/account_membership'
     autoload :PasswordResetToken, 'stormpath-sdk/resource/password_reset_token'
-    autoload :PasswordResetTokens, 'stormpath-sdk/resource/password_reset_tokens'
   end
 
   module Cache

data/lib/stormpath-sdk/auth/basic_authenticator.rb

@@ -40,6 +40,8 @@ module Stormpath
         attempt.type = 'basic'
         attempt.value = value
 
+        attempt.account_store = request.account_store if request.account_store
+
         href = parent_href + '/loginAttempts'
 
         @data_store.create href, attempt, AuthenticationResult

data/lib/stormpath-sdk/auth/basic_login_attempt.rb

@@ -19,6 +19,17 @@ module Stormpath
 
       TYPE = "type"
       VALUE = "value"
+      ACCOUNT_STORE = "account_store"
+
+      def account_store
+        get_property ACCOUNT_STORE
+      end
+
+      def account_store=(account_store)
+        if account_store.kind_of? Stormpath::Resource::Base
+          set_property ACCOUNT_STORE, {HREF_PROP_NAME => account_store.href}
+        end
+      end
 
       def type
         get_property TYPE

data/lib/stormpath-sdk/auth/username_password_request.rb

@@ -14,17 +14,16 @@
 # limitations under the License.
 #
 module Stormpath
-
   module Authentication
-
     class UsernamePasswordRequest
 
-      attr_reader :host
+      attr_reader :host, :account_store
 
-      def initialize username, password, host = nil
+      def initialize username, password, options = {}
         @username = username
         @password = (password != nil and password.length > 0) ? password.chars.to_a : "".chars.to_a
-        @host = host
+        @host = options[:host]
+        @account_store = options[:account_store]
       end
 
       def principals
@@ -38,18 +37,13 @@ module Stormpath
       def clear
         @username = nil
         @host = nil
+        @account_store = nil
 
-        @password.each { |pass_char|
-
-          pass_char = 0x00
-        }
-
+        @password.each { |pass_char| pass_char = 0x00 }
         @password = nil
       end
 
     end
-
   end
-
 end
 

data/lib/stormpath-sdk/data_store.rb

@@ -19,16 +19,17 @@ class Stormpath::DataStore
 
   DEFAULT_SERVER_HOST = "api.stormpath.com"
   DEFAULT_API_VERSION = 1
+  HREF_PROP_NAME = Stormpath::Resource::Base::HREF_PROP_NAME
 
-  CACHE_REGIONS = %w( applications directories accounts groups groupMemberships tenants )
+  CACHE_REGIONS = %w( applications directories accounts groups groupMemberships accountMemberships tenants customData )
 
-  attr_reader :client, :request_executor
+  attr_reader :client, :request_executor, :cache_manager
 
-  def initialize(request_executor, cache_opts, client, *base_url)
+  def initialize(request_executor, cache_opts, client, base_url = nil)
     assert_not_nil request_executor, "RequestExecutor cannot be null."
 
     @client = client
-    @base_url = get_base_url(*base_url)
+    @base_url = get_base_url(base_url)
     @request_executor = request_executor
     initialize_cache cache_opts
   end
@@ -48,11 +49,7 @@ class Stormpath::DataStore
   end
 
   def get_resource(href, clazz, query=nil)
-    q_href = if needs_to_be_fully_qualified href
-               qualify href
-             else
-               href
-             end
+    q_href = qualify href
 
     data = execute_request('get', q_href, nil, query)
     instantiate clazz, data.to_hash
@@ -63,7 +60,7 @@ class Stormpath::DataStore
     parent_href = "#{parent_href}?#{URI.encode_www_form(options)}" unless options.empty?
     save_resource(parent_href, resource, return_type).tap do |returned_resource|
       if resource.kind_of? return_type
-        resource.set_properties to_hash(returned_resource)
+        resource.set_properties returned_resource.properties
       end
     end
   end
@@ -73,13 +70,10 @@ class Stormpath::DataStore
     assert_kind_of Stormpath::Resource::Base, resource, "resource argument must be instance of Stormpath::Resource::Base"
 
     href = resource.href
+    assert_not_nil href, "href or resource.href cannot be null."
     assert_true href.length > 0, "save may only be called on objects that have already been persisted (i.e. they have an existing href)."
 
-    href = if needs_to_be_fully_qualified(href)
-             qualify(href)
-           else
-             href
-           end
+    href = qualify(href)
 
     clazz ||= resource.class
 
@@ -88,156 +82,153 @@ class Stormpath::DataStore
     end
   end
 
-  def delete(resource)
+  def delete(resource, property_name = nil)
     assert_not_nil resource, "resource argument cannot be null."
     assert_kind_of Stormpath::Resource::Base, resource, "resource argument must be instance of Stormpath::Resource::Base"
 
-    execute_request('delete', resource.href)
+    href = resource.href
+    href += "/#{property_name}" if property_name
+    href = qualify(href)
+   
+    execute_request('delete', href)
   end
 
-  def cache_manager
-    @cache_manager
-  end
+  private
 
-  protected
+    def needs_to_be_fully_qualified(href)
+      !href.downcase.start_with? 'http'
+    end
 
-  def needs_to_be_fully_qualified(href)
-    !href.downcase.start_with? 'http'
-  end
+    def qualify(href)
+      if needs_to_be_fully_qualified(href)
+        slash_added = href.start_with?('/') ? '' : '/'
+        @base_url + slash_added + href
+      else
+        href
+      end
+    end
 
-  def qualify(href)
-    slash_added = ''
+    def execute_request(http_method, href, body=nil, query=nil)
+      if http_method == 'get' && (cache = cache_for href)
+        cached_result = cache.get href
+        return cached_result if cached_result
+      end
 
-    if !href.start_with? '/'
-      slash_added = '/'
-    end
+      request = Request.new(http_method, href, query, Hash.new, body)
+      apply_default_request_headers request
+      response = @request_executor.execute_request request
+      result = response.body.length > 0 ? MultiJson.load(response.body) : ''
 
-    @base_url + slash_added + href
-  end
+      if response.error?
+        error = Stormpath::Resource::Error.new result
+        #puts "Error with request: #{http_method.upcase}: #{href}"
+        raise Stormpath::Error.new error
+      end
 
-  private
+      if http_method == 'delete'
+        cache = cache_for href
+        cache.delete href if cache
+        return nil
+      end
 
-  def execute_request(http_method, href, body=nil, query=nil)
-    if http_method == 'get' && (cache = cache_for href)
-      cached_result = cache.get href
-      return cached_result if cached_result
+      if result['href']
+        cache_walk result
+      else
+        result
+      end
     end
 
-    request = Request.new(http_method, href, query, Hash.new, body)
-    apply_default_request_headers request
-    response = @request_executor.execute_request request
+    def cache_walk(resource)
+      assert_not_nil resource['href'], "resource must have 'href' property"
+      items = resource['items']
 
-    result = response.body.length > 0 ? MultiJson.load(response.body) : ''
+      if items # collection resource
+        resource['items'] = items.map do |item|
+          cache_walk item
+          { 'href' => item['href'] }
+        end
+      else     # single resource
+        resource.each do |attr, value|
+          if value.is_a? Hash and value['href']
+            walked = cache_walk value
+            resource[attr] = { 'href' => value['href'] } if value["href"]
+            resource[attr]['items'] = walked['items'] if walked['items']
+          end
+        end
+        cache resource if resource.length > 1
+      end
+      resource
+    end
 
-    if response.error?
-      error = Stormpath::Resource::Error.new result
-      #puts "Error with request: #{http_method.upcase}: #{href}"
-      raise Stormpath::Error.new error
+    def cache(resource)
+      cache = cache_for resource['href']
+      cache.put resource['href'], resource if cache
     end
 
-    if http_method == 'delete'
-      cache = cache_for href
-      cache.delete href if cache
-      return nil
+    def cache_for(href)
+      @cache_manager.get_cache(region_for href)
     end
 
-    if result['href']
-      cache_walk result
-    else
-      result
+    def region_for(href)
+      return nil unless href
+      if href.include? "/customData"
+        region = href.split('/')[-1]
+      else
+        region = href.split('/')[-2]
+      end
+      CACHE_REGIONS.include?(region) ? region : nil
     end
-  end
 
-  def cache_walk(resource)
-    assert_not_nil resource['href'], "resource must have 'href' property"
-    items = resource['items']
+    def apply_default_request_headers(request)
+      request.http_headers.store 'Accept', 'application/json'
+      request.http_headers.store 'User-Agent', 'Stormpath-RubySDK/' + Stormpath::VERSION
 
-    if items # collection resource
-      resource['items'] = items.map do |item|
-        cache_walk item
-        { 'href' => item['href'] }
-      end
-    else     # single resource
-      resource.each do |attr, value|
-        if value.is_a? Hash
-          walked = cache_walk value
-          resource[attr] = { 'href' => value['href'] }
-          resource[attr]['items'] = walked['items'] if walked['items']
-        end
+      if !request.body.nil? and request.body.length > 0
+        request.http_headers.store 'Content-Type', 'application/json'
       end
-      cache resource if resource.length > 1
     end
-    resource
-  end
-
-  def cache(resource)
-    cache = cache_for resource['href']
-    cache.put resource['href'], resource if cache
-  end
 
-  def cache_for(href)
-    @cache_manager.get_cache(region_for href)
-  end
+    def save_resource(href, resource, return_type)
+      assert_not_nil resource, "resource argument cannot be null."
+      assert_not_nil return_type, "returnType class cannot be null."
+      assert_kind_of Stormpath::Resource::Base, resource, "resource argument must be instance of Stormpath::Resource::Base"
 
-  def region_for(href)
-    return nil unless href
-    region = href.split('/')[-2]
-    CACHE_REGIONS.include?(region) ? region : nil
-  end
+      q_href = qualify href
 
-  def apply_default_request_headers(request)
-    request.http_headers.store 'Accept', 'application/json'
-    request.http_headers.store 'User-Agent', 'Stormpath-RubySDK/' + Stormpath::VERSION
+      response = execute_request('post', q_href, MultiJson.dump(to_hash(resource)))
 
-    if !request.body.nil? and request.body.length > 0
-      request.http_headers.store 'Content-Type', 'application/json'
+      instantiate return_type, response.to_hash
     end
-  end
-
-  def save_resource(href, resource, return_type)
-    assert_not_nil resource, "resource argument cannot be null."
-    assert_not_nil return_type, "returnType class cannot be null."
-    assert_kind_of Stormpath::Resource::Base, resource, "resource argument must be instance of Stormpath::Resource::Base"
-
-    q_href = if needs_to_be_fully_qualified href
-               qualify href
-             else
-               href
-             end
 
-    response = execute_request('post', q_href, MultiJson.dump(to_hash(resource)))
-    instantiate return_type, response.to_hash
-  end
+    def get_base_url(base_url)
+        base_url || "https://" + DEFAULT_SERVER_HOST + "/v" + DEFAULT_API_VERSION.to_s
+    end
 
-  def get_base_url(*base_url)
-    (!base_url.empty? and !base_url[0].nil?) ?
-      base_url[0] :
-      "https://" + DEFAULT_SERVER_HOST + "/v" + DEFAULT_API_VERSION.to_s
-  end
+    def to_hash(resource)
+      Hash.new.tap do |properties|
+        resource.get_dirty_property_names.each do |name|
+          property = resource.get_property name
 
-  def to_hash(resource)
-    Hash.new.tap do |properties|
-      resource.get_property_names.each do |name|
-        property = resource.get_property name
+          # Special use case is with Custom Data, it's hashes should not be simplified
+          if property.kind_of?(Hash) and resource_not_custom_data resource, name
+            property = to_simple_reference name, property
+          end
 
-        if property.kind_of? Hash
-          property = to_simple_reference name, property
+          properties.store name, property
         end
-
-        properties.store name, property
       end
     end
-  end
 
-  def to_simple_reference(property_name, hash)
-    href_prop_name = Stormpath::Resource::Base::HREF_PROP_NAME
-    assert_true(
-      (hash.kind_of?(Hash) and !hash.empty? and hash.has_key?(href_prop_name)),
-      "Nested resource '#{property_name}' must have an 'href' property."
-    )
+    def to_simple_reference(property_name, hash)
+      assert_true hash.has_key?(HREF_PROP_NAME), "Nested resource '#{property_name}' must have an 'href' property."
 
-    href = hash[href_prop_name]
+      href = hash[HREF_PROP_NAME]
+
+      {HREF_PROP_NAME => href}
+    end
+
+    def resource_not_custom_data resource, name
+      resource.class != Stormpath::Resource::CustomData and name != "customData"
+    end
 
-    {href_prop_name => href}
-  end
 end