kinto_box 0.1.12 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 32a1ab4c6cd2f76e5a07c2c7df08e281b6ef8ae3
-  data.tar.gz: e4935d11684d5f8a6346c0b9dd7de758ef51548d
+  metadata.gz: 96296262d3eed5289517616cd4358a228ae1faba
+  data.tar.gz: 14eaa8ec93d64b6c01504d631d8a9c584aab4f86
 SHA512:
-  metadata.gz: 84f70e98d251392478f69938e5cfc480bf6ba608af4c03324eedf36d10ba2346bec2a9b69529af9e9f902eb139c175adfe718f5737803cb9cf031959f69871ee
-  data.tar.gz: 802b3bfc51dd2dbbb21357e8b629e919a70e5206082b6e669f2ede5d7df12ac8dade82ac33cbc6ea6de333b61ffe28ef39d048b3c6cb7f58b29684b4a6b5bf9f
+  metadata.gz: b3889be916740f913b0209a42054755eef40847249a9f6cc5b0416d4d94d5779ff13632ab9dbaf05b3e1785d4d9c6ca9d03a134265897f433bb6a0683c949d60
+  data.tar.gz: 71d1f0f150bab1cd756680153543afb3862635fce40a36d7546377737e12458788928f7ab382b1431c21d8d531953b694b73f5a09f522a3d8c66648e14a0ea0f

data/.rubocop.yml

@@ -0,0 +1,33 @@
+AllCops:
+  Include:
+    - '**/Rakefile'
+
+#Style/HashSyntax:
+  #EnforcedStyle: hash_rockets
+
+Style/GuardClause:
+  Enabled: false
+
+Style/LineLength:
+  Max: 100
+
+Style/NumericLiterals:
+  Enabled: false
+
+Style/ClassAndModuleChildren:
+  Enabled: false
+
+Style/SignalException:
+  EnforcedStyle: only_raise
+
+Style/ClassLength:
+  Enabled: false
+
+Style/MethodLength:
+  Enabled: false
+
+Metrics/CyclomaticComplexity:
+  Enabled: false
+
+Style/Alias:
+  Enabled: false

data/kinto_box.gemspec

@@ -4,33 +4,35 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'kinto_box/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "kinto_box"
+  spec.name          = 'kinto_box'
   spec.version       = KintoBox::VERSION
-  spec.authors       = ["Kavya Sukumar"]
-  spec.email         = ["Kavya.Sukumar@voxmedia.com"]
+  spec.authors       = ['Kavya Sukumar']
+  spec.email         = ['Kavya.Sukumar@voxmedia.com']
 
-  spec.summary       = %q{Kinto http client in ruby}
-  spec.description   = %q{Kinto http client in ruby}
-  spec.homepage      = "http://github.com/voxmedia/kinto_box"
-  spec.license       = "BSD"
+  spec.summary       = 'Kinto http client in ruby'
+  spec.description   = 'Kinto http client in ruby'
+  spec.homepage      = 'http://github.com/voxmedia/kinto_box'
+  spec.license       = 'BSD'
 
   # Prevent pushing this gem to RubyGems.org by setting 'allowed_push_host', or
   # delete this section to allow pushing this gem to any host.
   if spec.respond_to?(:metadata)
-    spec.metadata['allowed_push_host'] = "https://rubygems.org"
+    spec.metadata['allowed_push_host'] = 'https://rubygems.org'
   else
-    raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
+    raise 'RubyGems 2.0 or newer is required to protect against public gem pushes.'
   end
 
   spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
-  spec.bindir        = "exe"
+  spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
+  spec.require_paths = ['lib']
 
   spec.add_runtime_dependency 'httparty', '~> 0.13.7'
 
-  spec.add_development_dependency "bundler", "~> 1.11"
-  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency 'bundler', '~> 1.11'
+  spec.add_development_dependency 'rake', '~> 10.0'
   spec.add_development_dependency 'json', '~> 1.8', '>= 1.8.3'
-  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency 'minitest', '~> 5.0'
+  spec.add_development_dependency 'rdoc'
+  spec.add_development_dependency 'rubocop'
 end

data/lib/kinto_box.rb

@@ -1,19 +1,23 @@
-require "kinto_box/version"
 require 'httparty'
-require 'kinto_box/response_handler'
-require 'kinto_box/kinto_bucket'
 require 'base64'
 
-module KintoBox
+require 'kinto_box/version'
+require 'kinto_box/errors'
+require 'kinto_box/kinto_server'
+require 'kinto_box/kinto_batch_request'
 
+module KintoBox
   # Initializes a new Kinto client.
   #
   # @param [String] server Url of the server without the version
-  # @param [Hash] options Optional parameter. If the hash contains :username and :password, it will be used to authenticate.
-  # `options` parameter can be used to pass in credentials. If no credentials are passed, it looks for KINTO_API_TOKEN environment variable
+  # @param [Hash] options Optional parameter. If the hash contains :username
+  #                       and :password, it will be used to authenticate.
+  #                       `options` parameter Can be used to pass in
+  #                       credentials. If no credentials are passed, it looks
+  #                       for KINTO_API_TOKEN environment variable.
   # @return [KintoBox::KintoClient] A kinto client object
-  def KintoBox.new(server, options = nil)
-    return KintoClient.new(server, options)
+  def self.new(*args, **kwargs, &blk)
+    KintoClient.new(*args, **kwargs, &blk)
   end
 
   class KintoClient
@@ -24,49 +28,53 @@ module KintoBox
     # Initializes a new Kinto client.
     #
     # @param [String] server Url of the server without the version
-    # @param [Hash] options Optional parameter. If the hash contains :username and :password, it will be used to authenticate.
-    # `options` parameter can be used to pass in credentials. If no credentials are passed, it looks for KINTO_API_TOKEN environment variable
+    # @param [Hash] options Optional parameter. If the hash contains :username
+    #                       and :password, it will be used to authenticate.
+    #                       `options` parameter Can be used to pass in
+    #                       credentials. If no credentials are passed, it looks
+    #                       for KINTO_API_TOKEN environment variable.
     # @return [KintoBox::KintoClient] A kinto client object
-    def initialize(server, options = nil)
-      @server = server
-      self.class.base_uri URI.join(@server, '/v1/').to_s
+    def initialize(server, username: nil, password: nil)
+      self.class.base_uri(URI.join(server, '/v1/').to_s)
 
-      unless options.nil? || options[:username].nil? || options[:password].nil?
-        @auth = Base64.encode64("#{options[:username]}:#{options[:password]}")
-      end
+      auth = if username && password
+               Base64.encode64("#{username}:#{password}")
+             else
+               ENV['KINTO_API_TOKEN']
+             end
 
-      @auth = ENV['KINTO_API_TOKEN'] if @auth.nil?
-      self.class.headers('Authorization' => "Basic #{@auth}")
+      self.class.headers('Authorization' => "Basic #{auth}")
+
+      @server = KintoServer.new(client: self)
     end
 
     # Get reference to a bucket
     #
     # @param [String] bucket_id The id of the bucket
     # @return [KintoBox::KintoBucket] A kinto bucket object
-    def bucket (bucket_id)
-      @bucket = KintoBucket.new(self, bucket_id)
-      @bucket
+    def bucket(bucket_id)
+      @server.bucket(bucket_id)
     end
 
     # Get server information
     #
     # @return [Hash] Server info as a hash
     def server_info
-      get '/'
+      @server.info
     end
 
     # Get current user id
     #
     # @return [String] current user id
     def current_user_id
-      server_info['user']['id']
+      @server.current_user_id
     end
 
     # List of buckets
     #
     # @return [Hash] with list of buckets
     def list_buckets
-      get '/buckets'
+      @server.list_buckets
     end
 
     # Create a bucket
@@ -74,56 +82,22 @@ module KintoBox
     # @param [String] bucket_id The id of the bucket
     # @return [KintoBox::KintoBucket] A kinto bucket object
     def create_bucket(bucket_id)
-      put "/buckets/#{bucket_id}"
-      bucket(bucket_id)
+      @server.create_bucket(bucket_id)
     end
 
     # Delete all buckets
-    #
+    # @return [Hash] API response
     def delete_buckets
-      delete '/buckets'
+      @server.delete_buckets
     end
 
-    # Raw request
-    #
-    def request(path, method, data = {})
-      case method.upcase
-      when 'PUT'
-        self.class.put(path, :body => data.to_json)
-      when 'GET'
-        self.class.get(path)
-      when 'POST'
-        self.class.post(path, :body => data.to_json)
-      when 'DELETE'
-        self.class.delete(path)
-      when 'OPTIONS'
-        self.class.options(path)
-      when 'HEAD'
-        self.class.head(path)
-      when 'MOVE'
-        self.class.move(path, :body => data.to_json)
-      when 'COPY'
-        self.class.copy(path, :body => data.to_json)
-      when 'PATCH'
-        self.class.copy(path, :body => data.to_json)
-      else
-        raise HTTPBadRequest
-      end
-    end
-
-    # Make batch requests
-    def create_batch_request
-        KintoBatchRequest.new(self)
-    end
-
-
     # Calls http PUT on path
     #
     # @params [String]path Url path
     # @params [Hash] data to be sent in the body
     # @return [Hash] response body
     def put(path, data = {})
-      ResponseHandler.handle self.class.put(path, :body => data.to_json)
+      request 'PUT', path, body: data.to_json
     end
 
     # Calls http POST on path
@@ -132,7 +106,7 @@ module KintoBox
     # @params [Hash] data to be sent in the body
     # @return [Hash] response body
     def post(path, data = {})
-      ResponseHandler.handle self.class.post(path, :body => data.to_json)
+      request 'POST', path, body: data.to_json
     end
 
     # Calls http PATCH on path
@@ -141,34 +115,113 @@ module KintoBox
     # @params [Hash] data to be sent in the body
     # @return [Hash] response body
     def patch(path, data)
-      ResponseHandler.handle self.class.patch(path, :body => data.to_json)
+      request 'PATCH', path, body: data.to_json
     end
 
     # Calls http DELETE on path
     #
     # @params [String]path Url path
-    # @params [Hash] data to be sent in the body
     # @return [Hash] response body
     def delete(path)
-      ResponseHandler.handle self.class.delete(path)
+      request 'DELETE', path
     end
 
     # Calls http GET on path
     #
     # @params [String]path Url path
-    # @params [Hash] data to be sent in the body
     # @return [Hash] response body
     def get(path)
-      ResponseHandler.handle self.class.get(path)
+      request 'GET', path
     end
 
     # Calls http HEAD on path
     #
     # @params [String]path Url path
-    # @params [Hash] data to be sent in the body
     # @return [Hash] response body
-    def head(path, data = {})
-      ResponseHandler.get_response_head self.class.head(path)
+    def head(path)
+      request 'HEAD', path
+    end
+
+    # Get a request object
+    # @param [String] method
+    # @param [String] path
+    # @param [Hash] body
+    # @return [KintoRequest] Request object
+    def create_request(method, path, body = {})
+      KintoRequest.new self, method, path, body
+    end
+
+    # Make batch requests
+    # @return [KintoBatchRequest] New back request object
+    def create_batch_request
+      KintoBatchRequest.new self
+    end
+
+    # Make batch requests
+    #   results = client.batch do req
+    #               req.add_request(...)
+    #             end
+    def batch
+      req = create_batch_request
+      if block_given?
+        yield req
+        req.execute
+      else
+        req
+      end
+    end
+
+    # Send a prepared request
+    # @param [KintoRequest] request
+    # @return [Hash] response
+    def send_request(request_obj)
+      request(request_obj.method, request_obj.path, body: request_obj.body.to_json)
+    end
+
+    private
+
+    # Handle all the kinds of requests
+    #
+    # @param [String] HTTP method
+    # @param [String] Path to query
+    # @return [Hash] Return data
+    def request(method, path, **kwargs)
+      verbs = %w(put get post delete options head move copy patch)
+      method = method.to_s.downcase
+      raise HTTPBadRequest("Unsupported HTTP method #{method}") unless verbs.include?(method)
+      resp = self.class.send(method.to_sym, path, **kwargs)
+      if method == 'head'
+        handle_response resp, head_instead: true
+      else
+        handle_response resp
+      end
+    end
+
+    # Parse and process HTTP response. Check for codes, and parse return body.
+    # @param [Object] Response object
+    # @param [Boolean] <head_instead> Return headers instead of body
+    # @return [Hash] Response payload
+    def handle_response(resp, head_instead: false)
+      case resp.code
+      when 200, 201
+        head_instead ? resp.headers : JSON.parse(resp.body)
+      when 202, 204
+        true
+      when 400
+        raise BadRequest, resp
+      when 401
+        raise NotAllowed, resp
+      when 403
+        raise NotAuthorized, resp
+      when 404
+        raise NotFound, resp
+      else
+        if resp.code >= 500
+          raise ServerError, resp
+        else
+          raise Error, resp
+        end
+      end
     end
   end
 end

data/lib/kinto_box/{response_handler.rb → errors.rb}

@@ -28,34 +28,4 @@ module KintoBox
 
   # Raised when there is some sort of error on the server
   class ServerError < Error; end
-
-  class ResponseHandler
-    def self.handle(resp)
-      if [200, 201].include? resp.code
-        JSON.parse resp.body
-      elsif [202, 204].include? resp.code
-        true
-      elsif resp.code == 400
-        raise BadRequest, resp
-      elsif resp.code == 404
-        raise NotFound, resp
-      elsif resp.code == 401
-        raise NotAllowed, resp
-      elsif resp.code == 403
-        raise NotAuthorized, resp
-      elsif resp.code >= 500
-        raise ServerError, resp
-      else
-        raise Error, resp
-      end
-    end
-
-    def self.get_response_head(resp)
-      if [200, 201].include? resp.code
-        resp.headers
-      else
-        raise BadRequest, resp
-      end
-    end
-  end
 end

data/lib/kinto_box/kinto_batch_request.rb

@@ -1,30 +1,26 @@
-require 'kinto_box/kinto_collection'
-require 'kinto_box/kinto_object'
 require 'kinto_box/kinto_request'
-
 module KintoBox
-  class KintoBatchRequest
+  class KintoBatchRequest < KintoRequest
+    attr_reader :requests
 
-    def initialize(kinto_client)
-      @kinto_client = kinto_client
-      @request_data = {'defaults' => {
-                        'method'=> 'POST',
-                        'path'=> '/'
-                       },
-                       'requests' =>[]
-      }
-      @requests = @request_data['requests']
+    def initialize(client)
+      @requests = []
+      super(client, 'POST', '/batch')
     end
 
     def add_request(request)
-        @requests.push(request.hashed_object)
-        self
+      requests.push(request.to_hash)
+      self
     end
 
-    def send
-
-      @kinto_client.post('/batch', @request_data)
+    def body
+      {
+        'defaults' => {
+          'method' => 'POST',
+          'path' => '/'
+        },
+        'requests' => requests
+      }
     end
-
   end
-end
+end

data/lib/kinto_box/kinto_bucket.rb

@@ -1,62 +1,40 @@
 require 'kinto_box/kinto_collection'
-require 'kinto_box/kinto_object'
 require 'kinto_box/kinto_group'
 module KintoBox
   class KintoBucket < KintoObject
+    child_class KintoCollection
 
-    attr_reader :kinto_client
+    alias_method :collection, :child
 
-    def initialize (client, bucket_id)
-      raise ArgumentError if bucket_id.nil? || client.nil?
+    alias_method :list_collections, :list_children
+    alias_method :delete_collections, :delete_children
+    alias_method :count_collections, :count_children
 
-      @kinto_client = client
-      @id = bucket_id
-      @url_path = "/buckets/#{@id}"
-      @child_path = '/collections'
-    end
-
-    def list_collections(filters = nil, sort = nil)
-      @kinto_client.get(url_w_qsp(filters, sort))
-    end
-
-    def list_groups
-      @kinto_client.get("#{@url_path}/groups")
-    end
-
-    def collection (collection_id)
-      @collection = KintoCollection.new(self, collection_id)
-    end
+    alias_method :create_collection_request, :create_child_request
+    alias_method :list_collections_request, :list_children_request
+    alias_method :delete_collections_request, :delete_children_request
+    alias_method :count_collections_request, :count_children_request
 
     def group(group_id)
-      @group = KintoGroup.new(self, group_id)
+      KintoGroup.new(id: group_id, parent: self)
     end
 
-    def create_collection(collection_id)
-      @kinto_client.post("#{@url_path}#{@child_path}", { 'data' => { 'id' => collection_id}})
-      collection(collection_id)
+    def list_groups
+      @client.get("#{url_path}/groups")
     end
 
     def create_group(group_id, members)
       members = [members] unless members.is_a?(Array)
-      @kinto_client.put("#{@url_path}/groups/#{group_id}", { 'data' => { 'members' => members}})
-      group(group_id)
-    end
-
-    def delete_collections
-      @kinto_client.delete(url_w_qsp)
+      resp = @client.put("#{url_path}/groups/#{group_id}", 'data' => { 'members' => members })
+      KintoGroup.new(parent: self, info: resp)
     end
 
     def delete_groups
-      @kinto_client.delete("#{@url_path}/groups")
+      @client.delete("#{url_path}/groups")
     end
 
-    def count_collections(filters = nil)
-      @kinto_client.head(url_w_qsp(filters))['Total-Records'].to_i
+    def create_collection(id)
+      create_child(id: id)
     end
-
-    alias_method :create_collection_request, :create_child_request
-    alias_method :list_collection_request, :list_children_request
-    alias_method :delete_collections_request, :delete_children_request
-    alias_method :count_collections_request, :count_children_request
   end
-end
+end

data/lib/kinto_box/kinto_collection.rb

@@ -1,52 +1,19 @@
 require 'kinto_box/kinto_record'
-require 'kinto_box/kinto_object'
-require 'kinto_box/kinto_batch_request'
-
 module KintoBox
   class KintoCollection < KintoObject
+    child_class KintoRecord
 
+    alias_method :bucket, :parent
+    alias_method :record, :child
 
-    attr_reader :bucket
-
-    def initialize (bucket, collection_id)
-      raise ArgumentError if bucket.nil? || collection_id.nil?
-      @kinto_client = bucket.kinto_client
-      @bucket = bucket
-      @id = collection_id
-      @url_path = "/buckets/#{bucket.id}/collections/#{@id}"
-      @child_path = '/records'
-    end
-
-    def record (record_id)
-      KintoRecord.new(self, record_id)
-    end
-
-
-    def list_records(filters = nil, sort = nil)
-      @kinto_client.get(url_w_qsp(filters, sort))
-    end
-
-
-    def create_record(data)
-      resp = @kinto_client.post("#{@url_path}#{@child_path}", { 'data' => data})
-      record_id = resp['data']['id']
-      record(record_id)
-    end
-
-
-    def delete_records(filters = nil)
-      @kinto_client.delete(url_w_qsp(filters))
-    end
-
-
-    def count_records(filters = nil)
-      @kinto_client.head(url_w_qsp(filters))['Total-Records'].to_i
-    end
-
+    alias_method :create_record, :create_child
+    alias_method :list_records, :list_children
+    alias_method :delete_records, :delete_children
+    alias_method :count_records, :count_children
 
     alias_method :create_record_request, :create_child_request
     alias_method :list_records_request, :list_children_request
     alias_method :delete_records_request, :delete_children_request
     alias_method :count_records_request, :count_children_request
   end
-end
+end

data/lib/kinto_box/kinto_group.rb

@@ -1,34 +1,21 @@
 require 'kinto_box/kinto_object'
-
 module KintoBox
   class KintoGroup < KintoObject
-
-    attr_accessor :id
-    attr_reader :bucket
-
-    def initialize (bucket, group_id)
-      raise ArgumentError if bucket.nil? || group_id.nil?
-      @kinto_client = bucket.kinto_client
-      @bucket = bucket
-      @id = group_id
-      @url_path = "/buckets/#{bucket.id}/groups/#{@id}"
-    end
-
     def update_members(members)
       members = [members] unless members.is_a?(Array)
-      update({ 'members' => members })
+      update 'members' => members
     end
 
     def add_member(member)
       members = info['data']['members']
       members << member
-      update({ 'members' => members })
+      update 'members' => members
     end
 
     def remove_member(member)
       members = info['data']['members']
       members.delete(member)
-      update({ 'members' => members })
+      update 'members' => members
     end
   end
-end
+end

data/lib/kinto_box/kinto_object.rb

@@ -1,90 +1,231 @@
 module KintoBox
   class KintoObject
+    class << self
+      # Get the name of this class suitable for use in url path
+      def path_name
+        name.sub('KintoBox::Kinto', '').downcase + 's'
+      end
 
-    attr_accessor :id
-    attr_reader :url_path
+      # Assign or retrieve the child class
+      def child_class(value = nil)
+        return @child_class if value.nil?
+        @child_class = value
+      end
+    end
 
-    def info
-      @kinto_client.get(@url_path)
+    attr_reader :id, :parent, :client
+
+    def initialize(client: nil, id: nil, parent: nil, info: nil)
+      @client = client || parent.client
+      @parent = parent
+      @id = id || (info ? info['data']['id'] : nil)
+      @info = info
+      self
     end
 
-    def delete
-      @kinto_client.delete(@url_path)
+    # Get the path to this object in the Kinto API.
+    # This method uses the name of this class and whatever @parent.url_path is
+    # to create a partial url path.
+    # @return [String] URL fragment
+    def url_path
+      path = "/#{self.class.path_name}/#{id}"
+      path = parent.url_path + path unless parent.nil?
+      path.gsub(%r{/+}, '/')
     end
 
-    def update(data)
-      @kinto_client.patch(@url_path, {'data' => data})
+    # Get the path to this object in the Kinto API
+    # Use the name of url_path and whatever the child class has set for @parent.url_path is
+    # to create a partial url path.
+    # @return [String] URL fragment
+    def child_path
+      return unless child_class?
+      "#{url_path}/#{child_class.path_name}".gsub(%r{/+}, '/')
     end
 
+    # Check to see if this Kinto object exists
+    # @return [Boolean]
     def exists?
       begin
-        info
+        return false if info && info['data'] && info['data']['deleted'] == true
       rescue
         return false
       end
       true
     end
 
-    def info_request
-      KintoRequest.new('GET', @url_path)
+    # Get the data related to this object
+    # @return [Hash] Object data
+    def info
+      @info ||= info_request.execute
     end
 
-    def update_request(data)
-      KintoRequest.new('PATCH', @url_path, {'data' => data})
+    # Delete the cached info for this object
+    def reload
+      @info = nil
     end
 
-    def delete_request
-      KintoRequest.new('DELETE', @url_path)
+    # Delete this object
+    # @return [Hash] Response
+    def delete
+      @info = delete_request.execute
     end
 
-    def create_child_request(data)
-      KintoRequest.new('POST', url_w_qsp, { 'data' => data})
+    # Update this object
+    # @return [Hash] Response
+    def update(data)
+      @info = update_request(data).execute
     end
 
-    def list_children_request(filters = nil, sort = nil)
-      KintoRequest.new('GET', url_w_qsp(filters, sort))
+    # Replace all data in the object
+    # @return [Hash] Response
+    def replace(data)
+      @info = replace_request(data).execute
     end
 
-    def delete_children_request(filters = nil)
-      KintoRequest.new('DELETE', url_w_qsp(filters))
+    # Return an object for this child
+    # @param [String] Child object ID
+    # @return [KintoObject] Child for ID
+    def child(child_id)
+      child_class.new(id: child_id, parent: self)
     end
 
-    def count_children_request(filters = nil)
-      KintoRequest.new('HEAD',  url_w_qsp(filters))
+    # Create a child object
+    # @param [String] Child object ID
+    # @return [KintoObject] New child
+    def create_child(data)
+      resp = create_child_request(data).execute
+      child_class.new(info: resp, parent: self)
+    end
+
+    # Get all children
+    # @param [String,Array] Filters
+    # @param [String] Sort by
+    # @return [Hash] All children
+    def list_children(filters = nil, sort = nil)
+      list_children_request(filters, sort).execute
+    end
+
+    # Get all children
+    # @param [String,Array] Filters
+    # @param [String] Sort by
+    # @return [Hash] All children
+    def delete_children(filters = nil)
+      delete_children_request(filters).execute
     end
 
+    # Count all children
+    # @param [String,Array] Filters
+    # @return [Integer] Count
+    def count_children(filters = nil)
+      count_children_request(filters).execute['Total-Records'].to_i
+    end
+
+    # Add a permission to this object
+    # @param [String] Principal aka user or group name
+    # @param [String] Permission name i.e. read, write, etc
+    # @return [KintoObject] The current instance; for chaining
     def add_permission(principal, permission)
-      @kinto_client.patch(@url_path, {'permissions' => { permission => [principal_name(principal)] }})
+      @info = client.patch(url_path, 'permissions' => { permission => [principal_name(principal)] })
       self
     end
 
+    # Replace all permissions for this object
+    # @param [String] Principal aka user or group name
+    # @param [String] Permission name i.e. read, write, etc
+    # @return [KintoObject] The current instance; for chaining
     def replace_permission(principal, permission)
-      @kinto_client.put(@url_path, {'permissions' => { permission => [principal_name(principal)] }})
+      @info = client.put(url_path, 'permissions' => { permission => [principal_name(principal)] })
       self
     end
 
+    # Get the permissions for the current object
+    # @return [Hash] Hash of permissions and assigned principals.
     def permissions
       info['permissions']
     end
 
+    # Get a kinto request object for making an info request
+    # @return [KintoRequest] Object representing this request
+    def info_request
+      client.create_request('GET', url_path)
+    end
+
+    # Get a kinto request object for making an update request
+    # @param [Hash] Data
+    # @return [KintoRequest] Object representing this request
+    def update_request(data)
+      client.create_request('PATCH', url_path, 'data' => data)
+    end
+
+    # Get a kinto request object for making a delete request
+    # @param [Hash] Data
+    # @return [KintoRequest] Object representing this request
+    def replace_request(data)
+      client.create_request('PUT', url_path, 'data' => data)
+    end
+
+    # Get a kinto request object for making a delete request
+    # @return [KintoRequest] Object representing this request
+    def delete_request
+      client.create_request('DELETE', url_path)
+    end
+
+    # Get a kinto request object for making a create child request
+    # @return [KintoRequest] Object representing this request
+    def create_child_request(data)
+      client.create_request('POST', url_w_qsp, 'data' => data)
+    end
+
+    # Get a kinto request object for making a list children request
+    # @return [KintoRequest] Object representing this request
+    def list_children_request(filters = nil, sort = nil)
+      client.create_request('GET', url_w_qsp(filters, sort))
+    end
+
+    # Get a kinto request object for making a delete children request
+    # @return [KintoRequest] Object representing this request
+    def delete_children_request(filters = nil)
+      client.create_request('DELETE', url_w_qsp(filters))
+    end
+
+    # Get a kinto request object for making a count children request
+    # @return [KintoRequest] Object representing this request
+    def count_children_request(filters = nil)
+      client.create_request('HEAD', url_w_qsp(filters))
+    end
 
     private
 
+    # Get the class for this object's child
+    # @return [KintoObject] Child class
+    def child_class
+      self.class.child_class
+    end
+
+    # Does this class have a child class?
+    # @return [Boolean]
+    def child_class?
+      !(child_class.nil? || child_class.is_a?(KintoObject))
+    end
+
+    # Convert the principal name to something Kinto will like
+    # @return [String] Valid Kinto principal name
     def principal_name(principal)
       case principal.downcase
-        when 'authenticated'
-          return 'system.Authenticated'
-        when 'anonymous'
-          return 'system.Everyone'
-        when 'everyone'
-          return 'system.Everyone'
-        else
-          return principal
+      when 'authenticated'
+        'system.Authenticated'
+      when 'anonymous'
+        'system.Everyone'
+      when 'everyone'
+        'system.Everyone'
+      else
+        principal
       end
     end
 
+    # Build the path including querystring
     def url_w_qsp(filters = nil, sort = nil, add_child = true)
-      url = @child_path.nil? || !add_child ? @url_path : "#{@url_path}#{@child_path}"
+      url = child_path.nil? || !add_child ? url_path : child_path
       query_string = ''
       query_string = filters unless filters.nil?
       query_string = "#{query_string}&" unless filters.nil? || sort.nil?
@@ -92,4 +233,4 @@ module KintoBox
       query_string == '' ? url : "#{url}?#{query_string}"
     end
   end
-end
+end

data/lib/kinto_box/kinto_record.rb

@@ -1,17 +1,5 @@
 require 'kinto_box/kinto_object'
 module KintoBox
   class KintoRecord < KintoObject
-    attr_reader :id
-    def initialize (collection, record_id)
-      raise ArgumentError if collection.nil? || record_id.nil?
-      @kinto_client = collection.bucket.kinto_client
-      @id = record_id
-      @url_path = "/buckets/#{collection.bucket.id}/collections/#{collection.id}/records/#{@id}"
-      @child_path = nil
-    end
-
-    def replace(data)
-      @kinto_client.put(@url_path, {'data' => data})
-    end
   end
-end
+end

data/lib/kinto_box/kinto_request.rb

@@ -1,18 +1,21 @@
 module KintoBox
   class KintoRequest
+    attr_reader :method, :path, :body, :headers
 
-    def initialize(method = 'GET', path = nil , body = {}, headers = nil)
+    def initialize(client, method, path, body = {}, headers: nil)
+      @client = client
       @method = method
       @path = path
       @body = body
       @headers = headers
     end
 
-    def hashed_object
-      { 'method' => @method,
-        'path' => @path,
-        'body' => @body
-      }
+    def to_hash
+      { 'method' => method, 'path' => path, 'body' => body }
+    end
+
+    def execute
+      @client.send_request(self)
     end
   end
-end
+end

data/lib/kinto_box/kinto_server.rb

@@ -0,0 +1,31 @@
+require 'kinto_box/kinto_bucket'
+module KintoBox
+  class KintoServer < KintoObject
+    child_class KintoBox::KintoBucket
+
+    alias_method :bucket, :child
+
+    alias_method :list_buckets, :list_children
+    alias_method :delete_buckets, :delete_children
+    alias_method :count_buckets, :count_children
+
+    alias_method :create_bucket_request, :create_child_request
+    alias_method :list_bucket_request, :list_children_request
+    alias_method :delete_buckets_request, :delete_children_request
+    alias_method :count_buckets_request, :count_children_request
+
+    def url_path
+      '/'
+    end
+
+    # Get current user id
+    # @return [String] current user id
+    def current_user_id
+      info['user']['id']
+    end
+
+    def create_bucket(id)
+      create_child(id: id)
+    end
+  end
+end

data/lib/kinto_box/version.rb

@@ -1,3 +1,3 @@
 module KintoBox
-  VERSION = "0.1.12"
+  VERSION = '0.2.0'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kinto_box
 version: !ruby/object:Gem::Version
-  version: 0.1.12
+  version: 0.2.0
 platform: ruby
 authors:
 - Kavya Sukumar
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-11-01 00:00:00.000000000 Z
+date: 2016-12-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httparty
@@ -86,6 +86,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  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: rubocop
+  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: Kinto http client in ruby
 email:
 - Kavya.Sukumar@voxmedia.com
@@ -94,6 +122,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".rubocop.yml"
 - ".travis.yml"
 - Gemfile
 - LICENSE.txt
@@ -103,6 +132,7 @@ files:
 - bin/setup
 - kinto_box.gemspec
 - lib/kinto_box.rb
+- lib/kinto_box/errors.rb
 - lib/kinto_box/kinto_batch_request.rb
 - lib/kinto_box/kinto_bucket.rb
 - lib/kinto_box/kinto_collection.rb
@@ -110,7 +140,7 @@ files:
 - lib/kinto_box/kinto_object.rb
 - lib/kinto_box/kinto_record.rb
 - lib/kinto_box/kinto_request.rb
-- lib/kinto_box/response_handler.rb
+- lib/kinto_box/kinto_server.rb
 - lib/kinto_box/version.rb
 homepage: http://github.com/voxmedia/kinto_box
 licenses:
@@ -133,7 +163,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: Kinto http client in ruby