hal-client 3.13.0 → 3.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 553aacea1a5e60830f4444b701d714433dcb7fbc
-  data.tar.gz: dacb874f8b57a68e908028dee737b7d48cae4ce0
+  metadata.gz: 19eeb7d4e250354bcc747d7c65e66540d9bd2461
+  data.tar.gz: 6623c0304f0bc356a99ce59e88f976e5564d8e43
 SHA512:
-  metadata.gz: e58ada075076a0ebd8ea3aa8366ed4980d972d6813be97294c6eafde889ae03e5bfab120fe8ca797b1590f6fee8c27c670c7f141f8e444f88b080da2039443d8
-  data.tar.gz: d746794430e8b5bc974b8917dc33c4ce0fe5afe08d0fdf4c51978cb1cb2bd8a76f949c0eeb0d15aae39bf03ca0e1266c9ce42f590f9d4a2fa5ba141212e521a4
+  metadata.gz: 4a125acaab0e6eb493977b9f916d6b4246ac590bc80f59a3e2867d34666b9b4d8d4722aad7909e6f1d5a42c6f67799c7af2db0df092601c55f3d5d8003374686
+  data.tar.gz: 504e9b1eb3a3b8e74ec0e956ff47b6803aadcf0520d42e268a782b6c3ed24c69dc558ae4ab69d8ca73de4163e3012349195761781a3ea73182b6dd6f5a85e898

data/README.md

@@ -9,7 +9,7 @@ An easy to use client interface for REST APIs that use [HAL](http://stateless.co
 Usage
 -----
 
-The first step in using a HAL based API is getting a representation of one of its entry point. The simplest way to do this is using the `get` class method of `HalClient`.
+The first step in using a HAL based API is getting a representation of one of its entry points. The simplest way to do this is using the `get` class method of `HalClient`.
 
     blog = HalClient.get("http://blog.me/")
     # => #<Representation: http://blog.me/>
@@ -39,7 +39,7 @@ In the example above `item` is the link rel. The `#related` method extracts embe
 
 #### Request evaluation order
 
-If the `author` relationship was a regular link (that is, not embedded) in the above example the HTTP GET to retrieve Bob's representation from the server does not happen until the `#property` method is called. This lazy dereferencing allows for working with efficiently with larger relationship sets.
+If the `author` relationship was a regular link (that is, not embedded) in the above example the HTTP GET to retrieve Bob's representation from the server does not happen until the `#property` method is called. This lazy dereferencing allows for working more efficiently with larger relationship sets.
 
 #### CURIEs
 

data/lib/hal_client/curie_resolver.rb

@@ -2,8 +2,7 @@ require 'addressable/template'
 
 class HalClient
 
-  # Expands CURIEs to fully qualified URLs using a set curie
-  # definitions.
+  # Expands CURIEs to fully qualified URLs using a set of curie definitions.
   class CurieResolver
 
     # Initialize new CurieResolver

data/lib/hal_client/link.rb

@@ -0,0 +1,137 @@
+require 'hal_client/representation'
+
+class HalClient
+
+  # HAL representation of a single link. Provides access to an embedded representation.
+  class Link
+
+    # Create a new Link
+    #
+    # options - name parameters
+    #   :rel - This Link's rel property
+    #   :target - An instance of Representation
+    #   :template - A URI template ( https://www.rfc-editor.org/rfc/rfc6570.txt )
+    #   :curie_resolver - An instance of CurieResolver (used to resolve curied rels)
+    def initialize(options)
+      @literal_rel = options[:rel]
+      @target = options[:target]
+      @template = options[:template]
+      @curie_resolver = options[:curie_resolver] || CurieResolver.new([])
+
+      (fail ArgumentError, "A rel must be provided") if @literal_rel.nil?
+
+      if @target.nil? && @template.nil?
+        (fail ArgumentError, "A target or template must be provided")
+      end
+
+      if @target && @template
+        (fail ArgumentError, "Cannot provide both a target and a template")
+      end
+
+      if @target && !@target.kind_of?(Representation)
+        (fail ArgumentError, "Invalid HAL representation: #{target.inspect}")
+      end
+
+      if @template && !@template.kind_of?(Addressable::Template)
+        (fail ArgumentError, "Invalid Addressable::Template: #{template.inspect}")
+      end
+    end
+
+    attr_accessor :literal_rel, :target, :template, :curie_resolver
+
+
+    # Create a new Link using an entry from the '_links' section of a HAL document
+    #
+    # options - name parameters
+    #   :hash_entry - a hash containing keys :rel (string) and :data (hash from a '_links' entry)
+    #   :hal_client - an instance of HalClient
+    #   :curie_resolver - An instance of CurieResolver (used to resolve curied rels)
+    #   :base_url - Base url for resolving relative links in hash_entry (probably the parent
+    # document's "self" link)
+    def self.new_from_link_entry(options)
+      hash_entry = options[:hash_entry]
+      hal_client = options[:hal_client]
+      curie_resolver = options[:curie_resolver]
+      base_url = options[:base_url]
+
+      rel = hash_entry[:rel]
+      hash_data = hash_entry[:data]
+      href = (base_url + hash_data['href']).to_s
+
+      if hash_data['templated']
+        Link.new(rel: rel,
+                 template: Addressable::Template.new(href),
+                 curie_resolver: curie_resolver)
+      else
+        Link.new(rel: rel,
+                 target: Representation.new(hal_client: hal_client, href: href),
+                 curie_resolver: curie_resolver)
+      end
+    end
+
+
+    # Create a new Link using an entry from the '_embedded' section of a HAL document
+    #
+    # options - name parameters
+    #   :hash_entry - a hash containing keys :rel (string) and :data (hash from a '_embedded' entry)
+    #   :hal_client - an instance of HalClient
+    #   :curie_resolver - An instance of CurieResolver (used to resolve curied rels)
+    #   :base_url - Base url for resolving relative links in hash_entry (probably the parent
+    # document's "self" link)
+    def self.new_from_embedded_entry(options)
+      hash_entry = options[:hash_entry]
+      hal_client = options[:hal_client]
+      curie_resolver = options[:curie_resolver]
+      base_url = options[:base_url]
+
+      rel = hash_entry[:rel]
+      hash_data = hash_entry[:data]
+
+      absolute_href = (base_url + hash_data['_links']['self']['href']).to_s
+      hash_data['_links']['self']['href'] = absolute_href
+
+      Link.new(rel: rel,
+               target: Representation.new(hal_client: hal_client, parsed_json: hash_data),
+               curie_resolver: curie_resolver)
+    end
+
+
+    # Returns the URL of the resource this link references.
+    # In the case of a templated link, this is the unresolved url template pattern.
+    def raw_href
+      templated? ? template.pattern : target.href
+    end
+
+    def fully_qualified_rel
+      curie_resolver.resolve(literal_rel)
+    end
+
+    # Returns true for a templated link, false for an ordinary (non-templated) link
+    def templated?
+      !template.nil?
+    end
+
+    # Links with the same href, same rel value, and the same 'templated' value are considered equal
+    # Otherwise, they are considered unequal
+    def ==(other)
+      if other.respond_to?(:raw_href) &&
+         other.respond_to?(:fully_qualified_rel) &&
+         other.respond_to?(:templated?)
+        (raw_href == other.raw_href) &&
+          (fully_qualified_rel == other.fully_qualified_rel) &&
+          (templated? == other.templated?)
+      else
+        false
+      end
+    end
+    alias :eql? :==
+
+
+    # Differing Representations or Addressable::Templates with matching hrefs will get matching hash
+    # values, since we are using raw_href and not the objects themselves when computing hash
+    def hash
+      [fully_qualified_rel, raw_href, templated?].hash
+    end
+
+  end
+end

data/lib/hal_client/links_section.rb

@@ -2,8 +2,6 @@ class HalClient
 
   # Encapsulates a "_links" section.
   class LinksSection
-    UNSET = Object.new
-
     # section - json hash for the links section
     # base_url - base URL with which to resolve relative URLs
     def initialize(section, opts={} )

data/lib/hal_client/representation.rb

@@ -177,6 +177,28 @@ class HalClient
       RepresentationSet.new (Array(embedded) + Array(linked))
     end
 
+    def all_links
+      result = Set.new
+      base_url = Addressable::URI.parse(href || "")
+
+      embedded_entries = flatten_section(raw.fetch("_embedded", {}))
+      result.merge(embedded_entries.map do |entry|
+        Link.new_from_embedded_entry(hash_entry: entry,
+                                     hal_client: hal_client,
+                                     curie_resolver: namespaces,
+                                     base_url: base_url)
+      end)
+
+      link_entries = flatten_section(raw.fetch("_links", {}))
+      result.merge(link_entries.map { |entry|
+        Link.new_from_link_entry(hash_entry: entry,
+                                 hal_client: hal_client,
+                                 curie_resolver: namespaces,
+                                 base_url: base_url) })
+
+      result
+    end
+
     # Returns urls of resources related via the specified
     #   link rel or the specified default value.
     #
@@ -280,7 +302,16 @@ class HalClient
     def raw
       if @raw.nil? && @href
         (fail "unable to make requests due to missing hal client") unless hal_client
-        @raw ||= hal_client.get(@href).raw
+
+        response = hal_client.get(@href)
+
+        unless response.is_a?(Representation)
+          error_message = "Response body wasn't a valid HAL document:\n\n"
+          error_message += response.body
+          raise InvalidRepresentationError.new(error_message)
+        end
+
+        @raw ||= response.raw
       end
 
       @raw
@@ -294,6 +325,14 @@ class HalClient
 
     MISSING = Object.new
 
+    def flatten_section(section_hash)
+      section_hash
+        .each_pair
+        .flat_map { |rel, some_link_info|
+          [some_link_info].flatten
+          .map { |a_link_info| { rel: rel, data: a_link_info } }
+      }
+    end
 
     def links
       @links ||= LinksSection.new((raw.fetch("_links"){{}}),
@@ -318,7 +357,7 @@ class HalClient
 
     rescue InvalidRepresentationError => err
       fail InvalidRepresentationError, "/_embedded/#{jpointer_esc(link_rel)} is not a valid representation"
-end
+    end
 
     def linked(link_rel, options, &default_proc)
       default_proc ||= ->(link_rel,_options) {

data/lib/hal_client/version.rb

@@ -1,3 +1,3 @@
 class HalClient
-  VERSION = "3.13.0"
+  VERSION = "3.14.0"
 end

data/lib/hal_client.rb

@@ -7,6 +7,7 @@ class HalClient
   autoload :Representation, 'hal_client/representation'
   autoload :RepresentationSet, 'hal_client/representation_set'
   autoload :CurieResolver, 'hal_client/curie_resolver'
+  autoload :Link, 'hal_client/link'
   autoload :LinksSection, 'hal_client/links_section'
   autoload :Collection, 'hal_client/collection'
   autoload :InvalidRepresentationError, 'hal_client/errors'

data/spec/hal_client/link_spec.rb

@@ -0,0 +1,276 @@
+require 'hal-client'
+
+require_relative "../spec_helper"
+
+require "hal_client/link"
+
+describe HalClient::Link do
+
+  subject(:link) { described_class.new(rel: rel_1, target: repr_1) }
+
+  describe "#initialize" do
+    it "requires a target" do
+      expect { HalClient::Link.new(rel: rel_1) }.to raise_error(ArgumentError)
+    end
+
+    it "doesn't allow both target and template" do
+      expect {
+        HalClient::Link.new(rel: rel_1, target: repr_1, template: template_1)
+      }.to raise_error(ArgumentError)
+    end
+
+    it "requires target to be a Representation" do
+      expect {
+        HalClient::Link.new(rel: rel_1, target: template_1)
+      }.to raise_error(ArgumentError)
+    end
+
+    it "requires template to be an Addressable::Template" do
+      expect {
+        HalClient::Link.new(rel: rel_1, template: repr_1)
+      }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe ".new_from_link_entry" do
+    it "creates an instance of Link" do
+      my_link = described_class.new_from_link_entry(hash_entry: link_entry_hash(href: href_1),
+                                                    hal_client: a_client,
+                                                    curie_resolver: curie_resolver,
+                                                    base_url: href_1)
+      expect(my_link).to be_a(HalClient::Link)
+    end
+
+    it "handles relative hrefs" do
+      input_hash = link_entry_hash(href: relative_href_1)
+      base_url = Addressable::URI.parse(href_1)
+
+      my_link = described_class.new_from_link_entry(hash_entry: input_hash,
+                                                    hal_client: a_client,
+                                                    curie_resolver: curie_resolver,
+                                                    base_url: base_url)
+      expect(my_link.raw_href).to eq((base_url + relative_href_1).to_s)
+    end
+  end
+
+  describe ".new_from_embedded_entry" do
+    it "creates an instance of Link" do
+      my_link = described_class.new_from_embedded_entry(hash_entry: embedded_entry_hash,
+                                                        hal_client: a_client,
+                                                        curie_resolver: curie_resolver,
+                                                        base_url: href_1)
+      expect(my_link).to be_a(HalClient::Link)
+    end
+
+    it "handles relative hrefs" do
+      input_hash = embedded_entry_hash(href: relative_href_1)
+      base_url = Addressable::URI.parse(href_1)
+
+      my_link = described_class.new_from_embedded_entry(hash_entry: input_hash,
+                                                        hal_client: a_client,
+                                                        curie_resolver: curie_resolver,
+                                                        base_url: base_url)
+      expect(my_link.raw_href).to eq((base_url + relative_href_1).to_s)
+    end
+  end
+
+  describe "#href" do
+    specify { expect(link.raw_href).to eq('http://example.com/href_1') }
+    specify { expect(templated_link1.raw_href).to eq('http://example.com/people{?name}') }
+  end
+
+  describe "#templated?" do
+    specify { expect(link.templated?).to be false }
+    specify { expect(templated_link1.templated?).to be true }
+  end
+
+  context "equality and hash" do
+    let(:link_same_target_same_rel) { HalClient::Link.new(target: repr_1, rel: rel_1) }
+
+    let(:link_same_target_diff_rel) { HalClient::Link.new(target: repr_1, rel: rel_2) }
+    let(:link_diff_target_same_rel) { HalClient::Link.new(target: repr_2, rel: rel_1) }
+    let(:link_diff_target_diff_rel) { HalClient::Link.new(target: repr_2, rel: rel_2) }
+
+    let(:link_same_non_fetched) { HalClient::Link.new(target: href_only_repr, rel: rel_1) }
+
+    let(:same_as_templated_link1) do
+      HalClient::Link.new(rel: 'templated_link',
+                          template: Addressable::Template.new('http://example.com/people{?name}'))
+    end
+
+    let(:templated_link2) do
+      HalClient::Link.new(rel: 'templated_link',
+                          template: Addressable::Template.new('http://example.com/places{?name}'))
+    end
+
+    let(:template_but_not_a_template) do
+      HalClient::Link.new(rel: 'rel_1',
+                          template: Addressable::Template.new('http://example.com/href_1'))
+    end
+
+    describe "#==" do
+      specify { expect(link == link_same_target_same_rel).to eq true }
+      specify { expect(link == link_same_non_fetched).to eq true }
+
+      specify { expect(link == link_same_target_diff_rel).to eq false }
+      specify { expect(link == link_diff_target_same_rel).to eq false }
+      specify { expect(link == link_diff_target_diff_rel).to eq false }
+
+      specify { expect(templated_link1 == same_as_templated_link1).to eq true }
+      specify { expect(templated_link1 == templated_link2).to eq false }
+
+      specify { expect(link == template_but_not_a_template).to eq false }
+
+      specify { expect(full_uri_link_1 == curied_link_1).to eq true }
+
+      specify { expect(link == Object.new).to eq false }
+    end
+
+    describe ".eql?" do
+      specify { expect(link.eql? link_same_target_same_rel).to eq true }
+      specify { expect(link.eql? link_same_non_fetched).to eq true }
+
+      specify { expect(link.eql? link_same_target_diff_rel).to eq false }
+      specify { expect(link.eql? link_diff_target_same_rel).to eq false }
+      specify { expect(link.eql? link_diff_target_diff_rel).to eq false }
+
+      specify { expect(templated_link1.eql? same_as_templated_link1).to eq true }
+      specify { expect(templated_link1.eql? templated_link2).to eq false }
+
+      specify { expect(link.eql? template_but_not_a_template).to eq false }
+
+      specify { expect(full_uri_link_1.eql? curied_link_1).to eq true }
+
+      specify { expect(link.eql? Object.new).to eq false }
+    end
+
+    describe "hash" do
+      specify{ expect(link.hash).to eq link_same_target_same_rel.hash }
+      specify{ expect(link.hash).to eq link_same_non_fetched.hash }
+
+      specify{ expect(link.hash).to_not eq link_same_target_diff_rel.hash }
+      specify{ expect(link.hash).to_not eq link_diff_target_same_rel.hash }
+      specify{ expect(link.hash).to_not eq link_diff_target_diff_rel.hash }
+
+      specify { expect(templated_link1.hash).to eq(same_as_templated_link1.hash) }
+      specify { expect(templated_link1.hash).to_not eq(templated_link2.hash) }
+
+      specify { expect(link.hash).to_not eq(template_but_not_a_template.hash)}
+
+      specify { expect(full_uri_link_1.hash).to eq(curied_link_1.hash) }
+    end
+
+  end
+
+
+  # Background
+
+  let(:a_client) { HalClient.new }
+
+  let(:rel_1) { 'rel_1' }
+  let(:rel_2) { 'rel_2' }
+
+  let(:full_uri_rel_1) { 'http://example.com/rels/rel_1' }
+  let(:full_uri_link_1) { HalClient::Link.new(rel: full_uri_rel_1, target: repr_1) }
+
+  let(:curie_resolver) do
+    HalClient::CurieResolver.new({
+                                   'name' => 'ex',
+                                   'href' => 'http://example.com/rels/{rel}',
+                                   'templated' => true
+                                 })
+  end
+
+  let(:curied_rel_1) { 'ex:rel_1' }
+
+  let(:curied_link_1) do
+    HalClient::Link.new(rel: curied_rel_1, target: repr_1, curie_resolver: curie_resolver)
+  end
+
+  let(:href_1) { 'http://example.com/href_1' }
+  let(:href_2) { 'http://example.com/href_2' }
+
+  let(:relative_href_1) { 'path/to/href_1' }
+
+  def link_entry_hash(options = {})
+    href = options[:href] || href_1
+    rel = options[:rel] || rel_1
+    templated = options[:templated] || nil
+
+    hash_data = { 'href' => href }
+    hash_data['templated'] = templated if templated
+
+    {
+      rel: rel,
+      data: hash_data
+    }
+  end
+
+  def embedded_entry_hash(options = {})
+    href = options[:href] || href_1
+    rel = options[:rel] || rel_1
+
+    {
+      rel: rel,
+      data: { '_links' => { 'self' => { 'href' => href } } }
+    }
+  end
+
+  def raw_repr(options = {})
+    href = options[:href] || href_1
+
+    <<-HAL
+      {
+         "prop1": 1
+        ,"prop2": 2
+        ,"_links": {
+          "self": { "href": "#{href}" }
+          ,"link1": { "href": "http://example.com/bar" }
+          ,"templated_link": { "href": "http://example.com/people{?name}"
+                      ,"templated": true }
+          ,"link3": [{ "href": "http://example.com/link3-a" }
+                     ,{ "href": "http://example.com/link3-b" }]
+        }
+        ,"_embedded": {
+          "embed1": {
+            "_links": { "self": { "href": "http://example.com/baz" }}
+          }
+        }
+      }
+    HAL
+  end
+
+  def href_only_raw_repr(options = {})
+    href = options[:href] || href_1
+
+    <<-HAL
+      {
+        "_links": {
+          "self": { "href": "#{href}" }
+        }
+      }
+    HAL
+  end
+
+  def href_only_repr(options = {})
+    href = options[:href] || href_1
+
+    HalClient::Representation.new(hal_client: a_client,
+                                  parsed_json: MultiJson.load(href_only_raw_repr(href: href)))
+  end
+
+  let(:repr_1) do
+    HalClient::Representation.new(hal_client: a_client,
+                                  parsed_json: MultiJson.load(raw_repr))
+  end
+
+  let(:repr_2) do
+    HalClient::Representation.new(hal_client: a_client,
+                                  parsed_json: MultiJson.load(raw_repr(href: href_2)))
+  end
+
+  let(:template_1) { Addressable::Template.new('http://example.com/people{?name}') }
+
+  let(:templated_link1) { HalClient::Link.new(rel: 'templated_link', template: template_1) }
+
+end

data/spec/hal_client/representation_spec.rb

@@ -9,15 +9,20 @@ describe HalClient::Representation do
   ,"_links": {
     "self": { "href": "http://example.com/foo" }
     ,"link1": { "href": "http://example.com/bar" }
-    ,"templated_link": { "href": "http://example.com/people{?name}"
+    ,"templated": { "href": "http://example.com/people{?name}"
                 ,"templated": true }
     ,"link3": [{ "href": "http://example.com/link3-a" }
                ,{ "href": "http://example.com/link3-b" }]
+    ,"dup": { "href": "http://example.com/dup" }
   }
   ,"_embedded": {
     "embed1": {
       "_links": { "self": { "href": "http://example.com/baz" }}
     }
+    ,"dup": {
+      "dupProperty": "foo"
+      ,"_links": { "self": { "href": "http://example.com/dup" }}
+    }
   }
 }
 HAL
@@ -246,7 +251,7 @@ HAL
     end
 
     context "for existent templated link" do
-      subject { repr.related "templated_link", name: "bob" }
+      subject { repr.related "templated", name: "bob" }
       it { should have(1).item }
       it { should include_representation_of "http://example.com/people?name=bob"  }
     end
@@ -264,13 +269,27 @@ HAL
     end
   end
 
+  describe "#all_links" do
+    subject { repr.all_links }
+
+    specify { expect(subject).to include(link1_link) }
+    specify { expect(subject).to_not include(link2_link) }
+
+    specify { expect(subject).to include(templated_link) }
+
+    specify { expect(subject).to include(link3a_link) }
+    specify { expect(subject).to include(link3b_link) }
+
+    specify { expect(subject.any? { |item| item.target['dupProperty'] == 'foo' }).to be true }
+  end
+
   specify { expect(repr.related_hrefs "link1")
       .to contain_exactly "http://example.com/bar" }
   specify { expect(repr.related_hrefs "embed1")
       .to contain_exactly "http://example.com/baz" }
   specify { expect { repr.related_hrefs 'wat' }.to raise_exception KeyError }
 
-  specify { expect(repr.raw_related_hrefs("templated_link").map(&:pattern))
+  specify { expect(repr.raw_related_hrefs("templated").map(&:pattern))
       .to contain_exactly "http://example.com/people{?name}" }
   specify { expect(repr.raw_related_hrefs("link1"))
       .to contain_exactly "http://example.com/bar" }
@@ -396,6 +415,41 @@ HAL
 
   # Background
 
+  let(:link1_repr) do
+    HalClient::Representation.new(hal_client: a_client, href: "http://example.com/bar")
+  end
+
+  let(:link3a_repr) do
+    HalClient::Representation.new(hal_client: a_client, href: "http://example.com/link3-a")
+  end
+
+  let(:link3b_repr) do
+    HalClient::Representation.new(hal_client: a_client, href: "http://example.com/link3-b")
+  end
+
+
+  let(:link1_link) do
+    HalClient::Link.new(rel: 'link1', target: link1_repr)
+  end
+
+  let(:link2_link) do
+    HalClient::Link.new(rel: 'link2', target: link1_repr)
+  end
+
+  let(:templated_link) do
+    HalClient::Link.new(rel: 'templated',
+                        template: Addressable::Template.new('http://example.com/people{?name}'))
+  end
+
+  let(:link3a_link) do
+    HalClient::Link.new(rel: 'link3', target: link3a_repr)
+  end
+
+  let(:link3b_link) do
+    HalClient::Link.new(rel: 'link3', target: link3b_repr)
+  end
+
+
   let(:a_client) { HalClient.new }
   let!(:bar_request) { stub_identity_request("http://example.com/bar") }
   let!(:baz_request) { stub_identity_request "http://example.com/baz" }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hal-client
 version: !ruby/object:Gem::Version
-  version: 3.13.0
+  version: 3.14.0
 platform: ruby
 authors:
 - Peter Williams
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-12-23 00:00:00.000000000 Z
+date: 2016-01-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: http
@@ -147,6 +147,7 @@ files:
 - lib/hal_client/collection.rb
 - lib/hal_client/curie_resolver.rb
 - lib/hal_client/errors.rb
+- lib/hal_client/link.rb
 - lib/hal_client/links_section.rb
 - lib/hal_client/representation.rb
 - lib/hal_client/representation_editor.rb
@@ -154,6 +155,7 @@ files:
 - lib/hal_client/version.rb
 - spec/hal_client/collection_spec.rb
 - spec/hal_client/curie_resolver_spec.rb
+- spec/hal_client/link_spec.rb
 - spec/hal_client/links_section_spec.rb
 - spec/hal_client/representation_editor_spec.rb
 - spec/hal_client/representation_set_spec.rb
@@ -188,6 +190,7 @@ summary: Use HAL APIs easily
 test_files:
 - spec/hal_client/collection_spec.rb
 - spec/hal_client/curie_resolver_spec.rb
+- spec/hal_client/link_spec.rb
 - spec/hal_client/links_section_spec.rb
 - spec/hal_client/representation_editor_spec.rb
 - spec/hal_client/representation_set_spec.rb