placid 0.0.1

data/.gitignore

@@ -0,0 +1,7 @@
+Gemfile.lock
+.yardoc/*
+.rvmrc
+pkg/*
+coverage/*
+doc/*
+*~

data/.yardopts

@@ -0,0 +1 @@
+--markup markdown

data/Gemfile

@@ -0,0 +1,2 @@
+source :rubygems
+gemspec

data/MIT-LICENSE

@@ -0,0 +1,23 @@
+The MIT License
+
+Copyright (c) 2012 Society for Human Resource Management
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

data/README.md

@@ -0,0 +1,87 @@
+placid
+======
+
+Placid is an ActiveRecord-ish model using a REST API for storage. The REST API
+can be any backend you choose or create yourself, provided it follows some basic
+conventions.
+
+Installation
+------------
+
+    $ gem install placid
+
+Usage
+-----
+
+Define a subclass with the name of your REST model:
+
+    class Person < Placid::Model
+    end
+
+and you'll get these class methods, and their REST equivalents:
+
+    Person.list              # GET     /people
+    Person.create(attrs)     # POST    /person      (attrs)
+    Person.find(id)          # GET     /person/:id
+    Person.destroy(id)       # DELETE  /person/:id
+    Person.update(id, attrs) # PUT     /person/:id  (attrs)
+
+By default, placid assumes that your REST API is running on `localhost`. To
+change this, set:
+
+    Placid::Config.rest_url = 'http://my.rest.host:8080'
+
+Each model has a field that is used for uniquely identifying instances. This
+would be called the "primary key" in a relational database. If you don't
+specify the name of the field, `id` is assumed. If your model uses a
+different field name, you can specify it like this:
+
+    class Person < Placid::Model
+      unique_id :email
+    end
+
+The `Placid::Model` base class includes helper methods for basic HTTP requests.
+You can use these from any model instance, or call them from custom methods you
+define on your model. For example:
+
+    class Person < Placid::Model
+      unique_id :email
+
+      def add_phone(phone_number)
+        put(model, id, 'add_phone', phone_number)
+      end
+    end
+
+    jenny = Person.new(:email => 'jenny@example.com')
+
+    jenny.add_phone('867-5309')
+    # Same as:
+    jenny.put('person', 'jenny@example.com', 'add_phone', '867-5309')
+
+
+License
+-------
+
+The MIT License
+
+Copyright (c) 2012 Society for Human Resource Management
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

data/Rakefile

@@ -0,0 +1,12 @@
+require 'rake'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.pattern = 'spec/**/*.rb'
+  t.rspec_opts = ['--color', '--format doc']
+  t.rcov = true
+  t.rcov_opts = [
+    '--exclude /.gem/,/gems/,spec',
+  ]
+end
+

data/lib/placid/config.rb

@@ -0,0 +1,14 @@
+module Placid
+  class Config
+    class << self
+      attr_accessor :rest_url
+
+      def default_url
+        'http://localhost'
+      end
+    end
+  end
+end
+
+Placid::Config.rest_url = Placid::Config.default_url
+

data/lib/placid/exceptions.rb

@@ -0,0 +1,4 @@
+module Placid
+  class JSONParseError < RuntimeError
+  end
+end

data/lib/placid/helper.rb

@@ -0,0 +1,182 @@
+require 'uri'
+require 'json'
+require 'hashie'
+require 'rest-client'
+require 'placid/exceptions'
+
+module Placid
+  module Helper
+    # Escape any special URI characters in `text` and return the escaped string.
+    # `nil` is treated as an empty string.
+    #
+    # @return [String]
+    #
+    def escape(text)
+      URI.escape(text.to_s, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]"))
+    end
+
+    # If the last arg in `args` is a hash, pop it off and return it. Otherwise,
+    # return an empty hash. `args` is modified in-place. Behaves like
+    # ActiveSupport's `String#extract_options!` method.
+    #
+    # @param [Array] args
+    #   Zero or more arguments, the last of which might be a Hash.
+    #
+    # @return [Hash]
+    #
+    def extract_options(args)
+      args.last.is_a?(::Hash) ? args.pop : {}
+    end
+
+    # Return a full URL for a REST API request to the given path, relative to
+    # the configured `Placid::Config.rest_url`. Each path component is
+    # URI-escaped.
+    #
+    # @example
+    #   url('people', 'eric') #=> 'http://localhost/people/eric'
+    #   url('a b', 'c:d')     #=> 'http://localhost/a%20b/c%3Ad'
+    #
+    # @param [Array] path
+    #   Parts of the path to request. These will be escaped and joined with '/'.
+    #
+    # @return [String]
+    #
+    def url(*path)
+      url = Placid::Config.rest_url.to_s.gsub(/\/$/, '')
+      joined_path = path.map { |p| escape(p) }.join('/')
+      return "#{url}/#{joined_path}"
+    end
+
+    # Send a request and return the parsed JSON response.
+    #
+    # @example
+    #   request('get', 'people', 'eric')
+    #   request(:put, 'people', 'eric', {:title => "Developer"})
+    #
+    # @overload request(method, *path, params={})
+    #   @param [String, Symbol] method
+    #     Request method to use ('get', 'post', 'put', 'delete', etc.)
+    #   @param [Array] path
+    #     Path components for the request
+    #   @param [Hash] params
+    #     Optional parameters to send in the request.
+    #
+    # @return [Hash]
+    #   Parsed response, or an empty hash if parsing failed
+    #
+    def request(method, *path)
+      method = method.to_sym
+      params = extract_options(path)
+      params = {:params => params} if method == :get
+      base_url = Placid::Config.rest_url
+      begin
+        response = RestClient.send(method, url(*path), params)
+      rescue RestClient::Exception => e
+        response = e.response
+      rescue => e
+        raise
+      end
+      return JSON.parse(response) rescue {}
+    end
+
+    # Send a GET request and return the parsed JSON response.
+    #
+    # @example
+    #   get('people', 'eric')
+    #   get('people', {:name => 'eric'})
+    #
+    # @overload get(*path, params={})
+    #   See {#request} for allowed parameters.
+    #
+    # @return [Hash]
+    #   Parsed response, or an empty hash if parsing failed
+    #
+    def get(*path)
+      request('get', *path)
+    end
+
+    # Send a POST request and return the parsed JSON response.
+    #
+    # @example
+    #   post('people', 'new', {:name => 'eric'})
+    #
+    # @overload post(*path, params={})
+    #   See {#request} for allowed parameters.
+    #
+    # @return [Hash]
+    #   Parsed response, or an empty hash if parsing failed
+    #
+    def post(*path)
+      request('post', *path)
+    end
+
+    # Send a PUT request and return the parsed JSON response.
+    #
+    # @example
+    #   put('people', 'eric', {:title => 'Developer'})
+    #
+    # @overload put(*path, params={})
+    #   See {#request} for allowed parameters.
+    #
+    # @return [Hash]
+    #   Parsed response, or an empty hash if parsing failed
+    #
+    def put(*path)
+      request('put', *path)
+    end
+
+    # Send a DELETE request and return the parsed JSON response.
+    #
+    # @example
+    #   delete('people', 'eric')
+    #   delete('people', {:name => 'eric'})
+    #
+    # @overload delete(*path, params={})
+    #   See {#request} for allowed parameters.
+    #
+    # @return [Hash]
+    #   Parsed response, or an empty hash if parsing failed
+    #
+    def delete(*path)
+      request('delete', *path)
+    end
+
+    # Send a GET to a path that returns a single JSON object, and return the
+    # result as a Hashie::Mash.
+    #
+    # @overload get_mash(*path, params={})
+    #   See {#request} for allowed parameters.
+    #
+    # @return [Hashie::Mash]
+    #
+    def get_mash(*path)
+      json = get(*path)
+      begin
+        return Hashie::Mash.new(json)
+      rescue => e
+        raise Placid::JSONParseError,
+          "Cannot parse JSON as key-value pairs: #{e.message}"
+      end
+    end
+
+    # Send a GET to a path that returns a JSON array of objects, and return the
+    # result as an array of Hashie::Mash objects.
+    #
+    # @overload get_mashes(*path, params={})
+    #   See {#request} for allowed parameters.
+    #
+    # @return [Array]
+    #
+    def get_mashes(*path)
+      json = get(*path)
+      begin
+        return json.map {|rec| Hashie::Mash.new(rec)}
+      rescue => e
+        raise Placid::JSONParseError,
+          "Cannot parse JSON as an array of key-value pairs: #{e.message}"
+      end
+    end
+
+  end
+end
+

data/lib/placid/model.rb

@@ -0,0 +1,159 @@
+require 'hashie'
+require 'placid/helper'
+require 'active_support/inflector' # for `pluralize` and `underscore`
+
+module Placid
+  # Base class for RESTful models
+  class Model < Hashie::Mash
+
+    include Placid::Helper
+    extend Placid::Helper
+
+    # ------------------
+    # Instance methods
+    # ------------------
+
+    # Set the list of errors on this instance.
+    #
+    def errors=(new_errors)
+      self['errors'] = new_errors
+    end
+
+    # Return the list of errors on this instance. If the 'errors' attribute is
+    # either not set, or set to nil, then return an empty list.
+    #
+    def errors
+      return self['errors'] if self['errors']
+      return []
+    end
+
+    # Return true if there are any errors with this model.
+    #
+    def errors?
+      errors && !errors.empty?
+    end
+
+    # Return true if the given field is required.
+    #
+    def required?(field)
+      meta = self.class.meta
+      return meta[field] && meta[field][:required] == true
+    end
+
+    # Save this instance. This creates a new instance, or updates an existing
+    # one, with the attributes in this instance. Return true if creation or
+    # update were successful, false if there were any errors.
+    #
+    # @return [Boolean]
+    #   true if save was successful, false if there were any errors
+    #
+    def save
+      existing = self.class.find(self.id)
+      if existing.nil?
+        obj = self.class.create(self.to_hash)
+      else
+        obj = self.class.update(self.id, self.to_hash)
+      end
+      self.merge!(obj)
+      return !errors?
+    end
+
+    # Return the value in the unique_id field.
+    #
+    def id
+      self[self.class.unique_id]
+    end
+
+
+    # ------------------
+    # Class methods
+    # ------------------
+
+    @unique_id = nil
+    @meta = nil
+
+    # Return the `snake_case` name of this model, based on the derived class
+    # name. This name should match the REST API path component used to interact
+    # with the corresponding model.
+    #
+    def self.model
+      return self.name.underscore
+    end
+
+    # Get or set the field name used for uniquely identifying instances of this
+    # model.
+    def self.unique_id(field=nil)
+      if field.nil?
+        return @unique_id || :id
+      else
+        @unique_id = field
+      end
+    end
+
+    # Return a Hashie::Mash of meta-data for this model.
+    #
+    def self.meta
+      @meta ||= get_mash(model, 'meta')
+    end
+
+    # Return a Hashie::Mash with a list of all model instances.
+    #
+    def self.list
+      get_mashes(model.pluralize)
+    end
+
+    # Return a Model instance matching the given id
+    #
+    # @param [String] id
+    #   Identifier for the model instance to fetch
+    #
+    # @return [Model]
+    #
+    def self.find(id)
+      json = get(model, id)
+      return self.new(json)
+    end
+
+    # Create a new model instance and return it.
+    #
+    # @param [Hash] attrs
+    #   Attribute values for the new instance
+    #
+    # @return [Model]
+    #
+    def self.create(attrs={})
+      obj = self.new(attrs)
+      json = post(model, attrs)
+      obj.merge!(json)
+      return obj
+    end
+
+    # Update an existing model instance.
+    #
+    # @param [String] id
+    #   Identifier of the model instance to update
+    # @param [Hash] attrs
+    #   New attribute values to set
+    #
+    # @return [Model]
+    #
+    def self.update(id, attrs={})
+      obj = self.new(attrs)
+      json = put(model, id, attrs)
+      obj.merge!(json)
+      #obj.errors = json['errors']
+      return obj
+    end
+
+    # Destroy a model instance.
+    #
+    # @param [String] id
+    #   Identifier for the model instance to delete
+    #
+    def self.destroy(id)
+      delete(model, id)
+    end
+
+  end
+end
+

data/lib/placid.rb

@@ -0,0 +1,6 @@
+require 'placid/model'
+require 'placid/helper'
+require 'placid/config'
+
+module Placid
+end

data/placid.gemspec

@@ -0,0 +1,25 @@
+Gem::Specification.new do |s|
+  s.name = "placid"
+  s.version = "0.0.1"
+  s.summary = "Models from REST"
+  s.description = <<-EOS
+  EOS
+  s.authors = ["Eric Pierce"]
+  s.email = "epierce@automation-excellence.com"
+  s.homepage = "http://github.com/a-e/placid"
+  s.platform = Gem::Platform::RUBY
+
+  s.add_dependency 'hashie'
+  s.add_dependency 'json'
+  s.add_dependency 'rest-client'
+  s.add_dependency 'activesupport'
+
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'yard' # For documentation
+  s.add_development_dependency 'redcarpet' # For YARD / Markdown
+  s.add_development_dependency 'rcov'
+
+  s.files = `git ls-files`.split("\n")
+
+  s.require_path = 'lib'
+end

data/spec/placid_config_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Placid::Config do
+  after(:each) do
+    Placid::Config.rest_url = Placid::Config.default_url
+  end
+
+  it "has a default rest_url that is read-only" do
+    Placid::Config.rest_url.should == Placid::Config.default_url
+    lambda do
+      Placid::Config.default_url = 'foo'
+    end.should raise_error(NoMethodError)
+  end
+
+  it "allows setting rest_url" do
+    Placid::Config.rest_url = 'http://www.example.com'
+    Placid::Config.rest_url.should == 'http://www.example.com'
+  end
+end
+

data/spec/placid_helper_spec.rb

@@ -0,0 +1,109 @@
+require 'spec_helper'
+
+describe Placid::Helper do
+  describe "#escape" do
+    it "escapes all URI reserved characters" do
+      escape(";/?:@&=+$,[]").should == "%3B%2F%3F%3A%40%26%3D%2B%24%2C%5B%5D"
+    end
+  end
+
+  describe "#url" do
+    it "joins path components with '/'" do
+      url('foo', 'bar', 'baz').should == 'http://localhost/foo/bar/baz'
+    end
+
+    it "escapes path components to make them URI-safe" do
+      url('a b', 'c:d', 'e/f').should == 'http://localhost/a%20b/c%3Ad/e%2Ff'
+    end
+  end
+
+  describe "#request" do
+    it "returns a legitimate response as JSON" do
+      RestClient.stub(:get => '["success"]')
+      json = request('get')
+      json.should == ["success"]
+    end
+
+    it "returns a RestClient::Exception response as JSON" do
+      class RestException < RestClient::Exception
+        def response; '["fail"]'; end
+      end
+      RestClient.stub(:get).and_raise(RestException)
+      json = request('get')
+      json.should == ["fail"]
+    end
+
+    it "passes other exceptions through" do
+      RestClient.stub(:get).and_raise(URI::InvalidURIError)
+      lambda do
+        json = request('get')
+      end.should raise_error(URI::InvalidURIError)
+    end
+
+    it "returns an empty hash if there is no response" do
+      RestClient.stub(:get) { nil }
+      json = request('get')
+      json.should == {}
+    end
+
+    it "accepts a params hash as the last argument" do
+      RestClient.should_receive(:post).with('http://localhost/foo', {:bar => 'hi'})
+      json = request('post', 'foo', :bar => 'hi')
+    end
+
+    it "sends an empty params hash if none is given" do
+      RestClient.should_receive(:post).with('http://localhost/foo', {})
+      json = request('post', 'foo')
+    end
+
+    it "sends :params => params for get requests" do
+      RestClient.should_receive(:get).with('http://localhost/foo', {:params => {:x => 'y'}})
+      json = request('get', 'foo', :x => 'y')
+    end
+  end
+
+  describe "#get_mash" do
+    it "returns a Hashie::Mash for hash data" do
+      data = {
+        'first_name' => 'Nathan',
+        'last_name' => 'Stark',
+      }
+      RestClient.stub(:get => JSON(data))
+      mash = get_mash
+      mash.first_name.should == 'Nathan'
+      mash.last_name.should == 'Stark'
+    end
+
+    it "raises an exception when the JSON cannot be parsed" do
+      data = ['a', 'b', 'c']
+      RestClient.stub(:get => JSON(data))
+      lambda do
+        mashes = get_mash
+      end.should raise_error(Placid::JSONParseError)
+    end
+  end
+
+  describe "#get_mashes" do
+    it "returns a list of Hashie::Mash for list data" do
+      data = [
+        {'first_name' => 'Jack', 'last_name' => 'Carter'},
+        {'first_name' => 'Allison', 'last_name' => 'Blake'},
+      ]
+      RestClient.stub(:get => JSON(data))
+      mashes = get_mashes
+      mashes.first.first_name.should == 'Jack'
+      mashes.first.last_name.should == 'Carter'
+      mashes.last.first_name.should == 'Allison'
+      mashes.last.last_name.should == 'Blake'
+    end
+
+    it "raises an exception when the JSON cannot be parsed" do
+      data = ['a', 'b', 'c']
+      RestClient.stub(:get => JSON(data))
+      lambda do
+        mashes = get_mashes
+      end.should raise_error(Placid::JSONParseError)
+    end
+  end
+end
+

data/spec/placid_model_spec.rb

@@ -0,0 +1,330 @@
+require 'spec_helper'
+
+describe Placid::Model do
+  class Thing < Placid::Model
+  end
+
+  context "Instance methods" do
+    describe "#id" do
+      it "returns the value in the custom unique ID field" do
+        class Person < Placid::Model
+          unique_id :email
+        end
+        person_1 = Person.new(:email => 'foo1@bar.com')
+        person_2 = Person.new(:email => 'foo2@bar.org')
+        person_1.id.should == 'foo1@bar.com'
+        person_2.id.should == 'foo2@bar.org'
+      end
+
+      it "returns the value in the :id field if no custom field was set" do
+        thing_1 = Thing.new(:id => '111')
+        thing_2 = Thing.new(:id => '222')
+        thing_1.id.should == '111'
+        thing_2.id.should == '222'
+      end
+    end
+
+    describe "#save" do
+      it "creates a new instance if one doesn't exist" do
+        thing = Thing.new(:id => '123')
+        Thing.stub(:find => nil)
+        Thing.should_receive(:create).
+          with({'id' => '123'}).
+          and_return(Thing.new)
+        thing.save
+      end
+
+      it "updates an existing instance" do
+        thing = Thing.new(:id => '123')
+        Thing.stub(:find => {:id => '123'})
+        Thing.should_receive(:update).
+          with('123', {'id' => '123'}).
+          and_return(Thing.new)
+        thing.save
+      end
+
+      it "merges saved attributes on create" do
+        thing = Thing.new(:id => '123')
+        saved_attribs = {'id' => '123', 'name' => 'foo'}
+        Thing.stub(:find => nil)
+        Thing.should_receive(:create).
+          with({'id' => '123'}).
+          and_return(Thing.new(saved_attribs))
+        thing.save
+        thing.should == saved_attribs
+      end
+
+      it "merges saved attributes on update" do
+        thing = Thing.new(:id => '123')
+        saved_attribs = {'id' => '123', 'name' => 'foo'}
+        Thing.stub(:find => {:id => '123'})
+        Thing.should_receive(:update).
+          with('123', {'id' => '123'}).
+          and_return(Thing.new(saved_attribs))
+        thing.save
+        thing.should == saved_attribs
+      end
+
+      it "returns false if errors were reported" do
+        thing = Thing.new
+        Thing.stub(:find => nil)
+        Thing.stub(:post => {'errors' => 'Missing id'})
+        thing.save.should be_false
+      end
+
+      it "returns true if errors is an empty list" do
+        thing = Thing.new(:id => '123')
+        Thing.stub(:find => nil)
+        Thing.stub(:post => {'errors' => []})
+        thing.save.should be_true
+      end
+
+      it "returns true if no errors were reported" do
+        thing = Thing.new(:id => '123')
+        Thing.stub(:find => nil)
+        Thing.stub(:post => {})
+        thing.save.should be_true
+      end
+    end
+
+    describe "#required?" do
+      it "true if the given field is implicitly required" do
+        Thing.stub(:meta => {:id => {:required => true}})
+        thing = Thing.new
+        thing.required?(:id).should == true
+      end
+
+      it "false if the given field is explicitly optional" do
+        Thing.stub(:meta => {:id => {:required => false}})
+        thing = Thing.new
+        thing.required?(:id).should == false
+      end
+
+      it "false if the given field is implicitly optional" do
+        Thing.stub(:meta => {:id => {}})
+        thing = Thing.new
+        thing.required?(:id).should == false
+      end
+    end
+
+    describe "#errors=" do
+      it "sets the list of errors on the instance" do
+        thing = Thing.new
+        thing.errors = ['missing id']
+        thing['errors'].should == ['missing id']
+      end
+    end
+
+    describe "#errors" do
+      it "returns errors set on initialization" do
+        thing = Thing.new(:errors => ['missing id'])
+        thing.errors = ['missing id']
+        thing.errors.should == ['missing id']
+      end
+
+      it "returns errors set after initialization" do
+        thing = Thing.new
+        thing.errors = ['missing id']
+        thing.errors.should == ['missing id']
+      end
+
+      it "returns [] if errors are not set" do
+        thing = Thing.new
+        thing.errors.should == []
+      end
+
+      it "returns [] if errors is set to nil" do
+        thing = Thing.new
+        thing.errors = nil
+        thing.errors.should == []
+      end
+    end
+
+    describe "#errors?" do
+      it "returns true if errors is set to a nonempty value" do
+        thing = Thing.new(:errors => ['missing id'])
+        thing.errors?.should be_true
+      end
+
+      it "returns false if errors it not set" do
+        thing = Thing.new
+        thing.errors?.should be_false
+      end
+
+      it "returns false if errors is set to nil" do
+        thing = Thing.new
+        thing.errors = nil
+        thing.errors?.should be_false
+      end
+
+      it "returns false if errors is set to an empty list" do
+        thing = Thing.new
+        thing.errors = []
+        thing.errors?.should be_false
+      end
+    end
+
+    describe "helpers" do
+      it "can call #get on an instance" do
+        thing = Thing.new
+        RestClient.should_receive(:get).
+          with('http://localhost/thing/foo', {:params => {:x => 'y'}})
+        thing.get('thing', 'foo', :x => 'y')
+      end
+    end
+  end
+
+  context "Class methods" do
+    describe "#unique_id" do
+      it "returns :id if no ID was set in the derived class" do
+        class Default < Placid::Model
+        end
+        Default.unique_id.should == :id
+      end
+
+      it "returns the unique ID that was set in the derived class" do
+        class Explicit < Placid::Model
+          unique_id :custom
+        end
+        Explicit.unique_id.should == :custom
+      end
+    end
+
+    describe "#model" do
+      it "converts CamelCase to snake_case" do
+        class MyModelName < Placid::Model
+        end
+        MyModelName.model.should == 'my_model_name'
+      end
+    end
+
+    describe "#meta" do
+      it "returns a Mash of model meta-data" do
+        thing_meta = {
+          'name' => {'type' => 'String', 'required' => true}
+        }
+        RestClient.should_receive(:get).
+          with('http://localhost/thing/meta', {:params => {}}).
+          and_return(JSON(thing_meta))
+        Thing.meta.should == thing_meta
+      end
+
+      it "only sends a GET meta request once for the class" do
+        thing_meta = {
+          'name' => {'type' => 'String', 'required' => true}
+        }
+        RestClient.stub(:get => JSON(thing_meta))
+        RestClient.should_receive(:get).at_most(:once)
+        Thing.meta.should == thing_meta
+        Thing.meta.should == thing_meta
+        Thing.meta.should == thing_meta
+      end
+
+      it "stores meta-data separately for each derived class" do
+        class ThingOne < Placid::Model; end
+        class ThingTwo < Placid::Model; end
+
+        thing_one_meta = {
+          'one' => {'type' => 'String', 'required' => true}
+        }
+        RestClient.should_receive(:get).
+          with('http://localhost/thing_one/meta', {:params => {}}).
+          and_return(JSON(thing_one_meta))
+        ThingOne.meta.should == thing_one_meta
+
+        thing_two_meta = {
+          'two' => {'type' => 'String', 'required' => false}
+        }
+        RestClient.should_receive(:get).
+          with('http://localhost/thing_two/meta', {:params => {}}).
+          and_return(JSON(thing_two_meta))
+        ThingTwo.meta.should == thing_two_meta
+      end
+    end
+
+    describe "#list" do
+      it "returns a Mash list of all model instances" do
+        data = [
+          {'name' => 'Foo'},
+          {'name' => 'Bar'},
+        ]
+        RestClient.stub(:get => JSON(data))
+        Thing.list.should == data
+      end
+    end
+
+    describe "#find" do
+      it "returns a Model instance matching the given id" do
+        data = {'name' => 'Foo'}
+        RestClient.stub(:get => JSON(data))
+        Thing.find(1).should == data
+      end
+    end
+
+    describe "#create" do
+      context "attributes include" do
+        it "posted attributes if no attributes were returned" do
+          RestClient.stub(:post => '{}')
+          attrs = {'name' => 'Foo'}
+          Thing.create(attrs).should == {'name' => 'Foo'}
+        end
+
+        it "returned attributes if no attributes were posted" do
+          RestClient.stub(:post => '{"uri": "foo"}')
+          attrs = {}
+          Thing.create(attrs).should == {'uri' => 'foo'}
+        end
+
+        it "original attributes merged with returned attributes" do
+          RestClient.stub(:post => '{"uri": "foo"}')
+          attrs = {'name' => 'Foo'}
+          Thing.create(attrs).should == {'name' => 'Foo', 'uri' => 'foo'}
+        end
+      end
+
+      it "sets errors on the Model instance" do
+        data = {'errors' => ['name is required']}
+        RestClient.stub(:post => JSON(data))
+        Thing.create().errors.should == ['name is required']
+      end
+    end
+
+    describe "#update" do
+      context "attributes include" do
+        it "posted attributes if no attributes were returned" do
+          RestClient.stub(:put => '{}')
+          attrs = {'name' => 'Foo'}
+          result = Thing.update(1, attrs)
+          Thing.update(1, attrs).should == {'name' => 'Foo'}
+        end
+
+        it "returned attributes if no attributes were posted" do
+          RestClient.stub(:put => '{"uri": "foo"}')
+          attrs = {}
+          Thing.update(1, attrs).should == {'uri' => 'foo'}
+        end
+
+        it "original attributes merged with returned attributes" do
+          RestClient.stub(:put => '{"uri": "foo"}')
+          attrs = {'name' => 'Foo'}
+          Thing.update(1, attrs).should == {'name' => 'Foo', 'uri' => 'foo'}
+        end
+      end
+
+      it "sets errors on the Model instance" do
+        data = {'errors' => ['name is required']}
+        RestClient.stub(:put => JSON(data))
+        Thing.update(1, {}).errors.should == ['name is required']
+      end
+    end
+
+    describe "#destroy" do
+      it "returns the parsed JSON response" do
+        data = {'status' => 'ok'}
+        RestClient.stub(:delete => JSON(data))
+        Thing.destroy(1).should == data
+      end
+    end
+  end
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+# This file includes RSpec configuration that is needed for all spec testing.
+
+require 'rspec'
+require 'rspec/autorun' # needed for RSpec 2.6.x
+require 'placid'
+require 'json'
+
+RSpec.configure do |config|
+  config.color_enabled = true
+  config.include Placid
+  config.include Placid::Helper
+end

metadata

@@ -0,0 +1,192 @@
+--- !ruby/object:Gem::Specification 
+name: placid
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Eric Pierce
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-05-17 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hashie
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: json
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rest-client
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: yard
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: redcarpet
+  prerelease: false
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id007
+- !ruby/object:Gem::Dependency 
+  name: rcov
+  prerelease: false
+  requirement: &id008 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id008
+description: ""
+email: epierce@automation-excellence.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .yardopts
+- Gemfile
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/placid.rb
+- lib/placid/config.rb
+- lib/placid/exceptions.rb
+- lib/placid/helper.rb
+- lib/placid/model.rb
+- placid.gemspec
+- spec/placid_config_spec.rb
+- spec/placid_helper_spec.rb
+- spec/placid_model_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/a-e/placid
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Models from REST
+test_files: []
+
+has_rdoc: