storage_room 0.2.1 → 0.3.0

data/lib/storage_room/models/collection.rb

@@ -1,34 +1,99 @@
 module StorageRoom
   # A collection is used to define the structure of a data set. 
-  class Collection < Model        
+  class Collection < Model      
+    key :name
+    key :primary_field_identifier
+    
+    many :fields
+    
     class << self                  
       def index_path # :nodoc:
-        '/collections'
+        "#{Resource.base_uri}/collections"
       end
       
       def show_path(collection_id) # :nodoc:
         "#{index_path}/#{collection_id}"
       end
-      
-      def entries_path(collection_id) # :nodoc:
-        "#{show_path(collection_id)}/entries"
-      end
-      
+            
       def json_name # :nodoc:
         'collection'
       end
     end
     
+    # The class name of the collection's entries, can be overridden with a mapping
+    def entry_class_name
+      ensure_loaded { StorageRoom.entry_class_for_name(name)}
+    end
+    
+    # The class for the collection's entries
+    def entry_class
+      require_initialized_entry_class do 
+        self.entry_class_name.constantize
+      end
+    end
+    
     # Load all the entries of a collection
     def entries
-      Array.load(self[:@entries_url])
+      require_initialized_entry_class do 
+        Array.load(self[:@entries_url])
+      end
     end
     
-    # The class of the collection's objects
-    def entry_class
-      StorageRoom::Entry.class_with_options(self[:name].classify, :collection_path => self.url)
+    # The field with a specific identifier
+    def field(identifier)
+      ensure_loaded do
+        fields.each do |f|
+          return f if f.identifier == identifier
+        end
+      end
+      
+      nil
     end
+    
+    protected   
+      def initialize_from_response_data
+        super
+        require_initialized_entry_class
+      end
+     
+      def initialize_entry_class      
+        name = self.entry_class_name
+    
+        klass = if Object.is_constant_defined?(name.to_sym)  
+          name.constantize
+        else
+          klass = Class.new(Entry) 
+          Object.const_set(name, klass)
+          klass
+        end
 
+        klass.collection = self
+        
+        fields.each do |field|
+          field.add_to_entry_class(klass)
+        end
+      
+        true
+      end
     
+      def deconstruct_entry_class
+        if Object.is_const_defined?(self.entry_class_name.to_sym)
+          Object.send(:remove_const, self.entry_class_name) 
+        end
+
+        true
+      end
+
+      def recreate_entry_class
+        self.deconstruct_entry_class
+        self.initialize_entry_class
+      end
+
+      def require_initialized_entry_class
+        ensure_loaded do
+          self.initialize_entry_class
+          yield if block_given?
+        end
+      end
   end
 end

data/lib/storage_room/models/entry.rb

@@ -1,20 +1,10 @@
 module StorageRoom
   class Entry < Model
-    class_inheritable_accessor :collection_path
-    
-    class << self   
-      def class_with_options(name, options = {})
-        # TODO_SK: check options
-        
-        klass = StorageRoom.class_for_name(name)
-        
-        klass.collection_path = options[:collection_path]
+    class_inheritable_accessor :collection
         
-        klass
-      end
-      
-      def index_path
-        "#{collection_path}/entries"
+    class << self         
+      def index_path # :nodoc:
+        "#{collection[:@url]}/entries"
       end
             
       def show_path(entry_id) # :nodoc:
@@ -35,26 +25,10 @@ module StorageRoom
       end
     end
     
-    # Sets a entry with a hash from the API.
-    def set_from_api(attributes)
-      super(attributes)
-                  
-      self.attributes.each do |k, v|
-        if v.is_a?(Hash) && v[:@type].present?
-          object = StorageRoom.class_for_name(v[:@type]).new
-          object.set_from_api(v)
-          self.attributes[k] = object
-        end
-      end
-      
-      self.attributes
-    end
-    
     # The collection of a entry
     def collection
-      Collection.load(self[:@collection_url] || self.class.collection_path)
-    end
-    
+      self.class.collection
+    end    
 
   end
 end

data/lib/storage_room/plugins.rb

@@ -0,0 +1,22 @@
+# encoding: UTF-8
+
+module StorageRoom
+  module Plugins
+    include ActiveSupport::DescendantsTracker
+
+    def plugins
+      @plugins ||= []
+    end
+
+    def plugin(mod)
+      include mod
+      direct_descendants.each {|model| model.send(:include, mod) }
+      plugins << mod
+    end
+
+    def included(base = nil, &block)
+      direct_descendants << base if base
+      super
+    end
+  end
+end

data/lib/storage_room/proxy.rb

@@ -0,0 +1,49 @@
+module StorageRoom
+  # The Proxy class is used in resource associations to delay loading of a resource for as long as possible.
+  # Some method calls are directly forwarded to the resource, for others the resource is loaded first from the webservice
+  # and afterwards the call is made.
+  # The Proxy tries to be as transparent as possible so that you basically never know that you have a proxy object instead of a real resource.
+  class Proxy
+    METHODS_WITHOUT_RELOAD = [:reload, :response_data, :loaded?, :class, :set_from_response_data, :present?, :is_a?, :respond_to?, :as_json, :to_hash] # TODO: figure out what other methods might be needed?
+
+    instance_methods.each { |m| undef_method m unless m =~ /^(__|instance_eval|object_id)/ } # http://onestepback.org/index.cgi/Tech/Ruby/BlankSlate.rdoc
+
+    def initialize(object, parameters={})
+      @object = object
+      @parameters = parameters
+    end
+    
+    def proxy?
+      true
+    end
+    
+    def inspect
+      if @object.loaded?
+        @object.inspect
+      else
+        "#<#{@object.class} (proxied)>"        
+      end
+    end
+    
+    def to_s
+      inspect
+    end
+        
+    def _object
+      @object
+    end
+    
+    # Forward all method calls to the proxied object, reload if necessary
+    def method_missing(method_name, *args, &block)
+      if @object.loaded? || METHODS_WITHOUT_RELOAD.include?(method_name)
+        # no need to reload
+      else
+        StorageRoom.log("Reloading #{@object['url']} due to #{method_name}")
+        @object.reload(@object['url'], @parameters)
+      end
+
+      @object.send(method_name, *args, &block)       
+    end
+  end
+  
+end

data/lib/storage_room/{base.rb → resource.rb}

@@ -1,22 +1,17 @@
 module StorageRoom
   # The superclass of all the classes that load data from the API
-  class Base
-    include Attributes
+  class Resource
     include HTTParty
+    extend Plugins
+    
+    include Accessors
+    
+    plugin IdentityMap
     
     headers 'User-Agent' => 'StorageRoom Ruby Gem', 'Accept' => 'application/json', 'Content-Type' => 'application/json'
     format :json
 
-    
-    class << self
-      # Load an object with the specified URL from the API
-      def load(url, parameters = {})
-        httparty = get(url, parameters)
-        
-        handle_critical_response_errors(httparty)
-        create_from_api(httparty.parsed_response.first[1])
-      end
-      
+    class << self      
       # Handle known server errors
       def handle_critical_response_errors(httparty) # :nodoc:
         case httparty.response.code
@@ -26,21 +21,6 @@ module StorageRoom
         end
       end
       
-      # Creates a new object with a hash from the API with a @type attribute
-      def create_from_api(hash)  # :nodoc:
-        type = hash['@type']
-        
-        object = case type
-          when 'Array' then Array.new
-          when 'Collection' then Collection.new
-          else # entry
-            StorageRoom.class_for_name(type.classify).new
-        end
-        
-        object.set_from_api(hash)
-        object
-      end
-      
       # Find out if a key is user-defined or meta-data (begins with @)      
       def meta_data?(key) 
         key[0...1] == '@'
@@ -50,18 +30,15 @@ module StorageRoom
     # Reload an object from the API. Optionally pass an URL.
     def reload(url = nil, parameters = {})
       httparty = self.class.get(url || self[:@url], parameters)
-      set_from_api(httparty.parsed_response.first[1])
+      set_from_response_data(httparty.parsed_response.first[1])
       true
     end
-       
-    # Returns the remote URL of the object        
-    def url
-      self[:@url]
-    end
     
-    def version
-      self[:@version]
+    # Has the Resource been loaded from the API?
+    def loaded?
+      self['@url'] ? true : false
     end
-    
+       
+
   end
 end

data/spec/fixtures/collection.json

@@ -15,22 +15,6 @@
             "hint": "",
             "choices": [],
             "identifier": "title"
-        },
-        {
-            "name": "PDF",
-            "required": false,
-            "input_type": "file",
-            "@type": "FileField",
-            "hint": "Upload a PDF file",
-            "identifier": "pdf"
-        },
-        {
-            "name": "location",
-            "required": false,
-            "input_type": "location",
-            "@type": "LocationField",
-            "hint": "",
-            "identifier": "location"
         }],
         "@type": "Collection",
         "@url": "http://api.storageroomapp.com/accounts/4c8fd48542507175aa00002f/collections/4ddaf68b4d085d374a000003"

data/spec/spec_helper.rb

@@ -10,6 +10,7 @@ RSpec.configure do |config|
   
   config.before(:each) do
     StorageRoom.authenticate('USER_ID', 'APPLICATION_API_KEY')
+    StorageRoom::IdentityMap.clear
   end
 end
 

data/spec/storage_room/accessors_spec.rb

@@ -0,0 +1,107 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+module StorageRoom
+  class TestAccessors
+    include Accessors
+    
+    key :test
+    key :test2
+  end
+end
+
+describe StorageRoom::TestAccessors do
+  
+  context "Instance" do
+    before(:each) do
+      @test = StorageRoom::TestAccessors.new(:test => 1)
+    end
+    
+    describe "#initialize" do    
+      it "should set attributes" do
+        @test.test.should == 1
+        @test['test'].should be_nil
+        @test.test2.should be_nil
+        @test['test2'].should be_nil
+      end
+    end
+    
+    describe "#set_from_response_data" do  
+      before(:each) do
+        @test.set_from_response_data(:test2 => 3)
+      end
+        
+      it "should reset attributes" do
+        @test.test.should be_nil
+      end
+      
+      it "should set new attributes" do
+        @test['test2'].should == 3
+        @test.test2.should == 3
+      end
+    end
+    
+    describe "#inspect" do
+      it "should output string" do
+        @test.inspect.should be_present
+      end
+    end
+    
+    describe "#[]" do
+      it "should get attribute" do
+        @test.set_from_response_data(:test2 => 3)
+        
+        @test[:test].should be_nil
+        @test[:test2].should == 3
+      end
+    end
+        
+    describe "#attributes" do
+      it "should return existing attributes" do
+        @test.attributes[:test].should == 1
+        @test.attributes['test'].should == 1
+        @test.attributes['test2'].should be_nil
+      end
+    end
+    
+    describe "#attributes=" do
+      before(:each) do
+        @test.attributes = {:test => 0}
+      end
+      
+      it "should set attributes" do
+        @test.attributes[:test].should == 0
+      end
+    end
+    
+    describe "#as_json" do
+      it "should return attributes as hash" do
+        hash = @test.as_json
+        hash.should be_an_instance_of(Hash)
+        hash['test'].should == 1
+      end
+    end
+    
+    describe "#reset!" do
+      it "should reset" do  
+        @test.response_data = {'test' => 1}      
+        @test.reset!
+        @test.attributes.should == {}
+        @test.response_data.should == {}
+      end
+    end
+    
+    describe "#loaded?" do
+      it "should return true" do
+        @test.response_data = {'test' => 1}
+        @test.should be_loaded
+      end
+      
+      it "should return false" do
+        @test.reset!
+        @test.should_not be_loaded
+      end
+    end
+
+  end
+  
+end