frenetic 0.0.1.alpha1

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+.rspec
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rvmrc

@@ -0,0 +1 @@
+rvm --create use ruby-1.9.2-p290@frenetic > /dev/null

data/.travis.yml

@@ -0,0 +1,4 @@
+rvm:
+  - 1.9.2
+  - 1.9.3
+script: bundle exec rspec --require spec_helper --order rand --color --format documentation

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in frenetic.gemspec
+gemspec
+
+gem "awesome_print"
+gem "fakefs",         '~> 0.4.0', :require => false

data/Guardfile

@@ -0,0 +1,15 @@
+# More info at https://github.com/guard/guard#readme
+
+guard 'rspec', :notification => false do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})           { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')        { "spec" }
+  watch(%r{^spec/support/(.+)\.rb$})  { "spec" }
+end
+
+guard 'spork', :rspec_env => { 'RAILS_ENV' => 'test' } do
+  watch('config/environment.rb')
+  watch('Gemfile')
+  watch('Gemfile.lock')
+  watch('spec/spec_helper.rb') { :rspec }
+end

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Derek Lindahl
+
+MIT License
+
+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,223 @@
+# Frenetic [![Build Status][travis_status]][travis]
+
+[travis_status]: https://secure.travis-ci.org/dlindahl/frenetic.png
+[travis]: http://travis-ci.org/dlindahl/frenetic
+
+An opinionated Ruby-based Hypermedia API (HAL+JSON) client.
+
+## About
+
+fre&bull;net&bull;ic |frəˈnetik|<br/>
+adjective<br/>
+fast and energetic in a rather wild and uncontrolled way : *a frenetic pace of activity.*
+
+So basically, this is a crazy way to interact with your Hypermedia HAL+JSON API.
+
+Get it? *Hypermedia*?
+
+*Hyper*?
+
+...
+
+If you have not implemented a HAL+JSON API, then this will not work very well for you.
+
+## Opinions
+
+Like I said, it is opinionated. It is so opinionated, it is probably the biggest
+a-hole you've ever met.
+
+Maybe in time, if you teach it, it will become more open-minded.
+
+### HAL+JSON Content Type
+
+Frenetic expects all responses to be in [HAL+JSON][hal_json]. It chose that
+standard because it is trying to make JSON API's respond in a predictable
+manner, which it thinks is an awesome idea.
+
+### Authentication
+
+Frenetic is going to try and use Basic Auth whether you like it or not. If
+that is not required, nothing will probably happen. But its going to send the
+header anyway.
+
+### API Description
+
+The API's root URL must respond with a description, much like the
+[Spire.io][spire.io] API. This is crucial in order for Frenetic to work. If
+Frenetic doesn't know what the API contains, it can't parse any resource
+responses.
+
+It is expected that any subclasses of `Frenetic::Resource` will adhere to the
+schema defined here.
+
+Example:
+
+```js
+{
+  "_links":{
+    "self":{"href":"/api/"},
+    "inkers":{"href":"/api/inkers"},
+  },
+  "_embedded":{
+    "schema":{
+      "_links":{
+        "self":{"href":"/api/schema"}
+      },
+      "order":{
+        "description":"A widget order",
+        "type":"object",
+        "properties":{
+          "id":{"type":"integer"},
+          "first_name":{"type":"string"},
+          "last_name":{"type":"string"},
+        }
+      }
+    }
+  }
+}
+```
+
+This response will be requested by Frenetic whenever a call to
+`YourAPI.description` is made. The response is memoized so any future calls
+will not trigger another API request.
+
+### API Resources
+
+While HAL+JSON is awesome, not all implementations are perfect. Frenetic
+assumes a HAL+JSON response as built by [Roar], which may not be in 100%
+compliance.
+
+Example:
+
+```js
+{
+  "id":1,
+  "first_name":"Foo",
+  "last_name":"Bar",
+  "_links":{
+    "self":{"href":"/order/1"},
+    "next":{"href":"/order/2"}
+  }
+}
+```
+
+The problem here is that the entire response really should be wrapped in
+`"_embedded"` and `"order"` keys.
+
+So until that is fixed, Frenetic will continue to be pig headed and continue
+to do the "wrong" thing.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'frenetic'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install frenetic
+
+## Usage
+
+### Client Initialization
+
+```ruby
+MyAPI = Frenetic.new(
+  'url'          => 'https://api.yoursite.com',
+  'username'     => 'yourname',
+  'password'     => 'yourpassword',
+  'headers' => {
+    'accept' => 'application/vnd.yoursite-v1.hal+json'
+    # Optional
+    'user-agent' => 'Your Site's API Client', # Optional custom User Agent, just 'cuz
+  }
+)
+```
+
+### Making Requests
+
+Once you have created a client instance, you are free to use it however you'd
+like.
+
+A Frenetic instance supports any HTTP verb that [Faraday][faraday] has
+impletented. This includes GET, POST, PUT, PATCH, and DELETE.
+
+#### Frenetic::Resource
+
+An easier way to make requests for a resource is to have your model inherit from
+`Frenetic::Resource`. This makes it a bit easier to encapsulate all of your
+resource's API requests into one place.
+
+```ruby
+class Order < Frenetic::Resource
+
+  api_client { MyAPI }
+
+  class << self
+    def find( id )
+      if response = api.get( api.description.links.order.href.gsub('{id}', id.to_s) ) and response.success?
+        self.new( response.body )
+      else
+        raise OrderNotFound, "No Order found for #{id}"
+      end
+    end
+  end
+end
+```
+
+The `api_client` class method merely tells `Frenetic::Resource` which API Client
+instance to use. If you lazily instantiate your client, then you should pass a
+block as demonstrated above.
+
+Otherwise, you may pass by reference:
+
+```ruby
+class Order < Frenetic::Resource
+  api_client MyAPI
+end
+```
+
+When your model is initialized, it will contain attribute readers for every
+property defined in your API's schema or description. In theory, this allows an
+API to add, remove, or change properties without the need to directly update
+your model.
+
+### Interpretting Responses
+
+Any response body returned by a Frenetic generated API call will be returned as
+an OpenStruct-like object. This object responds to dot-notation as well as Hash
+keys and is enumerable.
+
+```ruby
+response.body.resources.orders.first
+```
+
+or
+
+```ruby
+response.body['_embedded']['orders'][0]
+```
+
+For your convenience, certain HAL+JSON keys have been aliased by methods a bit
+more readable:
+
+  * `_embedded` can be referenced as `resources`
+  * `_links` can be referenced as `links`
+  * `href` can be referenced as `url`
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+[hal_json]: http://stateless.co/hal_specification.html
+[spire.io]: http://api.spire.io/
+[roar]: https://github.com/apotonick/roar
+[faraday]: https://github.com/technoweenie/faraday

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/frenetic.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/frenetic/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Derek Lindahl"]
+  gem.email         = ["dlindahl@customink.com"]
+  gem.description   = %q{An opinionated Ruby-based Hypermedia API client.}
+  gem.summary       = %q{Here lies a Ruby-based Hypermedia API client that expects HAL+JSON and makes a lot of assumptions about your API.}
+  gem.homepage      = "http://dlindahl.github.com/frenetic/"
+
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.name          = "frenetic"
+  gem.require_paths = ["lib"]
+  gem.version       = Frenetic::VERSION
+
+  gem.add_dependency             'faraday',       '~> 0.8.0.rc2'
+  gem.add_dependency             'addressable',   '~> 2.2.7'
+  gem.add_dependency             'patron',        '~> 0.4.18'
+
+  gem.add_development_dependency 'guard-spork',   '~> 0.6.0'
+  gem.add_development_dependency 'guard-rspec',   '~> 0.7.0'
+  gem.add_development_dependency 'rspec',         '~> 2.9.0'
+  gem.add_development_dependency 'bourne',        '~> 1.1.2'
+  gem.add_development_dependency 'webmock',       '~> 1.8.6'
+  gem.add_development_dependency 'vcr',           '~> 2.0.1'
+end

data/lib/frenetic.rb

@@ -0,0 +1,49 @@
+require 'addressable/uri'
+require 'patron' # Needed to prevent https://github.com/technoweenie/faraday/issues/140
+require 'faraday'
+
+require "frenetic/configuration"
+require "frenetic/hal_json"
+require "frenetic/resource"
+require "frenetic/version"
+
+class Frenetic
+
+  class MissingAPIReference < StandardError; end
+
+  extend Forwardable
+  def_delegators :@connection, :get, :put, :post, :delete
+
+  attr_reader  :connection
+  alias_method :conn, :connection
+
+  def initialize( config = {} )
+    config      = Configuration.new( config )
+
+    api_url     = Addressable::URI.parse( config[:url] )
+    @root_url   = api_url.path
+
+    @connection = Faraday.new( config ) do |builder|
+      builder.use HalJson
+      builder.request :basic_auth, config[:username], config[:password]
+      builder.adapter :patron
+    end
+  end
+
+  def description
+    @description ||= load_description
+  end
+
+  # A naive approach to reloading a Frenetic instance for testing purpose.
+  def reload!
+    instance_variables.each { |var| instance_variable_set(var, nil) }
+  end
+
+private
+
+  def load_description
+    if response = get( @root_url ) and response.success?
+      response.body
+    end
+  end
+end

data/lib/frenetic/configuration.rb

@@ -0,0 +1,82 @@
+require 'socket'
+
+class Frenetic
+  class Configuration < Hash
+
+    class ConfigurationError < StandardError; end
+
+    # TODO: This is in desperate need of .with_indifferent_access...
+    # TODO: "content-type" should probably be within a "headers" key
+    def initialize( custom_config = {} )
+      config = config_file.merge custom_config
+      config = symbolize_keys config
+
+      config[:username] = config[:api_key] if config[:api_key]
+      config[:headers]  ||= {}
+      config[:request]  ||= {}
+
+      config[:headers][:accept] ||= "application/hal+json"
+
+      # Copy the config into this Configuration instance.
+      config.each { |k, v| self[k] = v }
+
+      super()
+
+      configure_user_agent
+
+      validate
+    end
+
+  private
+
+    def configure_user_agent
+      frenetic_ua = "Frenetic v#{Frenetic::VERSION}; #{Socket.gethostname}"
+
+      if self[:headers][:user_agent]
+        self[:headers][:user_agent] << " (#{frenetic_ua})"
+      else
+        self[:headers][:user_agent] = frenetic_ua
+      end
+    end
+
+    def validate
+      unless self[:url]
+        raise ConfigurationError, "No API URL defined!"
+      end
+    end
+
+    def config_file
+      config_path = File.join( 'config', 'frenetic.yml' )
+
+      if File.exists? config_path
+        config = YAML.load_file( config_path )
+        env    = ENV['RAILS_ENV'] || ENV['RACK_ENV']
+
+        if config and config.has_key? env
+          config[env]
+        else
+          {}
+        end
+      else
+        {}
+      end
+    end
+
+    def symbolize_keys( arg )
+      case arg
+      when Array
+        arg.map { |elem| symbolize_keys elem }
+      when Hash
+        Hash[
+          arg.map { |key, value|  
+            k = key.is_a?(String) ? key.to_sym : key
+            v = symbolize_keys value
+            [k,v]
+          }]
+      else
+        arg
+      end
+    end
+
+  end
+end

data/lib/frenetic/hal_json.rb

@@ -0,0 +1,23 @@
+require 'json'
+require 'recursive_open_struct'
+require 'frenetic/hal_json/response_wrapper'
+
+class Frenetic
+
+  class HalJson < Faraday::Middleware
+    def call( env )
+      @app.call(env).on_complete { |env| on_complete(env) }
+    end
+
+    def on_complete( env )
+      if success? env
+        env[:body] = ResponseWrapper.new( JSON.parse(env[:body]) )
+      end
+    end
+
+    def success?( env )
+      (200..201) === env[:status]
+    end
+  end
+
+end

data/lib/frenetic/hal_json/response_wrapper.rb

@@ -0,0 +1,43 @@
+class Frenetic
+  class HalJson < Faraday::Middleware
+    # TODO: The API for this differs greatly from the `inspect` output.
+    # Perhaps the Hash keys should be normalized and then aliased back to the original keys?
+    class ResponseWrapper < RecursiveOpenStruct
+      include Enumerable
+
+      def []( key )
+        self.send(key)
+      end
+
+      def members
+        methods(false).grep(%r{_as_a_hash}).map { |m| m[0...-10] }
+      end
+      alias_method :keys, :members
+
+      def each
+        members.each do |method|
+          yield method, send(method)
+        end
+
+        self
+      end
+
+      class << self
+        # Do not define setters
+        def define_setter( * ); end
+
+        def define_getter( method_name, hash_key )
+          method_name = case method_name
+            when :_embedded then :resources
+            when :_links    then :links
+            when :href      then :url
+            else method_name
+            end
+
+          super
+        end
+      end
+
+    end
+  end
+end

data/lib/frenetic/resource.rb

@@ -0,0 +1,68 @@
+class Frenetic
+  class Resource
+
+    attr_reader :links
+
+    def initialize( attributes = {} )
+      if attributes.is_a? Hash
+        load attributes.keys, attributes
+
+        @links = []
+      else
+        load self.class.schema, attributes
+        load attributes.resources.members, attributes.resources
+
+        @links = attributes.links
+      end
+    end
+
+    # Attempts to retrieve the Resource Schema from the API based on the name
+    # of the subclass.
+    class << self
+      def api_client( client = nil )
+        metaclass.instance_eval do
+          define_method :api do
+            block_given? ? yield : client
+          end
+        end
+      end
+
+      def schema
+        if self.respond_to? :api
+          class_name = self.to_s.split('::').last.downcase
+
+          api.description.resources.schema.send(class_name).properties
+        else
+          raise MissingAPIReference,
+              "This Resource needs a class accessor defined as " +
+              "`.api` that references an instance of Frenetic."
+        end
+      end
+
+    private
+
+      def metaclass
+        metaclass = class << self; self; end
+      end
+    end
+
+  private
+
+    def metaclass
+      metaclass = class << self; self; end
+    end
+
+    def load( keys, attributes )
+      keys.each do |key|
+        instance_variable_set "@#{key}", attributes[key.to_s]
+
+        metaclass.class_eval do
+          define_method key do
+            instance_variable_get( "@#{key}")
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/frenetic/version.rb

@@ -0,0 +1,3 @@
+class Frenetic
+  VERSION = "0.0.1.alpha1"
+end

data/lib/recursive_open_struct.rb

@@ -0,0 +1,79 @@
+# Stolen from https://github.com/aetherknight/recursive-open-struct/blob/master/lib/recursive_open_struct.rb
+require 'ostruct'
+
+class RecursiveOpenStruct < OpenStruct
+
+  def new_ostruct_member(name)
+    name = name.to_sym
+    unless self.respond_to?(name)
+      class << self; self; end.class_eval { define_accessors name, name }
+    end
+    name
+  end
+
+  def keys
+    @table.keys
+  end
+
+###
+
+  def self.define_accessors( *args )
+    define_getter *args
+    define_setter *args
+    define_getter_as_a_hash *args
+  end
+
+  def self.define_getter( method_name, hash_key )
+    define_method( method_name ) do
+      v = @table[hash_key]
+      v.is_a?(Hash) ? self.class.new(v) : v
+    end
+  end
+
+  def self.define_setter( method_name, hash_key )
+    define_method("#{method_name}=") { |x| modifiable[hash_key] = x }
+  end
+
+  def self.define_getter_as_a_hash( method_name, hash_key )
+    define_method("#{method_name}_as_a_hash") { @table[hash_key] }
+  end
+
+###
+
+  def debug_inspect(indent_level = 0, recursion_limit = 12)
+    display_recursive_open_struct(@table, indent_level, recursion_limit)
+  end
+
+  def display_recursive_open_struct(ostrct_or_hash, indent_level, recursion_limit)
+
+    if recursion_limit <= 0 then
+      # protection against recursive structure (like in the tests)
+      puts '  '*indent_level + '(recursion limit reached)'
+    else
+      #puts ostrct_or_hash.inspect
+      if ostrct_or_hash.is_a?(self.class) then
+        ostrct_or_hash = ostrct_or_hash.marshal_dump
+      end
+
+      # We'll display the key values like this :    key =  value
+      # to align display, we look for the maximum key length of the data that will be displayed
+      # (everything except hashes)
+      data_indent = ostrct_or_hash
+        .reject { |k, v| v.is_a?(self.class) || v.is_a?(Hash) }
+          .max {|a,b| a[0].to_s.length <=> b[0].to_s.length}[0].length
+      # puts "max length = #{data_indent}"
+
+      ostrct_or_hash.each do |key, value|
+        if (value.is_a?(self.class) || value.is_a?(Hash)) then
+          puts '  '*indent_level + key.to_s + '.'
+          display_recursive_open_struct(value, indent_level + 1, recursion_limit - 1)
+        else
+          puts '  '*indent_level + key.to_s + ' '*(data_indent - key.to_s.length) + ' = ' + value.inspect
+        end
+      end
+    end
+
+    true
+  end
+
+end

data/spec/fixtures/vcr_cassettes/description_success.yml

@@ -0,0 +1,38 @@
+---
+http_interactions:
+- request:
+    method: get
+    uri: http://example.org:5447/api
+    body:
+      encoding: US-ASCII
+      string: ''
+    headers:
+      Accept-Encoding:
+      - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
+      Accept:
+      - ! '*/*'
+      User-Agent:
+      - Ruby
+  response:
+    status:
+      code: 200
+      message: ! 'OK '
+    headers:
+      Content-Type:
+      - application/json
+      Content-Length:
+      - '620'
+      Server:
+      - WEBrick/1.3.1 (Ruby/1.9.2/2011-07-09)
+      Date:
+      - Sun, 08 Apr 2012 02:09:53 GMT
+      Connection:
+      - Keep-Alive
+    body:
+      encoding: US-ASCII
+      string: ! '{"_links":{"self":{"href":"/api/"},"inkers":{"href":"/api/inkers"},"inker":{"href":"/api/inker/{id}"},"sessions":{"href":"/api/sessions"}},"_embedded":{"schema":{"_links":{"self":{"href":"/api/schema"}},"mediaType":"application/vnd.customink-inker_directory-v1+json","inker":{"description":"A
+        CustomInk employee","type":"object","properties":{"first_name":{"type":"string"},"last_name":{"type":"string"},"city":{"type":"string"},"images":{"type":"array","items":{"type":"object"}}}},"session":{"description":"A
+        gatewat for generating an authenticated session.","type":"object","properties":{"st-ticket-FOO":"string"}}}}}'
+    http_version: !!null 
+  recorded_at: Sun, 08 Apr 2012 02:09:53 GMT
+recorded_with: VCR 2.0.1

data/spec/lib/frenetic/configuration_spec.rb

@@ -0,0 +1,77 @@
+describe Frenetic::Configuration do
+  let(:content_type) { 'application/vnd.frenetic-v1-hal+json' }
+  let(:yaml_config) {
+    { 'test' => {
+        'url'          => 'http://example.org',
+        'api_key'      => '1234567890',
+        'headers' => {
+          'accept' => content_type,
+        },
+        'request' => {
+          'timeout' => 10000
+        }
+      }
+    }
+  }
+  let(:config) { Frenetic::Configuration.new( unknown: :option ) }
+
+  subject { config }
+
+  describe ".configuration" do
+    include FakeFS::SpecHelpers
+
+    context "with a proper config YAML" do
+      before do
+        FileUtils.mkdir_p("config")
+        File.open( 'config/frenetic.yml', 'w') do |f|
+          f.write( YAML::dump(yaml_config) )
+        end
+      end
+
+      it { should include(:username) }
+      it { should include(:url) }
+
+      it { should_not include(:unknown => 'option')}
+      it "should set default request options" do
+        subject[:request][:timeout].should == 10000
+      end
+      it "should set a User Agent request header" do
+        subject[:headers][:user_agent].should =~ %r{Frenetic v.+; \S+$}
+      end
+
+      context "with a specified Accept header" do
+        it "should set an Accept request header" do
+          subject[:headers].should include(:accept => 'application/vnd.frenetic-v1-hal+json')
+        end
+      end
+      context "without a specified Accept header" do
+        let(:content_type) { nil }
+
+        it "should set an Accept request header" do
+          subject[:headers].should include(:accept => 'application/hal+json')
+        end
+      end
+    end
+
+    context "with no config YAML" do
+      context "and no passed options" do
+        it "should raise a configuration error" do
+          expect { Frenetic::Configuration.new }.to raise_error( Frenetic::Configuration::ConfigurationError )
+        end
+      end
+      context "and passed options" do
+        let(:config) { Frenetic::Configuration.new( 'url' => 'http://example.org' ) }
+
+        it { should be_a( Hash ) }
+        it { should_not be_empty }
+        it "should set an Accepts request header" do
+          subject[:headers].should include(:accept => 'application/hal+json')
+        end
+        it "should set a User Agent request header" do
+          subject[:headers][:user_agent].should =~ %r{Frenetic v.+; \S+$}
+        end
+      end
+    end
+  end
+
+end

data/spec/lib/frenetic/hal_json/response_wrapper_spec.rb

@@ -0,0 +1,70 @@
+describe Frenetic::HalJson::ResponseWrapper do
+  let(:properties) do
+    { 'a' => 1, 'b' => 2 }
+  end
+  let(:wrapper) { Frenetic::HalJson::ResponseWrapper.new( properties ) }
+
+  subject { wrapper }
+
+  describe "#members" do
+    subject { wrapper.members }
+
+    its(:size)  { should == 2 }
+    its(:first) { should == 'a' }
+    its(:last)  { should == 'b' }
+  end
+
+  describe "#keys" do
+    subject { wrapper.keys }
+
+    it { should == wrapper.members }
+  end
+
+  describe "#each" do
+    before do
+      @items = []
+      wrapper.each do |*args|
+        @items << args
+      end
+    end
+
+    it { should be_a Frenetic::HalJson::ResponseWrapper }
+    it "should iterate over each getter" do
+      @items.should == [ ['a',1], ['b',2] ]
+    end
+  end
+
+  describe ".define_setter" do
+    subject { wrapper.methods(false) }
+
+    it "should not create setters" do
+      subject.none? { |name| name.to_s =~ %r{=} }.should be_true
+    end
+  end
+
+  describe ".define_getter" do
+    context "with a :_links property" do
+      let(:properties) { { '_links' => 'foo' } }
+
+      it "should create a :links property" do
+        wrapper.links.should == 'foo'
+      end
+    end
+
+    context "with a :_embedded property" do
+      let(:properties) { { '_embedded' => 'foo' } }
+
+      it "should create a :resources property" do
+        wrapper.resources.should == 'foo'
+      end
+    end
+
+    context "with a :_embedded property" do
+      let(:properties) { { 'href' => 'foo' } }
+
+      it "should create a :url property" do
+        wrapper.url.should == 'foo'
+      end
+    end    
+  end
+end

data/spec/lib/frenetic/hal_json_spec.rb

@@ -0,0 +1,70 @@
+describe Frenetic::HalJson do
+  let(:hal_json) { Frenetic::HalJson.new }
+  let(:app_callbacks_stub) do
+    stub('FaradayCallbackStubs').tap do |cb_stub|
+      cb_stub.stubs('on_complete').yields env
+    end
+  end
+  let(:app_stub) do
+    stub('FaradayAppStub').tap do |app_stub|
+      app_stub.stubs(call: app_callbacks_stub)
+    end
+  end
+
+  before { hal_json.instance_variable_set("@app", app_stub) }
+
+  subject { hal_json }
+
+  describe "#call" do
+    let(:env) { Hash.new(:status => 200) }
+
+    before do
+      hal_json.stubs(:on_complete)
+
+      hal_json.call(env)
+    end
+
+    it "should execute the on_complete callback" do
+      hal_json.should have_received(:on_complete).with(env)
+    end
+  end
+
+  describe "#on_complete" do
+    context "with a successful response" do
+      let(:env) do
+        {
+          :status => 200,
+          :body => JSON.generate({
+            '_links' => {}
+          })
+        }
+      end
+
+      before { hal_json.on_complete(env) }
+
+      it "should parse the HAL+JSON response" do
+        env[:body].should be_a( Frenetic::HalJson::ResponseWrapper )
+      end
+    end    
+  end
+
+  describe "#success?" do
+    subject { hal_json.success?( env ) }
+
+    context "with a 200 OK response" do
+      let(:env) { {:status => 200 } }
+
+      it { should be_true }
+    end
+    context "with a 201 Created response" do
+      let(:env) { {:status => 201 } }
+
+      it { should be_true }
+    end
+    context "with a 204 No Content" do
+      let(:env) { {:status => 204 } }
+
+      it { should be_false }
+    end
+  end
+end

data/spec/lib/frenetic/resource_spec.rb

@@ -0,0 +1,102 @@
+describe Frenetic::Resource do
+
+  @client = Frenetic.new('url' => 'http://example.org')
+
+  let(:resource) { Frenetic::Resource.new }
+  let(:description_stub) do
+    Frenetic::HalJson::ResponseWrapper.new('resources' => { 'schema' => { 'resource' =>
+      { 'properties' => { 'foo' => 2 } }
+    } } )
+  end
+
+  subject { resource }
+
+  context "created from a Hash" do
+    let(:resource) { Frenetic::Resource.new( foo: 'bar' ) }
+
+    it { should respond_to(:foo) }
+    its(:links) { should be_empty }
+  end
+
+  context "created from a HAL-JSON response" do
+    let(:api_response) do
+      Frenetic::HalJson::ResponseWrapper.new(
+        '_links' => {
+          '_self' => { '_href' => 'bar' }
+        },
+        'foo' => 1,
+        'bar' => 2,
+        '_embedded' => {
+          'baz' => 'resource'
+        }
+      )
+    end
+    let(:resource_a) { Frenetic::Resource.new( api_response ) }
+    let(:resource_b) { Frenetic::Resource.new }
+
+    before do
+      @client.stubs(:description).returns( description_stub )
+
+      Frenetic::Resource.stubs(:api).returns( @client )
+
+      resource_a and resource_b
+    end
+
+    context "initialized with data" do
+      subject { resource_a }
+
+      its(:foo) { should == 1 }
+      it { should_not respond_to(:bar) }
+      its(:links) { should_not be_empty }
+    end
+    context "intiailized in sequence without data" do
+      subject { resource_b }
+
+      it { should_not respond_to(:foo) }
+      it { should_not respond_to(:bar) }
+      its(:links) { should be_empty }
+    end
+  end
+
+  describe ".api_client" do
+    context "with a block" do
+      before { resource.class.api_client { @client } }
+
+      it "should reference the defined API client" do
+        subject.class.api.should == @client
+      end
+    end
+
+    context "with an argument" do
+      before { resource.class.api_client @client }
+
+      it "should reference the defined API client" do
+        subject.class.api.should == @client
+      end
+    end
+  end
+
+  describe ".schema" do
+    subject { resource.class.schema }
+
+    context "with a defined API Client" do
+      before do
+        @client.stubs(:description).returns( description_stub )
+
+        resource.class.api_client @client
+      end
+
+      it "should return the schema for the specific resource" do
+        subject.should == description_stub.resources.schema.resource.properties
+      end
+    end
+
+    context "without a defined API Client" do
+      before { Frenetic::Resource.stubs(:respond_to?).with(:api).returns( false ) }
+
+      it "should raise an error" do
+        expect { subject }.to raise_error(Frenetic::MissingAPIReference)
+      end
+    end
+  end
+end

data/spec/lib/frenetic_spec.rb

@@ -0,0 +1,66 @@
+describe Frenetic do
+  let(:client) { Frenetic.new }
+  let(:config) { {
+    :url     => 'http://example.org:5447/api',
+    :api_key => '1234567890',
+    :version => 'v1'
+  } }
+
+  before { Frenetic::Configuration.stubs(:new).returns(config) }
+
+  subject { client }
+
+  it { should respond_to(:description) }
+  it { should respond_to(:connection) }
+  it { should respond_to(:conn) }
+  it { should respond_to(:get) }
+  it { should respond_to(:put) }
+  it { should respond_to(:post) }
+  it { should respond_to(:delete) }
+
+  its(:connection) { should be_a(Faraday::Connection) }
+
+  describe "#connection" do
+    before do
+      faraday_stub = Faraday.new
+      Faraday.stubs(:new).returns( faraday_stub )
+
+      client
+    end
+
+    subject { client.connection }
+
+    it { should be_a(Faraday::Connection) }
+
+    it "should be created" do
+      Faraday.should have_received(:new).with() { |config|
+        config.has_key? :url
+      }
+    end
+  end
+ 
+  describe "#description" do
+    subject do
+      VCR.use_cassette('description_success') do
+        client.description
+      end
+    end
+
+    it { should be_a( Frenetic::HalJson::ResponseWrapper ) }
+  end
+
+  describe "#reload!" do
+    before do
+      VCR.use_cassette('description_success') do
+        client.description
+      end
+
+      client.reload!
+    end
+
+    it "should not have any non-Nil instance variables" do
+      client.instance_variables.none? { |s| client.instance_variable_get(s).nil? }.should be_false
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,31 @@
+require 'spork'
+ENV['RAILS_ENV'] ||= 'test'
+
+Spork.prefork do
+  # Loading more in this block will cause your tests to run faster. However,
+  # if you change any configuration or code from libraries loaded here, you'll
+  # need to restart spork for it take effect.
+
+  require 'rspec'
+  require 'fakefs/spec_helpers'
+  require 'awesome_print'
+  require 'bourne'
+  require 'vcr'
+
+  RSpec.configure do |config|
+    config.filter_run :focus => true
+    config.run_all_when_everything_filtered = true
+    config.treat_symbols_as_metadata_keys_with_true_values = true
+    config.mock_with :mocha
+  end
+
+  VCR.configure do |c|
+    c.cassette_library_dir = 'spec/fixtures/vcr_cassettes'
+    c.hook_into :webmock
+  end
+end
+
+Spork.each_run do
+  # This code will be run each time you run your specs.
+  require 'frenetic'
+end

metadata

@@ -0,0 +1,175 @@
+--- !ruby/object:Gem::Specification
+name: frenetic
+version: !ruby/object:Gem::Version
+  version: 0.0.1.alpha1
+  prerelease: 6
+platform: ruby
+authors:
+- Derek Lindahl
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-16 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: &2156831400 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.8.0.rc2
+  type: :runtime
+  prerelease: false
+  version_requirements: *2156831400
+- !ruby/object:Gem::Dependency
+  name: addressable
+  requirement: &2156830640 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.2.7
+  type: :runtime
+  prerelease: false
+  version_requirements: *2156830640
+- !ruby/object:Gem::Dependency
+  name: patron
+  requirement: &2156829960 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.4.18
+  type: :runtime
+  prerelease: false
+  version_requirements: *2156829960
+- !ruby/object:Gem::Dependency
+  name: guard-spork
+  requirement: &2156829240 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+  type: :development
+  prerelease: false
+  version_requirements: *2156829240
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: &2156828580 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.7.0
+  type: :development
+  prerelease: false
+  version_requirements: *2156828580
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &2156827880 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.9.0
+  type: :development
+  prerelease: false
+  version_requirements: *2156827880
+- !ruby/object:Gem::Dependency
+  name: bourne
+  requirement: &2156827200 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.2
+  type: :development
+  prerelease: false
+  version_requirements: *2156827200
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: &2156826480 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.6
+  type: :development
+  prerelease: false
+  version_requirements: *2156826480
+- !ruby/object:Gem::Dependency
+  name: vcr
+  requirement: &2156825880 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.0.1
+  type: :development
+  prerelease: false
+  version_requirements: *2156825880
+description: An opinionated Ruby-based Hypermedia API client.
+email:
+- dlindahl@customink.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rvmrc
+- .travis.yml
+- Gemfile
+- Guardfile
+- LICENSE
+- README.md
+- Rakefile
+- frenetic.gemspec
+- lib/frenetic.rb
+- lib/frenetic/configuration.rb
+- lib/frenetic/hal_json.rb
+- lib/frenetic/hal_json/response_wrapper.rb
+- lib/frenetic/resource.rb
+- lib/frenetic/version.rb
+- lib/recursive_open_struct.rb
+- spec/fixtures/vcr_cassettes/description_success.yml
+- spec/lib/frenetic/configuration_spec.rb
+- spec/lib/frenetic/hal_json/response_wrapper_spec.rb
+- spec/lib/frenetic/hal_json_spec.rb
+- spec/lib/frenetic/resource_spec.rb
+- spec/lib/frenetic_spec.rb
+- spec/spec_helper.rb
+homepage: http://dlindahl.github.com/frenetic/
+licenses: []
+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
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Here lies a Ruby-based Hypermedia API client that expects HAL+JSON and makes
+  a lot of assumptions about your API.
+test_files:
+- spec/fixtures/vcr_cassettes/description_success.yml
+- spec/lib/frenetic/configuration_spec.rb
+- spec/lib/frenetic/hal_json/response_wrapper_spec.rb
+- spec/lib/frenetic/hal_json_spec.rb
+- spec/lib/frenetic/resource_spec.rb
+- spec/lib/frenetic_spec.rb
+- spec/spec_helper.rb