stormpath-sdk 0.4.0 → 1.0.0.beta

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

@@ -0,0 +1,97 @@
+module Stormpath
+  module Resource
+    module Associations
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+
+        def resource_prop_reader(*args)
+          args.each do |name|
+            resource_class = "Stormpath::Resource::#{name.to_s.camelize}".constantize
+            property_name = name.to_s.camelize :lower
+
+            define_method(name) do
+              get_resource_property property_name, resource_class
+            end
+          end
+        end
+
+        alias_method :has_one, :resource_prop_reader
+        alias_method :belongs_to, :resource_prop_reader
+
+        def has_many(name, options={}, &block)
+          item_class = options[:class] || "Stormpath::Resource::#{name.to_s.singularize.camelize}".constantize
+          property_name = name.to_s.camelize :lower
+          can = Array.wrap(options[:can]) || []
+
+          define_method(name) do
+            href = options[:href] || get_resource_href_property(property_name)
+            collection_href = if options[:delegate]
+              "#{tenant.applications.first.tenant.href}/#{name.to_s}"
+            end
+
+            Stormpath::Resource::Collection.new(href, item_class, client,
+              collection_href: collection_href).tap do |collection|
+
+              collection.class_eval do
+                if can.include? :create
+                  def create(properties_or_resource)
+                    resource = case properties_or_resource
+                      when Stormpath::Resource::Base
+                        properties_or_resource
+                      else
+                        item_class.new properties_or_resource, client
+                      end
+                    data_store.create href, resource, item_class
+                  end
+                end
+
+                if can.include? :get
+                  def get(id_or_href, expansion=nil)
+                    item_href = if id_or_href.index '/'
+                      id_or_href
+                    else
+                      "#{href}/#{id_or_href}"
+                    end
+                    data_store.get_resource item_href, item_class, (expansion ? expansion.to_query : nil)
+                  end
+                end
+              end
+
+              collection.class_eval(&block) if block
+            end
+          end
+        end
+
+      end
+
+      included do
+
+        private
+
+          def get_resource_property(key, clazz)
+            value = get_property key
+
+            if value.is_a? Hash
+              href = get_href_from_hash value
+            end
+
+            unless href.nil?
+              data_store.instantiate clazz, value
+            end
+          end
+
+          def get_resource_href_property(key)
+            value = get_property key
+
+            if value.is_a? Hash
+              get_href_from_hash value
+            else
+              nil
+            end
+          end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,256 @@
+#
+# Copyright 2012 Stormpath, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+class Stormpath::Resource::Base
+  include Stormpath::Resource::Utils
+  include Stormpath::Resource::Associations
+
+  HREF_PROP_NAME = "href"
+
+  attr_reader :client, :properties
+
+  class << self
+    def prop_reader(*args)
+      args.each do |name|
+        property_name = name.to_s.camelize :lower
+
+        define_method(name) do
+          get_property property_name
+        end
+      end
+    end
+
+    def prop_writer(*args)
+      args.each do |name|
+        property_name = name.to_s.camelize :lower
+
+        define_method("#{name.to_s}=") do |value|
+          set_property property_name, value
+        end
+      end
+    end
+
+    def prop_accessor(*args)
+      args.each do |name|
+        prop_reader name
+        prop_writer name
+      end
+    end
+
+    def prop_non_printable(*args)
+      @non_printable_properties ||= []
+      args.each do |name|
+        property_name = name.to_s.camelize :lower
+        @non_printable_properties << property_name
+      end
+    end
+
+    def non_printable_properties
+      @non_printable_properties ||= []
+      Array.new @non_printable_properties
+    end
+  end
+
+  def initialize properties_or_url, client=nil, query=nil
+    properties = case properties_or_url
+                 when String
+                   { HREF_PROP_NAME => properties_or_url }
+                 when Hash
+                   properties_or_url
+                 else
+                   {}
+                 end
+
+    @client = client
+    @query = query
+    @read_lock = Mutex.new
+    @write_lock = Mutex.new
+    @properties = Hash.new
+    @dirty_properties = Hash.new
+    set_properties properties
+  end
+
+  def new?
+    prop = read_property HREF_PROP_NAME
+
+    if prop.nil?
+      true
+    else
+      prop.respond_to? 'empty' and prop.empty?
+    end
+  end
+
+  def href
+    get_property HREF_PROP_NAME
+  end
+
+  def get_property_names
+    @read_lock.lock
+
+    begin
+      @properties.keys
+    ensure
+      @read_lock.unlock
+    end
+  end
+
+  def set_properties properties
+    @write_lock.lock
+
+    begin
+      @properties.clear
+      @dirty_properties.clear
+      @dirty = false
+
+      unless properties.nil?
+        @properties = deep_sanitize properties
+
+        # Don't consider this resource materialized if it is only a reference.  A reference is any object that
+        # has only one 'href' property.
+        href_only = (@properties.size == 1 and @properties.has_key? HREF_PROP_NAME)
+        @materialized = !href_only
+      else
+        @materialized = false
+      end
+
+    ensure
+      @write_lock.unlock
+    end
+  end
+
+  def get_property name
+    property_name = name.to_s.camelize :lower
+
+    if !HREF_PROP_NAME.eql? property_name
+      #not the href/id, must be a property that requires materialization:
+      unless new? or materialized?
+
+        # only materialize if the property hasn't been set previously (no need to execute a server
+        # request since we have the most recent value already):
+        present = false
+
+        @read_lock.lock
+        begin
+          present = @dirty_properties.has_key? property_name
+        ensure
+          @read_lock.unlock
+        end
+
+        unless present
+          # exhausted present properties - we require a server call:
+          materialize
+        end
+      end
+    end
+
+    read_property name
+  end
+
+  def set_property name, value
+    property_name = name.to_s.camelize :lower
+    @write_lock.lock
+
+    begin
+      @properties.store property_name, value
+      @dirty_properties.store property_name, value
+      @dirty = true
+    ensure
+      @write_lock.unlock
+    end
+  end
+
+  def == other
+    if other.is_a?(self.class)
+      href == other.href
+    else
+      super
+    end
+  end
+
+  protected
+
+  def data_store
+    client.data_store
+  end
+
+  def materialized?
+    @materialized
+  end
+
+  def materialize
+    clazz = self.class
+
+    @write_lock.lock
+
+    begin
+      resource = data_store.get_resource href, clazz, @query
+      @properties.replace resource.properties
+
+      #retain dirty properties:
+      @properties.merge! @dirty_properties
+
+      @materialized = true
+    ensure
+      @write_lock.unlock
+    end
+  end
+
+  def printable_property? property_name
+    !self.class.non_printable_properties.include? property_name
+  end
+
+  private
+
+  def get_href_from_hash(props)
+    if !props.nil? and props.is_a? Hash
+      props[HREF_PROP_NAME]
+    end
+  end
+
+  def read_property name
+    @read_lock.lock
+
+    begin
+      @properties[name]
+    ensure
+      @read_lock.unlock
+    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
+      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
+    end
+  end
+end

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

@@ -0,0 +1,94 @@
+#
+# Copyright 2012 Stormpath, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+class Stormpath::Resource::Collection
+  include Enumerable
+
+  attr_reader :href, :client, :item_class, :collection_href, :criteria
+
+  def initialize(href, item_class, client, options={})
+    @client = client
+    @href = href
+    @item_class = item_class
+    @collection_href = options[:collection_href] || @href
+    @criteria ||= {}
+  end
+
+  def data_store
+    client.data_store
+  end
+
+  def search query
+    query_hash = if query.is_a? String
+      { q: query }
+    elsif query.is_a? Hash
+      query
+    end
+
+    criteria.merge! query_hash
+    self
+  end
+
+  def offset offset
+    criteria.merge! offset: offset
+    self
+  end
+
+  def limit limit
+    criteria.merge! limit: limit
+    self
+  end
+
+  def order statement
+    criteria.merge! order_by: statement
+    self
+  end
+
+  def each(&block)
+    page = CollectionPage.new collection_href, client, @criteria
+    page.item_type = item_class
+    items = page.items
+    items.each(&block)
+  end
+
+  private
+
+  class CollectionPage < Stormpath::Resource::Base
+    ITEMS = 'items'
+
+    prop_accessor :offset, :limit
+
+    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

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

@@ -13,79 +13,22 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-module Stormpath
+class Stormpath::Resource::Directory < Stormpath::Resource::Instance
+  include Stormpath::Resource::Status
 
-  module Resource
+  prop_accessor :name, :description
 
-    class Directory < InstanceResource
+  belongs_to :tenant
 
-      include Status
-
-      NAME = "name"
-      DESCRIPTION = "description"
-      STATUS = "status"
-      ACCOUNTS = "accounts"
-      GROUPS = "groups"
-      TENANT = "tenant"
-
-      def get_name
-        get_property NAME
-      end
-
-      def set_name name
-        set_property NAME, name
-      end
-
-      def get_description
-        get_property DESCRIPTION
-      end
-
-      def set_description description
-        set_property DESCRIPTION, description
-      end
-
-      def get_status
-        value = get_property STATUS
-
-        if !value.nil?
-          value = value.upcase
-        end
-
-        value
-      end
-
-      def set_status status
-
-        if get_status_hash.has_key? status
-          set_property STATUS, get_status_hash[status]
-        end
-
-      end
-
-      def create_account account, *registration_workflow_enabled
-        accounts = get_accounts
-        href = accounts.get_href
-        if !registration_workflow_enabled.nil? and !registration_workflow_enabled.empty?
-          href += '?registrationWorkflowEnabled=' + registration_workflow_enabled[0].to_s
-        end
-
-        data_store.create href, account, Account
-      end
-
-      def get_accounts
-        get_resource_property ACCOUNTS, AccountList
-      end
-
-      def get_groups
-        get_resource_property GROUPS, GroupList
-      end
-
-      def get_tenant
-        get_resource_property TENANT, Tenant
-      end
+  has_many :accounts, can: :create
+  has_many :groups, can: :create
 
+  def create_account account, registration_workflow_enabled=nil
+    href = accounts.href
+    unless registration_workflow_enabled.nil?
+      href += "?registrationWorkflowEnabled=#{registration_workflow_enabled.to_s}"
     end
 
+    data_store.create href, account, Stormpath::Resource::Account
   end
 end
-