cistern 1.0.1.pre6 → 2.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 14abaac482ac21a28c8397bc14d3f122f8a8f7b6
+  data.tar.gz: 1bd8bbc0c5f2c0a11596b5e420042d7a468c2ea6
+SHA512:
+  metadata.gz: a30d8da5aac9ea437a76903c3183bfc0ae88ce295080e8703644eece9fa8c81656ef9df60e73d102384a7d9db9ea2e94bb96d39e30802b0e4238fc3d5647bcf0
+  data.tar.gz: 5bb8cf1014201e231ed9f51456369e410a3802b084f322c1f1d051b24124bdb20ba1048841a71c96b9952e89dd67e8628dd8b9533dc45481af9089ee5079d890

data/.gemrelease

@@ -0,0 +1,3 @@
+---
+bump:
+  tag: true

data/README.md

@@ -11,68 +11,6 @@ Cistern helps you consistenly build your API clients and faciliates building moc
 
 This represents the remote service that you are wrapping. If the service name is 'foo' then a good name is 'Foo::Client'.
 
-#### Requests
-
-Requests are enumerated using the `request` method and required immediately via the relative path specified via `request_path`.
-
-```ruby
-class Foo::Client < Cistern::Service
-  request_path "my-foo/requests"
-
-  request :get_bar  # require my-foo/requests/get_bar.rb
-  request :get_bars # require my-foo/requests/get_bars.rb
-
-  class Real
-    def request(url)
-      Net::HTTP.get(url)
-    end
-  end
-end
-```
-
-
-<!--todo move to a request section-->
-A request is method defined within the context of service and mode (Real or Mock).  Defining requests within the service mock class is optional.
-
-```ruby
-# my-foo/requests/get_bar.rb
-class Foo::Client
-  class Real
-    def get_bar(bar_id)
-      request("http://example.org/bar/#{bar_id}")
-    end
-  end # Real
-
-  # optional, but encouraged
-  class Mock
-    def get_bars
-      # do some mock things
-    end
-  end # Mock
-end # Foo::client
-```
-
-All declared requests can be listed via `Cistern::Service#requests`.
-
-```ruby
-Foo::Client.requests # => [:get_bar, :get_bars]
-```
-
-#### Models and Collections
-
-Models and collections have declaration semantics similar to requests.  Models and collections are enumerated via `model` and `collection` respectively.
-
-```ruby
-class Foo::Client < Cistern::Service
-  model_path "my-foo/models"
-
-  model :bar       # require my-foo/models/bar.rb
-  collection :bars # require my-foo/models/bars.rb
-end
-```
-
-#### Initialization
-
 Service initialization parameters are enumerated by `requires` and `recognizes`.  `recognizes` parameters are optional.
 
 ```ruby
@@ -90,6 +28,7 @@ Foo::Client.new(hmac_id: "1", url: "http://example.org")
 Foo::Client.new(hmac_id: "1")
 ```
 
+Cistern will define for you two classes, `Mock` and `Real`.
 
 ### Mocking
 
@@ -107,114 +46,72 @@ real.is_a?(Foo::Client::Real) # true
 fake.is_a?(Foo::Client::Mock) # true
 ```
 
-#### Data
-
-A uniform interface for mock data is mixed into the `Mock` class by default.
+### Requests
 
-```ruby
-Foo::Client.mock!
-client = Foo::Client.new     # Foo::Client::Mock
-client.data                  # Cistern::Data::Hash
-client.data["bars"] += ["x"] # ["x"]
-```
+Requests are defined by subclassing `#{service}::Request`.
 
-Mock data is class-level by default
+* `service` represents the associated `Foo::Client` instance.
 
 ```ruby
-Foo::Client::Mock.data["bars"] # ["x"]
-```
+class Foo::Client::GetBar < Foo::Client::Request
+  def real(params)
+    # make a real request
+    "i'm real"
+  end
 
-`reset!` dimisses the `data` object.
+  def mock(params)
+    # return a fake response
+    "imposter!"
+  end
+end
 
-```ruby
-client.data.object_id # 70199868585600
-client.reset!
-client.data["bars"]   # []
-client.data.object_id # 70199868566840
+Foo::Client.new.get_bar # "i'm real"
 ```
 
