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

data/lib/stormpath-sdk/http/utils.rb

@@ -24,28 +24,16 @@ module Stormpath
       end
 
       def encode_url(value, path, canonical)
-        URI.escape(value.to_s).tap do |encoded|
-          if canonical
-            str_map = {'+' => '%20', '*' => '%2A', '%7E' => '~'}
+        return URI.escape(value.to_s) if path
 
-            str_map.each do |key, str_value|
-              if encoded.include? key
-                encoded[key] = str_value
-              end
-            end
-
-            # encoded['%7E'] = '~'  --> yes, this is reversed (compared to the other two) intentionally
-
-            if path
-              str = '%2F'
-              if encoded.include? str
-                encoded[str] = '/'
-              end
-            end
+        CGI.escape(value.to_s).tap do |encoded|
+          str_map = {'+' => '%20', '%7E' => '~' }
+          str_map.each do |key, str_value|
+            encoded.gsub!(key, str_value) if encoded.include? key
           end
         end
       end
 
     end
   end
-end
+end

data/lib/stormpath-sdk/resource/associations.rb

@@ -39,9 +39,7 @@ module Stormpath
 
           define_method(name) do
             href = options[:href] || get_resource_href_property(property_name)
-            collection_href = if options[:delegate]
-              "#{tenant.send(name.to_s).href}"
-            end
+            collection_href = "#{tenant.send(name).href}" if options[:delegate]
 
             Stormpath::Resource::Collection.new(href, item_class, client,
               collection_href: collection_href).tap do |collection|
@@ -57,7 +55,7 @@ module Stormpath
                       end
                     data_store.create href, resource, item_class, options
                   end
-                end
+                end#can.include? :create
 
                 if can.include? :get
                   def get(id_or_href, expansion=nil)
@@ -68,15 +66,15 @@ module Stormpath
                     end
                     data_store.get_resource item_href, item_class, (expansion ? expansion.to_query : nil)
                   end
-                end
-              end
+                end#can.include? :get
+              end#collection.class_eval do
 
               collection.class_eval(&block) if block
-            end
-          end
-        end
+            end#Stormpath::Resource::Collection.new
+          end#define_method(name)
+        end#def has_many
 
-      end
+      end#module Class Methods
 
       included do
 
@@ -85,12 +83,14 @@ module Stormpath
           def get_resource_property(key, clazz)
             value = get_property key
 
+            return nil if value.nil? and clazz != Stormpath::Resource::CustomData
+
             if value.is_a? Hash
-              href = get_href_from_hash value
+              resource_href = get_href_from_hash value
             end
             
             if instance_variable_get("@_#{key.underscore}").nil?
-              if href
+              if resource_href
                 instance_variable_set("@_#{key.underscore}", data_store.instantiate(clazz, value))
               else
                 instance_variable_set("@_#{key.underscore}", clazz.new(value))
@@ -109,7 +109,7 @@ module Stormpath
             end
           end
 
-      end
-    end
-  end
-end
+      end#included do
+    end#Associations
+  end#Resource
+end#Stormpath

data/lib/stormpath-sdk/resource/base.rb

@@ -19,7 +19,7 @@ class Stormpath::Resource::Base
 
   HREF_PROP_NAME = "href"
   DEFAULT_SERVER_HOST = Stormpath::DataStore::DEFAULT_SERVER_HOST
-  attr_reader :client, :properties
+  attr_reader :client, :properties, :dirty_properties
 
   class << self
     def prop_reader(*args)
@@ -137,8 +137,12 @@ class Stormpath::Resource::Base
     end
   end
 
-  def get_property name
-    property_name = name.to_s.camelize :lower
+  def get_property name, options = {}
+    property_name = name.to_s
+
+    unless options[:ignore_camelcasing] == true
+      property_name = property_name.camelize(:lower)
+    end
 
     if HREF_PROP_NAME != property_name
       #not the href/id, must be a property that requires materialization:
@@ -165,8 +169,13 @@ class Stormpath::Resource::Base
     read_property property_name
   end
 
-  def set_property name, value
-    property_name = name.to_s.camelize :lower
+  def set_property name, value, options={}
+    property_name = name.to_s
+
+    unless options[:ignore_camelcasing] == true
+      property_name = property_name.camelize(:lower)
+    end
+
     @write_lock.lock
 
     begin
@@ -186,77 +195,75 @@ class Stormpath::Resource::Base
     end
   end
 
-  protected
+  private
 
-  def data_store
-    client.data_store
-  end
+    def data_store
+      client.data_store
+    end
 
-  def materialized?
-    @materialized
-  end
+    def materialized?
+      @materialized
+    end
 
-  def materialize
-    clazz = self.class
+    def materialize
+      clazz = self.class
 
-    @write_lock.lock
+      @write_lock.lock
 
-    begin
-      resource = data_store.get_resource href, clazz, @query
-      @properties.replace resource.properties
+      begin
+        resource = data_store.get_resource href, clazz, @query
+        @properties.replace resource.properties
 
-      #retain dirty properties:
-      @properties.merge! @dirty_properties
+        #retain dirty properties:
+        @properties.merge! @dirty_properties
 
-      @materialized = true
-    ensure
-      @write_lock.unlock
+        @materialized = true
+      ensure
+        @write_lock.unlock
+      end
     end
-  end
 
-  def printable_property? property_name
-    !self.class.non_printable_properties.include? property_name
-  end
-
-  private
+    def printable_property? property_name
+      !self.class.non_printable_properties.include? property_name
+    end
 
-  def get_href_from_hash(props)
-    if props and props.is_a? Hash
-      props[HREF_PROP_NAME]
+    def get_href_from_hash(props)
+      if props and props.is_a? Hash
+        props[HREF_PROP_NAME]
+      end
     end
-  end
 
-  def read_property name
-    @read_lock.lock
+    def read_property name
+      @read_lock.lock
 
-    begin
-      @properties[name]
-    ensure
-      @read_lock.unlock
+      begin
+        @properties[name]
+      ensure
+        @read_lock.unlock
+      end
     end
-  end
 
-  def sanitize(properties)
-    {}.tap do |sanitized_properties|
-      properties.map do |key, value|
-        property_name = key.to_s.camelize :lower
-        sanitized_properties[property_name] =
-          if value.kind_of? Hash or value.kind_of? Stormpath::Resource::Base
-            deep_sanitize value
-          else
-            value
-          end
+    def sanitize(properties)
+      {}.tap do |sanitized_properties|
+        properties.map do |key, value|
+          property_name = key.to_s.camelize :lower
+          sanitized_properties[property_name] =
+            if (value.kind_of? Hash or value.kind_of? Stormpath::Resource::Base) and property_name != "customData"
+              deep_sanitize value
+            else
+              value
+            end
+        end
       end
     end
-  end
 
-  def deep_sanitize(hash_or_resource)
-    case hash_or_resource
-    when Stormpath::Resource::Base
-      deep_sanitize hash_or_resource.properties
-    when Hash
-      sanitize hash_or_resource
+    def deep_sanitize(hash_or_resource)
+      case hash_or_resource
+      when Stormpath::Resource::Base
+        deep_sanitize hash_or_resource.properties
+      when Hash
+        sanitize hash_or_resource
+      end
     end
-  end
 
 end

data/lib/stormpath-sdk/resource/collection.rb

@@ -57,38 +57,58 @@ class Stormpath::Resource::Collection
   end
 
   def each(&block)
-    page = CollectionPage.new collection_href, client, @criteria
+    PaginatedIterator.iterate(collection_href, client, item_class, @criteria, &block)
+  end
+
+  def current_page
+    page = CollectionPage.new(collection_href, client, criteria)
     page.item_type = item_class
-    items = page.items
-    items.each(&block)
+    page
   end
 
   private
 
-  class CollectionPage < Stormpath::Resource::Base
-    ITEMS = 'items'
+    module PaginatedIterator
 
-    prop_accessor :offset, :limit
+      def self.iterate(collection_href, client, item_class, criteria, &block)
+        page = CollectionPage.new collection_href, client, criteria
+        page.item_type = item_class
 
-    attr_accessor :item_type
+        unless page.items.count.zero?
+          page.items.each(&block)
+          criteria[:offset] = page.offset + page.limit
+          iterate(collection_href, client, item_class, criteria, &block)
+        end
+      end
 
-    def items
-      to_resource_array get_property ITEMS
     end
 
-    def to_resource properties
-      data_store.instantiate item_type, properties
-    end
+    class CollectionPage < Stormpath::Resource::Base
+      ITEMS = 'items'
+
+      prop_accessor :offset, :limit
 
-    def to_resource_array vals
-      Array.new.tap do |items|
-        if vals.is_a? Array
-          vals.each do |val|
-            resource = to_resource val
-            items << resource
+      attr_accessor :item_type
+
+      def items
+        to_resource_array get_property(ITEMS)
+      end
+
+      def to_resource properties
+        data_store.instantiate item_type, properties
+      end
+
+      def to_resource_array vals
+        Array.new.tap do |items|
+          if vals.is_a? Array
+            vals.each do |val|
+              resource = to_resource val
+              items << resource
+            end
           end
         end
       end
