stormpath-sdk 1.6.0 → 1.7.0

data/lib/stormpath-sdk/cache/cache_manager.rb

@@ -1,13 +1,12 @@
 module Stormpath
   module Cache
     class CacheManager
-
-      def initialize(opts = nil)
+      def initialize(_opts = nil)
         @caches = {}
       end
 
       def create_cache(region, opts)
-        @caches[region] = Cache.new opts
+        @caches[region] = Cache.new(opts)
       end
 
       def get_cache(region)
@@ -15,7 +14,7 @@ module Stormpath
       end
 
       def stats
-        Hash[ @caches.map { |region, cache| [region, cache.stats] } ]
+        Hash[@caches.map { |region, cache| [region, cache.stats] }]
       end
     end
   end

data/lib/stormpath-sdk/cache/cache_stats.rb

@@ -22,9 +22,7 @@ module Stormpath
       end
 
       def delete
-        if @size > 0
-          @size -= 1
-        end
+        @size -= 1 if @size > 0
       end
 
       def summary

data/lib/stormpath-sdk/cache/disabled_cache_store.rb

@@ -1,18 +1,15 @@
 module Stormpath
   module Cache
     class DisabledCacheStore
-      def initialize(opts = nil)
-      end
+      def initialize(opts = nil); end
 
-      def get(key)
-      end
+      def get(key); end
 
-      def put(key, entry)
+      def put(_key, entry)
         entry
       end
 
-      def delete(key)
-      end
+      def delete(key); end
 
       def clear
         {}
@@ -23,4 +20,4 @@ module Stormpath
       end
     end
   end
-end
+end

data/lib/stormpath-sdk/cache/memory_store.rb

@@ -14,7 +14,7 @@ module Stormpath
       end
 
       def delete(key)
-        @store.delete key
+        @store.delete(key)
       end
 
       def clear

data/lib/stormpath-sdk/cache/redis_store.rb

@@ -4,20 +4,20 @@ module Stormpath
   module Cache
     class RedisStore
       def initialize(opts = {})
-        @redis = Redis.new opts
+        @redis = Redis.new(opts)
       end
 
       def get(key)
-        entry = @redis.get key
+        entry = @redis.get(key)
         entry && Stormpath::Cache::CacheEntry.from_h(MultiJson.load(entry))
       end
 
       def put(key, entry)
-        @redis.set key, MultiJson.dump(entry.to_h)
+        @redis.set(key, MultiJson.dump(entry.to_h))
       end
 
       def delete(key)
-        @redis.del key
+        @redis.del(key)
       end
 
       def clear

data/lib/stormpath-sdk/client.rb

@@ -28,7 +28,7 @@ module Stormpath
 
       api_key = ApiKey(options)
 
-      assert_not_nil api_key, "No API key has been provided. Please pass an 'api_key' or " +
+      assert_not_nil api_key, "No API key has been provided. Please pass an 'api_key' or " \
                               "'api_key_file_location' to the Stormpath::Client constructor."
 
       request_executor = Stormpath::Http::HttpClientRequestExecutor.new(proxy: options[:proxy])
@@ -36,7 +36,7 @@ module Stormpath
     end
 
     def tenant(expansion = nil)
-      tenants.get 'current', expansion
+      tenants.get('current', expansion)
     end
 
     def client
@@ -49,7 +49,7 @@ module Stormpath
     has_many :accounts, href: '/accounts', can: :get do
       def verify_email_token(token)
         token_href = "#{href}/emailVerificationTokens/#{token}"
-        token = Stormpath::Resource::EmailVerificationToken.new token_href, client
+        token = Stormpath::Resource::EmailVerificationToken.new(token_href, client)
         data_store.save token, Stormpath::Resource::Account
       end
     end
@@ -61,46 +61,48 @@ module Stormpath
     has_many :access_tokens, href: '/accessTokens', can: [:get]
     has_many :refresh_tokens, href: '/refreshTokens', can: [:get]
     has_many :account_links, href: '/accountLinks', can: :create
+    has_many :registered_saml_service_providers, href: '/registeredSamlServiceProviders', can: :create
 
     private
 
