hyperclient 0.0.8 → 0.1.0

data/Gemfile

@@ -9,5 +9,6 @@ gem 'guard-minitest'
 gem 'pry'
 
 gem 'redcarpet'
-gem 'yard', '~> 0.7.5'
+gem 'yard', '~> 0.8'
 gem 'yard-tomdoc', git: 'git://github.com/rubyworks/yard-tomdoc'
+gem 'simplecov', require: false

data/Readme.md

@@ -14,13 +14,12 @@ Hyperclient is a Ruby Hypermedia API client written in Ruby.
 Example API client:
 
 ````ruby
-class MyAPIClient
-  include Hyperclient
+options = {}
+options[:auth]    = {type: :digest, user:, 'user', password: 'password'}
+options[:headers] = {'accept-encoding' => 'deflate, gzip'}
+options[:debug]   = true
 
-  entry_point 'http://myapp.com/api'
-  auth :digest, 'user', 'password'
-  http_options headers: {'accept-encoding' => 'deflate, gzip'}, debug: true
-end
+api = Hyperclient::EntryPoint.new('http://myapp.com/api', options)
 ````
 
 [More examples][examples]
@@ -38,16 +37,15 @@ Hyperclient will try to fetch and discover the resources from your API.
 Accessing the links for a given resource is quite straightforward:
 
 ````ruby
-api = MyAPIClient.new
 api.links.posts_categories
-# => #<Resource @name="posts_categories" ...>
+# => #<Resource ...>
 ````
 
 You can also iterate between all the links:
 
 ````ruby
-api.links.each do |link|
-  puts link.name, link.url
+api.links.each do |name, link|
+  puts name, link.url
 end
 ````
 
@@ -56,7 +54,6 @@ Actually, you can call any [Enumerable][enumerable] method :D
 If a Resource doesn't have friendly name you can always access it as a Hash:
 
 ````ruby
-api = MyAPIClient.new
 api.links['http://myapi.org/rels/post_categories']
 ````
 
@@ -65,24 +62,21 @@ api.links['http://myapi.org/rels/post_categories']
 Accessing embedded resources is similar to accessing links:
 
 ````ruby
-api = MyAPIClient.new
-api.resources.posts
-# => #<Resource @name="posts" ...>
+api.embedded.posts
 ````
 
 And you can also iterate between them:
 
 ````ruby
-api.resources.each do |resource|
-  puts resource.name, resource.url
+api.embedded.each do |name, resource|
+  puts name, resource.attributes
 end
 ````
 
 You can even chain different calls (this also applies for links):
 
 ````ruby
-api.resources.posts.first.links.author
-# => #<Resource @name="author" ...>
+api.embedded.posts.first.links.author
 ````
 
 ### Attributes
@@ -91,7 +85,7 @@ Not only you might have links and embedded resources in a Resource, but also
 its attributes:
 
 ````ruby
-api.resources.posts.first.attributes
+api.embedded.posts.first.attributes
 # => {title: 'Linting the hell out of your Ruby classes with Pelusa',
       teaser: 'Gain new insights about your code thanks to static analysis',
       body:   '...' }
@@ -106,14 +100,14 @@ Hyperclient uses [HTTParty][httparty] under the hood to perform HTTP calls. You
 call any valid HTTP method on any Resource:
 
 ````ruby
-post = api.resources.posts.first
+post = api.embedded.posts.first
 post.get
 post.head
 post.put({title: 'New title'})
 post.delete
 post.options
 
-posts = api.resources.posts
+posts = api.links.posts
 posts.post({title: "I'm a blogger!", body: 'Wohoo!!'})
 ````
 

data/examples/cyberscore.rb

@@ -3,42 +3,54 @@ require 'hyperclient'
 class Cyberscore
   include Hyperclient
 
-  entry_point 'http://cs-api.heroku.com/api/'
-
   def news
-    links.feeds.links.submissions.embedded.news
+    client.links.submissions.embedded.news
   end
 
   def submissions
-    links.feeds.links.submissions.embedded.submissions
+    client.links..submissions.embedded.submissions
   end
 
   def games
-    links.feeds.links.games.embedded.games
+    client.links.games.embedded.games
   end
 
   def add_game(name)
-    links.feeds.links.submissions.post({name: name})
+    client.links.submissions.post({name: name})
   end
 
   def motd
-    attributes['motd']
+    client.attributes.motd
+  end
+
+  def method_missing(method, *args, &block)
+    if client.respond_to?(method)
+      client.send(method, *args, &block)
+    else
+      super
+    end
+  end
+
+  private
+  def client
+    @client ||= Hyperclient::EntryPoint.new 'http://cs-api.heroku.com/api', 
+                {debug: false, headers: {'content-type' => 'application/json'}}
   end
 end
 
-def print_resources(resources)
-  resources.each do |resource|
-    if resource.is_a?(Array)
-      print_resources(resource)
+def print_links(links)
+  links.each do |name, link|
+    if link.is_a?(Array)
+      print_links(link)
     else
-      puts %{Found "#{resource.name}" at "#{resource.url}" }
+      puts %{Found "#{name}" at "#{link.url}" }
     end
   end
 end
 
 def print_games(games)
   games.each do |game|
-    puts %{Found "#{game.attributes['name']}" at "#{game.url}" }
+    puts %{Found "#{game.attributes['name']}" }
   end
 end
 
@@ -49,15 +61,15 @@ puts "Let's inspect the API:"
 puts "\n"
 
 puts 'Links from the entry point:'
-print_resources(api.links)
+print_links(api.links)
 puts "\n"
 
 puts 'How is the server feeling today?'
 puts api.motd
 puts "\n"
 
-puts "Let's read the feeds:"
-print_resources(api.links.feeds.links)
+puts "Let's read the news:"
+print_links(api.links.news.links)
 puts "\n"
 
 puts "I like games!"

data/examples/hal_shop.rb

@@ -1,18 +1,12 @@
 require 'hyperclient'
-
-class HalShop
-  include Hyperclient
-
-  entry_point 'http://hal-shop.heroku.com'
-  http_options debug: true
-end
+require 'pp'
 
 def print_resources(resources)
-  resources.each do |resource|
-    if resource.is_a?(Array)
-      print_resources(resource)
-    else
-      puts %{Found "#{resource.name}" at "#{resource.url}" }
+  resources.each do |name, resource|
+    begin
+      puts %{Found #{name} at #{resource.url}}
+    rescue
+      puts %{Found #{name}}
     end
   end
 end
@@ -24,7 +18,7 @@ def print_attributes(attributes)
   end
 end
 
-api = HalShop.new
+api = Hyperclient::EntryPoint.new 'http://hal-shop.heroku.com'
 
 puts "Let's inspect the API:"
 puts "\n"
@@ -33,25 +27,24 @@ puts 'Links from the entry point:'
 
 print_resources(api.links)
 
-puts
-puts 'Resources at the entry point:'
-print_resources(api.embedded)
-
 puts
 puts "Let's see what stats we have:"
 print_attributes(api.embedded.stats.attributes)
 
-products = api.links["http://hal-shop.heroku.com/rels/products"].reload
+products = api.links["http://hal-shop.heroku.com/rels/products"].resource
 
 puts 
 puts "And what's the inventory of products?"
 puts products.attributes['inventory_size']
 
-puts 
-puts 'What resources does products have?'
-print_resources(products.embedded.products)
-
 puts
+puts 'What embedded resources does products have?'
+products.embedded.products.each do |product|
+  puts 'Product:'
+  print_attributes(product.attributes)
+  puts
+end
+
 puts 'And links?'
 print_resources(products.links)
 

data/hyperclient.gemspec

@@ -15,8 +15,10 @@ Gem::Specification.new do |gem|
   gem.version       = Hyperclient::VERSION
 
   gem.add_dependency 'httparty'
+  gem.add_dependency 'uri_template'
 
   gem.add_development_dependency 'minitest'
   gem.add_development_dependency 'turn'
   gem.add_development_dependency 'webmock'
+  gem.add_development_dependency 'mocha'
 end

data/lib/hyperclient.rb

@@ -1,89 +1,7 @@
-# Public: The Hyperclient module has various methods to so you can setup your
-# API client.
-#
-# Examples
-#
-#   class MyAPI
-#     extend Hyperclient
-#
-#     entry_point 'http://api.myapp.com'
-#   end
+# Public: Hyperclient namespace.
 #
 module Hyperclient
-  # Internal: Extend the parent class with our class methods.
-  def self.included(base)
-    base.send :extend, ClassMethods
-  end
-
-  # Public: Initializes the API with the entry point.
-  def entry
-    @entry ||= Resource.new('', resource_options)
-  end
-
-  # Internal: Delegate the method to the API if it exists.
-  #
-  # This way we can call our API client with the resources name instead of
-  # having to add the methods to it.
-  def method_missing(method, *args, &block)
-    if entry.respond_to?(method)
-      entry.send(method, *args, &block)
-    else
-      super
-    end
-  end
-
-  module ClassMethods
-    # Public: Set the entry point of your API.
-    #
-    # url - A block to pass the API url.
-    #
-    # Returns nothing.
-    def entry_point(&url)
-      Resource.entry_point = url.call
-    end
-
-    # Public: Sets the authentication options for your API client.
-    #
-    # options - A block used to pass authentication options. Needed data is:
-    #   type     - A String or Symbol with the authentication method. Can be 
-    #             either :basic or :digest.
-    #   user     - A String with the user.
-    #   password - A String with the password.
-    #
-    #   Example: 
-    #     auth{ {type: :digest, user: 'user', password: 'secret'} }
-    #
-    # Returns nothing.
-    def auth(&options)
-      options = options.call
-      http_options({auth: {type: options[:type], credentials: [options[:user], options[:password]]}})
-    end
-
-    # Public: Sets the HTTP options that will be used to initialize
-    # Hyperclient::HTTP.
-    #
-    # options - A Hash with options to pass to HTTP.
-    #
-    # Example:
-    #
-    #   http_options headers: {'accept-encoding' => 'deflate, gzip'}
-    #
-    # Returns a Hash.
-    def http_options(options = {})
-      @@http_options ||= {}
-      @@http_options.merge!(options)
-
-      {http: @@http_options}
-    end
-  end
-
-  private
-  # Internal: Returns a Hash with the options to initialize the entry point
-  # Resource.
-  def resource_options
-    {name: 'Entry point'}.merge(self.class.http_options)
-  end
 end
 
-require 'hyperclient/resource'
+require 'hyperclient/entry_point'
 require "hyperclient/version"

data/lib/hyperclient/attributes.rb

@@ -0,0 +1,20 @@
+require 'hyperclient/collection'
+
+module Hyperclient
+  # Public: A wrapper class to easily acces the attributes in a Resource.
+  #
+  # Examples
+  #
+  #   resource.attributes['title']
+  #   resource.attributes.title
+  #
+  class Attributes < Collection
+    # Public: Initializes the Attributes of a Resource.
+    #
+    # representation - The hash with the HAL representation of the Resource.
+    #
+    def initialize(representation)
+      @collection = representation.delete_if {|key, value| key =~ /^_/}
+    end
+  end
+end

data/lib/hyperclient/collection.rb

@@ -0,0 +1,53 @@
+module Hyperclient
+  # Public: A helper class to wrapp a collection of elements and provide
+  # Hash-like access or via a method call.
+  #
+  # Examples
+  #
+  #  collection['value']
+  #  collection.value
+  #
+  class Collection
+    include Enumerable
+
+    # Public: Initializes the Collection.
+    #
+    # collection - The Hash to be wrapped.
+    def initialize(collection)
+      @collection = collection
+    end
+
+    # Public: Each implementation to allow the class to use the Enumerable
+    # benefits.
+    #
+    # Returns an Enumerator.
+    def each(&block)
+      @collection.each(&block)
+    end
+
+    # Public: Provides Hash-like access to the collection.
+    #
+    # name - A String or Symbol of the value to get from the collection.
+    #
+    # Returns an Object.
+    def [](name)
+      @collection[name.to_s]
+    end
+
+    # Public: Provides method access to the collection values.
+    #
+    # It allows accessing a value as `collection.name` instead of
+    # `collection['name']`
+    #
+    # Returns an Object.
+    def method_missing(method_name, *args, &block)
+      @collection.fetch(method_name.to_s) { super }
+    end
+
+    # Internal: Accessory method to allow the collection respond to the
+    # methods that will hit method_missing.
+    def respond_to_missing?(method_name, include_private = false)
+      @collection.include?(method_name.to_s)
+    end
+  end
+end

data/lib/hyperclient/entry_point.rb

@@ -0,0 +1,49 @@
+require 'hyperclient/link'
+
+module Hyperclient
+  # Public: The EntryPoint is the main public API for Hyperclient. It is used to
+  # initialize an API client and setup the configuration.
+  #
+  # Examples
+  #
+  #  options = {}
+  #  options[:headers] = {'accept-encoding' => 'deflate, gzip'}
+  #  options[:auth]    = {type: 'digest', user: 'foo', password: 'secret'}
+  #  options[:debug]   = true
+  #
+  #  client = Hyperclient::EntryPoint.new('http://my.api.org', options)
+  #
+  class EntryPoint
+
+    # Public: Returns the Hash with the configuration.
+    attr_accessor :config
+
+    # Public: Initializes an EntryPoint.
+    #
+    # url    - A String with the entry point of your API.
+    # config - The Hash options used to setup the HTTP client (default: {})
+    #          See HTTP for more documentation.
+    def initialize(url, config = {})
+      @config = config.update(base_uri: url)
+      @entry  = Link.new({'href' => url}, self).resource
+    end
+
+    # Internal: Delegate the method to the entry point Resource if it exists.
+    #
+    # This way we can call our API client with the resources name instead of
+    # having to add the methods to it.
+    def method_missing(method, *args, &block)
+      if @entry.respond_to?(method)
+        @entry.send(method, *args, &block)
+      else
+        super
+      end
+    end
+
+    # Internal: Accessory method to allow the entry point respond to the
+    # methods that will hit method_missing.
+    def respond_to_missing?(method, include_private = false)
+      @entry.respond_to?(method.to_s)
+    end
+  end
+end