api-presenter 0.0.3.2 → 0.1.0

data/.travis.yml

@@ -0,0 +1,7 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 1.9.2
+  - jruby-19mode
+  - rbx-19mode
+  - jruby-head

data/Gemfile

@@ -1,3 +1,8 @@
 source 'https://rubygems.org'
 
 gemspec
+
+group :test do
+  gem 'rake'
+  gem 'minitest', require: ['minitest/autorun']
+end

data/README.md

@@ -54,15 +54,16 @@ class PersonResource < Api::Presenter::Resource
   property :name
   property :age
   
-  def self_link
-    "/person/#{@resource.name}"
-  end
+  link "self", "/person/{{name}}"
 end
 ```
 
 We should use the property method to define each of our resource properties.
 
-The self_link definition tell which is the link that represents itself.
+The ```link``` method defines there is a "self" link which represents itself. It receives, the name of the link,
+the url representing it and optionally a block, that may receive a hash with options and should return a boolean.
+
+The stubs that look like ```{{method_name}}``` will be latter replaced with a method call to ```method_name``` on the resource.
 
 So now there is only one more thing left to do: Add the to_resource method used to convert the model
 into a resource.
@@ -111,9 +112,7 @@ class DogResource < Api::Presenter::Resource
   property :name
   property :owner
 
-  def self_link
-    "/dog/#{@resource.name}"
-  end
+  link "self", "/dog/{{name}}"
 end
 
 class Dog
@@ -267,8 +266,7 @@ This is a special case of ```Api::Presenter::CollectionResource``` where it also
 The main difference with a Collection is that it receives as a parameter, the parameters which where used to build
 the collection and also adds them to the response.
 
-The method ```self.hypermedia_query_parameters``` determins which parameters are used in the search. It's later used
-by the helper method ```query_string``` to build the query string.
+The method ```self.hypermedia_query_parameters``` determins which parameters are used in the search. It's later used to build the query string for the url.
 
 ```ruby
 class PersonSearchResource < Api::Presenter::SearchResource
@@ -276,9 +274,7 @@ class PersonSearchResource < Api::Presenter::SearchResource
     ["name", "age"]
   end
 
-  def self_link
-    "/search_person#{query_string}"
-  end
+  link "self", "/search_person"
 end
 
 search = PersonSearchResource.new(Collection.new([Person.new("Joe", 50), Person.new("Jane", 45)]), age: 45)
@@ -325,19 +321,62 @@ It will look like this:
 
 ### Adding additional links
 
-When building a resource there may be the need to build custom links. In order to do so, you need to define
-two methods in your resource class:
+When building a resource there may be the need to build custom links. In order to do so, can use
+the ```link``` class method:
 
 ```ruby
-def custom_link
-  "/path/to/custom_link"
-end
+link("custom", "/path/to/custom_link") { |options = {}| a_condition_that_determins_if_it_should_be_displayed returning true or false }
+```
 
-def custom_link?(options = {})
-  a_condition_that_determins_if_it_should_be_displayed returning true or false
-end
+You can also use special stubs (enclosed with ```{{method_name}}``` ) that will latter be resolved in call to the resource, like this:
+
+```ruby
+link("custom", "/path/to/custom_link/{{method_call}}") { |options = {}| a_condition_that_determins_if_it_should_be_displayed returning true or false }
 ```
 
+### Using full links
+If you want to use full links and not parcial, you can say:
+
+```ruby
+Api::Presenter::Resource.host = "http://you.domain.goes.here:port"
+```
+
+Now links will be display like this:
+
+```json
+{
+  "links":
+  {
+    "self":
+    {
+      "href": "http://you.domain.goes.here:port/search_person?query[age]=45query[name]="
+    },
+  }
+  "offset": 0,
+  "limit": 10,
+  "total": 2,
+  "query":
+  {
+    "age": 45,
+    "name": nil
+  },
+  "entries":
+  [
+    {
+      "self":
+      {
+        "href" : "http://you.domain.goes.here:port/person/Joe"
+      }
+    },
+    {
+      "self":
+      {
+        "href" : "http://you.domain.goes.here:port/person/Jane"
+      }
+    }
+  ]
+}
+```
 
 ## Contributing
 

data/Rakefile

@@ -1,6 +1,8 @@
-require "bundler/gem_tasks"
+require 'bundler/gem_tasks'
 require 'rake/testtask'
 
+task :default => [:spec]
+
 Rake::TestTask.new('spec') do |t|
   t.test_files = FileList['spec/*_spec.rb']
   t.verbose = true

data/lib/api/presenter/hypermedia.rb

@@ -17,35 +17,44 @@ module Api
         def present_properties(resource, representation)
           resource_properties = resource.class.properties.dup
           
-          # Special treatment for entries
-          entries_property = resource_properties.delete(:entries)
-
-          if entries_property
-            representation[entries_property.to_s] = []
-            resource.send(entries_property).each do |nested_resource|
-              representation[entries_property.to_s] << build_links(nested_resource.to_resource, embed: true)
-            end
-          end
-          
-          # Now the other muggles   
+          # entries property receives special treatment
+          present_entries_property resource, representation, resource_properties if resource_properties.include? :entries
+                    
+          # Now the other muggles
           resource_properties.each do |property_name|
             property_value = resource.send(property_name)
             
             if property_value.kind_of?(Resource) || property_value.respond_to?(:to_resource)
               # Resource like properties
-              property_value = property_value.to_resource if property_value.respond_to? :to_resource
-              representation["links"][property_name.to_s] = property_value.links(embed: resource.kind_of?(CollectionResource))
-              # we only need the "self" contents
-              representation["links"][property_name.to_s] = representation["links"][property_name.to_s]["self"] if representation["links"][property_name.to_s]["self"]              
+              present_resoure_property property_name, property_value, resource, representation
             else
               # Non-Resource like properties
               representation[property_name.to_s] = property_value
             end
           end
         end
+        
+        def present_entries_property(resource, representation, resource_properties)
+          entries_property = resource_properties.delete(:entries)
+
+          representation[entries_property.to_s] = []
+
+          resource.send(entries_property).each do |nested_resource|
+            representation[entries_property.to_s] << build_links(nested_resource.to_resource, embed: true)
+          end
+        end
+        
+        def present_resoure_property(property_name, property_value, resource, representation)
+          property_value = property_value.to_resource if property_value.respond_to? :to_resource
+          
+          representation["links"][property_name.to_s] = property_value.build_links(embed: resource.kind_of?(CollectionResource))
+
+          # we only need the "self" contents
+          representation["links"][property_name.to_s] = representation["links"][property_name.to_s]["self"] if representation["links"][property_name.to_s]["self"]                        
+        end
 
         def build_links(resource, options = {})
-          { "links" => resource.links(options) }
+          { "links" => resource.build_links(options) }
         end
       end
     end

data/lib/api/presenter/resource.rb

@@ -14,6 +14,24 @@ module Api
           @properties ||= []
         end
 
+        def link(name, value, &condition)
+          condition = Proc.new { true } unless block_given?
+
+          links[name] = { value: value, condition: condition }
+        end
+
+        def links
+          @links ||= {}
+        end
+        
+        def host
+          @@host ||= ''
+        end
+        
+        def host=(v)
+          @@host = v
+        end
+
         def inherited(subclass)
           (subclass.properties << properties).flatten!
         end
@@ -27,12 +45,20 @@ module Api
         end
       end
 
-      def links(options = {})
+      def build_links(options = {})
         links = {}
 
-        self.methods.grep(/_link$/).each do |link_method|
-          link_name = link_method.to_s.split("_").first
-          links[link_name] = { "href" => self.send(link_method) } if self.send(link_method.to_s + "?", options)
+        self.class.links.each do |link_name, link_value|
+          link_actual_value = link_value[:value].dup
+          
+          # retrieve stubs to replace looking for {{method_to_call}}
+          stubs = link_actual_value.scan(/\{\{(\w+)\}\}/).flatten
+          
+          # now we replace them
+          stubs.each{ |stub| link_actual_value.gsub!(/\{\{#{stub}\}\}/, self.send(stub.to_sym).to_s) }
+          
+          # and finish the url
+          links[link_name.to_s] = { "href" => "#{self.class.host}#{link_actual_value}" } if link_value[:condition].call(options)
         end
 
         links

data/lib/api/presenter/search_resource.rb

@@ -2,18 +2,30 @@ module Api
   module Presenter
     class SearchResource < CollectionResource
       attr_reader :query
-      
+
+      property :query
+
       def initialize(resource, query)
         @resource = resource
         @query = query
       end
 
-      property :query
 
       def query_string
         result = self.class.hypermedia_query_parameters.inject([]) { |col, query_parameter| col << "query[#{query_parameter}]=#{@query[query_parameter]}" }
         "?" + result.join("&")
       end
+      
+      def build_links(options = {})
+        links = super
+
+        # this adds the query string
+        links.each do |link_name, link_value|
+          links[link_name]['href'] = "#{link_value['href']}#{query_string}"
+        end
+
+        links
+      end
     end
   end
 end

data/lib/api/presenter/version.rb

@@ -1,5 +1,5 @@
 module Api
   module Presenter
-    VERSION = "0.0.3.2"
+    VERSION = "0.1.0"
   end
 end

data/spec/hypertext_presenter_mocks.rb

@@ -36,23 +36,13 @@ module HypertextPresenterMocks
   end
 
   class MockSingleResource < Api::Presenter::Resource
-
     property :number
     property :string
     property :date
     property :sibling
-  
-    def self_link
-      "/path/to/single_resource/#{@resource.number}"
-    end
-  
-    def custom_link
-      "/path/to/custom_link"
-    end
-  
-    def custom_link?(options = {})
-      options[:embed].nil? || !options[:embed]
-    end
+    
+    link "self", "/path/to/single_resource/{{number}}"
+    link("custom", "/path/to/custom_link") { |options = {}| options[:embed].nil? || !options[:embed] }
   
     def sibling
       MockSingleResource.new(MockData.new(number: 20, string: "I'm a sibling of someone", date: (Date.today + 1)))
@@ -60,22 +50,18 @@ module HypertextPresenterMocks
   end
 
   class MockCollectionResource < Api::Presenter::CollectionResource
-    def self_link
-      "/path/to/collection_resource"
-    end
+    link "self", "/path/to/collection_resource"
   end
 
   class MockSearchResource < Api::Presenter::SearchResource
     def self.hypermedia_query_parameters
       ["page", "param1","param2"]
     end
-  
-    def self_link
-      "/path/to/search_resource#{query_string}"
-    end
-  
+
+    link "self", "/path/to/search_resource"
+
     def current_page
       1
     end
   end
-end
+end

data/spec/hypertext_presenter_spec.rb

@@ -145,43 +145,103 @@ describe Api::Presenter::Hypermedia do
       ]
     }
   end
+
+  let(:mock_data) { MockData.new(number: 1, string: 'This is a string', date: Date.today) }
+
+  describe "when defining properties" do
+    it "must add and display a property" do
+      class MockSpecificData < MockData
+        def floating_point_value
+          10.3
+        end
+        
+        def to_resource
+          MockSingleSpecificResource.new self
+        end
+      end
+
+      class MockSingleSpecificResource < MockSingleResource
+        property :floating_point_value
+
+        link "self", "/path/to/single_resource/{{number}}"
+        link("custom", "/path/to/custom_link") { |options = {}| options[:embed].nil? || !options[:embed] }
+      end
+
+      new_single_resource_standard = single_resource_standard
+      new_single_resource_standard['floating_point_value'] = 10.3
+      
+      mock_data = MockSpecificData.new(number: 1, string: 'This is a string', date: Date.today)
+
+      mock_data.to_resource.present.must_equal new_single_resource_standard
+    end
+  end
+  
+  describe "when using host" do
+    it "must display a complete url" do
+      Api::Presenter::Resource.host = "http://localhost:9292"
+      
+      mock_data.to_resource.present.wont_equal single_resource_standard
+
+      new_single_resource_standard = {
+        "links" =>
+        {
+          "self" =>
+          {
+            "href" => "http://localhost:9292/path/to/single_resource/1"
+          },
+          "custom" =>
+          {
+            "href" => "http://localhost:9292/path/to/custom_link"
+          },
+          "sibling" =>
+          {
+            "href" => "http://localhost:9292/path/to/single_resource/20"
+          }
+        },
+        "number" => 1,
+        "string" => 'This is a string',
+        "date" => Date.today
+      }
+      
+      mock_data.to_resource.present.must_equal new_single_resource_standard
+      
+      Api::Presenter::Resource.host = ''
+    end    
+  end
   
   describe "when presenting a single resource" do
-    
-    let(:mock_data) { MockData.new(number: 1, string: 'This is a string', date: Date.today) }
-    let(:single_resource) { MockSingleResource.new mock_data }
-    let(:presented_single_resource) { single_resource.present }
+    let(:presented_single_resource) { mock_data.to_resource.present }
     
     it "must respect the standard" do
       presented_single_resource.must_equal single_resource_standard
     end    
   end
 
-   describe "presenting a collection resource" do
-     
-     let(:mock_data_collection) do
-       collection = []
-       4.times { |number| collection << MockData.new(number: number + 1, string: 'This is a string', date: Date.today) }
-       Collection.new(collection)
-     end
-     
-     let(:collection_resource) { MockCollectionResource.new mock_data_collection }
-     
-     let(:presented_collection_resource) { collection_resource.present }
-  
-     it "must respect the standard" do
-       presented_collection_resource.must_equal collection_resource_standard
-     end
-     
-     describe "presenting a search resource" do
-       
-       let(:search_resource) { MockSearchResource.new mock_data_collection, "page" => 1, "param1" => 1, "param2" => "string" }
-       
-       let(:presented_search_resource) { search_resource.present }
-     
-       it "must respect the standard" do
-         presented_search_resource.must_equal search_resource_standard
-       end
-     end
+  describe "presenting a collection resource" do
+    
+    let(:mock_data_collection) do
+      collection = []
+      4.times { |number| collection << MockData.new(number: number + 1, string: 'This is a string', date: Date.today) }
+      Collection.new(collection)
+    end
+    
+    let(:collection_resource) { MockCollectionResource.new mock_data_collection }
+    
+    let(:presented_collection_resource) { collection_resource.present }
+ 
+    it "must respect the standard" do
+      presented_collection_resource.must_equal collection_resource_standard
+    end
+    
+    describe "presenting a search resource" do
+      
+      let(:search_resource) { MockSearchResource.new mock_data_collection, "page" => 1, "param1" => 1, "param2" => "string" }
+      
+      let(:presented_search_resource) { search_resource.present }
+    
+      it "must respect the standard" do
+        presented_search_resource.must_equal search_resource_standard
+      end
     end
+   end
 end

data/spec/spec_helper.rb

@@ -1,6 +1,5 @@
 require 'bundler'
-require 'minitest/autorun'
 require 'date'
 require 'time'
 
-Bundler.require
+Bundler.require :default, :test

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: api-presenter
 version: !ruby/object:Gem::Version
-  version: 0.0.3.2
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-10 00:00:00.000000000 Z
+date: 2013-06-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -51,6 +51,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .travis.yml
 - Gemfile
 - LICENSE.txt
 - README.md