hypertext_application_language 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1c9c7296b2e50bdb822d5af41b4ff5b562be1e2f
+  data.tar.gz: e863ec8f7f2ed73ef83d6a2a1fc3dc5f80f2b1fc
+SHA512:
+  metadata.gz: 035ba935018b647c548641f9005aebb79bc913ee99cde200a240dcd7a0cba64aeea0020c1526d88aeb3618a1a698d08217d7395b1d3e8b0caea8db54e1c318f2
+  data.tar.gz: c3e2785fa7a9cdc226b9c82b0077347114bad4c2b696411c788a1bf1e7bf8358b69f3e345bfad72e9ad45eaa119c70ad6dda86a508810f935b0625d2ffae4c93

data/.rspec

@@ -0,0 +1 @@
+--require spec_helper

data/.yardopts

@@ -0,0 +1,6 @@
+--no-private
+--protected
+--main README.md
+-
+MIT-LICENSE.txt
+ChangeLog.md

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,43 @@
+PATH
+  remote: .
+  specs:
+    hypertext_application_language (0.0.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.2.5)
+    docile (1.1.5)
+    json (1.8.3)
+    json (1.8.3-java)
+    rspec (3.3.0)
+      rspec-core (~> 3.3.0)
+      rspec-expectations (~> 3.3.0)
+      rspec-mocks (~> 3.3.0)
+    rspec-core (3.3.2)
+      rspec-support (~> 3.3.0)
+    rspec-expectations (3.3.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.3.0)
+    rspec-mocks (3.3.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.3.0)
+    rspec-support (3.3.0)
+    simplecov (0.10.0)
+      docile (~> 1.1.0)
+      json (~> 1.8)
+      simplecov-html (~> 0.10.0)
+    simplecov-html (0.10.0)
+
+PLATFORMS
+  java
+  ruby
+
+DEPENDENCIES
+  bundler
+  hypertext_application_language!
+  rspec
+  simplecov
+
+BUNDLED WITH
+   1.10.6

data/MIT-LICENSE.txt

@@ -0,0 +1,19 @@
+Copyright © 2015, Roy Ratcliffe, Pioneering Software, United Kingdom
+
+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, EITHER
+EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. 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,29 @@
+# Hypertext Application Language (HAL)
+
+What HTML does for web browsers, HAL does for applications.
+
+HTML gives you pages of marked-up information for presentation to users; HAL
+gives you marked-up representations for application consumption. Applications
+can easily extract information about remote resources, including relationships
+between resources. What HAL calls a representation, HTML calls a web page; such
+pages have links to other pages. HTML was designed for presenting information
+to humans. HAL was designed for presenting information to applications.
+
+This gem provides a suite of Ruby classes for rendering and parsing resource
+representations, including their links, properties and nested representations
+of embedded resources.
+
+## Deviations
+
+The interfaces and implementations largely echo those written in Java, but
+there are some deliberate deviations.
+
+The Ruby gem adds some consistency in naming. Representation is the name used
+to describe an object that represents some remote resource. The term “resource”
+describes the actual remote resource. Representations represent resources only;
+they are not the resource themselves.
+
+The use of “currie” has been replaced as it partially overlaps the idea of
+currying and curried functions in mathematics and computer science, when in
+fact the term ‘curie’ only refers to a compact URI. The acronym only
+coincidentally resembles the word “curry,” a delicious Asian meal.

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/hypertext_application_language.gemspec

@@ -0,0 +1,21 @@
+File.expand_path('../lib', __FILE__).tap do |path|
+  $LOAD_PATH.unshift(path) unless $LOAD_PATH.include?(path)
+end
+
+require 'hypertext_application_language/version'
+
+Gem::Specification.new do |spec|
+  spec.name = 'hypertext_application_language'
+  spec.version = HypertextApplicationLanguage::VERSION
+  spec.summary = %q{Hypertext Application Language}
+  spec.description = %q{}
+  spec.homepage = 'http://stateless.co/hal_specification.html'
+  spec.authors = ['Roy Ratcliffe']
+  spec.email = ['roy@pioneeringsoftware.co.uk']
+  spec.files = `git ls-files -z`.split("\x0")
+  spec.license = 'MIT'
+
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'simplecov'
+end

data/lib/hypertext_application_language/hash_representation_parser.rb

@@ -0,0 +1,86 @@
+# coding: utf-8
+module HypertextApplicationLanguage
+  # An object that parses a representation.
+  #
+  # The parser does not “parse” the hash, strictly speaking. Nor does it check
+  # the hash for strict compliance. Instead it just picks out pieces of the hash
+  # matching HAL expectations. Nothing more than that.
+  class HashRepresentationParser
+    # Parses a hash, loading the given representation with its
+    # hypertext-application-language content.
+    def parse(representation, object)
+      # Takes compact URI pairs from the links. Looks for the +curies+ sub-hash
+      # within +_links+ root-level hash. Every CURIE is a hash with a name and a
+      # hypertext reference.
+      links_object = object[Representation::LINKS]
+      if links_object
+        curie_objects = links_object[Link::CURIES_REL]
+        if curie_objects
+          curie_objects = [curie_objects] unless curie_objects.is_a?(Array)
+          curie_objects.select { |element| element.is_a?(Hash) }.each do |object|
+            # Both the name and the hypertext reference must have string type;
+            # there is no scope for representing references except using their
+            # string form. Represent with strings, otherwise the parser ignores
+            # it.
+            #
+            # The link's +href+ attribute carries the relative reference, even
+            # though the reference is not a true hypertext reference since it
+            # contains the +{rel}+ token as a placeholder for substitution.
+            name = object[Link::NAME]
+            next unless name.is_a?(String)
+            ref = object[Link::HREF]
+            next unless ref.is_a?(String)
+            representation.with_namespace(name, ref)
+          end
+        end
+
+        # The links object is a hash of strings paired with a hash or an array
+        # of hashes.
+        links_object.each do |rel, link_objects|
+          next if rel == Link::CURIES_REL
+          link_objects = [link_objects] unless link_objects.is_a?(Array)
+          link_objects.each do |link_object|
+            # Makes you wonder. Should the following pass the name? Doing so
+            # allows name-spaces to sneak into the links. Name-spaces should
+            # only appear in the +curies+ hash. They will never function as a
+            # CURIE unless they do.
+            href = object[Link::HREF]
+            next unless href
+            link = Link.new(rel, href)
+            link.name = object[Link::NAME] if object[Link::NAME]
+            link.title = object[Link::TITLE] if object[Link::TITLE]
+            link.hreflang = object[Link::HREFLANG] if object[Link::HREFLANG]
+            link.profile = object[Link::PROFILE] if object[Link::PROFILE]
+            representation.with_link(link)
+          end
+        end
+      end
+
+      # Properties should only contain primitive types: string, numbers,
+      # booleans or arrays of the same.
+      object.each do |name, value|
+        next if [Representation::LINKS, Representation::EMBEDDED].include?(name)
+        # if value.is_a?(Array)
+        #   representation.with_property(name, value.map(&:to_s))
+        # else
+        #   representation.with_property(name, value.to_s)
+        # end
+        representation.with_property(name, value)
+      end
+
+      embedded = object[Representation::EMBEDDED]
+      if embedded
+        embedded.each do |rel, objects|
+          # The relation key must be a string. Turn the value into an array of
+          # hashes, parsing an embedded representation from each hash.
+          objects = [objects] unless objects.is_a?(Array)
+          objects.each do |object|
+            embedded_representation = Representation.new
+            parse(embedded_representation, object)
+            representation.with_representation(rel, embedded_representation)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hypertext_application_language/hash_representation_renderer.rb