-    end
-  end
-end
+
+    end#class Stormpath::Resource::Collection::CollectionPage
+
+end#Stormpath::Resource::Collection

data/lib/stormpath-sdk/resource/custom_data.rb

@@ -17,11 +17,11 @@ class Stormpath::Resource::CustomData < Stormpath::Resource::Instance
   include Stormpath::Resource::CustomDataHashMethods
 
   def [](property_name)
-    get_property property_name
+    get_property property_name, ignore_camelcasing: true
   end
 
   def []=(property_name, property_value)
-    set_property property_name, property_value
+    set_property property_name, property_value, ignore_camelcasing: true
   end
   
   def save
@@ -34,7 +34,12 @@ class Stormpath::Resource::CustomData < Stormpath::Resource::Instance
   end
 
   def delete(name = nil)
-    super() if name.nil?
+    if name.nil?
+      @properties = { HREF_PROP_NAME => @properties[HREF_PROP_NAME] }
+      @dirty_properties.clear
+      @deleted_properties.clear
+      return super()
+    end
 
     @write_lock.lock
     property_name = name.to_s
@@ -53,7 +58,7 @@ class Stormpath::Resource::CustomData < Stormpath::Resource::Instance
     def sanitize(properties)
       {}.tap do |sanitized_properties|
         properties.map do |key, value|
-          property_name = key.to_s.camelize :lower
+          property_name = key.to_s
           sanitized_properties[property_name] = value
         end
       end
@@ -78,8 +83,9 @@ class Stormpath::Resource::CustomData < Stormpath::Resource::Instance
     end
 
     def delete_removed_properties
-      @deleted_properties.each do |deleted_property_name|
+      @deleted_properties.delete_if do |deleted_property_name|
         data_store.delete self, deleted_property_name
+        true
       end
     end
 

data/lib/stormpath-sdk/resource/custom_data_hash_methods.rb

@@ -4,7 +4,7 @@ module Stormpath::Resource::CustomDataHashMethods
   included do
     def has_key?(key)
       materialize unless materialized?
-      properties.has_key? key.to_s.camelize(:lower)
+      properties.has_key? key.to_s
     end
 
     alias_method :include?, :has_key?
@@ -21,7 +21,7 @@ module Stormpath::Resource::CustomDataHashMethods
 
     def keys
       materialize unless materialized?
-      properties.keys.map {|key| key.to_s.underscore}
+      properties.keys
     end
 
     def values

data/lib/stormpath-sdk/resource/custom_data_storage.rb

@@ -30,7 +30,7 @@ module Stormpath::Resource::CustomDataStorage
         custom_data.send :delete_removed_properties
       end
       if custom_data.send :has_new_properties?
-        self.set_property CUSTOM_DATA, custom_data.properties
+        self.set_property CUSTOM_DATA, custom_data.dirty_properties
       end
     end
 

data/lib/stormpath-sdk/version.rb

@@ -14,6 +14,6 @@
 # limitations under the License.
 #
 module Stormpath
-  VERSION = '1.0.0.beta.5'
-  VERSION_DATE = '2014-03-03'
+  VERSION = '1.0.0.beta.6'
+  VERSION_DATE = '2014-07-07'
 end

data/spec/client_spec.rb

@@ -301,7 +301,7 @@ properties
       end
 
       it 'accepts offset and limit' do
-        expect(test_api_client.applications.limit(2)).to have(2).items
+        expect(test_api_client.applications.limit(2)).to have_at_least(3).items
         expect(test_api_client.applications.offset(1).limit(2)).to have_at_least(2).items
       end
 
@@ -578,6 +578,25 @@ properties
       end
     end
 
+    context 'given a collection with a limit' do
+      let!(:directory_1) do
+        test_api_client.directories.create name: "0000_test_directory_with_limit"
+      end
+
+      let!(:directory_2) do
+        test_api_client.directories.create name: "0001_test_directory_with_limit"
+      end
+
+      after do
+        directory_1.delete if directory_1
+        directory_2.delete if directory_2
+      end
+
+      it 'should retrieve the number of directories described with the limit' do
+        expect(test_api_client.directories).to have_at_least(2).items
+      end
+    end
+
     describe '.create' do
       let(:directory_attributes) do
         {