shaf_client 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6522a9d02450366d188195b580b2880a643cd596d284e6ada3d13228160b0038
+  data.tar.gz: 3aa9f908ed8f9e7b3ce423c27fcd640bd4569cdbf1e533d64c67d76dd8da5962
+SHA512:
+  metadata.gz: 775eb0e67adf697b7213a407cf836a829ba2f73555cbb68b234ad94461a37966e4a278c7738259b0e9b127c40aacdc2cbae6adfa56d697655282c7d1c28b3cbf
+  data.tar.gz: c1cc2969026ab53b58d12a5c5404922afffa89f1be47a08f4b92eb0c3d9bd9d9e190265bd690a0939bcee1ca8dca9926884ecc88f99b625280f5104a13960ff7

data/lib/shaf_client.rb

@@ -0,0 +1,87 @@
+require 'faraday'
+require 'json'
+require 'shaf_client/middleware/cache'
+require 'shaf_client/resource'
+require 'shaf_client/form'
+
+class ShafClient
+  extend Middleware::Cache::Control
+
+  MIME_TYPE_JSON = 'application/json'
+
+  def initialize(root_uri, **options)
+    @root_uri = root_uri.dup
+    adapter = options.fetch(:faraday_adapter, :net_http)
+    setup options
+
+    @client = Faraday.new(url: root_uri) do |conn|
+      conn.basic_auth(@user, @pass) if basic_auth?
+      conn.use Middleware::Cache, auth_header: auth_header
+      conn.adapter adapter
+    end
+  end
+
+  def get_root
+    get(@root_uri)
+  end
+
+  def get_form(uri)
+    response = request(method: :get, uri: uri)
+    Form.new(self, response.body)
+  end
+
+  def get_doc(uri)
+    response = request(method: :get, uri: uri)
+    response&.body || ''
+  end
+
+  %i[get put post delete patch].each do |method|
+    define_method(method) do |uri, payload = nil|
+      with_resource do
+        request(method: method, uri: uri, payload: payload)
+      end
+    end
+  end
+
+  private
+
+  attr_reader :auth_header
+
+  def setup(options)
+    setup_default_headers options
+    setup_basic_auth options
+  end
+
+  def setup_default_headers(options)
+    @default_headers = {
+      'Content-Type' => options.fetch(:content_type, MIME_TYPE_JSON)
+    }
+    return unless token = options[:auth_token]
+
+    @auth_header = options.fetch(:auth_header, 'X-Auth-Token')
+    @default_headers[@auth_header] = token
+  end
+
+  def setup_basic_auth(options)
+    @user, @pass = options.slice(:user, :password).values
+    @auth_header = options.fetch(:auth_header, 'Authorization') if basic_auth?
+  end
+
+  def basic_auth?
+    @user && @pass
+  end
+
+  def with_resource
+    response = yield
+    Resource.new(self, response.body)
+  end
+
+  def request(method:, uri:, payload: nil, headers: {})
+    payload = JSON.generate(payload) if payload&.is_a?(Hash)
+    @client.send(method) do |req|
+      req.url uri
+      req.body = payload if payload
+      req.headers.merge! @default_headers.merge(headers)
+    end
+  end
+end

data/lib/shaf_client/base_resource.rb

@@ -0,0 +1,118 @@
+require 'json'
+require 'shaf_client/link'
+require 'shaf_client/curie'
+
+class ShafClient
+  class BaseResource
+    attr_reader :attributes, :links, :curies, :embedded_resources
+
+    def initialize(payload)
+      @payload =
+        if payload&.is_a? String
+          JSON.parse(payload)
+        else
+          payload
+        end
+
+      parse
+    end
+
+    def to_s
+      attributes
+        .merge(_links: transform_values_to_s(links))
+        .merge(_embedded: transform_values_to_s(embedded_resources))
+        .to_s
+    end
+
+    def attribute(key)
+      attributes.fetch(key.to_sym)
+    end
+
+    def link(rel)
+      links.fetch(rel.to_sym)
+    end
+
+    def curie(rel)
+      curies.fetch(rel.to_sym)
+    end
+
+    def embedded(rel)
+      embedded_resources.fetch(rel.to_sym)
+    end
+
+    def [](key)
+      attributes[key]
+    end
+
+    def actions
+      links.keys
+    end
+
+    private
+
+    def payload
+      @payload ||= {}
+    end
+
+    def parse
+      @attributes = payload.transform_keys(&:to_sym)
+      parse_links
+      parse_embedded
+    end
+
+    def parse_links
+      links = attributes.delete(:_links) || {}
+      @links ||= {}
+      @curies ||= {}
+
+      links.each do |key, value|
+        next parse_curies(value) if key == 'curies'
+        @links[key.to_sym] = Link.from(value)
+      end
+    end
+
+    def parse_curies(curies)
+      curies.each do |value|
+        curie = Curie.from(value)
+        @curies[curie.name.to_sym] = curie
+      end
+    end
+
+    def parse_embedded
+      embedded = @attributes.delete(:_embedded) || {}
+      @embedded_resources ||= {}
+
+      embedded.each do |key, value|
+        @embedded_resources[key.to_sym] =
+          if value.is_a? Array
+            value.map { |d| BaseResource.new(d) }
+          else
+            BaseResource.new(value)
+          end
+      end
+    end
+
+    def method_missing(method_name, *args, &block)
+      if attributes.key?(method_name)
+        attribute(method_name)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      return true if attributes.key?(method_name)
+      super
+    end
+
+    def transform_values_to_s(hash)
+      hash.transform_values do |value|
+        if value.is_a? Array
+          value.map(&:to_s)
+        else
+          value.to_s
+        end
+      end
+    end
+  end
+end

data/lib/shaf_client/curie.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'shaf_client/link'
+
+class ShafClient
+  class Curie < Link
+    attr_reader :name
+
+    def self.from(data)
+      if data.is_a? Array
+        data.map do |d|
+          new(name: data['name'], href: d['href'], templated: d['templated'])
+        end
+      else
+        new(name: data['name'], href: data['href'], templated: data['templated'])
+      end
+    end
+
+    def initialize(name:, href:, templated: nil)
+      @name = name
+      @href = href
+      @templated = !!templated
+    end
+  end
+end

data/lib/shaf_client/form.rb

@@ -0,0 +1,37 @@
+require 'json'
+require 'shaf_client/link'
+
+class ShafClient
+  class Form < Resource
+
+    def values
+      return @values if defined? @values
+
+      @values = attribute(:fields).each_with_object({}) do |d, v|
+        v[d['name'].to_sym] = d['value']
+      end
+    end
+
+    def [](key)
+      values[key]
+    end
+
+    def []=(key, value)
+      values[key] = value
+    end
+
+    def target
+      attribute(:href)
+    end
+
+    def http_method
+      attribute(:method).downcase.to_sym
+    end
+
+    # def validate; end
+
+    def submit
+      client.send(http_method, target, @values)
+    end
+  end
+end