-      def ApiKey(options={})
-        if api_key = options[:api_key]
-          case api_key
-          when ApiKey then api_key
-          when Hash then ApiKey.new api_key[:id], api_key[:secret]
-          end
-        elsif options[:api_key_file_location]
-          load_api_key_file(options[:api_key_file_location],
-                            options[:api_key_id_property_name],
-                            options[:api_key_secret_property_name])
+    def ApiKey(options = {})
+      if api_key = options[:api_key]
+        case api_key
+        when ApiKey then api_key
+        when Hash then ApiKey.new(api_key[:id], api_key[:secret])
         end
+      elsif options[:api_key_file_location]
+        load_api_key_file(
+          options[:api_key_file_location],
+          options[:api_key_id_property_name],
+          options[:api_key_secret_property_name]
+        )
       end
+    end
 
-      def load_api_key_file api_key_file_location, id_property_name, secret_property_name
-        begin
-          api_key_properties = JavaProperties::Properties.new api_key_file_location
-        rescue
-          raise ArgumentError, "No API Key file could be found or loaded from '#{api_key_file_location}'."
-        end
-
-        id_property_name ||= 'apiKey.id'
-        secret_property_name ||= 'apiKey.secret'
+    def load_api_key_file(api_key_file_location, id_property_name, secret_property_name)
+      begin
+        api_key_properties = JavaProperties::Properties.new(api_key_file_location)
+      rescue
+        raise ArgumentError, "No API Key file could be found or loaded from '#{api_key_file_location}'."
+      end
 
-        api_key_id = api_key_properties[id_property_name]
-        assert_not_nil api_key_id, api_key_warning_message(:id, api_key_file_location)
+      id_property_name ||= 'apiKey.id'
+      secret_property_name ||= 'apiKey.secret'
 
-        api_key_secret = api_key_properties[secret_property_name]
-        assert_not_nil api_key_secret, api_key_warning_message(:secret, api_key_file_location)
+      api_key_id = api_key_properties[id_property_name]
+      assert_not_nil api_key_id, api_key_warning_message(:id, api_key_file_location)
 
-        ApiKey.new api_key_id, api_key_secret
-      end
+      api_key_secret = api_key_properties[secret_property_name]
+      assert_not_nil api_key_secret, api_key_warning_message(:secret, api_key_file_location)
 
-      def api_key_warning_message id_or_secret, api_key_file_location
-        "No API #{id_or_secret} in properties. Please provide a 'apiKey.#{id_or_secret}' property " +
-        "in '#{api_key_file_location}' or pass in an 'api_key_#{id_or_secret}_property_name' " +
-        "to the Stormpath::Client constructor to specify an alternative property."
-      end
+      ApiKey.new(api_key_id, api_key_secret)
+    end
 
+    def api_key_warning_message(id_or_secret, api_key_file_location)
+      "No API #{id_or_secret} in properties. Please provide a 'apiKey.#{id_or_secret}' property " \
+        "in '#{api_key_file_location}' or pass in an 'api_key_#{id_or_secret}_property_name' " \
+        'to the Stormpath::Client constructor to specify an alternative property.'
+    end
   end
 end

data/lib/stormpath-sdk/data_store.rb

@@ -13,346 +13,367 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-class Stormpath::DataStore
-  include Stormpath::Http
-  include Stormpath::Util::Assert
+module Stormpath
+  class DataStore
+    include Stormpath::Http
+    include Stormpath::Util::Assert
 
-  DEFAULT_SERVER_HOST = "api.stormpath.com"
-  DEFAULT_API_VERSION = 1
-  DEFAULT_BASE_URL = "https://" + DEFAULT_SERVER_HOST + "/v" + DEFAULT_API_VERSION.to_s
-  HREF_PROP_NAME = Stormpath::Resource::Base::HREF_PROP_NAME
+    DEFAULT_SERVER_HOST = 'api.stormpath.com'.freeze
+    DEFAULT_API_VERSION = 1
+    DEFAULT_BASE_URL = 'https://' + DEFAULT_SERVER_HOST + '/v' + DEFAULT_API_VERSION.to_s
+    HREF_PROP_NAME = Stormpath::Resource::Base::HREF_PROP_NAME
 
-  CACHE_REGIONS = %w(applications directories accounts groups groupMemberships accountMemberships tenants customData provider providerData)
+    CACHE_REGIONS = %w(applications directories accounts groups groupMemberships accountMemberships
+                       tenants customData provider providerData).freeze
 
-  attr_reader :client, :request_executor, :cache_manager, :api_key, :base_url
+    attr_reader :client, :request_executor, :cache_manager, :api_key, :base_url
 
-  def initialize(request_executor, api_key, cache_opts, client, base_url = nil)
-    assert_not_nil request_executor, "RequestExecutor cannot be null."
+    def initialize(request_executor, api_key, cache_opts, client, base_url = nil)
+      assert_not_nil request_executor, 'RequestExecutor cannot be null.'
 
-    @client = client
-    @base_url = base_url || DEFAULT_BASE_URL
-    @request_executor = request_executor
-    @api_key = api_key
-    initialize_cache cache_opts
-  end
+      @client = client
+      @base_url = base_url || DEFAULT_BASE_URL
+      @request_executor = request_executor
+      @api_key = api_key
+      initialize_cache(cache_opts)
+    end
 
-  def initialize_cache(cache_opts)
-    @cache_manager = Stormpath::Cache::CacheManager.new
-    regions_opts = cache_opts[:regions] || {}
-    CACHE_REGIONS.each do |region|
-      region_opts = regions_opts[region.to_sym] || {}
-      region_opts[:store] ||= cache_opts[:store]
-      region_opts[:store_opts] ||= cache_opts[:store_opts]
-      @cache_manager.create_cache region, region_opts
+    def initialize_cache(cache_opts)
+      @cache_manager = Stormpath::Cache::CacheManager.new
+      regions_opts = cache_opts[:regions] || {}
+      CACHE_REGIONS.each do |region|
+        region_opts = regions_opts[region.to_sym] || {}
+        region_opts[:store] ||= cache_opts[:store]
+        region_opts[:store_opts] ||= cache_opts[:store_opts]
+        @cache_manager.create_cache(region, region_opts)
+      end
     end
-  end
 
-  def instantiate(clazz, properties = {})
-    clazz.new properties, client
-  end
+    def instantiate(clazz, properties = {})
+      clazz.new(properties, client)
+    end
 
-  def get_resource(href, clazz, query=nil)
-    q_href = qualify href
+    def get_resource(href, clazz, query = nil)
+      q_href = qualify href
 
-    data = execute_request('get', q_href, nil, query)
+      data = execute_request('get', q_href, nil, query)
 
-    clazz = clazz.call(data) if clazz.respond_to? :call
+      clazz = clazz.call(data) if clazz.respond_to? :call
 
-    instantiate clazz, data.to_hash
-  end
+      instantiate(clazz, data.to_hash)
+    end
 
-  def create(parent_href, resource, return_type, options = {})
-    #TODO assuming there is no ? in url
-    parent_href = "#{parent_href}?#{URI.encode_www_form(options)}" unless options.empty?
+    def create(parent_href, resource, return_type, options = {})
+      # TODO: assuming there is no ? in url
+      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 returned_resource.properties
+      save_resource(parent_href, resource, return_type).tap do |returned_resource|
+        if resource.is_a?(return_type)
+          resource.set_properties(returned_resource.properties)
+        end
       end
     end
-  end
-
-  def save(resource, clazz = 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"
-    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 = qualify(href)
-
-    clazz ||= resource.class
+    def save(resource, clazz = 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'
+      )
+      href = resource.href
+      assert_not_nil(href, 'href or resource.href cannot be null.')
+      assert_true(
+        !href.empty?,
+        'save may only be called on objects that have already been persisted'\
+        ' (i.e. they have an existing href).'
+      )
+
+      href = qualify(href)
+
+      clazz ||= resource.class
+
+      save_resource(href, resource, clazz).tap do |return_value|
+        resource.set_properties(return_value)
+      end
+    end
 
-    save_resource(href, resource, clazz).tap do |return_value|
-      resource.set_properties return_value
+    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'
+      )
+
+      href = resource.href
+      href += "/#{property_name}" if property_name
+      href = qualify(href)
+
+      execute_request('delete', href)
+      clear_cache_on_delete(href)
+      nil
     end
-  end
 
-  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"
+    def execute_raw_request(href, body, klass)
+      request = Request.new('POST', href, nil, {}, body.to_json, @api_key)
+      apply_default_request_headers(request)
+      response = @request_executor.execute_request(request)
+      result = !response.body.empty? ? MultiJson.load(response.body) : ''
 
-    href = resource.href
-    href += "/#{property_name}" if property_name
-    href = qualify(href)
+      if response.error?
+        error = Stormpath::Resource::Error.new(result)
+        raise Stormpath::Error, error
+      end
 
-    execute_request('delete', href)
-    clear_cache_on_delete(href)
-    return nil
-  end
+      cache_walk(result)
+      instantiate(klass, result)
+    end
 
-  def execute_raw_request(href, body, klass)
-    request = Request.new('POST', href, nil, {}, body.to_json, @api_key)
-    apply_default_request_headers(request)
-    response = @request_executor.execute_request(request)
-    result = response.body.length > 0 ? MultiJson.load(response.body) : ''
+    private
 
-    if response.error?
-      error = Stormpath::Resource::Error.new result
-      raise Stormpath::Error.new(error)
+    def needs_to_be_fully_qualified?(href)
+      !href.downcase.start_with?('http')
     end
 
-    cache_walk(result)
-    instantiate(klass, result)
-  end
+    def qualify(href)
+      needs_to_be_fully_qualified?(href) ? @base_url + href : href
+    end
 
-  private
+    def execute_request(http_method, href, resource = nil, query = nil)
+      if http_method == 'get' && (cache = cache_for href)
+        cached_result = cache.get(href)
+        return cached_result if cached_result
+      end
 
-  def needs_to_be_fully_qualified?(href)
-    !href.downcase.start_with? 'http'
-  end
+      body = extract_body_from_resource(resource)
 
-  def qualify(href)
-    needs_to_be_fully_qualified?(href) ? @base_url + href : href
-  end
+      request = Request.new(http_method, href, query, {}, body, @api_key)
 
-  def execute_request(http_method, href, resource=nil, query=nil)
-    if http_method == 'get' && (cache = cache_for href)
-      cached_result = cache.get href
-      return cached_result if cached_result
-    end
+      if resource.try(:form_data?)
+        apply_form_data_request_headers(request)
+      else
+        apply_default_request_headers(request)
+      end
 
-    body = extract_body_from_resource(resource)
+      response = @request_executor.execute_request(request)
 
-    request = Request.new(http_method, href, query, Hash.new, body, @api_key)
+      result = !response.body.empty? ? MultiJson.load(response.body) : ''
 
-    if resource.try(:form_data?)
-      apply_form_data_request_headers request
-    else
-      apply_default_request_headers request
-    end
+      if response.error?
+        error = Stormpath::Resource::Error.new(result)
+        raise Stormpath::Error, error
+      end
 
-    response = @request_executor.execute_request request
+      if resource.is_a?(Stormpath::Provider::AccountAccess)
+        is_new_account = response.http_status == 201
+        result = { is_new_account: is_new_account, account: result }
+      end
 
-    result = response.body.length > 0 ? MultiJson.load(response.body) : ''
+      return if http_method == 'delete'
 
-    if response.error?
-      error = Stormpath::Resource::Error.new result
-      raise Stormpath::Error.new error
+      if result[HREF_PROP_NAME] && !resource_is_saml_mapping_rules?(resource) && !user_info_mapping_rules?(resource)
+        cache_walk result
+      else
+        result
+      end
     end
 
-    if resource.is_a? Stormpath::Provider::AccountAccess
-      is_new_account = response.http_status == 201
-      result = {is_new_account: is_new_account, account: result }
+    def clear_cache_on_delete(href)
+      if href =~ custom_data_delete_field_url_regex
+        href = href.split('/')[0..-2].join('/')
+      end
+      clear_cache(href)
     end
 
-    return if http_method == 'delete'
-
-    if result[HREF_PROP_NAME] && !resource_is_saml_mapping_rules?(resource) && !user_info_mapping_rules?(resource)
-      cache_walk result
-    else
-      result
+    def custom_data_delete_field_url_regex
+      /#{@base_url}\/(accounts|groups)\/\w+\/customData\/\w+[\/]{0,1}$/
     end
-  end
 
-  def clear_cache_on_delete href
-    if href =~ custom_data_delete_field_url_regex
-      href = href.split('/')[0..-2].join('/')
+    def clear_cache(href)
+      cache = cache_for(href)
+      cache.delete(href) if cache
     end
-    clear_cache href
-  end
 
-  def custom_data_delete_field_url_regex
-    /#{@base_url}\/(accounts|groups)\/\w+\/customData\/\w+[\/]{0,1}$/
-  end
-
-  def clear_cache(href)
-    cache = cache_for href
-    cache.delete href if cache
-  end
+    def cache_walk(resource)
+      assert_not_nil(resource[HREF_PROP_NAME], "resource must have 'href' property")
+      items = resource['items']
 
-  def cache_walk(resource)
-    assert_not_nil resource[HREF_PROP_NAME], "resource must have 'href' property"
-    items = resource['items']
-
-    if items # collection resource
-      resource['items'] = items.map do |item|
-        cache_walk item
-        { HREF_PROP_NAME => item[HREF_PROP_NAME] }
-      end
-    else     # single resource
-      resource.each do |attr, value|
-        if value.is_a? Hash and value[HREF_PROP_NAME]
-          walked = cache_walk value
+      if items # collection resource
+        resource['items'] = items.map do |item|
+          cache_walk(item)
+          { HREF_PROP_NAME => item[HREF_PROP_NAME] }
+        end
+      else     # single resource
+        resource.each do |attr, value|
+          next unless value.is_a?(Hash) && value[HREF_PROP_NAME]
+          walked = cache_walk(value)
           resource[attr] = { HREF_PROP_NAME => value[HREF_PROP_NAME] }
           resource[attr]['items'] = walked['items'] if walked['items']
         end
+        cache(resource) if resource.length > 1
       end
-      cache resource if resource.length > 1
+      resource
     end
-    resource
-  end
-
-  def cache(resource)
-    cache = cache_for resource[HREF_PROP_NAME]
-    cache.put resource[HREF_PROP_NAME], resource if cache
-  end
-
-  def cache_for(href)
-    @cache_manager.get_cache(region_for href)
-  end
 
-  def region_for(href)
-    return nil if href.nil?
-    if href.include? "/customData"
-      region = href.split('/')[-1]
-    else
-      region = href.split('/')[-2]
+    def cache(resource)
+      cache = cache_for(resource[HREF_PROP_NAME])
+      cache.put(resource[HREF_PROP_NAME], resource) if cache
     end
-    CACHE_REGIONS.include?(region) ? region : nil
-  end
-
-  def apply_default_request_headers(request)
-    request.http_headers.store 'Accept', 'application/json'
-    apply_default_user_agent(request)
 
-    if request.body and request.body.length > 0
-      request.http_headers.store 'Content-Type', 'application/json'
+    def cache_for(href)
+      @cache_manager.get_cache(region_for(href))
     end
-  end
 
-  def apply_form_data_request_headers(request)
-    request.http_headers.store 'Content-Type', 'application/x-www-form-urlencoded'
-    apply_default_user_agent(request)
-  end
-
-  def apply_default_user_agent(request)
-    request.http_headers.store 'User-Agent', 'stormpath-sdk-ruby/' + Stormpath::VERSION +
-    " ruby/#{RUBY_VERSION}-p#{RUBY_PATCHLEVEL}" +
-    " " + Gem::Platform.local.os.to_s + "/" + Gem::Platform.local.version.to_s
-  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 = qualify href
-
-    clear_cache_on_save(resource)
+    def region_for(href)
+      return nil if href.nil?
+      region = if href.include?('/customData')
+                 href.split('/')[-1]
+               else
+                 href.split('/')[-2]
+               end
+      CACHE_REGIONS.include?(region) ? region : nil
+    end
 
-    response = execute_request 'post', q_href, resource
+    def apply_default_request_headers(request)
+      request.http_headers.store('Accept', 'application/json')
+      apply_default_user_agent(request)
 
-    instantiate return_type, parse_response(response)
-  end
+      if request.body && !request.body.empty?
+        request.http_headers.store('Content-Type', 'application/json')
+      end
+    end
 
-  def parse_response(response)
-    return {} if response.is_a? String and response.blank?
-    response.to_hash
-  end
+    def apply_form_data_request_headers(request)
+      request.http_headers.store('Content-Type', 'application/x-www-form-urlencoded')
+      apply_default_user_agent(request)
+    end
 
-  def clear_cache_on_save(resource)
-    if resource.is_a? Stormpath::Resource::CustomDataStorage
-      clear_custom_data_cache_on_custom_data_storage_save(resource)
-    elsif resource.is_a? Stormpath::Resource::AccountStoreMapping
-      clear_application_cache_on_account_store_save(resource)
+    def apply_default_user_agent(request)
+      request.http_headers.store(
+        'User-Agent', 'stormpath-sdk-ruby/' + Stormpath::VERSION +
+        " ruby/#{RUBY_VERSION}-p#{RUBY_PATCHLEVEL}" \
+        ' ' + Gem::Platform.local.os.to_s + '/' + Gem::Platform.local.version.to_s
+      )
     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 = qualify(href)
+      clear_cache_on_save(resource)
+      response = execute_request('post', q_href, resource)
+      instantiate(return_type, parse_response(response))
+    end
 
-  def clear_custom_data_cache_on_custom_data_storage_save resource
-    if resource.dirty_properties.has_key? "customData" and resource.new? == false
-      cached_href = resource.href + "/customData"
-      clear_cache cached_href
+    def parse_response(response)
+      return {} if response.is_a?(String) && response.blank?
+      response.to_hash
     end
-  end
 
-  def clear_application_cache_on_account_store_save resource
-    if resource.new?
-      if resource.default_account_store? == true || resource.default_group_store? == true
-        clear_cache resource.application.href
-      end
-    else
-      if resource.dirty_properties["isDefaultAccountStore"] != nil || resource.dirty_properties["isDefaultGroupStore"] != nil
-        clear_cache resource.application.href
+    def clear_cache_on_save(resource)
+      if resource.is_a?(Stormpath::Resource::CustomDataStorage)
+        clear_custom_data_cache_on_custom_data_storage_save(resource)
+      elsif resource.is_a?(Stormpath::Resource::AccountStoreMapping)
+        clear_application_cache_on_account_store_save(resource)
       end
     end
-  end
 
-  def extract_body_from_resource(resource)
-    return if resource.nil?
-    form_data = resource.try(:form_data?)
+    def clear_custom_data_cache_on_custom_data_storage_save(resource)
+      if resource.dirty_properties.key?('customData') && (resource.new? == false)
+        cached_href = resource.href + '/customData'
+        clear_cache(cached_href)
+      end
+    end
 
-    if form_data
-      form_request_parse(resource)
-    else
-      MultiJson.dump(to_hash(resource))
+    def clear_application_cache_on_account_store_save(resource)
+      if resource.new?
+        if resource.default_account_store? == true || resource.default_group_store? == true
+          clear_cache(resource.application.href)
+        end
+      else
+        if !resource.dirty_properties['isDefaultAccountStore'].nil? || !resource.dirty_properties['isDefaultGroupStore'].nil?
+          clear_cache(resource.application.href)
+        end
+      end
     end
-  end
 
-  def form_request_parse(resource)
-    URI.encode_www_form(resource.form_properties.to_a)
-  end
+    def extract_body_from_resource(resource)
+      return if resource.nil?
+      form_data = resource.try(:form_data?)
 
-  def to_hash(resource)
-    {}.tap do |properties|
-      resource.get_dirty_property_names.each do |name|
-        ignore_camelcasing = resource_is_custom_data(resource, name)
-        property = resource.get_property name, ignore_camelcasing: ignore_camelcasing
+      if form_data
+        form_request_parse(resource)
+      else
+        MultiJson.dump(to_hash(resource))
+      end
+    end
 
-        # Special use cases are with Custom Data, Provider and ProviderData, their hashes should not be simplified
-        # As of the implementation for MFA, Phone resource is added too
-        if property.is_a?(Hash) && !resource_nested_submittable(resource, name) && name != 'items' && name != 'phone'
-          property = to_simple_reference name, property
-        end
+    def form_request_parse(resource)
+      URI.encode_www_form(resource.form_properties.to_a)
+    end
 
-        if name == 'items' && resource_is_saml_mapping_rules?(resource)
-          property = property.map { |item| item.transform_keys { |key| key.to_s.camelize(:lower).to_sym }  }
+    def to_hash(resource)
+      {}.tap do |properties|
+        resource.get_dirty_property_names.each do |name|
+          ignore_camelcasing = resource_is_custom_data(resource, name)
+          property = resource.get_property name, ignore_camelcasing: ignore_camelcasing
+
+          # Special use cases are with Custom Data, Provider and ProviderData, their hashes should not be simplified
+          # As of the implementation for MFA, Phone resource is added too
+          if property.is_a?(Hash) && !resource_nested_submittable(resource, name) && name != 'items' && name != 'phone'
+            property = to_simple_reference(name, property)
+          end
+
+          if name == 'items' && resource_is_saml_mapping_rules?(resource)
+            property = property.map do |item|
+              item.transform_keys { |key| key.to_s.camelize(:lower).to_sym }
+            end
+          end
+
+          properties.store(name, property)
         end
-
-        properties.store name, property
       end
     end
-  end
 
-  def to_simple_reference(property_name, hash)
-    assert_true hash.key?(HREF_PROP_NAME), "Nested resource '#{property_name}' must have an 'href' property."
+    def to_simple_reference(property_name, hash)
+      assert_true(
+        hash.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
+      { HREF_PROP_NAME => href }
+    end
 
-  def resource_nested_submittable(resource, name)
-    ['provider', 'providerData', 'accountStore'].include?(name) ||
-      resource_is_custom_data(resource, name) ||
-      resource_is_application_web_config(resource, name)
-  end
+    def resource_nested_submittable(resource, name)
+      ['provider', 'providerData', 'accountStore'].include?(name) ||
+        resource_is_custom_data(resource, name) ||
+        resource_is_application_web_config(resource, name)
+    end
 
-  def resource_is_custom_data(resource, name)
-    resource.is_a?(Stormpath::Resource::CustomData) || name == 'customData'
-  end
+    def resource_is_custom_data(resource, name)
+      resource.is_a?(Stormpath::Resource::CustomData) || name == 'customData'
+    end
 
-  def resource_is_application_web_config(resource, name)
-    resource.is_a?(Stormpath::Resource::ApplicationWebConfig) &&
-      Stormpath::Resource::ApplicationWebConfig::ENDPOINTS.include?(name.underscore.to_sym)
-  end
+    def resource_is_application_web_config(resource, name)
+      resource.is_a?(Stormpath::Resource::ApplicationWebConfig) &&
+        Stormpath::Resource::ApplicationWebConfig::ENDPOINTS.include?(name.underscore.to_sym)
+    end
 
-  def user_info_mapping_rules?(resource)
-    resource.is_a?(Stormpath::Resource::UserInfoMappingRules)
-  end
+    def resource_is_saml_mapping_rules?(resource)
+      resource.is_a?(Stormpath::Resource::AttributeStatementMappingRules)
+    end
 
-  def resource_is_saml_mapping_rules?(resource)
-    resource.is_a?(Stormpath::Provider::SamlMappingRules)
+    def user_info_mapping_rules?(resource)
+      resource.is_a?(Stormpath::Resource::UserInfoMappingRules)
+    end
   end
 end