dm-grape-hypertext_application_language 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9622d1a9adcd27fa3afe257b96b72cf42747d8ff
+  data.tar.gz: aaff528b3cbf07283f78f82bf1443cb679ae3c3f
+SHA512:
+  metadata.gz: 9fbfbdb83df6dba07a37dc2d8a75f2116c1d39f42a555a37a0d7663cc1c343598082b88be903ac0df7d966ad49a583eff68d76f22aad8ff10c2870c6224ffede
+  data.tar.gz: 060dd2664ac27bb5bb14cf6b7a0d817e6fa3e2a3072d75ec2fa73a5461e6b3dd3b36d6dd4c7368a69d762cf2983df2a61af36fccb88835070214e962d79d061f

data/.gitignore

@@ -0,0 +1,3 @@
+# Ignore everything beneath the +pkg+ folder. The Bundler +build+ task places
+# +*.gem+ packages in this folder.
+pkg

data/Gemfile

@@ -0,0 +1,10 @@
+source 'https://rubygems.org'
+
+gemspec
+
+# %w(dm grape).each do |ext|
+#   name = ext + '-hypertext_application_language'
+#   path File.join(File.dirname(__FILE__), '..', name) do
+#     gem name
+#   end
+# end

data/Gemfile.lock

@@ -0,0 +1,125 @@
+PATH
+  remote: .
+  specs:
+    dm-grape-hypertext_application_language (0.0.0)
+      data_mapper
+      grape-hypertext_application_language
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (4.2.4)
+      i18n (~> 0.7)
+      json (~> 1.7, >= 1.7.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.3, >= 0.3.4)
+      tzinfo (~> 1.1)
+    addressable (2.3.8)
+    axiom-types (0.1.1)
+      descendants_tracker (~> 0.0.4)
+      ice_nine (~> 0.11.0)
+      thread_safe (~> 0.3, >= 0.3.1)
+    bcrypt (3.1.10)
+    bcrypt (3.1.10-java)
+    bcrypt-ruby (3.1.5)
+      bcrypt (>= 3.1.3)
+    bcrypt-ruby (3.1.5-java)
+      bcrypt (>= 3.1.3)
+    builder (3.2.2)
+    coercible (1.0.0)
+      descendants_tracker (~> 0.0.1)
+    data_mapper (1.2.0)
+      dm-aggregates (~> 1.2.0)
+      dm-constraints (~> 1.2.0)
+      dm-core (~> 1.2.0)
+      dm-migrations (~> 1.2.0)
+      dm-serializer (~> 1.2.0)
+      dm-timestamps (~> 1.2.0)
+      dm-transactions (~> 1.2.0)
+      dm-types (~> 1.2.0)
+      dm-validations (~> 1.2.0)
+    descendants_tracker (0.0.4)
+      thread_safe (~> 0.3, >= 0.3.1)
+    dm-aggregates (1.2.0)
+      dm-core (~> 1.2.0)
+    dm-constraints (1.2.0)
+      dm-core (~> 1.2.0)
+    dm-core (1.2.1)
+      addressable (~> 2.3)
+    dm-migrations (1.2.0)
+      dm-core (~> 1.2.0)
+    dm-serializer (1.2.2)
+      dm-core (~> 1.2.0)
+      fastercsv (~> 1.5)
+      json (~> 1.6)
+      json_pure (~> 1.6)
+      multi_json (~> 1.0)
+    dm-timestamps (1.2.0)
+      dm-core (~> 1.2.0)
+    dm-transactions (1.2.0)
+      dm-core (~> 1.2.0)
+    dm-types (1.2.2)
+      bcrypt-ruby (~> 3.0)
+      dm-core (~> 1.2.0)
+      fastercsv (~> 1.5)
+      json (~> 1.6)
+      multi_json (~> 1.0)
+      stringex (~> 1.4)
+      uuidtools (~> 2.1)
+    dm-validations (1.2.0)
+      dm-core (~> 1.2.0)
+    equalizer (0.0.11)
+    fastercsv (1.5.5)
+    grape (0.13.0)
+      activesupport
+      builder
+      hashie (>= 2.1.0)
+      multi_json (>= 1.3.2)
+      multi_xml (>= 0.5.2)
+      rack (>= 1.3.0)
+      rack-accept
+      rack-mount
+      virtus (>= 1.0.0)
+    grape-hypertext_application_language (0.0.0)
+      addressable
+      grape
+      hypertext_application_language
+    hashie (3.4.3)
+    hypertext_application_language (0.0.1)
+    i18n (0.7.0)
+    ice_nine (0.11.1)
+    json (1.8.3)
+    json (1.8.3-java)
+    json_pure (1.8.3)
+    minitest (5.8.2)
+    multi_json (1.11.2)
+    multi_xml (0.5.5)
+    rack (1.6.4)
+    rack-accept (0.4.5)
+      rack (>= 0.4)
+    rack-mount (0.8.3)
+      rack (>= 1.0.0)
+    rake (10.4.2)
+    stringex (1.5.1)
+    thread_safe (0.3.5)
+    thread_safe (0.3.5-java)
+    tzinfo (1.2.2)
+      thread_safe (~> 0.1)
+    uuidtools (2.1.5)
+    virtus (1.0.5)
+      axiom-types (~> 0.1)
+      coercible (~> 1.0)
+      descendants_tracker (~> 0.0, >= 0.0.3)
+      equalizer (~> 0.0, >= 0.0.9)
+
+PLATFORMS
+  java
+  ruby
+
+DEPENDENCIES
+  bundler
+  dm-grape-hypertext_application_language!
+  rake
+
+BUNDLED WITH
+   1.10.6

data/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/dm-grape-hypertext_application_language.gemspec

@@ -0,0 +1,17 @@
+Gem::Specification.new do |spec|
+  spec.name = 'dm-grape-hypertext_application_language'
+  spec.version = '0.0.0'
+  spec.summary = %q{Data Mapper and Grape extensions for 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_dependency 'data_mapper'
+  spec.add_dependency 'grape-hypertext_application_language'
+
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'rake'
+end

data/lib/dm-grape-hypertext_application_language.rb

@@ -0,0 +1 @@
+require 'hypertext_application_language/data_mapper/grape/api'

data/lib/dm-serializer/to_hal.rb

@@ -0,0 +1,98 @@
+require 'data_mapper'
+require 'hypertext_application_language'
+
+module DataMapper
+  module Serializer
+    # Converts a Data Mapper resource to a hypertext application language (HAL)
+    # representation.
+    #
+    # The resulting representation contains links for each relationship. There
+    # are two main kinds of Data Mapper relationships: to-one and to-many. For
+    # to-many relationships, the links contain a reference to a sub-path for
+    # accessing or creating sub-resources based on the name of the
+    # relationship. If the relationship is to-one, then the link depends on
+    # whether or not the to-one association exists. If it does already exist,
+    # then the link references a root-level hypertext path to the resource by
+    # its relationship name and its unique identifier; assuming that path
+    # +relationship/identifier+ resolves to the existing resources
+    # representation.
+    def to_hal(*args)
+      representation = HypertextApplicationLanguage::Representation.new
+
+      rel = model.to_s.tableize
+      representation.with_link(HypertextApplicationLanguage::Link::SELF_REL, "#{rel}/#{id}")
+
+      model.relationships.each do |relationship|
+        association = __send__(relationship.name)
+        href = if association == nil || association.is_a?(DataMapper::Collection)
+                 "#{representation.link.href}/#{relationship.name}"
+               else
+                 "#{association.model.to_s.tableize}/#{association.id}"
+               end
+        representation.with_link(relationship.name, href)
+      end
+
+      exclude = model.properties(repository.name).map(&:name).select do |name|
+        name.to_s.end_with?('_id')
+      end + %i(id)
+
+      properties_to_serialize(exclude: exclude).map(&:name).each do |name|
+        value = __send__(name)
+        representation.with_property(name, value)
+      end
+
+      representation
+    end
+  end
+
+  class Collection
+    # Converts a collection to HAL. Represents a collection by constructing a
+    # set of embedded representations associated with a relation. The name of
+    # the relation is the table name of the collection's underlying model. The
+    # collection representation includes other useful pieces of information: the
+    # offset, limit and chunk size, useful for paging.
+    #
+    # Sends +each+ to the collection to access the individual
+    # resources. Converts each one to HAL then embeds the results within the
+    # resulting collection representation. The resulting collection
+    # representation both embeds the resources and includes links to the same
+    # resources.
+    #
+    # Only adds a link to self if the arguments include a Rack environment and
+    # the rack environment specifies the request path. This assumes that the
+    # request path is either an absolute path because it begins with a slash, or
+    # a relative path because higher-level Rack formatters will make the
+    # reference absolute by adding the base URL and script name.
+    #
+    # @return [HypertextApplicationLanguage::Representation]
+    #   Representation of a collection of resources.
+    def to_hal(*args)
+      keyword_args = args.last.is_a?(Hash) ? args.pop : {}
+      representation = HypertextApplicationLanguage::Representation.new
+
+      if (env = keyword_args[:env]) && (href = env['REQUEST_PATH'])
+        representation.with_link(HypertextApplicationLanguage::Link::SELF_REL, href)
+      end
+
+      rel = model.to_s.tableize
+
+      each do |resource|
+        resource_representation = resource.to_hal(*args)
+        representation.with_link(rel, resource_representation.link.href)
+        representation.with_representation(rel, resource_representation)
+      end
+
+      %w(size).each do |name|
+        representation.with_property(name, __send__(name))
+      end
+      %w(offset limit).each do |name|
+        representation.with_property(name, query.__send__(name))
+      end
+      %w(count).each do |name|
+        representation.with_property(name, model.__send__(name, conditions: query.conditions))
+      end
+
+      representation
+    end
+  end
+end

data/lib/hypertext_application_language/data_mapper/grape/api.rb

@@ -0,0 +1,163 @@
+require 'grape'
+require 'data_mapper'
+require 'active_support/core_ext/hash'
+
+module HypertextApplicationLanguage
+  module DataMapper
+    module Grape
+      class API < ::Grape::API
+        route_param :model do
+          helpers do
+            # Takes the model name from the route path. Takes a string and
+            # answers a string, but the result is upper camel-case and singular.
+            # @return [String] Answers the name of the model based on the route
+            # parameter.
+            def model_name
+              params[:model].classify
+            end
+
+            def model
+              ::DataMapper::Model.descendants.select do |model|
+                model.name == model_name
+              end.first
+            end
+
+            # @return [Array<Symbol>] Answers the names of the model properties.
+            def property_names(model=model)
+              model.properties.map(&:name)
+            end
+
+            def attribute_names(property_names=property_names)
+              property_names.map(&:to_s).select do |name|
+                !name.end_with?('_id')
+              end - %w(id)
+            end
+
+            def attributes
+              params.slice(*attribute_names)
+            end
+
+            # The order parameter is an array of Data Mapper query
+            # directions. Each direction specifies a target property and a
+            # vector, ascending or descending, space delimited (or plus
+            # delimited after URL encoding). However, Grape cannot coerce the
+            # directions because directions need access to the model properties
+            # in order to construct the direction. The model comes from the
+            # helpers who only become available after parameter coercion and
+            # validation of parameters. Note that Grape _does_ coerce the order
+            # to an array even if the parameters do not specify an array.
+            def query(model=model)
+              query = declared(params, include_missing: true)
+              if query.order
+                query.order.map! do |direction|
+                  target, operator = direction.split(' ', 2)
+                  property = model.properties[target]
+                  error! "no property named #{target}" unless property
+                  ::DataMapper::Query::Direction.new(property, operator || 'asc')
+                end
+              end
+              query.to_h.symbolize_keys
+            end
+          end
+
+          params do
+            optional :offset, type: Integer, default: 0
+            optional :limit, type: Integer, default: 30
+            optional :order, type: [String]
+          end
+          get do
+            model.all(query)
+          end
+
+          post do
+            resource = model.create(attributes)
+            error! resource.errors.full_messages unless resource.save
+            resource
+          end
+
+          route_param :id do
+            helpers do
+              def resource
+                model.get(params[:id])
+              end
+            end
+
+            get do
+              resource
+            end
+
+            patch do
+              resource = self.resource
+              resource.update(attributes)
+              error! resource.errors.full_messages unless resource.save
+              resource
+            end
+
+            delete do
+              resource = self.resource
+              error! unless resource.destroy
+            end
+
+            route_param :relationship do
+              helpers do
+                def relationship_name
+                  params[:relationship]
+                end
+
+                def relationship
+                  resource.model.relationships.select do |relationship|
+                    relationship.name.to_s == relationship_name
+                  end.first
+                end
+
+                def target_model
+                  relationship.target_model
+                end
+
+                def target_property_names
+                  property_names(target_model)
+                end
+
+                def target_attribute_names
+                  attribute_names(target_property_names)
+                end
+
+                def target_attributes
+                  params.slice(*target_attribute_names)
+                end
+
+                def association
+                  resource.__send__(relationship_name)
+                end
+
+                def association=(target)
+                  resource.__send__("#{relationship_name}=", target)
+                end
+              end
+
+              params do
+                optional :offset, type: Integer, default: 0
+                optional :limit, type: Integer, default: 30
+                optional :order, type: [String]
+              end
+              get do
+                association.all(query(target_model))
+              end
+
+              post do
+                target = target_model.create(target_attributes)
+                if association.is_a?(::DataMapper::Collection)
+                  association << target
+                else
+                  self.assocation = target
+                end
+                error! target.errors.full_messages unless target.save
+                target
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification
+name: dm-grape-hypertext_application_language
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Roy Ratcliffe
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-11-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: data_mapper
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: grape-hypertext_application_language
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  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"
+- Gemfile
+- Gemfile.lock
+- Rakefile
+- dm-grape-hypertext_application_language.gemspec
+- lib/dm-grape-hypertext_application_language.rb
+- lib/dm-serializer/to_hal.rb
+- lib/hypertext_application_language/data_mapper/grape/api.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: Data Mapper and Grape extensions for Hypertext Application Language
+test_files: []