data/lib/shaf_client/link.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+class ShafClient
+  class Link
+    attr_reader :templated
+
+    def self.from(data)
+      if data.is_a? Array
+        data.map { |d| new(href: d['href'], templated: d['templated']) }
+      else
+        new(href: data['href'], templated: data['templated'])
+      end
+    end
+
+    def initialize(href:, templated: nil)
+      @href = href
+      @templated = !!templated
+    end
+
+    alias templated? templated
+
+    def href
+      @href.dup
+    end
+
+    def resolve_templated(**args)
+      return unless templated?
+
+      args.inject(href) do |uri, (key, value)|
+        value = value.to_s.sub(/.+:/, '')
+        uri.sub(/{#{key}}/, value)
+      end
+    end
+
+    def to_s
+      {
+        href: href,
+        templated: templated?
+      }.to_s
+    end
+  end
+end

data/lib/shaf_client/middleware/cache.rb

@@ -0,0 +1,181 @@
+# FIXME zip payload
+
+class ShafClient
+  module Middleware
+    class Cache
+      DEFAULT_THRESHOLD = 10_000
+
+      Response = Struct.new(:status, :body, :headers, keyword_init: true)
+
+      module Control
+        def cache_size
+          Cache.size
+        end
+
+        def clear_cache
+          Cache.clear
+        end
+
+        def clear_stale_cache
+          Cache.clear_stale
+        end
+      end
+
+      class << self
+        attr_writer :threshold
+
+        def inc_request_count
+          @request_count ||= 0
+          @request_count += 1
+          return if (@request_count % 500 != 0)
+          clear_stale
+          check_threshold
+        end
+
+        def size
+          cache.size
+        end
+
+        def clear
+          mutex.synchronize do
+            @cache = {}
+          end
+        end
+
+        def clear_stale
+          mutex.synchronize do
+            cache.delete_if { |_key, entry| expired? entry }
+          end
+        end
+
+        def get(key:, check_expiration: true)
+          entry = nil
+          mutex.synchronize do
+            entry = cache[key.to_sym].dup
+          end
+          return entry[:payload] if valid?(entry, check_expiration)
+          yield if block_given?
+        end
+
+        def get_etag(key:)
+          mutex.synchronize do
+            cache.dig(key.to_sym, :etag)
+          end
+        end
+
+        def store(key:, payload:, etag: nil, expire_at: nil)
+          return unless payload && key && (etag || expire_at)
+
+          mutex.synchronize do
+            cache[key.to_sym] = {
+              payload: payload,
+              etag: etag,
+              expire_at: expire_at
+            }
+          end
+        end
+
+        def threshold
+          @threshold ||= DEFAULT_THRESHOLD
+        end
+
+        private
+
+        def mutex
+          @mutex = Mutex.new
+        end
+
+        def cache
+          mutex.synchronize do
+            @cache ||= {}
+          end
+        end
+
+        def valid?(entry, check_expiration = true)
+          return false unless entry
+          return false unless entry[:payload]
+          return true unless check_expiration
+          !expired? entry
+        end
+
+        def expired?(entry)
+          return true unless entry[:expire_at]
+          entry[:expire_at] < Time.now
+        end
+
+        def check_threshold
+          return if size < threshold
+
+          count = 500
+          cache.each do |key, _value|
+            break if count <= 0
+            cache[key] = nil
+            count -= 1
+          end
+          cache.compact!
+        end
+      end
+
+      def initialize(app, **options)
+        @app = app
+        @options = options
+      end
+
+      def call(request_env)
+        key = cache_key(request_env)
+
+        if request_env[:method] == :get
+          cached = self.class.get(key: key)
+          return Response.new(body: cached, headers: {}) if cached
+        end
+
+        add_etag(request_env, key)
+
+        @app.call(request_env).on_complete do |response_env|
+          add_cached_payload(response_env, key)
+          cache_response(response_env, key)
+          self.class.inc_request_count
+        end
+      end
+
+      def add_etag(env, key = nil)
+        key ||= cache_key(env)
+        etag = self.class.get_etag(key: key)
+        env[:request_headers]['If-None-Match'] = etag if etag
+      end
+
+      def add_cached_payload(response_env, key)
+        return if response_env[:status] != 304
+        cached = self.class.get(key: key, check_expiration: false)
+        response_env[:body] = cached if cached
+      end
+
+      def cache_response(response_env, key)
+        etag = response_env[:response_headers]['etag']
+        cache_control = response_env[:response_headers]['cache-control']
+        expire_at = expiration(cache_control)
+        self.class.store(
+          key: key,
+          payload: response_env[:body],
+          etag: etag,
+          expire_at: expire_at
+        )
+      end
+
+      def cache_key(env)
+        :"#{env[:url]}.#{env[:request_headers][auth_header]}"
+      end
+
+      def auth_header
+        @options.fetch(:auth_header, 'X-AUTH-TOKEN')
+      end
+
+      def expiration(cache_control)
+        return unless cache_control
+
+        max_age = cache_control[/max-age=\s?(\d+)/, 1]
+        Time.now + max_age.to_i if max_age
+      end
+    end
+  end
+end

data/lib/shaf_client/resource.rb

@@ -0,0 +1,39 @@
+require 'json'
+require 'shaf_client/base_resource'
+
+class ShafClient
+  class Resource < BaseResource
+
+    def initialize(client, payload)
+      @client = client
+      super(payload)
+    end
+
+    %i[get put post delete patch get_form].each do |method|
+      define_method(method) do |rel, payload = nil|
+        href = link(rel).href
+        args = [method, href]
+        args << payload unless method.to_s.start_with? 'get'
+        client.send(*args)
+      end
+    end
+
+    def get_doc(rel:)
+      rel = rel.to_s
+      curie_name, rel =
+        if rel.include? ':'
+          rel.split(':')
+        else
+          [:doc, rel]
+        end
+
+      curie = curie(curie_name)
+      uri = curie.resolve_templated(rel: rel)
+      client.get_doc(uri)
+    end
+
+    private
+
+    attr_reader :client
+  end
+end

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification
+name: shaf_client
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Sammy Henningsson
+autorequire: 
+bindir: bin
+cert_chain:
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIDXjCCAkagAwIBAgIBATANBgkqhkiG9w0BAQsFADAsMSowKAYDVQQDDCFzYW1t
+  eS5oZW5uaW5nc3Nvbi9EQz1nbWFpbC9EQz1jb20wHhcNMTgwNzE2MTYzNTMzWhcN
+  MjAwNzE2MTYzNTMzWjAsMSowKAYDVQQDDCFzYW1teS5oZW5uaW5nc3Nvbi9EQz1n
+  bWFpbC9EQz1jb20wggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCvkgwt
+  Zn8obnCelWttayB1BrHBLUK3b8gasRRtbNk4DzAL+EW6sHSVT2u5I7Wws7JQA5VB
+  NaK7tgvq3CbDLVRl9NrpDCDx09To08stPxDKi6kst1nkSPAD8g0sQlW3voeQTH98
+  2Z2H3XUegHhu5Z9PU9T/7V/vZUzHPiPg1tX1JUIGOPAjVGsr7SUetbL171zK4S4Y
+  tvUkIoNaph+maHttvyYB/ptiZLD53WORKd4Knw3OiJsLtrxr5hhKyQ+txQdF0P8G
+  +FlR+Je7B0Ek3yg6fEiJgrdcajYCMo8Oe/GRtoHhi6J3LsYA620P1BSCddZQ2XeL
+  y3rzIZyMU0iaT69nAgMBAAGjgYowgYcwCQYDVR0TBAIwADALBgNVHQ8EBAMCBLAw
+  HQYDVR0OBBYEFLpI49QndnmuiDhwy2XtMps7No1pMCYGA1UdEQQfMB2BG3NhbW15
+  Lmhlbm5pbmdzc29uQGdtYWlsLmNvbTAmBgNVHRIEHzAdgRtzYW1teS5oZW5uaW5n
+  c3NvbkBnbWFpbC5jb20wDQYJKoZIhvcNAQELBQADggEBAFJZqH6sgeiTLvMLpxaK
+  K1GaYSCyZbMutf5C3tIAgkmU5UD6B8R0bw6gTM1deM5NJ60LjzqY7rlK3YKDIbTn
+  iXMCe9vd4yE/jb5Zi8Wk//9n8CMG68dQpBvmcQ58/M4gTtgsx+lIgXuI5dPQMmRi
+  bhWQqqWqxT9X6njjfXFk4xn3z6mfFQNPAYqRVeTHUpXBQZPt+bYXRwHPFZGWkx4l
+  BnuuhYKt3CR7YIgvnsQWlTAcU1Ipdayj6UfYqUtlc6cF3CL96NOx7mgZXV8URFiX
+  ZMhjYR7sRczGJx+GxGU2EaR0bjRsPVlC4ywtFxoOfRG3WaJcpWGEoAoMJX6Z0bRv
+  M40=
+  -----END CERTIFICATE-----
+date: 2018-12-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.15'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.15'
+description: A HAL client customized for Shaf APIs
+email: sammy.henningsson@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/shaf_client.rb
+- lib/shaf_client/base_resource.rb
+- lib/shaf_client/curie.rb
+- lib/shaf_client/form.rb
+- lib/shaf_client/link.rb
+- lib/shaf_client/middleware/cache.rb
+- lib/shaf_client/resource.rb
+homepage: https://github.com/sammyhenningsson/shafClient
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.5'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: HAL client for Shaf
+test_files: []