chaingang 0.0.3 → 0.1.0

data/lib/chaingang/chaingang.rb

@@ -7,8 +7,16 @@ module ChainGang
   end
 
   module ClassMethods
-    def find_with_chaingang(id=nil)
-      Proxy.new(self).tap {|p| p.single id if id}
+    # the #find method is aliased to this.
+    # If you call #find with no arguments, it's assumed
+    # you're doing a find(:all).
+    #     Article.find # defaults to :all
+    #     Article.find(:first)
+    #     Article.find(:last)
+    #     Article.find(:one)
+    #     Article.find('some-id')
+    def find_with_chaingang(find_scope = :all)
+      Proxy.new(self, find_scope)
     end
   end
 end

data/lib/chaingang/proxy.rb

@@ -1,41 +1,48 @@
 module ChainGang
   class Proxy
-    def initialize(client)
+    attr_accessor :find_scope
+
+    def initialize(client, id=nil)
       @client = client
       @params = {}
-      @find_scope = :all
+      @find_scope = id || :all
     end
 
+    # Specify a custom url path to retrieve send 
+    # the service call to.
+    #     Article.find(:all).from :published
     def from(f); @from = f; self; end
 
-    def one;    @find_scope = :one;   self; end
-    def all;    @find_scope = :all;   self; end
-    def first;  @find_scope = :first; self; end
-    def last;   @find_scope = :last;  self; end
-    
-    def single(id)
-      @find_scope = id
-      self
-    end
-
+    # Simply improves readability. Does nothing but return self.
+    #     Article.find.where.author!("moonmaster9000").and.published!(true)
     def and;    self; end
+
+    # Simply improves readability. Does nothing but return self.
+    #     Article.find.where.author!("moonmaster9000").and.published!(true)
     def where;  self; end
 
-    def method_missing(method_name, *args, &block)
-      if args.length == 1
-        @params[method_name] = args.first
-      else
-        super method_name, *args, &block
-      end
+    # Suppose you have a parameter name that collides with an existing method.
+    # Simply set it with this param! method:
+    #     Article.find(:all).param!(:from, "New York Times")
+    def param!(name, value)
+      @params[name] = value
       self
     end
 
-    def each
-      self.execute.each do |result|
-        yield result
+    # Set the query string parameters on your request by calling them as methods
+    # with an exclamation point at the end. 
+    #     Article.find(:all).where.author!("moonmaster9000") #/articles.xml?author=moonmaster9000
+    def method_missing(method_name, *args, &block)
+      if args.length == 1 && exclamatory?(method_name)
+        @params[unexclaim method_name] = args.first
+        self
+      else
+        self.execute.send method_name, *args, &block
       end
     end
 
+    # Make the service call immediately. 
+    #     Article.find(:all).execute
     def execute
       options = {}
       options[:from] = @from if @from
@@ -44,8 +51,19 @@ module ChainGang
     end
   
     private 
-    def value(attr)
+    # @private
+    def value(attr) #:nodoc:
       eval "@#{attr}"
     end
+    
+    # @private
+    def exclamatory?(string) #:nodoc:
+      string.to_s[-1..-1] == "!"
+    end
+
+    # @private
+    def unexclaim(string) #:nodoc:
+      string.to_s[0..-2].to_sym
+    end
   end
 end

data/spec/chaingang/proxy_spec.rb

@@ -18,7 +18,7 @@ describe ChainGang do
 
     context "when called with an argument" do
       it "should return a ChainGang::Proxy" do
-        Client.find(1).class.should == ChainGang::Proxy
+        Client.find(:first).class.should == ChainGang::Proxy
       end
 
       it "should set the @client to the calling class" do
@@ -36,30 +36,6 @@ describe ChainGang do
       @proxy = Client.find
     end
 
-    describe "#all" do
-      it "should set @find_scope to :all" do
-        @proxy.all.send(:value, :find_scope).should == :all
-      end
-    end
-
-    describe "#first" do
-      it "should set @find_scope to :first" do
-        @proxy.first.send(:value, :find_scope).should == :first
-      end
-    end
-
-    describe "#last" do
-      it "should set @find_scope to :last" do
-        @proxy.last.send(:value, :find_scope).should == :last
-      end
-    end
-
-    describe "#one" do
-      it "should set @find_scope to :one" do
-        @proxy.one.send(:value, :find_scope).should == :one
-      end
-    end
-
     describe "#from" do
       it "should require an argument" do
         proc { @proxy.from }.should raise_exception
@@ -87,26 +63,71 @@ describe ChainGang do
         @proxy = Client.find
       end
 
-      it "should allow you to set any parameter" do
-        @proxy.food("taco").send(:value, :params)[:food].should == "taco"
+      it "should set a parameter when you call a method that ends with an exclamation and has exactly one argument" do
+        @proxy.food!("taco").send(:value, :params)[:food].should == "taco"
+      end
+
+      it "should proxy the method to the executed result otherwise" do
+        Dupe.stub 5, :clients
+        @proxy.count.should == 5
       end
     end
 
     describe "#execute" do
       it "should call the #find_without_chaingang method on the original client class" do
         Client.should_receive(:find_without_chaingang).with(:all, :from => "/poo", :params => { :hi => 'hi', :yes => 'no' }).and_return([])
-        Client.find.from("/poo").where.hi("hi").and.yes("no").execute
+        Client.find.from("/poo").where.hi!("hi").and.yes!("no").execute
       end
     end
+
+    describe "#param!" do
+      before do
+        @proxy = Client.find
+      end
+
+      it "should require two arguments: param name and param value" do
+        proc { @proxy.param!                            }.should     raise_exception 
+        proc { @proxy.param! :param_name                }.should     raise_exception 
+        proc { @proxy.param! :param_name, "param value" }.should_not raise_exception 
+      end
+
+      it "should set the parameter" do
+        @proxy.param! :param_name, "param value"
+        @proxy.send(:value, :params)[:param_name].should == "param value"
+      end
+    end
+
+    describe "#first" do
+      before do
+        @proxy = Client.find
+      end
+
+      it "should call the execute method, then call #first on the result" do
+        @proxy.should_receive(:execute).and_return ['hi', 'there']
+        @proxy.first.should == 'hi'
+      end
+    end
+
+    describe "#last" do
+      before do
+        @proxy = Client.find
+      end
+
+      it "should call the execute method, then call #last on the result" do
+        @proxy.should_receive(:execute).and_return ['hi', 'there']
+        @proxy.last.should == 'there'
+      end
+    end
+
     
     describe "#each" do
       before do
         Dupe.stub 10, :clients
-        @proxy = Client.find.all
+        @proxy = Client.find
       end
 
       it "should call #execute" do
-        @proxy.should_receive(:execute).and_return([])
+        @proxy.should_receive(:execute).and_return []
         @proxy.each {}
       end
     end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: chaingang
 version: !ruby/object:Gem::Version 
-  hash: 25
+  hash: 27
   prerelease: false
   segments: 
   - 0
+  - 1
   - 0
-  - 3
-  version: 0.0.3
+  version: 0.1.0
 platform: ruby
 authors: 
 - Matt Parker