@@ -0,0 +1,88 @@
+module HypertextApplicationLanguage
+  # Renders a representation as a Hash.
+  class HashRepresentationRenderer
+    # Renders a representation to a Hash.
+    # @return [Hash] The resulting Hash representation.
+    def render(representation)
+      render_representation(representation)
+    end
+
+    private
+
+    # Renders either a top-level representation or an embedded resource.
+    def render_representation(representation, embedded=false)
+      object = {}
+
+      # Render the name-spaces and links but only if there are name-spaces and
+      # links; also render links if there are name-spaces to render, assuming
+      # not embedded. Create a hash representation without links if there are
+      # none. Merge the name-spaces and links.
+      unless representation.links.empty? && (embedded || representation.namespaces.empty?)
+        links_object = object[Representation::LINKS] ||= {}
+        links = []
+        unless embedded
+          representation.namespaces.each do |name, ref|
+            links.push(Link.new(Link::CURIES_REL, ref, Link::NAME => name))
+          end
+        end
+        links.concat(representation.links)
+        links_for_rel = {}
+        links.each do |link|
+          (links_for_rel[link.rel] ||= []).push(link)
+        end
+        links_for_rel.each do |rel, links|
+          link_objects = links.map do |link|
+            # Render a link as a hash. Importantly, the following does not
+            # render the link relation; it only renders the link content. The
+            # relation appears in the rendered output as the key, not as part of
+            # the hash value paired with the key.
+            link_object = {}
+
+            # There is always a relation and a hypertext reference for every
+            # link; no need to check for +nil+. If you set up a link with a
+            # +nil+ reference, the output will contain a blank string, since
+            # +nil.to_s+ answers +""+.
+            link_object[Link::HREF] = link.href.to_s
+
+            link_object[Link::NAME] = link.name.to_s if link.name
+            link_object[Link::TITLE] = link.title.to_s if link.title
+            link_object[Link::HREFLANG] = link.hreflang.to_s if link.hreflang
+            link_object[Link::PROFILE] = link.profile.to_s if link.profile
+
+            link_object
+          end
+          links_object[rel] = link_objects.length == 1 ? link_objects.first : link_objects
+        end
+      end
+
+      # Merge the representation's properties. Properties live at the root of
+      # the hash. Merging is just another way to assign values to their name
+      # keys.
+      #
+      #   representation.properties.each do |name, value|
+      #     hash[name] = value
+      #   end
+      #
+      # This makes some assumptions about the representation properties. It
+      # assumes that the property values are primitive types: strings, numbers,
+      # booleans. They should never be hashes or custom classes.
+      object.merge!(representation.properties)
+
+      # Render embedded resource representations. Each representation retains
+      # zero or more sub-representations by their relation. The relation maps to
+      # an array of embedded representations, zero or more for each
+      # relation. Render each one recursively.
+      unless representation.representations.empty?
+        embedded_object = object[Representation::EMBEDDED] ||= {}
+        representation.representations_for_rel.each do |rel, representations|
+          objects = representations.map do |representation|
+            render_representation(representation, true)
+          end
+          embedded_object[rel] = objects.length == 1 ? objects.first : objects
+        end
+      end
+
+      object
+    end
+  end
+end

data/lib/hypertext_application_language/link.rb

