lucid_works 0.5.3 → 0.6.0

data/README.rdoc

@@ -227,23 +227,6 @@ Then
   
   thing.build_whatnot                     -> an unsaved Whatnot
 
-==== Has_singleton associations
-
-The has_singleton association is used to associate a resource with another intransient singleton resource, i.e. one that always exists and calling destroy does not remove it.
-
-  class Thing < LucidWorks::Base
-    has_one :whatnot
-  end
-
-  class Whatnot < LucidWorks::Base
-    self.singleton = true
-    belongs_to :thing
-  end
-
-Then
-
-  thing.whatnot                           -> an unsaved Whatnot
-  
 === Belongs_to associations
 
 Te belongs to association augments the model with methods to access its parent. Given:
@@ -257,6 +240,8 @@ Then:
 
   whatnot.thing         -> A Thing
 
+For more information on association see LucidWorks::Associations::ClassMethods
+
 === Schema
 
 A class may have a schema defined as follows:
@@ -267,11 +252,11 @@ A class may have a schema defined as follows:
       attribute :bool1,    :boolean
       attribute :integer1, :integer
       attributes :string2, :string3, :string4
-      attributes :bool2, :bool3, :type => :boolean
-      attributes :int2,  :int3,  :type => :integer
+      attributes :bool2,   :bool3, :type => :boolean
+      attributes :int2,    :int3,  :type => :integer
       attribute :string_with_values, :values => ['one', 'two']
       attribute :dontsendme, :omit_during_update => true
-      attribute :sendnull, :string, :nil_when_blank => true
+      attribute :sendnull,   :string, :nil_when_blank => true
     end
   end
 

data/lib/lucid_works/associations/has_many.rb

@@ -0,0 +1,70 @@
+module LucidWorks
+  module Associations
+    class HasMany < Proxy #:nodoc:
+
+      def build(attributes={})
+        @target_class.new(attributes.merge({:parent => @owner}))
+        # Don't cache it - it's only a single target
+      end
+
+      def create(attributes={})
+        target = build(attributes)
+        target.save
+        target
+      end
+
+      def create!(attributes={})
+        target = build(attributes)
+        if target.save
+          target
+        else
+          raise target.errors.full_messages
+        end
+      end
+
+      def remember_find_options(options)
+        @find_options = options
+      end
+
+      # Explicit find call does not use the remembered options, or cache the result
+      def find(id_or_find_type, options={})
+        @target_class.send(:find, id_or_find_type, options.merge(:parent => @owner))
+      end
+
+      private
+
+      # Caching rules
+      # It's easy to cache a has_one resource as we never search for different things.
+      # With a has_many the user can either use .others and get the entire collection
+      # or .others.find(id) and get just one.  What do we cache?
+      #
+      # Interestingly for us the cost difference is marginal between the two forms of
+      # the call.  Should we just grab all of them and return the one they want?
+      # Probably not.  Not every elegant and there is some cost to creating models
+      # on our end.
+      #
+      # Okay for now we will just not cache .find()
+      #
+      # The largest challenge is this sequence:
+      #
+      # a = others.find(1)  #
+      # others.find(1).name
+      # b = others.first    # requires retrieving all
+
+
+      def load_target(options={})
+        if @target.nil? || options[:force]
+          if @options[:has_content] === false
+           return true # make method_missing happy so it will operate on NilClass
+          else
+            opts = (@find_options || {}).merge(:parent => @owner)
+            @target = @target_class.send(:find, :all, opts)
+            @find_options = {}
+          end
+        else
+        end
+        @target
+      end
+    end
+  end
+end

data/lib/lucid_works/associations/has_one.rb

@@ -0,0 +1,38 @@
+module LucidWorks
+  module Associations
+    class HasOne < Proxy #:nodoc:
+
+      def build(attributes={})
+        @target = @target_class.new(attributes.merge({:parent => @owner}))
+      end
+
+      def create(attributes={})
+        build(attributes)
+        @target.save
+        @target
+      end
+
+      def create!(attributes={})
+        build(attributes)
+        if @target.save
+          @target
+        else
+          raise @target.errors.full_messages
+        end
+      end
+
+      private
+
+      def load_target(options={})
+        if @target.nil? || options[:force]
+          if @options[:has_content] === false
+           return true # make method_missing happy so it will operate on NilClass
+          else
+            @target = @target_class.send(:find, :singleton, :parent => @owner)
+          end
+        end
+        @target
+      end
+    end
+  end
+end

data/lib/lucid_works/associations/proxy.rb

@@ -0,0 +1,51 @@
+module LucidWorks
+  module Associations
+
+    # This is the root class of our association proxies:
+    #
+    #   Associations
+    #     Proxy
+    #       HasOne
+    #       HasMany
+
+    class Proxy #:nodoc:
+      instance_methods.each { |m| undef_method m unless m =~ /(^__|^nil\?$|^send$|proxy_|caller|^object_id$)/ }
+
+      def initialize(owner, target_class, options={})
+        @owner, @target_class, @options = owner, target_class, options
+        @target = nil
+      end
+
+      # Sets the target of this proxy to <tt>\target</tt>.
+      def target=(target)
+        @target = target
+      end
+
+      def loaded?
+        !!@target
+      end
+
+      # Can targets be retrieved for all owners if this type, in one step using owner/all/target
+      def supports_all?
+        @options[:supports_all]
+      end
+
+      def reload!
+        load_target(:force => true)
+      end
+
+      private
+
+      # Forwards any missing method call to the \target.
+      def method_missing(method, *args, &block)
+        if load_target
+          if @target.respond_to?(method)
+            @target.send(method, *args, &block)
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lucid_works/associations.rb

@@ -1,37 +1,58 @@
 module LucidWorks
 
+  #
+  # See LucidWorks::Associations::ClassMethods
+  #
   module Associations
     extend ActiveSupport::Concern
 
     module ClassMethods
 
+      def associations #:nodoc:
+        @associations ||= {}
+      end
+
       # Specifies a singleton child resource.
       #
-      # In the parent resource creates methods:
-      #   if option :has_content is true (default)
-      #     child       - load and cache the child. Subsequent calls will access the cached value.
-      #     child!      - load and cache the child, ignoring existing cached value if present.
-      #     build_child - create a new, unsaved resource
-      #   if option :has_content is false
-      #     child       - create a new, unsaved resource
+      #  has_one :resource, <options>
+      #
+      # In the parent resource, creates methods:
+      #
+      #   .resource
+      #   .resource!
+      #   .resource.build(attributes={})
+      #   .resource.create(attributes={})
+      #   .resource.create!(attributes={})
+      #   .build_resource(attributes={})
+      #   .create_resource(attributes={})
+      #
+      # _.resource_ will not actually load the resource until used i.e. resource._anything_ is called.
+      # After being loaded, the child is cached.  Use _.resource!_ or _resource.reload!_ to relaod it.
+      #
+      # _.resource!_ will load the resource immediately, or reload it if it was already loaded.
+      #
+      # _.build_ creates a new model but does not save it.  Parent is preset to the calling class.
+      #
+      # _.create_ builds the model, saves it, then returns it.
+      # You need to check persisted? and errors to see if the save succeeded.
+      #
+      # _.build_resource_ and _.create_resource_ are aliases for _.resource.build_ and _.resource.create_ respectively.
+      #
       # === Options
       #
       # The declaration can also include an options hash to specialize the behavior of the association.
       #
       # Options are:
-      # [:class_name]
-      #   Specify the class name of the association. Use it only if you want to us a child class name different
+      # [:class_name => "name"]
+      #   Specify the class name of the association. Use it if you want to us a child class name different
       #   from the association name, e.g.
-      #     has_one :info, :class_name => :collection_info # use CollectionInfo class
-      #     has_one :foo,  :class_name => :'foo/bar'       # use Foo::Bar class
-      # [:has_content]
-      #   Changes the behavior of the .<resource> association method:
-      #   If set to true (default), indicates that this resource may be retrieved using a GET, and
-      #   the .<resource> method will retrieve it.
-      #   If set to false, this resource may not be retrieved using a GET, and the .<resource> method
-      #   will instead build and return new, unsaved, model. This is useful for pseudo-resources that only
-      #   provide actions, not data.
-      #
+      #     has_one :foo                                     # Use class Foo
+      #     has_one :foo,  :class_name => :'things/foo_bar'  # use class Things::FooBar
+      # [:has_content => false]
+      #   If set to false, indicated that this resource may not be retrieved using a GET,
+      #   and will cause the _.resource_ method to return nil until the resource is built or created.
+      #   This is useful for pseudo-resources that only provide actions, not data.
+
       def has_one(*arguments)
         options = arguments.last.is_a?(Hash) ? arguments.pop : {}
         arguments.each do |resource|
@@ -39,7 +60,7 @@ module LucidWorks
         end
       end
 
-      # Specifies a child resource.
+      # Specifies a collection child resource.
       #
       # e.g. for Blog has_many posts
       #
@@ -86,57 +107,55 @@ module LucidWorks
 
       private
 
-      def define_has_one(resource, options={})
-        resource_class_name = (options[:class_name] || resource).to_s.camelize
+      def define_has_one(resource, options={}) #:nodoc:
+        resource_class_name = (options.delete(:class_name) || resource).to_s.camelize
+        associations[resource.to_sym] = {:type => :has_one, :class_name => "#{resource_class_name}"}.merge(options)
 
         class_eval <<-EOF, __FILE__, __LINE__ + 1
-          def #{resource}                                                  # def child
-            @#{resource} || #{resource}!                                   #   @child || child!
-          end                                                              # end
-        EOF
+          def #{resource}
+            @#{resource}_association ||= HasOne.new(self, #{resource_class_name}, #{options.to_s})
+          end
 
-        if options[:has_content] == false
-          class_eval <<-EOF, __FILE__, __LINE__ + 1
-            def #{resource}!                                               # def child!
-              @#{resource} = #{resource_class_name}.new(:parent => self)   #   @child = Child.new(options.merge :parent => self)
-            end                                                            # end
-          EOF
-        else
-          class_eval <<-EOF, __FILE__, __LINE__ + 1
-            def #{resource}!                                               # def child!
-              @#{resource} = #{resource_class_name}.find(:parent => self)  #   @child = Child.find(:parent => self)
-            end                                                            # end
-
-            def build_#{resource}(options = {})
-              #{resource_class_name}.new(options.merge :parent => self)
-            end
-          EOF
-        end
+          def #{resource}!
+            #{resource}.reload!
+          end
+
+          def build_#{resource}(options = {})
+            #{resource}.build(options)
+          end
+
+          def create_#{resource}(options = {})
+            #{resource}.create(options)
+          end
+        EOF
       end
 
-      def define_has_many(resources, options = {})
+      def define_has_many(resources, options={}) #:nodoc:
         resource = resources.to_s.singularize
-        resource_class_name = (options[:class_name] || resource).to_s.classify
+        resource_class_name = (options.delete(:class_name) || resource).to_s.classify
+        associations[resource.to_sym] = {:type => :has_many, :class_name => "#{resource_class_name}"}.merge(options)
 
         class_eval <<-EOF, __FILE__, __LINE__ + 1
           def #{resources}(options={})
-            @#{resources} || #{resources}!(options)
+            @#{resources}_association ||= HasMany.new(self, #{resource_class_name}, #{options.to_s})
+            @#{resources}_association.remember_find_options(options) unless options.empty?
+            @#{resources}_association
           end
 
           def #{resources}!(options={})
-            @#{resources} = #{resource_class_name}.all(options.merge :parent => self)
+            #{resources}(options).reload!
           end
 
-          def #{resource}(id, options={})
-            #{resource_class_name}.find(id, options.merge(:parent => self))
+          def build_#{resource}(options = {})
+            #{resources}.build(options)
           end
 
           def create_#{resource}(options = {})
-            #{resource_class_name}.create(options.merge :parent => self)
+            #{resources}.create(options)
           end
 
-          def build_#{resource}(options = {})
-            #{resource_class_name}.new(options.merge :parent => self)
+          def #{resource}(id, options={})
+            #{resources}.find(id, options)
           end
         EOF
       end

data/lib/lucid_works/base.rb

@@ -141,8 +141,8 @@ module LucidWorks
 
         results =
           if kind_of_find == :all
-            data.collect do |collection_attributes|
-              new(collection_attributes.merge(:parent => parent, :persisted => true))
+            data.collect do |model_attributes|
+              new(model_attributes.merge(:parent => parent, :persisted => true))
             end
           else
             attributes = data.is_a?(Hash) ? data : {}
@@ -154,11 +154,56 @@ module LucidWorks
           end
 
         # Process :include options
-        # Pedestrian version first: step through all results and pull in submodel
-        if includes
-          [results].flatten.each do |model|
-            [includes].flatten.each do |include|
-              model.send(include)
+        #
+        # In the section, to reduce confusion we will use the terms owner/target instead of
+        # parent/child to describe the association.
+        #
+        # If we are doing a find(:all) and this owner resource supports retrieval of all targets
+        # in one request with owners/all/targets, get them and attach them to the original models'
+        # association proxys.
+        #
+        results_array = [results].flatten # allow us to process a single result or array with the same code
+        if includes && !results_array.empty?
+          includes = [includes].flatten
+          includes.each do |association_name|
+            association_info = associations[association_name.to_s.singularize.to_sym]
+            target_class     = class_eval(association_info[:class_name]) # get scoping right
+            target_name      = association_info[:class_name].underscore
+
+            if kind_of_find == :all && association_info[:supports_all]
+              all_targets_path = "#{collection_url(parent)}/all/#{target_name}"
+              raw_response = ActiveSupport::Notifications.instrument("lucid_works.request") do |payload|
+                payload[:method]   = :get
+                payload[:uri]      = all_targets_path
+                payload[:response] = RestClient.get(all_targets_path)
+              end
+              if association_info[:type] == :has_one
+                all_targets_attributes = JSON.parse raw_response
+                all_targets_attributes.each do |target_attributes|
+                  owner_id = target_attributes['id']
+                  owner = results_array.detect { |result| result.id == owner_id }
+                  if owner
+                    target = target_class.new(target_attributes.merge(:parent => owner, :persisted => true))
+                    association_proxy = owner.send(association_name)
+                    association_proxy.target = target
+                  end
+                end
+              elsif association_info[:type] == :has_many
+                # [{"history":[...history_models...],"id":372},{"history":[...history_models...],"id":371}]
+                JSON.parse(raw_response).each do |group_of_targets|
+                  owner_id = group_of_targets['id']
+                  owner = results_array.detect { |result| result.id == owner_id }
+                  targets = group_of_targets[target_name].collect do |target_attrs|
+                    target_class.new(target_attrs.merge(:parent => owner, :persisted => true))
+                  end
+                  association_proxy = owner.send(association_name)
+                  association_proxy.target = targets
+                end
+              end
+            else # kind_of_find != :all || !supports_all
+              results_array.each do |result|
+                result.send("#{association_name}!")
+              end
             end
           end
         end
@@ -249,6 +294,7 @@ module LucidWorks
     def initialize(options)
       raise ArgumentError.new("new requires a Hash") unless options.is_a?(Hash)
       @parent = self.class.extract_parent_from_options(options)
+      @associations = {}
       @persisted = options.delete(:persisted) || singleton? || false
       @attributes = {}.with_indifferent_access
       load_attributes(options)

data/lib/lucid_works/collection.rb

@@ -19,7 +19,7 @@ module LucidWorks
     end
 
     def empty!
-      index.destroy(:params => {:key => 'iaccepttherisk'})
+      build_index.destroy(:params => {:key => 'iaccepttherisk'})
     end
 
     # Setup the Collection with an RSolr object that it can use to search.

data/lib/lucid_works/datasource.rb

@@ -2,8 +2,9 @@ module LucidWorks
   
   class Datasource < Base
     belongs_to :collection
-    has_many   :histories, :class_name => :history
-    has_one :status, :schedule, :crawldata
+    has_many   :histories, :class_name => :history, :supports_all => true
+    has_one :status, :supports_all => true
+    has_one :schedule, :crawldata
     has_one :index, :job, :has_content => false
 
     schema do
@@ -62,7 +63,7 @@ module LucidWorks
 
 
     def empty!
-      index.destroy
+      build_index.destroy
     end
 
     def editable?
@@ -81,11 +82,11 @@ module LucidWorks
     end
 
     def start_crawl!
-      job.save
+      build_job.save
     end
 
     def stop_crawl!
-      job.destroy
+      build_job.destroy
     end
     
     def t_type

data/lib/lucid_works/patch_restclient.rb

@@ -1,5 +1,5 @@
-module RestClient
-  class Request
+module RestClient #:nodoc:
+  class Request #:nodoc:
 
     # Extract the query parameters for get request and append them to the url
     def process_get_params url, headers

data/lib/lucid_works/patch_time.rb

@@ -1,6 +1,6 @@
 require 'time'
 
-class Time
+class Time #:nodoc:
   class << self
     # Ruby's 'Time.is08601 can't handle timezone offsets expressed as +nnnn.
     # It prefers +nn:nn.  Morph the former to the latter.

data/lib/lucid_works/version.rb

@@ -1,3 +1,3 @@
 module LucidWorks
-  VERSION = "0.5.3"
+  VERSION = "0.6.0"
 end

data/lib/lucid_works.rb

@@ -23,6 +23,9 @@ require 'lucid_works/patch_time'
 
 require 'lucid_works/exceptions'
 require 'lucid_works/associations'
+require 'lucid_works/associations/proxy'
+require 'lucid_works/associations/has_one'
+require 'lucid_works/associations/has_many'
 require 'lucid_works/server'
 require 'lucid_works/base'
 require 'lucid_works/schema'

data/spec/lib/lucid_works/associations/has_many_spec.rb

@@ -0,0 +1,167 @@
+require 'spec_helper'
+
+describe LucidWorks::Associations::HasMany do
+  before :all do
+    @fake_server_uri = "http://12.0.0.1:99999"
+    @server = LucidWorks::Server.new(@fake_server_uri)
+
+    class ::Target < LucidWorks::Base
+      attr_accessor :foo
+    end
+    class ::Owner < LucidWorks::Base
+      has_many :targets
+    end
+  end
+
+  before :each do
+    @owner = Owner.new(:parent => @server)
+  end
+
+  it "should not load the targets if just referenced" do
+    Target.should_not_receive(:find)
+    @owner.targets
+  end
+
+  it "should load the target with find(:parent => Owner) when target is accessed" do
+    Target.should_receive(:find).with(:all, :parent => @owner)
+    @owner.targets.first
+  end
+
+  it "should load the target with find(:parent => Owner) and remembered options when target is accessed" do
+    Target.should_receive(:find).with(:all, :parent => @owner, :include => :foo)
+    @owner.targets(:include => :foo)
+    @owner.targets.first
+  end
+
+  it "should cache the targets and not reload them on every access" do
+    mock_targets = [double('target1'), double('target2')]
+    Target.should_receive(:find).with(:all, :parent => @owner).once.and_return(mock_targets)
+    @owner.targets.first
+    @owner.targets.first
+  end
+
+  it "should delegate methods to the target" do
+    mock_targets = [double('target1'), double('target2')]
+    Target.stub(:find) { mock_targets }
+    mock_targets.should_receive(:first)
+    @owner.targets.first
+  end
+
+  describe "#loaded?" do
+    it "should return true if the target has been loaded, false otherwise" do
+      mock_targets = [double('target1'), double('target2')]
+      Target.stub(:find) { mock_targets }
+
+      @owner.targets.loaded?.should be_false
+      @owner.targets.first
+      @owner.targets.loaded?.should be_true
+    end
+  end
+
+  describe "#reload!" do
+    it "should force a reload of the target" do
+      mock_targets = [double('target1'), double('target2')]
+      Target.should_receive(:find).with(:all, :parent => @owner).twice.and_return(mock_targets)
+      @owner.targets.first
+      @owner.targets.reload!
+    end
+  end
+
+  describe "#find" do
+    it "should call Target.find with the provided options (not remembered options)" do
+      @owner.targets(:include => :foo)
+      Target.should_receive(:find).with(123, :parent => @owner)
+      @owner.targets.find(123)
+    end
+
+    it "should pass the find options to Target.find() when actually accessed" do
+      mock_target = double('target')
+      Target.should_receive(:find).with(123, :parent => @owner).and_return(mock_target)
+      @owner.targets.find(123).class
+    end
+  end
+
+  describe "#build" do
+    it "should new up a target and initialize it with the supplied attributes" do
+      target = @owner.targets.build(:foo => 'bar')
+      target.should_not be_persisted
+      target.foo.should == 'bar'
+    end
+
+    it "should initialize the new target's parent" do
+      target = @owner.targets.build
+      target.parent.should == @owner
+    end
+  end
+
+  describe "#create" do
+    it "should new up a target and initialize it with the supplied attributes, then attempt to save it" do
+      mock_target = double('target')
+      Target.should_receive(:new).with(:foo => :bar, :parent => @owner).and_return(mock_target)
+      mock_target.should_receive(:save).and_return(:save_result)
+      target = @owner.targets.create(:foo => :bar)
+      target.should == mock_target
+    end
+
+    it "should initialize the new target's parent" do
+      target = @owner.targets.build
+      target.parent.should == @owner
+    end
+  end
+
+  describe "#create!" do
+    before do
+      @mock_target = double('target')
+      Target.should_receive(:new).with(:foo => :bar, :parent => @owner).and_return(@mock_target)
+    end
+
+    context "when save succeeds" do
+      before do
+        @mock_target.should_receive(:save).and_return(true)
+      end
+
+      it "should return the target" do
+        target = @owner.targets.create!(:foo => :bar)
+        target.should == @mock_target
+      end
+    end
+
+    context "when save fails" do
+      before do
+        @mock_target.should_receive(:save).and_return(false)
+      end
+
+      it "should raise an error" do
+        lambda {
+          @owner.targets.create!(:foo => :bar)
+        }.should raise_error
+      end
+    end
+  end
+
+  context "with options :supports_all => true" do
+    before :all do
+      class ::AllableTarget < LucidWorks::Base
+      end
+      class ::Owner
+        has_many :allable_targets, :supports_all => true
+      end
+    end
+
+    describe "Owner.find(:all, :include => :targets)" do
+      it "should use owwner/all/targets to retrieve the targets" do
+        owners_json = '[{"id":1},{"id":2}]'
+        target_json = '[{"id":1,"allable_target":[{"id":1,"fruit":"apple"},{"id":1,"fruit":"pear"}]},' +
+                       '{"id":2,"allable_target":[{"id":2,"fruit":"orange"}]}]'
+        RestClient.should_receive(:get).with("#{@fake_server_uri}/api/owners").
+                                        once.ordered.and_return(owners_json)
+        RestClient.should_receive(:get).with("#{@fake_server_uri}/api/owners/all/allable_target").
+                                        once.ordered.and_return(target_json)
+        owners = Owner.find(:all, :parent => @server, :include => :allable_targets)
+        owners.first.allable_targets.first.fruit.should == 'apple'
+        owners.first.allable_targets.last.fruit.should == 'pear'
+        owners.last.allable_targets.first.fruit.should == 'orange'
+      end
+    end
+  end
+end

data/spec/lib/lucid_works/associations/has_one_spec.rb

@@ -0,0 +1,177 @@
+require 'spec_helper'
+
+describe LucidWorks::Associations::HasOne do
+  before :all do
+    @fake_server_uri = "http://12.0.0.1:99999"
+    @server = LucidWorks::Server.new(@fake_server_uri)
+
+    class ::Target < LucidWorks::Base
+      attr_accessor :foo
+    end
+    class ::Owner < LucidWorks::Base
+      has_one :target
+    end
+  end
+
+  before :each do
+    @owner = Owner.new(:parent => @server)
+  end
+
+  it "should not load the target if just referenced" do
+    Target.should_not_receive(:find)
+    @owner.target
+  end
+
+  it "should load the target with find(:parent => Owner) when target is accessed" do
+    Target.should_receive(:find).with(:singleton, :parent => @owner)
+    @owner.target.class
+  end
+
+  it "should cache the target and not reload it on every access" do
+    mock_target = double('target')
+    Target.should_receive(:find).with(:singleton, :parent => @owner).once.and_return(mock_target)
+    @owner.target.class
+    @owner.target.class
+  end
+
+  it "should delegate methods to the target" do
+    mock_target = double('target')
+    Target.stub(:find) { mock_target }
+    mock_target.should_receive(:foo)
+    @owner.target.foo
+  end
+
+  describe "#loaded?" do
+    it "should return true if the target has been loaded, false otherwise" do
+      mock_target = double('target')
+      Target.stub(:find) { mock_target }
+
+      @owner.target.loaded?.should be_false
+      @owner.target.class
+      @owner.target.loaded?.should be_true
+    end
+  end
+
+  describe "#reload!" do
+    it "should force a reload of the target" do
+      mock_target = double('target')
+      Target.should_receive(:find).with(:singleton, :parent => @owner).twice.and_return(mock_target)
+      @owner.target.class
+      @owner.target.reload!
+    end
+  end
+
+  describe "#build" do
+    it "should new up a target and initialize it with the supplied attributes" do
+      target = @owner.target.build(:foo => 'bar')
+      target.should_not be_persisted
+      target.foo.should == 'bar'
+    end
+
+    it "should initialize the new target's parent" do
+      target = @owner.target.build
+      target.parent.should == @owner
+    end
+  end
+
+  describe "#create" do
+    it "should new up a target and initialize it with the supplied attributes, then attempt to save it" do
+      mock_target = double('target')
+      Target.should_receive(:new).with(:foo => :bar, :parent => @owner).and_return(mock_target)
+      mock_target.should_receive(:save).and_return(:save_result)
+      target = @owner.target.create(:foo => :bar)
+      target.should == mock_target
+    end
+
+    it "should initialize the new target's parent" do
+      target = @owner.target.build
+      target.parent.should == @owner
+    end
+  end
+
+  describe "#create!" do
+    before do
+      @mock_target = double('target')
+      Target.should_receive(:new).with(:foo => :bar, :parent => @owner).and_return(@mock_target)
+    end
+
+    context "when save succeeds" do
+      before do
+        @mock_target.should_receive(:save).and_return(true)
+      end
+
+      it "should return the target" do
+        target = @owner.target.create!(:foo => :bar)
+        target.should == @mock_target
+      end
+    end
+
+    context "when save fails" do
+      before do
+        @mock_target.should_receive(:save).and_return(false)
+      end
+
+      it "should raise an error" do
+        lambda {
+          @owner.target.create!(:foo => :bar)
+        }.should raise_error
+      end
+    end
+  end
+
+  context "with option has_content => false" do
+    before :all do
+      class ::TargetWithoutContent < LucidWorks::Base
+        attr_accessor :foo
+      end
+      class ::Owner
+        has_one :target_without_content, :has_content => false
+      end
+    end
+
+    before :each do
+      @owner = Owner.new(:parent => @server)
+    end
+
+    context "before any build or create" do
+      describe "attribute accesses" do
+        it "should not attempt to retrieve the target, and let the caller interact with NilClass" do
+          TargetWithoutContent.should_not_receive(:find)
+          @owner.target_without_content.should be_a(NilClass)
+        end
+      end
+    end
+
+    context "after build" do
+      it "should return the target" do
+        target = @owner.target_without_content.build(:foo => 'bar')
+        target.should be_a(TargetWithoutContent)
+        target.foo.should == 'bar'
+      end
+    end
+  end
+
+  context "with options :supports_all => true" do
+    before :all do
+      class ::TargetWithAll < LucidWorks::Base
+      end
+      class ::Owner
+        has_one :target_with_all, :supports_all => true
+      end
+    end
+
+    describe "Owner.find(:all, :include => :target)" do
+      it "should use owwner/all/target to retrieve the targets" do
+        owners_json = '[{"id":1},{"id":2}]'
+        target_json = '[{"id":1,"fruit":"apple"},{"id":2,"fruit":"orange"}]'
+        RestClient.should_receive(:get).with("#{@fake_server_uri}/api/owners").
+                                        once.ordered.and_return(owners_json)
+        RestClient.should_receive(:get).with("#{@fake_server_uri}/api/owners/all/target_with_all").
+                                        once.ordered.and_return(target_json)
+        owners = Owner.find(:all, :parent => @server, :include => :target_with_all)
+        owners.first.target_with_all.fruit.should == 'apple'
+        owners.last.target_with_all.fruit.should == 'orange'
+      end
+    end
+  end
+end

data/spec/lib/lucid_works/associations_spec.rb

@@ -4,128 +4,108 @@ describe LucidWorks::Associations do
   before :all do
     @fake_server_uri = "http://fakehost.com:8888"
     @server = LucidWorks::Server.new(@fake_server_uri)
-
-    class ::Blog < LucidWorks::Base
-      has_many :posts
-      has_one :homepage
-      has_one :launch_party, :has_content => false
-    end
-    @blog = ::Blog.new(:parent => @server)
-
-    class ::Post < LucidWorks::Base
-      belongs_to :blog
-    end
-
-    class ::Homepage < LucidWorks::Base
-      self.singleton = true
-      belongs_to :blog
-    end
-
-    class ::LaunchParty < LucidWorks::Base
-      self.singleton = true
-      belongs_to :blog
-    end
   end
 
   describe ".has_one" do
-    context "without content" do
-      describe "#<child>" do
-        it "should call child! the first time then return the cached value thereafter" do
-          mock_launch_party = double('launch_party')
-          LaunchParty.should_receive(:new).once.and_return(mock_launch_party)
-
-          @blog.launch_party.should == mock_launch_party
-          @blog.launch_party.should == mock_launch_party
-        end
+    before :all do
+      class ::Blog < LucidWorks::Base
+        has_one :homepage
+        has_one :calendar, :bogus_option => :bogus_value
+        has_one :sitemap,  :class_name => 'blog_site_map', :bogus_option => :bogus_value
       end
+      class ::Homepage    < LucidWorks::Base ; end
+      class ::Calendar    < LucidWorks::Base ; end
+      class ::BlogSiteMap < LucidWorks::Base ; end
 
-      describe "#<child!>" do
-        it "should build a new model, and not call REST API to retrieve" do
-          LaunchParty.should_not_receive(:find)
-          
-          launch_party = @blog.launch_party!
+      @blog = ::Blog.new(:parent => @server)
+    end
 
-          launch_party.should be_a(LaunchParty)
-          launch_party.should be_persisted # All singletons are always persisted
-        end
+    describe "#resource" do
+      it "should create a HasOne association proxy for the specified class" do
+        LucidWorks::Associations::HasOne.should_receive(:new).
+          with(@blog, Homepage, {})
+        @blog.homepage
       end
     end
 
-    context "with content" do
-      describe "#<child>!" do
-        it "should call Child.find" do
-          Homepage.should_receive(:find).with(:parent => @blog)
-          @blog.homepage!
-        end
+    describe "#build_resource" do
+      it "should call .resource.build" do
+        mock_association = double("has_one association")
+        @blog.should_receive(:homepage).and_return(mock_association)
+        mock_association.should_receive(:build).with(:foo => :bar)
+        @blog.build_homepage(:foo => :bar)
       end
+    end
 
-      describe "#<child>" do
-        it "should call child! the first time then return the cached value thereafter" do
-          mock_homepage = double('homepage')
-          Homepage.should_receive(:find).once.and_return(mock_homepage)
-          @blog.homepage.should == mock_homepage
-          @blog.homepage.should == mock_homepage
-        end
+    describe "#create_resource" do
+      it "should call .resource.create" do
+        mock_association = double("has_one association")
+        @blog.should_receive(:homepage).and_return(mock_association)
+        mock_association.should_receive(:create).with(:foo => :bar)
+        @blog.create_homepage(:foo => :bar)
       end
+    end
 
-      describe "#build_<child>" do
-        it "should create a new child with persisted = true" do
-          homepage = @blog.build_homepage
-          homepage.should be_a(Homepage)
-          homepage.should be_persisted
-        end
-      end
+    it "should pass thru options to the proxy" do
+      LucidWorks::Associations::HasOne.should_receive(:new).
+        with(@blog, Calendar, :bogus_option => :bogus_value)
+      @blog.calendar
     end
-  end
 
-  describe ".has_singleton" do
-    describe "#<child>" do
-      it "should create a new child with persisted = true" do
-      end
+    it "should respect the :class_name option" do
+      LucidWorks::Associations::HasOne.should_receive(:new).
+        with(@blog, BlogSiteMap, :bogus_option => :bogus_value)
+      @blog.sitemap
     end
   end
 
   describe ".has_many" do
-    describe "#<children>!" do
-      it "should call Child.all" do
-        Post.should_receive(:all).with(:parent => @blog)
-        @blog.posts!
+    before :all do
+      class ::Blog < LucidWorks::Base
+        has_many :posts
       end
-    end
 
-    describe "#<children>" do
-      it "should call children! the first time then return the cached value thereafter" do
-        mock_posts = double('some posts')
-        Post.should_receive(:find).once.and_return(mock_posts)
-        @blog.posts.should == mock_posts
-        @blog.posts.should == mock_posts
+      class ::Post < LucidWorks::Base
+        belongs_to :blog
       end
     end
 
-    describe "#<child>" do
-      it "should call Child.find" do
-        Post.should_receive(:find).with('child_id', :parent => @blog)
-        @blog.post('child_id')
-      end
+    before :each do
+      @blog = ::Blog.new(:parent => @server)
     end
 
-    describe "create_<child>" do
-      it "should call Child.create" do
-        Post.should_receive(:create).with(:name => 'child_name', :parent => @blog)
-        @blog.create_post(:name => 'child_name')
+    describe "#resources" do
+      it "should create a HasMany association proxy for the specified class" do
+        mock_proxy = double('hasmany proxy', :find => nil)
+        LucidWorks::Associations::HasMany.should_receive(:new).
+          with(@blog, Post, {}).
+          and_return(mock_proxy)
+        @blog.posts
       end
     end
 
-    describe "#build_<child>" do
-      it "should create a new child with persisted = true" do
-        post = @blog.build_post
-        post.should be_a(Post)
-        post.should_not be_persisted
+    describe "#resource" do
+      it "should call Resource.find" do
+        mock_proxy = double('hasmany proxy', :first => nil)
+        Post.should_receive(:find).with('child_id', :parent => @blog).and_return(mock_proxy)
+        @blog.post('child_id').first
       end
     end
   end
 
   describe ".belongs_to" do
+    before :all do
+      class ::Blog < LucidWorks::Base
+        has_many :posts # Same as above - keep
+      end
+      class ::Post < LucidWorks::Base
+        belongs_to :blog
+      end
+    end
+
+    before :each do
+      @blog = ::Blog.new(:parent => @server)
+    end
 
     describe ".belongs_to_association_name (private)" do
       it "should return the name of the association" do

data/spec/lib/lucid_works/base_spec.rb

@@ -16,6 +16,7 @@ describe LucidWorks::Base do
 
     class Widget < LucidWorks::Base
       has_one :singleton_widget
+      has_one :singleton_widget_that_supports_all, :supports_all => true
     end
 
     class SingletonWidget < LucidWorks::Base
@@ -226,18 +227,36 @@ describe LucidWorks::Base do
 
       describe ":include option" do
         context "with a single argument" do
-          it "should retrieve the :included submodel" do
-            RestClient.should_receive(:get).with("#{@fake_server_uri}/widgets").and_return(WIDGETS_JSON)
-            mock_singleton1 = double('singleton widget1')
-            mock_singleton2 = double('singleton widget2')
-            mock_singleton3 = double('singleton widget3')
-            SingletonWidget.should_receive(:find).and_return(mock_singleton1, mock_singleton2, mock_singleton3)
+          context "for a subresource that does not support /all" do
+            it "should retrieve the :included submodel by retrieving them individually" do
+              RestClient.should_receive(:get).with("#{@fake_server_uri}/widgets").and_return(WIDGETS_JSON)
+              mock_singleton1 = double('singleton widget1')
+              mock_singleton2 = double('singleton widget2')
+              mock_singleton3 = double('singleton widget3')
+              SingletonWidget.should_receive(:find).and_return(mock_singleton1, mock_singleton2, mock_singleton3)
+
+              widgets = Widget.find(:all, :include => :singleton_widget, :parent => @server)
+
+              widgets[0].singleton_widget.should == mock_singleton1
+              widgets[1].singleton_widget.should == mock_singleton2
+              widgets[2].singleton_widget.should == mock_singleton3
+            end
+          end
 
-            widgets = Widget.find(:all, :include => :singleton_widget, :parent => @server)
+          context "for a subresource that supports /all" do
+            it "should retrieve the :included submodel by using /submodel/all" do
+              RestClient.should_receive(:get).with("#{@fake_server_uri}/widgets").and_return(WIDGETS_JSON)
+              mock_singleton1 = double('singleton widget1')
+              mock_singleton2 = double('singleton widget2')
+              mock_singleton3 = double('singleton widget3')
+              SingletonWidget.should_receive(:find).and_return(mock_singleton1, mock_singleton2, mock_singleton3)
 
-            widgets[0].singleton_widget.should == mock_singleton1
-            widgets[1].singleton_widget.should == mock_singleton2
-            widgets[2].singleton_widget.should == mock_singleton3
+              widgets = Widget.find(:all, :include => :singleton_widget, :parent => @server)
+
+              widgets[0].singleton_widget.should == mock_singleton1
+              widgets[1].singleton_widget.should == mock_singleton2
+              widgets[2].singleton_widget.should == mock_singleton3
+            end
           end
         end
 
@@ -253,9 +272,9 @@ describe LucidWorks::Base do
             mock_singleton1 = double('singleton widget1')
             mock_singleton2 = double('singleton widget2')
             mock_singleton3 = double('singleton widget3')
-            mock_other_widgets_1 = double('other widgets 1')
-            mock_other_widgets_2 = double('other widgets 2')
-            mock_other_widgets_3 = double('other widgets 3')
+            mock_other_widgets_1 = double('other widgets 1', :supports_all? => false)
+            mock_other_widgets_2 = double('other widgets 2', :supports_all? => false)
+            mock_other_widgets_3 = double('other widgets 3', :supports_all? => false)
             SingletonWidget.should_receive(:find).and_return(mock_singleton1, mock_singleton2, mock_singleton3)
             OtherWidget.should_receive(:find).and_return(mock_other_widgets_1, mock_other_widgets_2, mock_other_widgets_3)
 

data/spec/lib/lucid_works/collection_spec.rb

@@ -250,7 +250,7 @@ describe LucidWorks::Collection do
 
   describe "#empty!" do
     before do
-      @collection = @server.collections.first
+      @collection = @server.collections!.first
     end
 
     it "should DELETE /api/collections/<collection_id>/index" do

data/spec/lib/lucid_works/datasource_spec.rb

@@ -222,7 +222,7 @@ describe LucidWorks::Datasource do
     end
   end
 
-  describe "#index" do
+  describe "#build_index" do
     it "should return a new LucidWorks::Datasource::Index for this datasource" do
       @datasource = LucidWorks::Datasource.create(
         :collection => @collection,
@@ -234,7 +234,7 @@ describe LucidWorks::Datasource do
       )
       @datasource.should be_valid
 
-      index = @datasource.index
+      index = @datasource.build_index
       index.should be_a(LucidWorks::Datasource::Index)
       index.should be_persisted # special case - singletons are always considered persisted
     end
@@ -253,9 +253,9 @@ describe LucidWorks::Datasource do
       @datasource.should be_valid
     end
     
-    describe "#job" do
+    describe "#build_job" do
       it "should return a new LucidWorks::Datasource::Job for this datasource" do
-        job = @datasource.job
+        job = @datasource.build_job
         job.should be_a(LucidWorks::Datasource::Job)
         job.should be_persisted # special case - singletons are always considered persisted
       end

data/spec/lib/lucid_works/server_spec.rb

@@ -29,9 +29,12 @@ describe LucidWorks::Server do
     end
 
     describe "#collections" do
-
-      it "should call Collection.get and pass the server" do
-        LucidWorks::Collection.should_receive(:all).with(:parent => @server)
+      it "should create a HasMany association proxy for the specified class" do
+        mock_proxy = double('has_many proxy', :find => nil)
+        LucidWorks::Associations::HasMany.should_receive(:new).
+          with(@server, LucidWorks::Collection, {}).
+          and_return(mock_proxy)
+        
         @server.collections
       end
     end

metadata

@@ -2,7 +2,7 @@
 name: lucid_works
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.5.3
+  version: 0.6.0
 platform: ruby
 authors: 
 - Sam Pierson
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-04-15 00:00:00 -07:00
+date: 2011-04-25 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -101,6 +101,9 @@ files:
 - config/locales/en.yml
 - lib/lucid_works.rb
 - lib/lucid_works/associations.rb
+- lib/lucid_works/associations/has_many.rb
+- lib/lucid_works/associations/has_one.rb
+- lib/lucid_works/associations/proxy.rb
 - lib/lucid_works/base.rb
 - lib/lucid_works/collection.rb
 - lib/lucid_works/collection/activity.rb
@@ -131,6 +134,8 @@ files:
 - lib/lucid_works/utils.rb
 - lib/lucid_works/version.rb
 - lucid_works.gemspec
+- spec/lib/lucid_works/associations/has_many_spec.rb
+- spec/lib/lucid_works/associations/has_one_spec.rb
 - spec/lib/lucid_works/associations_spec.rb
 - spec/lib/lucid_works/base_spec.rb
 - spec/lib/lucid_works/collection/activity/history_spec.rb
@@ -176,6 +181,8 @@ signing_key:
 specification_version: 3
 summary: Ruby wrapper for the LucidWorks REST API
 test_files: 
+- spec/lib/lucid_works/associations/has_many_spec.rb
+- spec/lib/lucid_works/associations/has_one_spec.rb
 - spec/lib/lucid_works/associations_spec.rb
 - spec/lib/lucid_works/base_spec.rb
 - spec/lib/lucid_works/collection/activity/history_spec.rb