-`clear` removes existing keys and values but keeps the same object.
+The `#service_method` function allows you to specific the name of generated method.
 
 ```ruby
-client.data["bars"] += ["y"] # ["y"]
-client.data.object_id        # 70199868378300
-client.clear
-client.data["bars"]          # []
-
-client.data.object_id        # 70199868566840
-```
-
-* `store` and `[]=` write
-* `fetch` and `[]` read
+class Foo::Client::GetBars < Foo::Client::Request
+  service_method :get_all_the_bars
 
-You can make the service bypass Cistern's mock data structures by simply creating a `self.data` function in your service `Mock` declaration.
-
-```ruby
-class Foo::Client < Cistern::Service
-  class Mock
-    def self.data
-      @data ||= {}
-    end
+  def real(params)
+    "all the bars"
   end
 end
-```
-
 
-#### Requests
+Foo::Client.new.respond_to?(:get_bars) # false
+Foo::Client.new.get_all_the_bars       # "all the bars"
 
-Mock requests should be defined within the contextual `Mock` module and interact with the `data` object directly.
+All declared requests can be listed via `Cistern::Service#requests`.
 
 ```ruby
-# lib/foo/requests/create_bar.rb
-class Foo::Client
-  class Mock
-    def create_bar(options={})
-      id = Foo.random_hex(6)
-
-      bar = {
-        "id" => id
-      }.merge(options)
-
-      self.data[:bars][id] = bar
-
-      response(
-        :body   => {"bar" => bar},
-        :status => 201,
-        :path => '/bar',
-      )
-    end
-  end # Mock
-end # Foo::Client
+Foo::Client.requests # => [Foo::Client::GetBars, Foo::Client::GetBar]
 ```
 
-#### Storage
-
-Currently supported storage backends are:
+### Models
 
-* `:hash` : `Cistern::Data::Hash` (default)
-* `:redis` : `Cistern::Data::Redis`
+* `service` represents the associated `Foo::Client` instance.
+* `collection` represents the related collection (if applicable)
+* `new_record?` checks if `identity` is present
+* `requires(*requirements)` throws `ArgumentError` if an attribute matching a requirement isn't set
+* `merge_attributes(attributes)` sets attributes for the current model instance
 
+#### Attributes
 
-Backends can be switched by using `store_in`.
+Attributes are designed to be a flexible way of parsing service request responses.
 
-```ruby
-# use redis with defaults
-Patient::Mock.store_in(:redis)
-# use redis with a specific client
-Patient::Mock.store_in(:redis, client: Redis::Namespace.new("cistern", redis: Redis.new(host: "10.1.0.1"))
-# use a hash
-Patient::Mock.store_in(:hash)
-```
+`identity` is special but not required.
 
-### Model
+`attribute :flavor` makes `Foo::Client::Bar.new.respond_to?(:flavor)`
 
-* `service` represents the associated `Foo::Client` instance.
-* `collection` represents the related collection (if applicable)
+* `:aliases` or `:alias` allows a attribute key to be different then a response key. `attribute :keypair_id, alias: "keypair"` with `merge_attributes("keypair" => 1)` sets `keypair_id` to `1`
+* `:type` automatically casts the attribute do the specified type. `attribute :private_ips, type: :array` with `merge_attributes("private_ips" => 2)` sets `private_ips` to `[2]`
+* `:squash` traverses nested hashes for a key. `attribute :keypair_id, aliases: "keypair", squash: "id"` with `merge_attributes("keypair" => {"id" => 3})` sets `keypair_id` to `3`
 
 Example
 
 ```ruby
-class Foo::Client::Bar < Cistern::Model
+class Foo::Client::Bar < Foo::Client::Model
   identity :id
 
   attribute :flavor
@@ -249,40 +146,18 @@ class Foo::Client::Bar < Cistern::Model
 end
 ```
 