@@ -0,0 +1,119 @@
+module HypertextApplicationLanguage
+  # Links belong to representations; a representation retains zero or more
+  # links. Each link gives a hypertext reference for a relation, at least. Some
+  # links provide more information.
+  #
+  # Links have attributes. The relation and hypertext reference attributes are
+  # primary and are always required for every link. Representations may carry
+  # multiple links with the _same_ relation, just like a HTML page. Links
+  # sharing the same relation refer to the same thing, or things.
+  #
+  # This is the simplest possible implementation of a
+  # hypertext-application-language (HAL) link. It does not support
+  # immutability. All links and their attributes remain mutable, even after
+  # attaching to a representation. This condition continues until you freeze the
+  # instance, according to the Ruby immutability paradigm.
+  class Link
+    # Creates a new mutable link.
+    # @return [Link] Answers a newly initialised link.
+    # @param [String] rel Relation.
+    # @param [String] href Hypertext reference.
+    # @param [Array<String, Hash>] args Array of strings used to initialise the
+    #   optional attributes in the following order: +name+, +title+, +hreflang+
+    #   and +profile+. If the last element is a Hash, these become keyword
+    #   arguments where you can set up the optional link attributes by name,
+    #   either symbolic or string.
+    def initialize(rel, href, *args)
+      @rel = rel
+      @href = href
+
+      # Take an array of arguments following the #rel and #href; these arguments
+      # assign to the optional link attributes in order. Pick out keyword
+      # arguments if the last argument is a #Hash. Be indifferent about the
+      # keywords; accept both string and symbols. Do this by converting the
+      # string keys to symbols if they do not otherwise match anything in the
+      # keyword arguments hash. Take care not to re-invoke the hash fetch again
+      # using the subscript operator, otherwise the default #Proc will recurse
+      # indefinitely.
+      keyword_args = args.last.is_a?(Hash) ? args.pop : {}
+      keyword_args.default_proc = proc do |hash, key|
+        hash.fetch(key.to_sym, nil)
+      end
+      @name, @title, @hreflang, @profile = args
+      @name ||= keyword_args[NAME]
+      @title ||= keyword_args[TITLE]
+      @hreflang ||= keyword_args[HREFLANG]
+      @profile ||= keyword_args[PROFILE]
+    end
+
+    # When you freeze the object, also freeze all the instance
+    # variables. Otherwise, you can still modify the existing instance
+    # variables' assigned objects even though you cannot reassign the variables
+    # themselves.
+    def freeze
+      instance_variables.each do |instance_variable|
+        instance_variable_get(instance_variable).freeze
+      end
+      super
+    end
+
+    # @!group Required attributes
+
+    attr_accessor :rel
+
+    # Link attribute describing the hypertext reference. The reference can be a
+    # full universal resource location, or some element thereof. It can be just
+    # the path.
+    attr_accessor :href
+
+    # @!group Optional attributes
+
+    attr_accessor :name
+    attr_accessor :title
+
+    # Returns the ISO 639-1 code describing the link's language. You can have
+    # multiple links for the same relation but for different languages.
+    attr_accessor :hreflang
+
+    attr_accessor :profile
+
+    # @!group Required link attribute names
+
+    REL = 'rel'.freeze
+    HREF = 'href'.freeze
+
+    # @!group Optional link attribute names
+
+    NAME = 'name'.freeze
+    TITLE = 'title'.freeze
+    HREFLANG = 'hreflang'.freeze
+    PROFILE = 'profile'.freeze
+
+    # @!endgroup
+
+    # Array of attribute names including those required and those optional.
+    ATTRIBUTE_NAMES = [
+      # required
+      REL,
+      HREF,
+
+      # optional
+      NAME,
+      TITLE,
+      HREFLANG,
+      PROFILE,
+    ].freeze
+
+    # @!group Special link relations
+
+    # This special link relation describes the link to the representations own
+    # source, i.e. itself.
+    SELF_REL = 'self'.freeze
+
+    # Special link relation used for name-spaces. Representation name-spaces
+    # appear in rendered links under the "curies" relation; where the link
+    # +name+ corresponds to the name-space name and the link +href+ corresponds
+    # to the name-space reference with its embedded +{rel}+ placeholder.
+    CURIES_REL = 'curies'.freeze
+  end
+end

data/lib/hypertext_application_language/namespace_manager.rb

@@ -0,0 +1,72 @@
+module HypertextApplicationLanguage
+  # Handles _compact_ URIs, a.k.a. CURIEs. Representations and representation
+  # factories have CURIEs handled by a name-space manager instance.
+  #
+  # @see http://www.w3.org/TR/curie/
+  class NamespaceManager
+    # Defines the relative reference token, the placeholder used in CURIEs.
+    REL = '{rel}'.freeze
+
+    extend Forwardable
+
+    # @!method namespaces
+    #   @return [Hash<String, String>] Answers a hash of relative references by
+    #   their name.
+    def_delegator :@ref_for_name, :dup, :namespaces
+
+    def initialize
+      # Retains one relative hypertext reference for one name.
+      @ref_for_name = {}
+    end
+
+    # Adds a name-space to this manager.
+    # @param [String] name
+    #   Names the CURIE. This appears in CURIE references as the prefix before
+    #   the colon. The relative reference comes after the colon.
+    # @param [String] ref
+    #   Gives the CURIE's relative reference. It must include the +{rel}+
+    #   placeholder identifying where to substitute the CURIE argument, the
+    #   value that replaces the placeholder.
+    def with_namespace(name, ref)
+      @ref_for_name[name] = ref
+      self
+    end
+
+    # Converts an expanded hypertext reference to a CURIE'd reference based on
+    # the current set of CURIE specifications, the name-spaces.
+    # @return [String] Answers the CURIE'd reference corresponding to the given
+    # hypertext reference, or +nil+ if there is no matching CURIE.
+    def curie(href)
+      @ref_for_name.each do |name, ref|
+        # start_index = ref.index(REL)
+        # end_index = start_index + REL.length
+        # left = ref[0...start_index]
+        # right = ref[end_index..-1]
+        # if href.start_with?(left) && href.end_with?(right)
+        #   middle = href[start_index..(end_index - 2)]
+        #   return name + ':' + middle
+        # end
+        left, right = ref.split(REL)
+        if href.start_with?(left) && href.end_with?(right)
+          return name + ':' + href[left.length...-right.length]
+        end
+      end
+      nil
+    end
+
+    # Converts a CURIE'd reference to a hypertext reference.
+    # @param [String] curie The argument is a string comprising a name prefix
+    # followed by a colon delimiter, followed by a CURIE argument.
+    #
+    # Splits the name at the first colon. The prefix portion before the colon
+    # identifies the name of the CURIE. The portion after the colon replaces the
+    # +{rel}+ placeholder. This is a very basic way to parse a CURIE, but it
+    # works.
+    def href(curie)
+      name, arg = curie.split(':', 2)
+      ref = @ref_for_name[name]
+      return nil unless ref
+      ref.sub(REL, arg)
+    end
+  end
+end

data/lib/hypertext_application_language/representation.rb

@@ -0,0 +1,97 @@
+require 'hypertext_application_language/namespace_manager'
+require 'hypertext_application_language/link'
+
+module HypertextApplicationLanguage
+  # Represents a resource. This includes sub-resources which also have their own
+  # representation. Representations have links, properties and sub-resources.
+  #
+  # Resource is the name of a representation embedded within another
+  # super-representation. Representations have zero or resources. They will
+  # appear in the rendered results as embedded resources.
+  class Representation
+    LINKS = '_links'.freeze
+    EMBEDDED = '_embedded'.freeze
+
+    # Array of links.
+    attr_accessor :links
+
+    attr_accessor :properties
+
+    # Hash of string-array pairs. The arrays contain embedded representations,
+    # zero or more.
+    attr_accessor :representations_for_rel
+
+    def initialize
+      @namespace_manager = NamespaceManager.new
+      @links = []
+      @properties = {}
+      @representations_for_rel = {}
+    end
+
+    # @!group Namespaces
+
+    def namespaces
+      @namespace_manager.namespaces
+    end
+
+    def with_namespace(name, ref)
+      @namespace_manager.with_namespace(name, ref)
+      self
+    end
+
+    # @!group Links
+
+    def link
+      link_for(Representation::SELF_REL)
+    end
+
+    def link_for(href_or_rel)
+      links_for(href_or_rel).first
+    end
+
+    # Answers the representation's links selected by either a hypertext
+    # reference or by a relation.
+    def links_for(href_or_rel)
+      rel = @namespace_manager.curie(href_or_rel) || href_or_rel
+      @links.select { |link| link.rel == rel }
+    end
+
+    # Adds a link to this representation.
+    #
+    # Ruby does not support argument overloading. If there is just one argument,
+    # assume that it is a +Link+ instance. If not, if more than one argument,
+    # assume that they are +String+ instances.
+    def with_link(*args)
+      @links.push(args.length == 1 ? args.first : Link.new(*args))
+      self
+    end
+
+    # @!group Properties
+
+    def value_for(name, default_value=nil)
+      @properties[name] || default_value
+    end
+
+    def with_property(name, value)
+      @properties[name] = value
+      self
+    end
+
+    # @!group Representations
+
+    # Takes the array values from the representations by relation, then flattens
+    # the array of arrays of representations. The result becomes an array of
+    # representations, all of them but without their relation to the
+    # super-representation that having been stripped away.
+    def representations
+      @representations_for_rel.values.flatten
+    end
+
+    # Associates a given embedded representation with this representation by a
+    # given relation.
+    def with_representation(rel, representation)
+      (@representations_for_rel[rel] ||= []).push(representation)
+      self
+    end
+  end
+end

data/lib/hypertext_application_language/version.rb

@@ -0,0 +1,6 @@
+# Describes the Hypertext Application Language in Ruby, a set of classes for
+# parsing and rendering between external representations and internal Ruby
+# classes.
+module HypertextApplicationLanguage
+  VERSION = '0.0.0'.freeze
+end

data/lib/hypertext_application_language.rb

@@ -0,0 +1,8 @@
+require 'hypertext_application_language/version'
+
+require 'hypertext_application_language/namespace_manager'
+require 'hypertext_application_language/link'
+require 'hypertext_application_language/representation'
+
+require 'hypertext_application_language/hash_representation_parser'
+require 'hypertext_application_language/hash_representation_renderer'

data/spec/hypertext_application_language/link_spec.rb

@@ -0,0 +1,30 @@
+describe HypertextApplicationLanguage::Link do
+  let(:link) { described_class.new('rel', '/path') }
+
+  it 'initializes' do
+    expect(link.rel).to eq('rel')
+    expect(link.href).to eq('/path')
+
+    other_link = described_class.new('other_rel', '/other_path', name: 'other_name')
+    expect(other_link.name).to eq('other_name')
+  end
+
+  it 'mutates' do
+    link.rel = 'otherRel'
+    expect(link.rel).to eq('otherRel')
+  end
+
+  it 'freezes' do
+    link.freeze
+    expect do
+      link.rel = 'frozenRel'
+    end.to raise_error(RuntimeError)
+  end
+
+  it 'freezes attributes' do
+    link.freeze
+    expect do
+      link.rel.prepend('other_')
+    end.to raise_error(RuntimeError)
+  end
+end

data/spec/hypertext_application_language/namespace_manager_spec.rb

@@ -0,0 +1,38 @@
+describe HypertextApplicationLanguage::NamespaceManager do
+  let(:manager) { described_class.new }
+
+  it 'initializes' do
+    expect(manager).not_to be_nil
+    expect(manager.namespaces).to be_empty
+    expect(manager.namespaces.length).to eq(0)
+
+    namespaces = manager.namespaces
+    namespaces['name'] = 'href'
+    expect(manager.namespaces.length).to eq(0)
+  end
+
+  it 'loads with namespaces' do
+    expect(manager.namespaces.length).to eq(0)
+    manager.with_namespace('name', 'http://localhost/' + described_class::REL)
+    expect(manager.namespaces['name']).to eq('http://localhost/{rel}')
+    expect(manager.namespaces.length).to eq(1)
+  end
+
+  let(:ns_manager) { manager.with_namespace('ns', 'http://localhost/{rel}/to') }
+
+  it 'answers curie for href' do
+    expect(ns_manager.curie('http://localhost/path/to')).to eq('ns:path')
+  end
+
+  it 'answers nil when no matching href' do
+    expect(ns_manager.curie('http://localhost:8080/to')).to be_nil
+  end
+
+  it 'answers href for curie' do
+    expect(ns_manager.href('ns:arg')).to eq('http://localhost/arg/to')
+  end
+
+  it 'answers nil when no matching curie' do
+    expect(ns_manager.href('n$:arg')).to be_nil
+  end
+end

data/spec/hypertext_application_language/representation_spec.rb

@@ -0,0 +1,9 @@
+describe HypertextApplicationLanguage::Representation do
+  let(:representation) { described_class.new }
+
+  it 'retains links' do
+    expect(representation.links).to be_empty
+    representation.with_link(HypertextApplicationLanguage::Link::SELF_REL, 'http://localhost/rel/1')
+    expect(representation.links).not_to be_empty
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+# Do not forget to place `--require spec_helper` in your `.rspec` file. RSpec
+# loads local command line options from this file found in the project's root
+# folder.
+
+require 'simplecov'
+SimpleCov.start
+
+require 'hypertext_application_language'

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification
+name: hypertext_application_language
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Roy Ratcliffe
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2015-09-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: bundler
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: rspec
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: simplecov
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ''
+email:
+- roy@pioneeringsoftware.co.uk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".yardopts"
+- ChangeLog.md
+- Gemfile
+- Gemfile.lock
+- MIT-LICENSE.txt
+- README.md
+- Rakefile
+- hypertext_application_language.gemspec
+- lib/hypertext_application_language.rb
+- lib/hypertext_application_language/hash_representation_parser.rb
+- lib/hypertext_application_language/hash_representation_renderer.rb
+- lib/hypertext_application_language/link.rb
+- lib/hypertext_application_language/namespace_manager.rb
+- lib/hypertext_application_language/representation.rb
+- lib/hypertext_application_language/version.rb
+- spec/hypertext_application_language/link_spec.rb
+- spec/hypertext_application_language/namespace_manager_spec.rb
+- spec/hypertext_application_language/representation_spec.rb
+- spec/spec_helper.rb
+homepage: http://stateless.co/hal_specification.html
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project:
+rubygems_version: 2.4.8
+signing_key:
+specification_version: 4
+summary: Hypertext Application Language
+test_files: []
+has_rdoc: