lhs 2.0.5 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bf11afeed9a8a7a43f2c594ad95dd909e1a12f0d
-  data.tar.gz: 885dacb37539493c398957242a4fba4c20e13a4f
+  metadata.gz: df827d2008392c40865a0c82e9a515b4bc541ee2
+  data.tar.gz: 5b589ba038ded4cb9407c24091ed7c0b08f96a63
 SHA512:
-  metadata.gz: e854348297280962ce9553f22112b0f014462263f94eef3d18f870e4602524ac658679427927827230977c1052234d7dda39e6350b54bd1676599a1af83163c1
-  data.tar.gz: 760777a4f2e23e6a31509aa436417ce5abcff5a60805b5ec56a81fbe75594ac7b5562738179c16418b6c4203ae3563127e3729de94763924b392be4dcdd28506
+  metadata.gz: 3648b5f1e76c703a6f56cfc78b9b8d4bc2a983947f42dfd819e087aca2d5100b8846ca3a8c4059a86b54cf033a18e648f9881d8cf5a40fbfe337268d3d53472f
+  data.tar.gz: 8f797d35de13f0e3f1e8171c15730137834029a95aae831a2d174e78e377779b5fd3d0227e578bb00469bbfc17528388279147c2f2944ef0758d0e1d14960fd4

data/docs/items.md

@@ -16,7 +16,7 @@ An item proxy contains setter methods, in order to set/change values.
   rcord.recommended = false
 ```
 
-## Build
+## Build (new)
 
 Build and persist new items from scratch.
 
@@ -25,6 +25,12 @@ feedback = Feedback.build(recommended: true)
 feedback.save
 ```
 
+`new` is an alias for `build`:
+
+```ruby
+Feedback.new(recommended: true)
+```
+
 ## Save
 
 You can persist changes like you would usually do with `save`.

data/docs/services.md

@@ -155,6 +155,12 @@ Build and persist new items from scratch.
   feedback.save
 ```
 
+`new` is an alias for `build`:
+
+```ruby
+Feedback.new(recommended: true)
+```
+
 → [Read more about items](items.md)
 
 

data/lib/lhs/concerns/item/destroy.rb

@@ -7,8 +7,8 @@ class LHS::Item < LHS::Proxy
     extend ActiveSupport::Concern
 
     def destroy
-      service_instance = _data._root._service.instance
-      _data._request = service_instance.request(method: :delete, url: href)._request
+      service = _data._root._service
+      _data._request = service.request(method: :delete, url: href)._request
       _data
     end
   end

data/lib/lhs/concerns/item/save.rb

@@ -19,9 +19,9 @@ class LHS::Item < LHS::Proxy
       url = if href.present?
        href
       else
-        service.instance.find_endpoint(data).compile(data)
+        service.find_endpoint(data).compile(data)
       end
-      data = service.instance.request(method: :post, url: url, body: data.to_json, headers: {'Content-Type' => 'application/json'})
+      data = service.request(method: :post, url: url, body: data.to_json, headers: {'Content-Type' => 'application/json'})
       self._data.merge_raw!(data)
       true
     end

data/lib/lhs/concerns/item/update.rb

@@ -16,7 +16,7 @@ class LHS::Item < LHS::Proxy
     def update!(params)
       service = _data._root._service
       _data.merge_raw!(LHS::Data.new(params))
-      response_data = service.instance.request(
+      response_data = service.request(
         method: :post,
         url: href,
         body: _data.to_json,

data/lib/lhs/concerns/item/validation.rb

@@ -29,7 +29,7 @@ class LHS::Item < LHS::Proxy
     private
 
     def validation_endpoint
-      endpoint = _data._service.instance.find_endpoint(_data._raw)
+      endpoint = _data._service.find_endpoint(_data._raw)
       endpoint ||= LHS::Endpoint.for_url(_data.href) if _data.href
       validates = endpoint.options && endpoint.options.fetch(:validates, false)
       fail 'Endpoint does not support validations!' unless validates

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

@@ -15,7 +15,7 @@ class LHS::Service
       def all(params = {})
         all = []
         default_max_limit = 100
-        data = instance.request(params: params.merge(limit: default_max_limit))
+        data = request(params: params.merge(limit: default_max_limit))
         all.concat(data._raw[:items])
         total_left = data._raw[:total] - data.count
         limit = data._raw[:limit] || data.count
@@ -23,7 +23,7 @@ class LHS::Service
           requests = total_left / limit
           requests.times do |i|
             offset = limit * (i+1) + 1
-            all.concat instance.request(params: params.merge(limit: limit, offset: offset))._raw[:items]
+            all.concat request(params: params.merge(limit: limit, offset: offset))._raw[:items]
           end
         end
         LHS::Data.new(all, nil, self)

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

@@ -11,8 +11,8 @@ class LHS::Service
       def find_each(options = {})
         find_in_batches(options) do |data|
           data.each do |record|
-            item = LHS::Item.new(LHS::Data.new(record, data, self.class))
-            yield LHS::Data.new(item, data, self.class)
+            item = LHS::Item.new(LHS::Data.new(record, data, self))
+            yield LHS::Data.new(item, data, self)
           end
         end
       end
@@ -24,7 +24,7 @@ class LHS::Service
         batch_size = options[:batch_size] || 100
         params = options[:params] || {}
         loop do # as suggested by Matz
-          data = instance.request(params: params.merge(limit: batch_size, offset: start))
+          data = request(params: params.merge(limit: batch_size, offset: start))
           batch_size = data._raw[:limit]
           left = data._raw[:total].to_i - data._raw[:offset].to_i - data._raw[:limit].to_i
           yield data

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

@@ -12,6 +12,8 @@ class LHS::Service
         item = LHS::Item.new(data)
         LHS::Data.new(item, nil, self)
       end
+      alias_method :new, :build
+      
     end
   end
 end

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

@@ -11,15 +11,15 @@ class LHS::Service
         create!(data)
         rescue LHC::Error => e
           json = JSON.parse(data.to_json)
-          data = LHS::Data.new(json, nil, self.class, e.response.request)
+          data = LHS::Data.new(json, nil, self, 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'})
+        url = compute_url!(data)
+        request(url: url, method: :post, body: data.to_json, headers: {'Content-Type' => 'application/json'})
       end
     end
   end

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

@@ -9,18 +9,25 @@ class LHS::Service
   module Endpoints
     extend ActiveSupport::Concern
 
-    attr_accessor :endpoints
     mattr_accessor :all
 
     module ClassMethods
 
+      def endpoints
+        @endpoints ||= []
+      end
+
+      def endpoints=(endpoints)
+        @endpoints = endpoints
+      end
+
       # 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)
+        sanity_check(endpoint)
+        endpoints.push(endpoint)
         LHS::Service::Endpoints.all ||= {}
-        LHS::Service::Endpoints.all[url] = instance
+        LHS::Service::Endpoints.all[url] = self
       end
 
       def for_url(url)
@@ -30,63 +37,58 @@ class LHS::Service
         end
         service
       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
+      # 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
+      # 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)
-      endpoint.remove_interpolated_params!(params)
-      url
-    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)
+        endpoint.remove_interpolated_params!(params)
+        url
+      end
 
-    private
+      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) }
+      # 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
-    end
 
-    # Sort endpoints by number of placeholders, heighest first
-    def sorted_endpoints
-      endpoints.sort{|a, b| b.placeholders.count <=> a.placeholders.count }
-    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
+      # 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
-      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

@@ -19,7 +19,7 @@ class LHS::Service
       private
 
       def find_with_parameters(params)
-        data = instance.request(params: params)
+        data = 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))
@@ -29,7 +29,7 @@ class LHS::Service
       end
 
       def find_by_id(id)
-        instance.request(params: { id: id })
+        request(params: { id: id })
       end
     end
   end

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

@@ -23,7 +23,7 @@ class LHS::Service
 
       def _find_by(params)
         params = params.dup.merge(limit: 1)
-        data = instance.request(params: params)
+        data = 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/lib/lhs/concerns/service/includes.rb

@@ -5,15 +5,21 @@ class LHS::Service
   module Includes
     extend ActiveSupport::Concern
 
-    attr_accessor :includes
-
     module ClassMethods
 
+      def including
+        @including
+      end
+
+      def including=(including)
+        @including = including
+      end
+
       def includes(*args)
         class_clone = clone
-        class_clone.instance.endpoints = instance.endpoints
-        class_clone.instance.mapping = instance.mapping
-        class_clone.instance.includes = args.size == 1 ? args[0] : args
+        class_clone.endpoints = endpoints
+        class_clone.mapping = mapping
+        class_clone.including = args.size == 1 ? args[0] : args
         class_clone
       end
     end

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

@@ -6,18 +6,19 @@ class LHS::Service
   module Mapping
     extend ActiveSupport::Concern
 
-    attr_accessor :mapping
-
     module ClassMethods
+      
+      def mapping
+        @mapping ||= {}
+      end
 
-      def map(name, block)
-        instance.mapping[name] = block
+      def mapping=(mapping)
+        @mapping = mapping
       end
-    end
 
-    def initialize
-      self.mapping = {}
-      super
+      def map(name, block)
+        mapping[name] = block
+      end
     end
   end
 end

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

@@ -5,138 +5,142 @@ class LHS::Service
   module Request
     extend ActiveSupport::Concern
 
-    def request(options)
-      if options.is_a? Array
-        multiple_requests(options)
-      else
-        single_request(options)
+    module ClassMethods
+
+      def request(options)
+        if options.is_a? Array
+          multiple_requests(options)
+        else
+          single_request(options)
+        end
       end
-    end
 
-    private
+      private
 
-    # Convert URLs in options to endpoint templates
-    def convert_options_to_endpoints(options)
-      if options.is_a?(Array)
-        options.map { |option| convert_option_to_endpoints(option) }
-      else
-        convert_option_to_endpoints(options)
+      # Convert URLs in options to endpoint templates
+      def convert_options_to_endpoints(options)
+        if options.is_a?(Array)
+          options.map { |option| convert_option_to_endpoints(option) }
+        else
+          convert_option_to_endpoints(options)
+        end
       end
-    end
 
-    def convert_option_to_endpoints(option)
-      new_options = option.dup
-      url = option[:url]
-      return unless endpoint = LHS::Endpoint.for_url(url)
-      template = endpoint.url
-      new_options = new_options.merge(params: LHC::Endpoint.values_as_params(template, url))
-      new_options[:url] = template
-      new_options
-    end
+      def convert_option_to_endpoints(option)
+        new_options = option.dup
+        url = option[:url]
+        return unless endpoint = LHS::Endpoint.for_url(url)
+        template = endpoint.url
+        new_options = new_options.merge(params: LHC::Endpoint.values_as_params(template, url))
+        new_options[:url] = template
+        new_options
+      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_sym].merge!(addition[i]._raw)
+      # Extends existing raw data with additionaly fetched data
+      def extend_raw_data(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_sym].merge!(addition[i]._raw)
+          end
+        elsif data._proxy.is_a? LHS::Item
+          data._raw[key.to_sym].merge!(addition._raw)
         end
-      elsif data._proxy.is_a? LHS::Item
-        data._raw[key.to_sym].merge!(addition._raw)
       end
-    end
 
-    def handle_includes(includes, data)
-      if includes.is_a? Hash
-        includes.each { |_include, sub_includes| handle_include(_include, data, sub_includes) }
-      elsif includes.is_a? Array
-        includes.each { |_include| handle_includes(_include, data) }
-      else
-        handle_include(includes, data)
+      def handle_includes(includes, data)
+        if includes.is_a? Hash
+          includes.each { |_include, sub_includes| handle_include(_include, data, sub_includes) }
+        elsif includes.is_a? Array
+          includes.each { |_include| handle_includes(_include, data) }
+        else
+          handle_include(includes, data)
+        end
       end
-    end
 
-    def handle_include(_include, data, sub_includes = nil)
-      return unless data.present?
-      options = if data._proxy.is_a? LHS::Collection
-        options_for_multiple(data, _include)
-      else
-        url_option_for(data, _include)
+      def handle_include(_include, data, sub_includes = nil)
+        return unless data.present?
+        options = if data._proxy.is_a? LHS::Collection
+          options_for_multiple(data, _include)
+        else
+          url_option_for(data, _include)
+        end
+        addition = load_include(options, data, sub_includes)
+        extend_raw_data(data, addition, _include)
       end
-      addition = load_include(options, data, sub_includes)
-      extend(data, addition, _include)
-    end
 
-    # Load additional resources that are requested with include
-    def load_include(options, data, sub_includes)
-      service = service_for_options(options) || self
-      options = convert_options_to_endpoints(options) if service_for_options(options)
-      begin
-        service.class.includes(sub_includes).instance.request(options)
-      rescue LHC::NotFound
-        LHS::Data.new({}, data, service)
+      # Load additional resources that are requested with include
+      def load_include(options, data, sub_includes)
+        service = service_for_options(options) || self
+        options = convert_options_to_endpoints(options) if service_for_options(options)
+        begin
+          service.includes(sub_includes).request(options)
+        rescue LHC::NotFound
+          LHS::Data.new({}, data, service)
+        end
       end
-    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
+      # 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 multiple_requests(options)
-      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(includes, data) if includes
-      data
-    end
+      def multiple_requests(options)
+        options = options.map { |options| process_options(options) }
+        responses = LHC.request(options)
+        data = responses.map{ |response| LHS::Data.new(response.body, nil, self, response.request) }
+        data = LHS::Data.new(data, nil, self)
+        handle_includes(including, data) if including
+        data
+      end
 
-    def options_for_multiple(data, key)
-      data.map do |item|
-        url_option_for(item, key)
+      def options_for_multiple(data, key)
+        data.map do |item|
+          url_option_for(item, key)
+        end
       end
-    end
 
-    # Merge explicit params and take configured endpoints options as base
-    def process_options(options)
-      options ||= {}
-      options = options.dup
-      options[:params].deep_symbolize_keys! if options[:params]
-      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 and take configured endpoints options as base
+      def process_options(options)
+        options ||= {}
+        options = options.dup
+        options[:params].deep_symbolize_keys! if options[:params]
+        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
 
-    def service_for_options(options)
-      services = []
-      if options.is_a?(Array)
-        options.each do |option|
-          next unless service = LHS::Service.for_url(option[:url])
-          services.push(service)
+      def service_for_options(options)
+        services = []
+        if options.is_a?(Array)
+          options.each do |option|
+            next unless service = LHS::Service.for_url(option[:url])
+            services.push(service)
+          end
+          fail 'Found more than one service that could be used to do the request' if services.uniq.count > 1
+          services.uniq.first
+        else # Hash
+          LHS::Service.for_url(options[:url])
         end
-        fail 'Found more than one service that could be used to do the request' if services.uniq.count > 1
-        services.uniq.first
-      else # Hash
-        LHS::Service.for_url(options[:url])
       end
-    end
 
-    def single_request(options)
-      response = LHC.request(process_options(options))
-      data = LHS::Data.new(response.body, nil, self.class, response.request)
-      handle_includes(includes, data) if includes
-      data
-    end
+      def single_request(options)
+        response = LHC.request(process_options(options))
+        data = LHS::Data.new(response.body, nil, self, response.request)
+        handle_includes(including, data) if including
+        data
+      end
 
-    def url_option_for(item, key)
-      link = item[key]
-      { url: link.href }
+      def url_option_for(item, key)
+        link = item[key]
+        { url: link.href }
+      end
     end
   end
 end

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

@@ -9,7 +9,7 @@ class LHS::Service
 
       # Used to query data from the service.
       def where(params = {})
-        instance.request(params: params)
+        request(params: params)
       end
     end
   end

data/lib/lhs/data.rb

@@ -52,7 +52,7 @@ class LHS::Data
   end
 
   def respond_to_missing?(name, include_all = false)
-    (root_item? && _root._service.instance.mapping.keys.map(&:to_s).include?(name.to_s)) ||
+    (root_item? && _root._service.mapping.keys.map(&:to_s).include?(name.to_s)) ||
     _proxy.respond_to?(name, include_all)
   end
 
@@ -63,10 +63,10 @@ class LHS::Data
   end
 
   def mapping_for(name)
-    service_instance = LHS::Service.for_url(_raw[:href]) if _raw.is_a?(Hash)
-    service_instance ||= _root._service.instance if root_item? && _root._service
-    return unless service_instance
-    service_instance.mapping[name]
+    service = LHS::Service.for_url(_raw[:href]) if _raw.is_a?(Hash)
+    service ||= _root._service if root_item? && _root._service
+    return unless service
+    service.mapping[name]
   end
 
   def root_item

data/lib/lhs/proxy.rb

@@ -18,7 +18,7 @@ class LHS::Proxy
   def reload!
     fail 'No href found' unless _data.href
     service = _data._root._service
-    data = service.instance.request(url: _data.href, method: :get)
+    data = service.request(url: _data.href, method: :get)
     _data.merge_raw!(data)
     self._loaded = true
     self

data/lib/lhs/service.rb

@@ -1,7 +1,6 @@
-require 'singleton'
 Dir[File.dirname(__FILE__) + '/concerns/service/*.rb'].each {|file| require file }
 
-# A Service makes data available using multiple endpoints.
+# A Service makes data available by using backend endpoints.
 class LHS::Service
   include All
   include Batch
@@ -15,6 +14,5 @@ class LHS::Service
   include Model
   include Includes
   include Request
-  include Singleton
   include Where
 end

data/lib/lhs/version.rb

@@ -1,3 +1,3 @@
 module LHS
-  VERSION = "2.0.5"
+  VERSION = "2.1.0"
 end

data/spec/service/build_spec.rb

@@ -2,7 +2,7 @@ require 'rails_helper'
 
 describe LHS::Service do
 
-  context 'new' do
+  context 'build' do
 
     let(:datastore) { 'http://local.ch/v2' }
 

data/spec/service/endpoint_options_spec.rb

@@ -11,7 +11,7 @@ describe LHS::Service do
     end
 
     it 'stores endpoints with options' do
-      expect(SomeService.instance.endpoints[0].options).to eq(cache_expires_in: 86400, retry: 2, cache: true)
+      expect(SomeService.endpoints[0].options).to eq(cache_expires_in: 86400, retry: 2, cache: true)
     end
 
     it 'uses the options that are configured for an endpoint' do

data/spec/service/endpoints_spec.rb

@@ -22,24 +22,24 @@ describe LHS::Service do
     end
 
     it 'stores the endpoints of the service' do
-      expect(SomeService.instance.endpoints.count).to eq 3
-      expect(SomeService.instance.endpoints[0].url).to eq ':datastore/entries/:entry_id/content-ads/:campaign_id/feedbacks'
-      expect(SomeService.instance.endpoints[1].url).to eq ':datastore/:campaign_id/feedbacks'
-      expect(SomeService.instance.endpoints[2].url).to eq ':datastore/feedbacks'
+      expect(SomeService.endpoints.count).to eq 3
+      expect(SomeService.endpoints[0].url).to eq ':datastore/entries/:entry_id/content-ads/:campaign_id/feedbacks'
+      expect(SomeService.endpoints[1].url).to eq ':datastore/:campaign_id/feedbacks'
+      expect(SomeService.endpoints[2].url).to eq ':datastore/feedbacks'
     end
 
     it 'finds the endpoint by the one with the most route param hits' do
       expect(
-        SomeService.instance.find_endpoint(campaign_id: '12345').url
+        SomeService.find_endpoint(campaign_id: '12345').url
       ).to eq ':datastore/:campaign_id/feedbacks'
       expect(
-        SomeService.instance.find_endpoint(campaign_id: '12345', entry_id: '123').url
+        SomeService.find_endpoint(campaign_id: '12345', entry_id: '123').url
       ).to eq ':datastore/entries/:entry_id/content-ads/:campaign_id/feedbacks'
     end
 
     it 'finds the base endpoint (endpoint with least amount of route params)' do
       expect(
-        SomeService.instance.find_endpoint.url
+        SomeService.find_endpoint.url
       ).to eq ':datastore/feedbacks'
     end
 

data/spec/service/new_spec.rb

@@ -0,0 +1,25 @@
+require 'rails_helper'
+
+describe LHS::Service do
+
+  context 'new' do
+
+    let(:datastore) { 'http://local.ch/v2' }
+
+    before(:each) do
+      LHC.config.placeholder('datastore', datastore)
+      class Feedback < LHS::Service
+        endpoint ':datastore/content-ads/:campaign_id/feedbacks'
+        endpoint ':datastore/feedbacks'
+      end
+    end
+
+    it 'builds a new item from scratch (like build)' do
+      feedback = Feedback.new recommended: true
+      expect(feedback.recommended).to eq true
+      stub_request(:post, "http://local.ch/v2/feedbacks")
+      .with(body: "{\"recommended\":true}")
+      feedback.save
+    end
+  end
+end

data/spec/support/cleanup_services.rb

@@ -14,7 +14,7 @@ RSpec.configure do |config|
 
   config.before(:each) do
     LHS::Service::CHILDREN.each do |child|
-      child.instance.endpoints = [] if !child.name['LHS']
+      child.endpoints = [] if !child.name['LHS']
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lhs
 version: !ruby/object:Gem::Version
-  version: 2.0.5
+  version: 2.1.0
 platform: ruby
 authors:
 - local.ch
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-12-29 00:00:00.000000000 Z
+date: 2015-12-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lhc
@@ -240,6 +240,7 @@ files:
 - spec/service/includes_spec.rb
 - spec/service/mapping_spec.rb
 - spec/service/model_name_spec.rb
+- spec/service/new_spec.rb
 - spec/service/request_spec.rb
 - spec/service/where_spec.rb
 - spec/spec_helper.rb
@@ -355,6 +356,7 @@ test_files:
 - spec/service/includes_spec.rb
 - spec/service/mapping_spec.rb
 - spec/service/model_name_spec.rb
+- spec/service/new_spec.rb
 - spec/service/request_spec.rb
 - spec/service/where_spec.rb
 - spec/spec_helper.rb