zendesk_api 0.1.7 → 0.1.8

data/lib/zendesk_api/sideloading.rb

@@ -1,4 +1,5 @@
 module ZendeskAPI
+  # @private
   module Sideloading
     def self.included(klass)
       klass.send(:attr_reader, :included)

data/lib/zendesk_api/track_changes.rb

@@ -1,6 +1,6 @@
-# Shamelessly stolen and modified from https://github.com/archan937/dirty_hashy
-
 module ZendeskAPI
+  # Shamelessly stolen and modified from https://github.com/archan937/dirty_hashy
+  # @private
   module TrackChanges
     def self.included(base)
       base.method_defined?(:regular_writer).tap do |defined|
@@ -17,6 +17,7 @@ module ZendeskAPI
       end
     end
 
+    # @private
     module InstanceMethods
       def clear_changes
         each do |k, v|

data/lib/zendesk_api/trackie.rb

@@ -2,6 +2,7 @@ require 'hashie'
 require 'zendesk_api/track_changes'
 
 module ZendeskAPI
+  # @private
   class Trackie < Hashie::Mash
     include ZendeskAPI::TrackChanges
   end

data/lib/zendesk_api/version.rb

@@ -1,3 +1,3 @@
 module ZendeskAPI
-  VERSION = "0.1.7"
+  VERSION = "0.1.8"
 end

data/spec/association_spec.rb

@@ -8,7 +8,7 @@ describe ZendeskAPI::Association do
     context "has" do
       before do
         ZendeskAPI::TestResource.associations.clear
-        ZendeskAPI::TestResource.has :child, :class => :test_child
+        ZendeskAPI::TestResource.has :child, :class => ZendeskAPI::TestResource::TestChild
       end
 
       it "should cache an set object" do

data/spec/client_spec.rb

@@ -117,7 +117,7 @@ describe ZendeskAPI::Client do
       context "with a logger" do
         let(:out){ StringIO.new }
         subject { Logger.new(out) }
-        
+
         it "should log" do
           @client.connection.builder.handlers.should include(ZendeskAPI::Middleware::Response::Logger)
         end
@@ -154,8 +154,19 @@ describe ZendeskAPI::Client do
 
   context "resources" do
     it "should return an instance of ZendeskAPI::Collection if there is no method" do
+      subject.instance_variable_get(:@resource_cache)["tickets"].should be_nil
+
       subject.tickets.should be_instance_of(ZendeskAPI::Collection)
-      subject.instance_variable_defined?(:@tickets).should be_true
+
+      subject.instance_variable_get(:@resource_cache)["tickets"].should_not be_empty
+    end
+
+    it "should not cache calls with different options" do
+      subject.search(:query => 'abc').should_not == subject.search(:query => '123')
+    end
+
+    it "should cache calls with the same options" do
+      subject.search(:query => 'abc').should == subject.search(:query => 'abc')
     end
   end
 

data/spec/collection_spec.rb

@@ -408,7 +408,7 @@ describe ZendeskAPI::Collection do
 
     context "singular id on resource" do
       before(:each) do
-        ZendeskAPI::TestResource.has :nil_resource
+        ZendeskAPI::TestResource.has ZendeskAPI::NilResource
 
         stub_json_request(:get, %r{test_resources\?include=nil_resources}, json(
           :test_resources => [{ :id => 1, :nil_resource_id => 4 }],
@@ -431,7 +431,7 @@ describe ZendeskAPI::Collection do
 
     context "plural ids on resource" do
       before(:each) do
-        ZendeskAPI::TestResource.has_many :nil_resources
+        ZendeskAPI::TestResource.has_many ZendeskAPI::NilResource
 
         stub_json_request(:get, %r{test_resources\?include=nil_resources}, json(
           :test_resources => [{ :id => 1, :nil_resource_ids => [1, 4] }],
@@ -454,7 +454,7 @@ describe ZendeskAPI::Collection do
 
     context "ids in side load" do
       before(:each) do
-        ZendeskAPI::TestResource.has_many :nil_resources
+        ZendeskAPI::TestResource.has_many ZendeskAPI::NilResource
 
         stub_json_request(:get, %r{test_resources\?include=nil_resources}, json(
           :test_resources => [{ :id => 1 }],
@@ -476,7 +476,7 @@ describe ZendeskAPI::Collection do
 
     context "id in side load" do
       before(:each) do
-        ZendeskAPI::TestResource.has :nil_resource
+        ZendeskAPI::TestResource.has ZendeskAPI::NilResource
 
         stub_json_request(:get, %r{test_resources\?include=nil_resources}, json(
           :test_resources => [{ :id => 1 }],
@@ -498,7 +498,7 @@ describe ZendeskAPI::Collection do
 
     context "with name as key" do
       before(:each) do
-        ZendeskAPI::TestResource.has :nil_resource, :include_key => :name
+        ZendeskAPI::TestResource.has ZendeskAPI::NilResource, :include_key => :name
 
         stub_json_request(:get, %r{test_resources\?include=nil_resources}, json(
           :test_resources => [{ :id => 1, :nil_resource_id => 4 }],
@@ -521,8 +521,8 @@ describe ZendeskAPI::Collection do
 
     context "sub-loading" do
       before(:each) do
-        ZendeskAPI::TestResource.has :test_child
-        ZendeskAPI::TestResource::TestChild.has :nil_resource
+        ZendeskAPI::TestResource.has ZendeskAPI::TestResource::TestChild
+        ZendeskAPI::TestResource::TestChild.has ZendeskAPI::NilResource
 
         stub_json_request(:get, %r{test_resources\?include=nil_resources}, json(
           :test_resources => [{ :id => 1, :test_child => { :nil_resource_id => 4 } }],

data/spec/data_resource_spec.rb

@@ -1,21 +1,6 @@
 require 'spec_helper'
 
 describe ZendeskAPI::DataResource do
-  context "ZendeskAPI.get_class" do
-    it "should create a new class if there is none" do
-      ZendeskAPI.const_defined?("Blergh").should be_false
-      ZendeskAPI.get_class(:blergh).should == ZendeskAPI::Blergh
-    end
-
-    it "should find the class if it exists" do
-      ZendeskAPI.get_class(:tickets).should == ZendeskAPI::Tickets
-    end
-
-    it "should handle 'nil' be passed in" do
-      ZendeskAPI.get_class(nil).should be_false
-    end
-  end
-
   specify "singular resource name" do
     ZendeskAPI::Ticket.singular_resource_name.should == "ticket"
     ZendeskAPI::TicketField.singular_resource_name.should == "ticket_field"
@@ -72,23 +57,20 @@ describe ZendeskAPI::DataResource do
   end
 
   context "has" do
-    before(:each) { ZendeskAPI::TestResource.has :foo }
+    before(:each) { ZendeskAPI::TestResource.has ZendeskAPI::TestResource }
 
     context "class methods" do
       subject { ZendeskAPI::TestResource }
-      it "should define a method with the same name" do
-        subject.instance_methods.map(&:to_s).should include("foo")
-      end
 
-      it "should create a class if none exists" do
-        ZendeskAPI.const_defined?("Foo").should be_true
+      it "should define a method with the same name" do
+        subject.instance_methods.map(&:to_s).should include("test_resource")
       end
 
       context "with explicit class name" do
-        before(:all) { ZendeskAPI::TestResource.has :baz, :class => :foo }
+        before(:all) { ZendeskAPI::TestResource.has :baz, :class => ZendeskAPI::TestResource }
 
-        it "should not create a baz class" do
-          ZendeskAPI.const_defined?("Baz").should be_false
+        it "should define a method with the same name" do
+          subject.instance_methods.map(&:to_s).should include("baz")
         end
       end
     end
@@ -96,82 +78,83 @@ describe ZendeskAPI::DataResource do
     context "instance method" do
       context "with no side-loading" do
         subject { ZendeskAPI::TestResource.new(client, :id => 1) }
-        before(:each) { stub_json_request(:get, %r{test_resources/\d+/foo}, json(:foo => {})) }
+        before(:each) { stub_json_request(:get, %r{test_resources/\d+/test_resource}, json(:test_resource => {})) }
 
         it "should attempt to grab the resource from the host" do
-          subject.foo.should be_instance_of(ZendeskAPI::Foo)
+          subject.test_resource.should be_instance_of(ZendeskAPI::TestResource)
         end
 
         it "should pass the path on to the resource" do
-          subject.foo.path.should == "foos"
+          subject.test_resource.path.should == "test_resources"
         end
 
         context "with a client error" do
-          before(:each) { stub_request(:get, %r{test_resources/\d+/foo}).to_return(:status => 500) }
+          before(:each) { stub_request(:get, %r{test_resources/\d+/test_resource}).to_return(:status => 500) }
 
           it "should handle it properly" do
-            expect { silence_logger{ subject.foo.should be_nil } }.to_not raise_error
+            expect { silence_logger{ subject.test_resource.should be_nil } }.to_not raise_error
           end
         end
-        
+
         context "with an explicit path set" do
           before(:each) do
-            ZendeskAPI::TestResource.has :foo, :path => "blergh"
-            stub_json_request(:get, %r{test_resources/\d+/blergh}, json(:foo => {}))
+            ZendeskAPI::TestResource.has ZendeskAPI::TestResource, :path => "blergh"
+            stub_json_request(:get, %r{test_resources/\d+/blergh}, json(:test_resource => {}))
           end
 
           it "should call the right path" do
-            subject.foo.should be_instance_of(ZendeskAPI::Foo)
+            subject.test_resource.should be_instance_of(ZendeskAPI::TestResource)
           end
         end
       end
 
       context "with side-loading of resource" do
-        let(:foo) { { :message => "FOO_OBJ" } }
-        subject { ZendeskAPI::TestResource.new(client, :foo => foo) }
+        let(:test_resource) { { :message => "FOO_OBJ" } }
+        subject { ZendeskAPI::TestResource.new(client, :test_resource => test_resource).test_resource }
+
+        it "should load the correct instance" do
+          subject.should be_instance_of(ZendeskAPI::TestResource)
+        end
 
         it "should load foo from the hash" do
-          subject.foo.should be_instance_of(ZendeskAPI::Foo)
+          subject.message.should == "FOO_OBJ"
         end
       end
 
       context "with side-loading of id" do
-        subject { ZendeskAPI::TestResource.new(client, :foo_id => 1) }
+        subject { ZendeskAPI::TestResource.new(client, :test_resource_id => 1) }
         before(:each) do
-          stub_json_request(:get, %r{foos/1}, json("foo" => {}))
+          stub_json_request(:get, %r{test_resources/1}, json("test_resource" => {}))
         end
 
         it "should find foo_id and load it from the api" do
-          subject.foo
+          subject.test_resource
         end
 
         it "should handle nil response from find api" do
-          ZendeskAPI::Foo.should_receive(:find).twice.and_return(nil)
-          subject.foo.should be_nil
-          subject.foo
+          ZendeskAPI::TestResource.should_receive(:find).twice.and_return(nil)
+          subject.test_resource.should be_nil
+          subject.test_resource
         end
       end
     end
   end
 
   context "has_many" do
-    before(:each) { ZendeskAPI::TestResource.has_many :bars }
+    before(:each) { ZendeskAPI::TestResource.has_many ZendeskAPI::TestResource }
 
     context "class methods" do
       subject { ZendeskAPI::TestResource }
-      it "should define a method with the same name" do
-        subject.instance_methods.map(&:to_s).should include("bars")
-      end
 
-      it "should create a class if none exists" do
-        ZendeskAPI.const_defined?("Bar").should be_true
+      it "should define a method with the same name" do
+        subject.instance_methods.map(&:to_s).should include("test_resources")
       end
 
       context "with explicit class name" do
-        before(:each) { ZendeskAPI::TestResource.has_many :cats, :class => :foo }
+        before(:each) { ZendeskAPI::TestResource.has_many :cats, :class => ZendeskAPI::TestResource }
 
-        it "should not create a baz class" do
-          ZendeskAPI.const_defined?("Cat").should be_false
+        it "should define a method with the same name" do
+          subject.instance_methods.map(&:to_s).should include("cats")
         end
       end
     end
@@ -181,46 +164,50 @@ describe ZendeskAPI::DataResource do
         subject { ZendeskAPI::TestResource.new(client, :id => 1) }
 
         it "should not attempt to grab the resource from the host" do
-          subject.bars.should be_instance_of(ZendeskAPI::Collection)
+          subject.test_resources.should be_instance_of(ZendeskAPI::Collection)
         end
 
         it "should pass the path on to the resource" do
-          subject.bars.path.should == "test_resources/1/bars"
+          subject.test_resources.path.should == "test_resources/1/test_resources"
         end
 
         context "with an explicit path set" do
           before(:each) do
-            ZendeskAPI::TestResource.has_many :bars, :path => "blargh"
+            ZendeskAPI::TestResource.has_many ZendeskAPI::TestResource, :path => "blargh"
           end
 
           it "should call the right path" do
-            subject.bars.path.should == "test_resources/1/blargh"
+            subject.test_resources.path.should == "test_resources/1/blargh"
           end
         end
       end
 
       context "with side-loading of resource" do
-        let(:bars) { [{ :message => "FOO_OBJ" }] }
-        subject { ZendeskAPI::TestResource.new(client, :bars => bars) }
+        let(:test_resources) { [{ :message => "FOO_OBJ" }] }
+        subject { ZendeskAPI::TestResource.new(client, :test_resources => test_resources).test_resources.first }
+
+        it "should properly create instance" do
+          subject.message.should == "FOO_OBJ"
+        end
 
-        it "should map bars onto Bar class" do
-          subject.bars.first.should be_instance_of(ZendeskAPI::Bar)
+        it "should map bars onto TestResource class" do
+          subject.should be_instance_of(ZendeskAPI::TestResource)
         end
       end
 
       context "with side-loading of id" do
-        let(:bars) { [1, 2, 3] }
-        subject { ZendeskAPI::TestResource.new(client, :bar_ids => bars) }
+        let(:test_resource_ids) { [1, 2, 3] }
+        subject { ZendeskAPI::TestResource.new(client, :test_resource_ids => test_resource_ids) }
 
         it "should find foo_id and load it from the api" do
-          ZendeskAPI::Bar.should_receive(:find).with(client, kind_of(Hash)).exactly(bars.length).times
-          subject.bars
+          ZendeskAPI::TestResource.should_receive(:find).with(client, kind_of(Hash)).exactly(test_resource_ids.length).times
+          subject.test_resources
         end
 
         it "should handle nil response from find api" do
-          ZendeskAPI::Bar.should_receive(:find).with(client, kind_of(Hash)).exactly(bars.length).times.and_return(nil)
-          subject.bars.should be_empty
-          subject.bars # Test expectations
+          ZendeskAPI::TestResource.should_receive(:find).with(client, kind_of(Hash)).exactly(test_resource_ids.length).times.and_return(nil)
+          subject.test_resources.should be_empty
+          subject.test_resources # Test expectations
         end
       end
     end

data/spec/read_resource_spec.rb

@@ -28,7 +28,7 @@ describe ZendeskAPI::ReadResource do
           "nil_resources" => [{ :id => 1, :name => :bye }, { :id => 2, :name => :hi }]
         ))
 
-        subject.has :nil_resource
+        subject.has ZendeskAPI::NilResource
         @resource = subject.find(client, :id => id, :include => :nil_resource)
       end
 

data/spec/resource_spec.rb

@@ -114,8 +114,8 @@ describe ZendeskAPI::Resource do
     context "with unused associations" do
       before do
         ZendeskAPI::TestResource.associations.clear
-        ZendeskAPI::TestResource.has :child, :class => :test_child
-        ZendeskAPI::TestResource.has_many :children, :class => :test_child
+        ZendeskAPI::TestResource.has :child, :class => ZendeskAPI::TestResource::TestChild
+        ZendeskAPI::TestResource.has_many :children, :class => ZendeskAPI::TestResource::TestChild
       end
 
       it "should not touch them" do
@@ -155,7 +155,7 @@ describe ZendeskAPI::Resource do
       context "has" do
         before(:each) do
           ZendeskAPI::TestResource.associations.clear
-          ZendeskAPI::TestResource.has :child, :class => :test_child
+          ZendeskAPI::TestResource.has :child, :class => ZendeskAPI::TestResource::TestChild
           stub_json_request(:put, %r{test_resources})
           subject.child = { :id => 2 }
         end
@@ -181,7 +181,7 @@ describe ZendeskAPI::Resource do
       context "has_many" do
         before(:each) do
           ZendeskAPI::TestResource.associations.clear
-          ZendeskAPI::TestResource.has_many :children, :class => :test_child
+          ZendeskAPI::TestResource.has_many :children, :class => ZendeskAPI::TestResource::TestChild
 
           stub_json_request(:put, %r{test_resources})
           stub_json_request(:get, %r{children}, json(:test_children => []))
@@ -236,7 +236,7 @@ describe ZendeskAPI::Resource do
 
         context "true" do
           before(:each) do
-            ZendeskAPI::TestResource.has :nil, :class => :nil_resource, :inline => true
+            ZendeskAPI::TestResource.has :nil, :class => ZendeskAPI::NilResource, :inline => true
 
             subject.nil = { :abc => :def }
             subject.save_associations
@@ -249,7 +249,7 @@ describe ZendeskAPI::Resource do
 
         context "create" do
           before(:each) do
-            ZendeskAPI::TestResource.has :nil, :class => :nil_resource, :inline => :create
+            ZendeskAPI::TestResource.has :nil, :class => ZendeskAPI::NilResource, :inline => :create
             subject.nil = { :abc => :def }
           end
 

data/spec/spec_helper.rb

@@ -85,7 +85,7 @@ RSpec.configure do |c|
 
   c.before(:each) do
     ZendeskAPI::TestResource.associations.clear
-    ZendeskAPI::TestResource.has_many :children, :class => :test_child
+    ZendeskAPI::TestResource.has_many :children, :class => ZendeskAPI::TestResource::TestChild
   end
 
   c.before(:each) do

data/util/resource_handler.rb

@@ -0,0 +1,68 @@
+require 'zendesk_api'
+
+class ResourceHandler < YARD::Handlers::Ruby::Base
+  handles method_call(:has), method_call(:has_many)
+
+  def process
+    many = statement.jump(:ident).source == "has_many"
+
+    klass = get_klass(statement)
+
+    if klass
+      begin
+        klass = klass.split("::").inject(ZendeskAPI) do |p,k|
+          p.const_get(k)
+        end
+      rescue NameError
+        parent = ZendeskAPI.const_get(namespace.to_s.split('::').last)
+        klass = parent.const_get(klass)
+      end
+
+      name = statement.parameters.first.jump(:ident).source
+    else
+      klass = statement.parameters.first.source
+
+      begin
+        klass = ZendeskAPI.const_get(klass)
+      rescue NameError
+        parent = ZendeskAPI.const_get(namespace.to_s.split('::').last)
+        klass = parent.const_get(klass)
+      end
+
+      name = many ? klass.resource_name : klass.singular_resource_name
+    end
+
+    reader = YARD::CodeObjects::MethodObject.new(namespace, name)
+    register(reader)
+    reader.dynamic = true
+    reader.docstring.add_tag(YARD::Tags::Tag.new(:return, "The associated object", klass.name))
+
+    if many
+      reader.signature = "def #{name}=(options = {})"
+      reader.parameters = [['options', {}]]
+      reader.docstring.add_tag(YARD::Tags::Tag.new(:param, "Options to pass to the collection object", "Hash", "options"))
+    end
+
+    writer = YARD::CodeObjects::MethodObject.new(namespace, "#{name}=")
+    register(writer)
+    writer.signature = "def #{name}=(value)"
+    writer.parameters = [['value', nil]]
+    writer.dynamic = true
+    writer.docstring.add_tag(YARD::Tags::Tag.new(:return, "The associated object", klass.name))
+    writer.docstring.add_tag(YARD::Tags::Tag.new(:param, "The associated object or its attributes", "Hash or #{klass.name}", "value"))
+  end
+
+  def get_klass(statement)
+    statement.traverse do |node|
+      if node.type == :assoc && node.jump(:kw).source == "class"
+        classes = node.traverse do |value|
+          if value.type == :const_path_ref || value.type == :var_ref
+            return value.source
+          end
+        end
+      end
+    end
+
+    nil
+  end
+end