lhs 0.3.0

data/lib/lhs/concerns/service/build.rb

@@ -0,0 +1,17 @@
+require 'active_support'
+
+class LHS::Service
+
+  module Build
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+
+      def build(data = {})
+        data = LHS::Data.new(data, nil, self)
+        item = LHS::Item.new(data)
+        LHS::Data.new(item, nil, self)
+      end
+    end
+  end
+end

data/lib/lhs/concerns/service/create.rb

@@ -0,0 +1,26 @@
+require 'active_support'
+
+class LHS::Service
+
+  module Create
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+
+      def create(data = {})
+        create!(data)
+        rescue LHC::Error => e
+          json = JSON.parse(data.to_json)
+          data = LHS::Data.new(json, nil, self.class, e.response.request)
+          item = LHS::Item.new(data)
+          item.errors = LHS::Errors.new(e.response)
+          LHS::Data.new(item, data)
+      end
+
+      def create!(data = {})
+        url = instance.compute_url!(data)
+        instance.request(url: url, method: :post, body: data.to_json, headers: {'Content-Type' => 'application/json'})
+      end
+    end
+  end
+end

data/lib/lhs/concerns/service/endpoints.rb

@@ -0,0 +1,82 @@
+require 'active_support'
+
+class LHS::Service
+
+  # An endpoint is an url that leads to a backend resource.
+  # A service can contain multiple endpoints.
+  # The endpoint that is used to request data is choosen
+  # based on the provided parameters.
+  module Endpoints
+    extend ActiveSupport::Concern
+
+    attr_accessor :endpoints
+
+    module ClassMethods
+
+      # Adds the endpoint to the list of endpoints.
+      def endpoint(url, options = nil)
+        endpoint = LHC::Endpoint.new(url, options)
+        instance.sanity_check(endpoint)
+        instance.endpoints.push(endpoint)
+      end
+    end
+
+    def initialize
+      self.endpoints = []
+      super
+    end
+
+    # Find an endpoint based on the provided parameters.
+    # If no parameters are provided it finds the base endpoint
+    # otherwise it finds the endpoint that matches the parameters best.
+    def find_endpoint(params = {})
+      endpoint = find_best_endpoint(params) if params && params.keys.count > 0
+      endpoint ||= find_base_endpoint
+      endpoint
+    end
+
+    # Prevent clashing endpoints.
+    def sanity_check(endpoint)
+      placeholders = endpoint.placeholders
+      fail 'Clashing endpoints.' if endpoints.any? { |e| e.placeholders.sort == placeholders.sort }
+    end
+
+    # Computes the url from params
+    # by identifiying endpoint and compiles it if necessary.
+    # Id in params is threaded in a special way.
+    def compute_url!(params)
+      endpoint = find_endpoint(params)
+      url = endpoint.compile(params)
+      url +=  "/#{params.delete(:id)}" if params && params[:id]
+      endpoint.remove_interpolated_params!(params)
+      url
+    end
+
+    private
+
+    # Finds the best endpoint.
+    # The best endpoint is the one where all placeholders are interpolated.
+    def find_best_endpoint(params)
+      sorted_endpoints.find do |endpoint|
+        endpoint.placeholders.all? { |match| endpoint.find_value(match, params) }
+      end
+    end
+
+    # Sort endpoints by number of placeholders, heighest first
+    def sorted_endpoints
+      endpoints.sort{|a, b| b.placeholders.count <=> a.placeholders.count }
+    end
+
+    # Finds the base endpoint.
+    # A base endpoint is the one thats has the least amont of placeholers.
+    # There cannot be multiple base endpoints.
+    def find_base_endpoint
+      endpoints = self.endpoints.group_by do |endpoint|
+        endpoint.placeholders.length
+      end
+      bases = endpoints[endpoints.keys.min]
+      fail 'Multiple base endpoints found' if bases.count > 1
+      bases.first
+    end
+  end
+end

data/lib/lhs/concerns/service/find.rb

@@ -0,0 +1,36 @@
+require 'active_support'
+
+class LHS::Service
+
+  module Find
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+
+      # Find a single uniqe record
+      def find(args)
+        if args.is_a? Hash
+          find_with_parameters(args)
+        else
+          find_by_id(args)
+        end
+      end
+
+      private
+
+      def find_with_parameters(params)
+        data = instance.request(params: params)
+        if data._proxy.is_a?(LHS::Collection)
+          fail LHC::NotFound.new('Requested unique item. Multiple were found.', data._request.response) if data.count > 1
+          data.first || fail(LHC::NotFound.new('No item was found.', data._request.response))
+        else
+          data
+        end
+      end
+
+      def find_by_id(id)
+        instance.request(params: { id: id })
+      end
+    end
+  end
+end

data/lib/lhs/concerns/service/find_by.rb

@@ -0,0 +1,35 @@
+require 'active_support'
+
+class LHS::Service
+
+  module FindBy
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+
+      # Fetch some record by parameters
+      def find_by(params = {})
+        _find_by(params)
+        rescue LHC::NotFound
+          nil
+      end
+
+      # Raise if no record was found
+      def find_by!(params = {})
+        _find_by(params)
+      end
+
+      private
+
+      def _find_by(params)
+        params = params.dup.merge(limit: 1)
+        data = instance.request(params: params)
+        if data._proxy.is_a?(LHS::Collection)
+          data.first || fail(LHC::NotFound.new('No item was found.', data._request.response))
+        else
+          data
+        end
+      end
+    end
+  end
+end

data/lib/lhs/concerns/service/first.rb

@@ -0,0 +1,19 @@
+require 'active_support'
+
+class LHS::Service
+
+  module First
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+
+      def first
+        find_by
+      end
+
+      def first!
+        find_by!
+      end
+    end
+  end
+end

data/lib/lhs/concerns/service/includes.rb

@@ -0,0 +1,21 @@
+require 'active_support'
+
+class LHS::Service
+
+  module Includes
+    extend ActiveSupport::Concern
+
+    attr_accessor :includes
+
+    module ClassMethods
+
+      def includes(args)
+        class_clone = clone
+        class_clone.instance.endpoints = instance.endpoints
+        class_clone.instance.mapping = instance.mapping
+        class_clone.instance.includes = args
+        class_clone
+      end
+    end
+  end
+end

data/lib/lhs/concerns/service/mapping.rb

@@ -0,0 +1,23 @@
+require 'active_support'
+
+class LHS::Service
+
+  # Mapping allows to configure some accessors that access data using a provided proc
+  module Mapping
+    extend ActiveSupport::Concern
+
+    attr_accessor :mapping
+
+    module ClassMethods
+
+      def map(name, block)
+        instance.mapping[name] = block
+      end
+    end
+
+    def initialize
+      self.mapping = {}
+      super
+    end
+  end
+end

data/lib/lhs/concerns/service/model.rb

@@ -0,0 +1,16 @@
+require 'active_support'
+require 'active_model'
+
+class LHS::Service
+
+  module Model
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+
+      def model_name
+        ActiveModel::Name.new(self)
+      end
+    end
+  end
+end

data/lib/lhs/concerns/service/request.rb

@@ -0,0 +1,96 @@
+require 'active_support'
+
+class LHS::Service
+
+  module Request
+    extend ActiveSupport::Concern
+
+    def request(options)
+      if options.is_a? Array
+        multiple_requests(options)
+      else
+        single_request(options)
+      end
+    end
+
+    private
+
+    def multiple_requests(options)
+      options.map { |options| process_options(options) }
+      responses = LHC.request(options)
+      data = responses.map{ |response| LHS::Data.new(response.body, nil, self.class, response.request) }
+      data = LHS::Data.new(data, nil, self.class)
+      handle_includes(data) if includes
+      data
+    end
+
+    def single_request(options)
+      response = LHC.request(process_options(options))
+      data = LHS::Data.new(response.body, nil, self.class, response.request)
+      handle_includes(data) if includes
+      data
+    end
+
+    # Merge explicit params and take configured endpoints options as base
+    def process_options(options)
+      endpoint = find_endpoint(options[:params])
+      options = (endpoint.options || {}).merge(options)
+      options[:url] = compute_url!(options[:params]) unless options.key?(:url)
+      merge_explicit_params!(options[:params])
+      options.delete(:params) if options[:params] && options[:params].empty?
+      options
+    end
+
+    # Merge explicit params nested in 'params' namespace with original hash.
+    def merge_explicit_params!(params)
+      return true unless params
+      explicit_params = params[:params]
+      params.delete(:params)
+      params.merge!(explicit_params) if explicit_params
+    end
+
+    def handle_includes(data)
+      if includes.is_a? Hash
+        includes.keys.each { |key| handle_include(data, key) }
+      else
+        handle_include(data, includes)
+      end
+    end
+
+    def handle_include(data, key)
+      options = if data._proxy.is_a? LHS::Collection
+        include_multiple(data, key)
+      else
+        include_single(data, key)
+      end
+      addition = if (further_keys = includes.fetch(key, nil) if includes.is_a? Hash)
+        self.class.includes(further_keys).instance.request(options)
+      else
+        self.class.includes(nil).instance.request(options)
+      end
+      extend(data, addition, key)
+    end
+
+    def extend(data, addition, key)
+      if data._proxy.is_a? LHS::Collection
+        data.each_with_index do |item, i|
+          item = item[i] if item.is_a? LHS::Collection
+          item._raw[key.to_s].merge!(addition[i]._raw)
+        end
+      elsif data._proxy.is_a? LHS::Item
+        data._raw[key.to_s].merge!(addition._raw)
+      end
+    end
+
+    def include_multiple(data, key)
+      data.map do |item|
+        include_single(item, key)
+      end
+    end
+
+    def include_single(item, key)
+      link = item[key]
+      { url: link.href }
+    end
+  end
+end

data/lib/lhs/concerns/service/where.rb

@@ -0,0 +1,16 @@
+require 'active_support'
+
+class LHS::Service
+
+  module Where
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+
+      # Used to query data from the service.
+      def where(params = {})
+        instance.request(params: params)
+      end
+    end
+  end
+end

data/lib/lhs/data.rb

@@ -0,0 +1,103 @@
+require File.join(__dir__, 'proxy.rb')
+Dir[File.dirname(__FILE__) + '/concerns/data/*.rb'].each {|file| require file }
+
+# Data provides functionalities to accesses information
+class LHS::Data
+  include Json
+
+  # prevent clashing with attributes of underlying data
+  attr_accessor :_proxy, :_raw, :_parent, :_service, :_request
+
+  def initialize(input, parent = nil, service = nil, request = nil)
+    self._raw = raw_from_input(input)
+    self._proxy = proxy_from_input(input)
+    self._service = service
+    self._parent = parent
+    self._request = request
+  end
+
+  # merging data
+  # e.g. when loading remote data via link
+  def merge!(data)
+    return false unless data._raw.is_a?(Hash)
+    _raw.merge! data._raw
+  end
+
+  def _root
+    root = self
+    root = root._parent while root && root._parent
+    root
+  end
+
+  def class
+    _root._service
+  end
+
+  protected
+
+  # Use existing mapping to provide data
+  # or forward to proxy
+  def method_missing(name, *args, &block)
+    if root_item? && mapping = _root._service.instance.mapping[name]
+      mapping.call(self)
+    else
+      _proxy.send(name, *args, &block)
+    end
+  end
+
+  def respond_to_missing?(name, include_all = false)
+    (root_item? && _root._service.instance.mapping.keys.map(&:to_s).include?(name.to_s)) ||
+    _proxy.respond_to?(name, include_all)
+  end
+
+  private
+
+  def collection_proxy?(input)
+    (_raw.is_a?(Hash) && _raw['items']) || 
+      input.is_a?(Array) || _raw.is_a?(Array)
+  end
+
+  def root_item
+    return if self._proxy.class != LHS::Item
+    root = root_item = self
+    loop do
+      root = root._parent
+      root_item = root if root && root._proxy.is_a?(LHS::Item)
+      if !(root && root._parent)
+        break
+      else
+      end
+    end
+    root_item
+  end
+
+  def root_item?
+    root_item == self
+  end
+
+  def root?
+    _root == self
+  end
+
+  def proxy_from_input(input)
+    if input.is_a? LHS::Proxy
+      input
+    elsif collection_proxy?(input)
+      LHS::Collection.new(self)
+    else
+      LHS::Item.new(self)
+    end
+  end
+
+  def raw_from_input(input)
+    if input.is_a?(String) && input.length > 0
+      JSON.parse(input)
+    elsif defined?(input._raw)
+      input._raw
+    elsif defined?(input._data)
+      input._data._raw
+    else
+      input
+    end
+  end
+end