-#### Dirty
-
-Dirty attributes are tracked and cleared when `merge_attributes` is called.
-
-* `changed` returns a Hash of changed attributes mapped to there initial value and current value
-* `dirty_attributes` returns Hash of changed attributes with there current value.  This should be used in the model `save` function.
-
-
-```ruby
-bar = Foo::Client::Bar.new(id: 1, flavor: "x") # => <#Foo::Client::Bar>
-
-bar.dirty?           # => false
-bar.changed          # => {}
-bar.dirty_attributes # => {}
-
-bar.flavor = "y"
-
-bar.dirty?           # => true
-bar.changed          # => {flavor: ["x", "y"]}
-bar.dirty_attributes # => {flavor: "y"}
-
-bar.save
-bar.dirty?           # => false
-bar.changed          # => {}
-bar.dirty_attributes # => {}
-```
-
 ### Collection
 
-`model` tells Cistern which class is contained within the collection.  `Cistern::Collection` inherits from `Array` and lazy loads where applicable.
+* `model` tells Cistern which class is contained within the collection.
+* `service` is the associated `Foo::Client` instance
+* `attribute` specifications on collections are allowed. use `merge_attributes`
+* `load` consumes an Array of data and constructs matching `model` instances
 
 ```ruby
 class Foo::Client::Bars < Cistern::Collection
 
+  attribute :count, type: :integer
+
   model Foo::Client::Bar
 
   def all(params = {})
@@ -313,40 +188,103 @@ class Foo::Client::Bars < Cistern::Collection
 end
 ```
 
-### Request
+#### Data
+
+A uniform interface for mock data is mixed into the `Mock` class by default.
+
+```ruby
+Foo::Client.mock!
+client = Foo::Client.new     # Foo::Client::Mock
+client.data                  # Cistern::Data::Hash
+client.data["bars"] += ["x"] # ["x"]
+```
+
+Mock data is class-level by default
+
+```ruby
+Foo::Client::Mock.data["bars"] # ["x"]
+```
+
+`reset!` dimisses the `data` object.
+
+```ruby
+client.data.object_id # 70199868585600
+client.reset!
+client.data["bars"]   # []
+client.data.object_id # 70199868566840
+```
+
+`clear` removes existing keys and values but keeps the same object.
+
+```ruby
+client.data["bars"] += ["y"] # ["y"]
+client.data.object_id        # 70199868378300
+client.clear
+client.data["bars"]          # []
+
+client.data.object_id        # 70199868566840
+```
+
+* `store` and `[]=` write
+* `fetch` and `[]` read
+
+You can make the service bypass Cistern's mock data structures by simply creating a `self.data` function in your service `Mock` declaration.
+
+```ruby
+class Foo::Client < Cistern::Service
+  class Mock
+    def self.data
+      @data ||= {}
+    end
+  end
+end
+```
+
+#### Storage
+
+Currently supported storage backends are:
+
+* `:hash` : `Cistern::Data::Hash` (default)
+* `:redis` : `Cistern::Data::Redis`
+
+
+Backends can be switched by using `store_in`.
+
+```ruby
+# use redis with defaults
+Patient::Mock.store_in(:redis)
+# use redis with a specific client
+Patient::Mock.store_in(:redis, client: Redis::Namespace.new("cistern", redis: Redis.new(host: "10.1.0.1"))
+# use a hash
+Patient::Mock.store_in(:hash)
+```
+
+
+#### Dirty
+
+Dirty attributes are tracked and cleared when `merge_attributes` is called.
+
+* `changed` returns a Hash of changed attributes mapped to there initial value and current value
+* `dirty_attributes` returns Hash of changed attributes with there current value.  This should be used in the model `save` function.
+
 
 ```ruby
-module Foo
-  class Client
-    class Real
-      def create_bar(options={})
-        request(
-          :body     => {"bar" => options},
-          :method   => :post,
-          :path     => '/bar'
-        )
-      end
-    end # Real
-
-    class Mock
-      def create_bar(options={})
-        id = Foo.random_hex(6)
-
-        bar = {
-          "id" => id
-        }.merge(options)
-
-        self.data[:bars][id]= bar
-
-        response(
-          :body   => {"bar" => bar},
-          :status => 201,
-          :path => '/bar',
-        )
-      end
-    end # Mock
-  end # Client
-end # Foo
+bar = Foo::Client::Bar.new(id: 1, flavor: "x") # => <#Foo::Client::Bar>
+
+bar.dirty?           # => false
+bar.changed          # => {}
+bar.dirty_attributes # => {}
+
+bar.flavor = "y"
+
+bar.dirty?           # => true
+bar.changed          # => {flavor: ["x", "y"]}
+bar.dirty_attributes # => {flavor: "y"}
+
+bar.save
+bar.dirty?           # => false
+bar.changed          # => {}
+bar.dirty_attributes # => {}
 ```
 
 ## Examples

data/lib/cistern/attributes.rb

@@ -26,10 +26,12 @@ module Cistern::Attributes
 
           travel.call(v, squash.dup)
         elsif v.is_a?(::Hash)
-          if v.key?(squash.to_s.to_sym)
-            v[squash.to_s.to_sym]
-          elsif v.has_key?(squash.to_s)
-            v[squash.to_s]
+          squash_s = squash.to_s
+
+          if v.key?(key = squash_s.to_sym)
+            v[key]
+          elsif v.has_key?(squash_s)
+            v[squash_s]
           else
             v
           end
@@ -92,7 +94,7 @@ module Cistern::Attributes
         self.attributes[name] = options
       end
 
-      options[:aliases] = Array(options[:aliases]).map { |a| a.to_s.to_sym }
+      options[:aliases] = Array(options[:aliases] || options[:alias]).map { |a| a.to_s.to_sym }
 
       options[:aliases].each do |new_alias|
         aliases[new_alias] << name.to_s.to_sym
@@ -173,26 +175,39 @@ module Cistern::Attributes
     end
 
     def merge_attributes(new_attributes = {})
+      protected_methods  = (Cistern::Model.instance_methods - [:service, :identity, :collection])
+      ignored_attributes = self.class.ignored_attributes
+      class_attributes   = self.class.attributes
+      class_aliases      = self.class.aliases
+
       new_attributes.each do |_key, value|
-        key = _key.to_s.to_sym
+        string_key = _key.kind_of?(String) ? _key : _key.to_s
+        symbol_key = case _key
+              when String
+                _key.to_sym
+              when Symbol
+                _key
+              else
+                string_key.to_sym
+              end
+
         # find nested paths
-        value.is_a?(::Hash) && self.class.attributes.each do |name, options|
-          if (options[:squash] || []).first == key.to_s
-            send("#{name}=", {key => value})
+        value.is_a?(::Hash) && class_attributes.each do |name, options|
+          if options[:squash] && options[:squash].first == string_key
+            send("#{name}=", {symbol_key => value})
           end
         end
 
-        unless self.class.ignored_attributes.include?(key)
-          if self.class.aliases.has_key?(key)
-            self.class.aliases[key].each do |aliased_key|
+        unless ignored_attributes.include?(symbol_key)
+          if class_aliases.has_key?(symbol_key)
+            class_aliases[symbol_key].each do |aliased_key|
               send("#{aliased_key}=", value)
             end
           end
 
-          protected_methods = Cistern::Model.instance_methods - [:service, :identity, :collection]
-
-          if !protected_methods.include?(key) && self.respond_to?("#{key}=", true)
-            send("#{key}=", value)
+          assignment_method = "#{string_key}="
+          if !protected_methods.include?(symbol_key) && self.respond_to?(assignment_method, true)
+            send(assignment_method, value)
           end
         end
       end

data/lib/cistern/collection.rb

@@ -6,11 +6,9 @@ module Cistern::Collection
     :keep_if, :pop, :shift, :delete_at, :compact
   ].to_set # :nodoc:
 
-  def self.service_collection(service, klass)
-    plural_name = service.collection_method(klass)
-
+  def self.service_collection(service, klass, name)
     service.const_get(:Collections).module_eval <<-EOS, __FILE__, __LINE__
-      def #{plural_name}(attributes={})
+      def #{name}(attributes={})
         #{klass.name}.new(attributes.merge(service: self))
       end
     EOS
@@ -20,7 +18,11 @@ module Cistern::Collection
 
   module ClassMethods
     def model(new_model=nil)
-      @model ||= new_model
+      @_model ||= new_model
+    end
+
+    def service_method(name=nil)
+      @_service_method ||= name
     end
   end
 
@@ -69,7 +71,7 @@ module Cistern::Collection
   end
 
   def model
-    self.class.instance_variable_get('@model')
+    self.class.model
   end
 
   def new(attributes = {})

data/lib/cistern/model.rb

@@ -4,6 +4,21 @@ module Cistern::Model
   def self.included(klass)
     klass.send(:extend, Cistern::Attributes::ClassMethods)
     klass.send(:include, Cistern::Attributes::InstanceMethods)
+    klass.send(:extend, Cistern::Model::ClassMethods)
+  end
+
+  def self.service_model(service, klass, name)
+    service.const_get(:Collections).module_eval <<-EOS, __FILE__, __LINE__
+      def #{name}(attributes={})
+        #{klass.name}.new(attributes.merge(service: self))
+      end
+    EOS
+  end
+
+  module ClassMethods
+    def service_method(name=nil)
+      @_service_method ||= name
+    end
   end
 
   attr_accessor :collection, :service

data/lib/cistern/request.rb

@@ -1,20 +1,16 @@
 module Cistern::Request
-  def self.service_request(service, klass)
-    request = klass.request_name || Cistern::String.camelize(Cistern::String.demodulize(klass.name))
-
+  def self.service_request(service, klass, name)
     service::Mock.module_eval <<-EOS, __FILE__, __LINE__
-      def #{request}(*args)
+      def #{name}(*args)
         #{klass}.new(self)._mock(*args)
       end
     EOS
 
     service::Real.module_eval <<-EOS, __FILE__, __LINE__
-      def #{request}(*args)
+      def #{name}(*args)
         #{klass}.new(self)._real(*args)
       end
     EOS
-
-    request
   end
 
   attr_reader :service
@@ -24,7 +20,8 @@ module Cistern::Request
   end
 
   module ClassMethods
-    def request_name
+    def service_method(name=nil)
+      @_service_method ||= name
     end
   end
 end

data/lib/cistern/service.rb

@@ -9,10 +9,6 @@ class Cistern::Service
       service.collections
     end
 
-    def mocked_requests
-      service.mocked_requests
-    end
-
     def requests
       service.requests
     end
@@ -46,6 +42,10 @@ class Cistern::Service
         class Model
           include Cistern::Model
 
+          def self.inherited(klass)
+            service.models << klass
+          end
+
           def self.service
             #{klass.name}
           end
@@ -59,7 +59,7 @@ class Cistern::Service
             klass.send(:extend, Cistern::Collection::ClassMethods)
             klass.send(:include, Cistern::Attributes::InstanceMethods)
 
-            Cistern::Collection.service_collection(service, klass)
+            service.collections << klass
           end
 
           def self.service
@@ -73,9 +73,7 @@ class Cistern::Service
           def self.inherited(klass)
             klass.extend(Cistern::Request::ClassMethods)
 
-            name = Cistern::Request.service_request(service, klass)
-
-            service.requests[name.to_sym] = klass
+            service.requests << klass
           end
 
           def self.service
@@ -109,26 +107,20 @@ class Cistern::Service
       @collections ||= []
     end
 
-    def collection_method(klass)
-      relative_demodulized = klass.name.gsub("#{self.name}::", "").gsub("::", "")
-
-      Cistern::String.underscore(relative_demodulized)
-    end
-
     def models
-      @models ||= []
+      @_models ||= []
     end
 
     def recognized_arguments
-      @recognized_arguments ||= []
+      @_recognized_arguments ||= []
     end
 
     def required_arguments
-      @required_arguments ||= []
+      @_required_arguments ||= []
     end
 
     def requests
-      @requests ||= {}
+      @_requests ||= []
     end
 
     def requires(*args)
@@ -139,10 +131,6 @@ class Cistern::Service
       self.recognized_arguments.concat(args)
     end
 
-    def mocked_requests
-      @mocked_requests ||= {}
-    end
-
     def validate_options(options={})
       required_options = Cistern::Hash.slice(options, *required_arguments)
 
@@ -159,7 +147,35 @@ class Cistern::Service
       end
     end
 
+    def setup
+      return true if @_setup
+
+      requests.each do |klass|
+        name = klass.service_method ||
+          Cistern::String.camelize(Cistern::String.demodulize(klass.name))
+
+        Cistern::Request.service_request(self, klass, name)
+      end
+
+      collections.each do |klass|
+        name = klass.service_method ||
+          Cistern::String.underscore(klass.name.gsub("#{self.name}::", "").gsub("::", ""))
+
+        Cistern::Collection.service_collection(self, klass, name)
+      end
+
+      models.each do |klass|
+        name = klass.service_method ||
+          Cistern::String.underscore(klass.name.gsub("#{self.name}::", "").gsub("::", ""))
+
+        Cistern::Model.service_model(self, klass, name)
+      end
+
+      @_setup = true
+    end
+
     def new(options={})
+      setup
       validate_options(options)
 
       self.const_get(self.mocking? ? :Mock : :Real).new(options)

data/lib/cistern/version.rb

@@ -1,3 +1,3 @@
 module Cistern
-  VERSION = "1.0.1.pre6"
+  VERSION = "2.0.1"
 end

data/spec/collection_spec.rb

@@ -1,51 +1,67 @@
 require 'spec_helper'
 
 describe "Cistern::Collection" do
-  class SampleCollectionModel < Sample::Model
+  class SampleService < Cistern::Service
+  end
+
+  class Drug < SampleService::Model
     identity :id
     attribute :name
   end
 
-  class SampleCollection < Sample::Collection
-    model SampleCollectionModel
+  class Drugs < SampleService::Collection
+    model Drug
 
     def all
       self.load([{id: 1}, {id: 3, name: "tom"}, {id: 2}])
     end
   end
 
+  class Tacs < SampleService::Collection
+    service_method :toes
+  end
+
+  it "should generate a default collection method" do
+    expect(SampleService.new.drugs).not_to be_empty
+  end
+
+  it "should allow for a specific collection name" do
+    expect(SampleService.new).to     respond_to(:toes)
+    expect(SampleService.new).not_to respond_to(:tacs)
+  end
+
   it "should give to_s" do
-    collection = SampleCollection.new
+    collection = Drugs.new
     expect(collection.to_s).not_to eq "[]"
     expect(collection.to_s.gsub(/:[^>]*/,'')).to eq(collection.all.to_s.gsub(/:[^>]*/,''))
   end
 
   it "should give size and count" do
-    expect(SampleCollection.new.size).to eq(3)
-    expect(SampleCollection.new.count).to eq(3)
+    expect(Drugs.new.size).to eq(3)
+    expect(Drugs.new.count).to eq(3)
   end
 
   it "should give first" do
-    expect(SampleCollection.new.first).to eq(SampleCollectionModel.new(id: 1))
+    expect(Drugs.new.first).to eq(Drug.new(id: 1))
   end
 
   it "should give last" do
-    expect(SampleCollection.new.last).to eq(SampleCollectionModel.new(id: 2))
+    expect(Drugs.new.last).to eq(Drug.new(id: 2))
   end
 
   it "should reject" do
-    expect(SampleCollection.new.reject{|m| m.id == 2}).to eq([SampleCollectionModel.new(id: 1), SampleCollectionModel.new(id: 3)])
+    expect(Drugs.new.reject{|m| m.id == 2}).to eq([Drug.new(id: 1), Drug.new(id: 3)])
   end
 
   it "should select" do
-    expect(SampleCollection.new.select{|m| m.id == 2}).to eq([SampleCollectionModel.new(id: 2)])
+    expect(Drugs.new.select{|m| m.id == 2}).to eq([Drug.new(id: 2)])
   end
 
   it "should slice" do
-    expect(SampleCollection.new.slice(0,2)).to eq([SampleCollectionModel.new(id: 1), SampleCollectionModel.new(id: 3, name: "tom")])
+    expect(Drugs.new.slice(0,2)).to eq([Drug.new(id: 1), Drug.new(id: 3, name: "tom")])
   end
 
   it "should ==" do
-    SampleCollection.new.all == SampleCollection.new.all
+    Drugs.new.all == Drugs.new.all
   end
 end

data/spec/hash_spec.rb

@@ -15,6 +15,20 @@ describe "Cistern::Hash" do
     end
   end
 
+  describe "#except" do
+    let(:input) do
+      { one: "one", two: "two", three: "three" }
+    end
+
+    it "returns a new hash without the specified keys" do
+      expect(Cistern::Hash.except(input, :one, :two)).to eq({three: "three"})
+    end
+
+    it "skips keys that aren't in the original hash" do
+      expect(Cistern::Hash.except(input, :four)).to eq(input)
+    end
+  end
+
   describe "#stringify_keys" do
     let(:input) do
       { one: "one", two: "two" }

data/spec/model_spec.rb

@@ -20,6 +20,30 @@ describe "Cistern::Model" do
     end
   end
 
+  it "should set singular resource service method" do
+    class ModelService < Cistern::Service
+    end
+
+    class ModelService::Jimbob < ModelService::Model
+    end
+
+    expect(ModelService.new).to respond_to(:jimbob)
+    expect(ModelService.new.jimbob).to be_a(ModelService::Jimbob)
+  end
+
+  it "should set specific singular resource service method" do
+    class SpecificModelService < Cistern::Service
+    end
+
+    class SpecificModelService::Jimbob < SpecificModelService::Model
+      service_method :john_boy
+    end
+
+    expect(SpecificModelService.new).not_to respond_to(:jimbob)
+    expect(SpecificModelService.new).to respond_to(:john_boy)
+    expect(SpecificModelService.new.john_boy).to be_a(SpecificModelService::Jimbob)
+  end
+
   it "should duplicate a model" do
     class DupSpec < Sample::Model
       identity :id

data/spec/request_spec.rb

@@ -15,8 +15,8 @@ describe "Cistern::Request" do
 
   # @todo Sample::Service.request
   class ListSamples < SampleService::Request
-    # @todo name
-    # name :list_all_samples
+    service_method :list_all_samples
+
     def real(*args)
       service.service_args + args + ["real"]
     end
@@ -27,11 +27,11 @@ describe "Cistern::Request" do
   end
 
   it "should execute a new-style request" do
-    expect(SampleService.new.list_samples("sample1")).to eq([{}, "sample1", "real"])
-    expect(SampleService::Real.new.list_samples("sample2")).to eq(["sample2", "real"])
-    expect(SampleService::Mock.new.list_samples("sample3")).to eq(["sample3", "mock"])
+    expect(SampleService.new.list_all_samples("sample1")).to eq([{}, "sample1", "real"])
+    expect(SampleService::Real.new.list_all_samples("sample2")).to eq(["sample2", "real"])
+    expect(SampleService::Mock.new.list_all_samples("sample3")).to eq(["sample3", "mock"])
 
     # service access
-    expect(SampleService.new(:key => "value").list_samples("stat")).to eq([{:key => "value"}, "stat", "real"])
+    expect(SampleService.new(:key => "value").list_all_samples("stat")).to eq([{:key => "value"}, "stat", "real"])
   end
 end

metadata

@@ -1,15 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cistern
 version: !ruby/object:Gem::Version
-  version: 1.0.1.pre6
-  prerelease: 6
+  version: 2.0.1
 platform: ruby
 authors:
 - Josh Lane
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-28 00:00:00.000000000 Z
+date: 2015-03-05 00:00:00.000000000 Z
 dependencies: []
 description: API client framework extracted from Fog
 email:
@@ -18,8 +17,9 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .travis.yml
+- ".gemrelease"
+- ".gitignore"
+- ".travis.yml"
 - Gemfile
 - Guardfile
 - LICENSE.txt
@@ -62,27 +62,26 @@ files:
 homepage: http://joshualane.com/cistern
 licenses:
 - MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>'
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23.2
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: API client framework
 test_files:
 - spec/collection_spec.rb
@@ -97,3 +96,4 @@ test_files:
 - spec/spec_helper.rb
 - spec/support/service.rb
 - spec/wait_for_spec.rb
+has_rdoc: