klient 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 05be7e8bf426e334012023a497e378cbede55ec3b6ea3f1f7c0f912798744f3c
+  data.tar.gz: 46406b31960577c079ea06bfcd4532e5f175a5a1330d68f26ecac50f999850ba
+SHA512:
+  metadata.gz: 06c7b1ed4383baf74ab9ccd24e471671cc2cbb2f208ce14c56d42962b7e951594210e2a3c082c9478ce275ca7d3058f612933fc6ac748e9beb88b5b60e4bcc70
+  data.tar.gz: 411da5be1600da3008f9fb0b3d7bf4804292297984bb78fa8446fd1cb38f72499608ece66c899ac83915c4565f83dfb5b1be1e28843594c6d96df661b183e487

data/lib/klient.rb

@@ -0,0 +1,12 @@
+require 'active_support'
+require 'active_support/core_ext'
+require 'addressable'
+require 'nokogiri'
+# require 'parsed_data'
+
+require_relative "klient/hash_methods.rb"
+require_relative "klient/klient.rb"
+require_relative "klient/resource.rb"
+require_relative "klient/response.rb"
+require_relative "klient/response_data.rb"
+require_relative "klient/version.rb"

data/lib/klient/hash_methods.rb

@@ -0,0 +1,32 @@
+class Hash
+  def deep_get(key, obj, found = nil)
+    if obj.respond_to?(:key?) && obj.key?(key)
+      return obj[key]
+    elsif obj.respond_to?(:each)
+      obj.find { |*a| found = deep_get(key, a.last) }
+      return found
+    end
+  end
+
+  def deep_set(key, obj, value, found = nil)
+    if obj.respond_to?(:key?) && obj.key?(key)
+      obj[key] = value
+      return value
+    elsif obj.respond_to?(:each)
+      obj.find { |*a| found = deep_set(key, a.last, value) }
+      return found
+    end
+  end
+
+  def method_missing(mth, *args, &block)
+    m = mth.to_s
+
+    if keys.include?(m)
+      self[m]
+    elsif m =~ /\S+=/
+      deep_set(m.gsub(/=/, ''), self, args[0])
+    else
+      deep_get(m, self)
+    end
+  end
+end

data/lib/klient/klient.rb

@@ -0,0 +1,77 @@
+require 'rest-client'
+require_relative "resource"
+require_relative "resource_methods"
+
+module Klient
+  attr_reader :base_url, :header_proc, :collection_accessor, :headers, :collection_key, :url_template, :root
+
+  module KlientClassMethods
+    attr_reader :header_proc, :resource_map
+
+    include ResourceMethods
+  end
+
+  def self.included(klass)
+    klass.extend(KlientClassMethods)
+    klass.send(:attr_reader, :header_proc)
+    klass.send(:attr_reader, :resource_map)
+    klass.send(:attr_reader, :identifier_map)
+    klass.instance_variable_set(:@resource_map, {})
+    klass.instance_variable_set(:@identifier_map, {})
+  end
+
+  def initialize(base_url)
+    @root = self
+    @header_proc = self.class.header_proc
+    @collection_accessor = self.class.instance_variable_get(:@collection_accessor)
+    @base_url = base_url
+    @headers = headers
+    @url_template = Addressable::Template.new(base_url)
+
+    rmap = {}
+    self.class::Resource.descendants
+      .select { |x| x.name.split('::').length == 2 }
+      .sort   { |x, y| x.name.demodulize <=> y.name.demodulize }
+      .each do |klass|
+        next unless klass.id
+        cname = klass.name.demodulize.underscore.singularize.to_sym
+        cname_plural = klass.name.demodulize.underscore.pluralize.to_sym
+
+        if rmap.include?(cname)
+          next
+        else
+          rmap[cname_plural] = klass
+          rmap[cname] = klass
+        end
+      end
+
+    imap = {}
+    rmap.values.each do |klass|
+      next unless klass.id
+      imap[klass.id] = klass
+    end
+
+    @resource_map = rmap
+    @identifier_map = imap
+
+    self.class::Resource.descendants.each do |rklass|
+      cname = rklass.name.demodulize.underscore.to_sym
+
+      if rklass && rklass.arguments && rklass.arguments[:type]
+        rklass.resource_type = @resource_map[rklass.arguments[:type]]
+      elsif @resource_map[rklass.arguments[:type]] && @identifier_map.key(rklass)
+        rklass.resource_type = @resource_map[@identifier_map.key(rklass)]
+      elsif @resource_map.values.include?(rklass)
+        rklass.resource_type = rklass
+      elsif @resource_map[cname]
+        rklass.resource_type = @resource_map[cname]
+      elsif @identifier_map[rklass.id]
+        rklass.resource_type = rklass.id
+      else
+        rklass.resource_type = rklass
+      end
+    end
+  end
+
+  alias url base_url
+end

data/lib/klient/resource.rb

@@ -0,0 +1,203 @@
+require_relative "resource_methods"
+require_relative "resource_collection"
+require 'pry'
+module Klient
+  class Resource
+    attr_reader :collection_accessor, :header_proc, :headers, :id, :last_response, :parent, :status, :url, :url_arguments, :url_template,:root
+
+    class << self
+      attr_reader :collection_accessor, :id, :identifier, :mapping, :url_template
+      attr_accessor :arguments, :resource_type, :type
+    end
+
+    extend ResourceMethods
+
+    def initialize(parent)
+      @root = parent.root
+      @header_proc = parent.header_proc
+      @regexp = /#{self.class.name.demodulize.underscore.gsub(/(_|-|\s+)/, "(_|-|\s*)")}/i
+      @id = self.class.try(:id)
+      @collection_accessor = @identifier = self.class.try(:identifier)
+
+      if @id
+        @url_arguments = {@id => @identifier}
+      else
+        @url_arguments = {}
+      end
+
+      @parent = parent
+      @headers = {}
+
+      @url_template = Addressable::Template.new(
+        @parent.url + self.class.url_template.pattern
+      )
+    end
+
+    def inspect
+      "#<#{self.class.name}:#{object_id} @url=#{self.url.inspect} @status_code=#{self.last_response.try(:status) || 'nil'}>"
+    end
+
+    %i(delete get head).each do |mth|
+      define_method(mth) do |identifier = nil, **params|
+
+        if params.empty?
+          @headers = @header_proc.call
+        else
+          @headers = @header_proc.call.merge(params: params)
+        end
+
+        if identifier
+          out = process_response(
+            RestClient.send(
+              mth,
+              @url_template.expand(@id => identifier).to_s,
+              @headers
+            )
+          )
+        else
+          out = process_response(RestClient.send(mth, url, @headers))
+        end
+
+        if respond_to?(:last_response) && out.respond_to?(:last_response)
+          @last_response = out.last_response
+        end
+
+        out.instance_variable_set(:@identifier, identifier)
+        out
+      end
+    end
+
+    %i(post put).each do |mth|
+      define_method(mth) do |identifier = nil, doc, **params|
+        if params.empty?
+          @headers = @header_proc.call
+        else
+          @headers = @header_proc.call.merge(params: params)
+        end
+        out = process_response(
+          RestClient.send(mth, url, doc, @headers)
+        )
+
+        if respond_to?(:last_response) && out.respond_to?(:last_response)
+          @last_response = out.last_response
+        end
+
+        out.instance_variable_set(:@identifier, identifier)
+        out
+      end
+    end
+
+    def url
+      @url_template.expand(@url_arguments).to_s
+    end
+
+    private
+    # Assumes JSON for the moment.
+    def process_doc(doc)
+      if doc.is_a?(Hash)
+        doc.to_json
+      elsif doc.empty?
+        {}.to_json
+      else
+        doc
+      end
+    end
+
+    def method_missing(mth, *args, &block)
+      if @parsed_body.respond_to?(mth)
+        @parsed_body.send(mth, *args, &block)
+      else
+        @last_response.send(mth, *args, &block)
+      end
+    end
+
+    # EXPERIMENTAL (USING HASH MODS)
+    def process_response(resp)
+      parsed = JSON.parse(resp.body)#.to_data
+
+      klass_type = self.class.resource_type
+
+      if klass_type == self.class
+        klass = self.class.new(parent)
+      else
+        klass = self.class.resource_type.new(@root)
+      end
+
+      if klass_type != self.class
+        if match = klass.url_template.match(resp.request.args[:url])
+          klass.url_arguments[klass.id] = match.mapping.with_indifferent_access[klass.id]
+        end
+      else
+        if match = self.url_template.match(resp.request.args[:url])
+          klass.url_arguments[klass.id] = match.mapping.with_indifferent_access[klass.id]
+        end
+      end
+
+      if klass.url_arguments[klass.id]
+        klass.url_arguments[klass.id]= parsed[klass.id]
+        klass.instance_variable_set(:@last_response, Response.new(resp))
+        return klass
+      # elsif parsed.is_a?(Hash) && parsed.keys.any? { |k| k.to_sym == @root.collection_accessor }
+      #   klass.url_arguments[klass.id]= parsed[klass.id]
+      #   klass.instance_variable_set(:@last_response, Response.new(resp))
+      #   return klass
+      elsif key = parsed.keys.find { |k| k.to_s =~ @regexp }
+        if parsed[key].is_a?(Array)
+          arr = parsed[key].map! do |res|
+            tmp = klass_type.new(@root)
+            # TODO: Ugly. Revisit after recursive lookup.
+            tmp.url_arguments[klass.id]= res.send(klass.id) || res.send(klass.collection_accessor).try(klass.id)
+
+            processed = Response.new(resp, res)
+            tmp.instance_variable_set(:@last_response, processed)
+
+            tmp.instance_variable_set(:@parsed_body, processed.parsed_body)
+            tmp.instance_variable_set(:@status, processed.status)
+            tmp
+          end
+          return Klient::ResourceCollection.new(arr)
+        else
+          klass.url_arguments[klass.id]= parsed.send(klass.id) if klass.id
+          klass.instance_variable_set(:@last_response, Response.new(resp))
+          return klass
+        end
+      elsif self.class.type == :resource
+        klass.url_arguments[klass.id]= parsed.send(klass.id) if klass.id
+        klass.instance_variable_set(:@last_response, Response.new(resp))
+        return klass
+      elsif klass.url_arguments[klass.id]
+        klass.url_arguments[klass.id]= parsed.send(klass.id)
+        klass.instance_variable_set(:@last_response, Response.new(resp))
+        return klass
+      else
+        if parsed.is_a?(Array)
+          arr = parsed
+        elsif parsed.keys.length == 1 && parsed[parsed.keys.first].is_a?(Array)
+          arr = parsed[parsed.keys.first]
+        else
+          parsed.keys.each do |k|
+            if parsed[k].is_a?(Array) && parsed[k].first && parsed[k].first.send(klass.id.to_sym)
+              arr = parsed[k]
+              break
+            end
+          end
+        end
+
+        arr.map! do |res|
+          tmp = klass_type.new(@root)
+          # TODO: Ugly. Revisit after recursive lookup.
+          tmp.url_arguments[klass.id]= res.send(klass.id) || res.send(klass.collection_accessor).try(klass.id)
+
+          processed = Response.new(resp, res)
+          tmp.instance_variable_set(:@last_response, processed)
+
+          tmp.instance_variable_set(:@parsed_body, processed.parsed_body)
+          tmp.instance_variable_set(:@status, processed.status)
+          tmp
+        end
+
+        return Klient::ResourceCollection.new(arr)
+      end
+    end
+  end
+end

data/lib/klient/resource_collection.rb

@@ -0,0 +1,17 @@
+module Klient
+  class ResourceCollection
+    attr_reader :members, :last_response
+
+    def initialize(arr)
+      @members = arr
+    end
+
+    def method_missing(mth, *args, &block)
+      @members.send(mth, *args, &block)
+    end
+
+    def respond_to?(mth, *args, &block)
+      super || @members.respond_to?(mth)
+    end
+  end
+end

data/lib/klient/resource_methods.rb

@@ -0,0 +1,82 @@
+module ResourceMethods
+  def default_collection_accessor(sym)
+    @collection_accessor = sym
+  end
+
+  def headers(&block)
+    @header_proc = block
+  end
+
+  def collection(name, template = nil, **hash_args, &block)
+    klass_name = name.to_s.camelcase
+
+    klass = Class.new(Klient::Resource) do
+      @arguments = hash_args
+      @type = :collection
+
+      # Obtain the collection's resource identifier. Don't allow hash arg AND block
+      # param for same thing -- it has to be either one or the other.
+      if block_given? && block.arity > 0 && hash_args[:identifier]
+        raise ArgumentError, "Collection identifier for :#{name} can be specified as a " \
+        "hash argument OR a block parameter (You can't use both simultaneously.)"
+      elsif block_given? && block.arity > 0
+        @id = block.parameters[0][1]
+      elsif hash_args[:identifier]
+        @id = hash_args[:identifier]
+      else
+        # raise ArgumentError, "#{name} collection definition does not specify a resource identifier."
+      end
+
+      # Don't allow templates with variables.
+      if template && template =~ /[\{\}]/
+        raise ArgumentError, "URL template variables not supported."
+      end
+
+      # Build a URL template if the template arg was provided.
+      if template && id
+        @url_template = Addressable::Template.new(template.to_s + "{/#{id}}")
+      elsif id
+        @identifier = nil
+        @url_template = Addressable::Template.new("/#{name}{/#{id}}")
+      else
+        @identifier = nil
+        @url_template = Addressable::Template.new("/#{name}")
+      end
+
+      class_eval(&block) if block
+    end
+    const_set(klass_name, klass)
+
+    define_method(name) do
+      klass.new(self)
+    end
+  end
+
+  def resource(name, template = nil, **hash_args, &block)
+    klass_name = name.to_s.camelcase
+
+    klass = Class.new(Klient::Resource) do
+      @arguments = hash_args
+      @type = :resource
+
+      # TODO: Avoid identifier conflicts between hash and URL template.
+      if template
+        @url_template = Addressable::Template.new(template)
+      else
+        @identifier = nil
+        @url_template = Addressable::Template.new("/#{name}")
+      end
+
+      class_eval(&block) if block
+    end
+    const_set(klass_name, klass)
+
+    define_method(name) do
+      klass.new(self)
+    end
+  end
+
+  def resources(*resource_names)
+    resource_names.each { |rname| resource rname }
+  end
+end

data/lib/klient/response.rb

@@ -0,0 +1,59 @@
+require 'json'
+module Klient
+  class Response
+    attr_reader :original_response, :parsed_body, :parsed_headers, :status
+
+    def body
+      @original_response.body
+    end
+
+    def ok?
+      (200..299).include?(status_code)
+    end
+
+    def status_code
+      @original_response.code
+    end
+
+    def headers
+      @parsed_headers
+    end
+
+    def initialize(original_response, data = nil)
+      @status = original_response.code
+
+      # If data arg is provided then it's a collection resource and the original
+      # response is for the entire collection. We don't want that -- this is an
+      # individual resource FOR the collection -- so the data arg is used in place
+      # of the parsed body for the collection response.
+      if data
+        @original_response = nil
+        @parsed_body = data
+        @parsed_headers = nil
+      else
+        @original_response = original_response
+        @body = @original_response.body
+        @parsed_headers = @original_response.headers
+
+        if @original_response.body.blank?
+           @parsed_body = {}
+        else
+          @parsed_body = JSON.parse(@original_response.body)
+        end
+      end
+    end
+
+    # TODO: This is dangerously wrong. It's just a shortcut to get something working.
+    def method_missing(mth, *args, &block)
+      if mth.to_s =~ /http_(\d+)\?/
+        status_code == $1.to_i
+      else
+        @parsed_body.send(mth)
+      end
+    end
+
+    def respond_to_missing?(mth, *args)
+      mth.to_s =~ /http_(\d+)\?/ || @parsed_body.respond_to?(mth) || super
+    end
+  end
+end

data/lib/klient/response_data.rb

@@ -0,0 +1,31 @@
+module Klient
+  class ResponseData
+    attr_reader :original_response, :parsed_body, :parsed_headers, :status_code
+
+    def body
+      nil
+    end
+
+    def headers
+      nil
+    end
+
+    def initialize(status_code, parsed_body)
+      @status_code = status_code
+      @parsed_body = parsed_body.freeze
+    end
+
+    def ok?
+      (200..299).include?(status_code)
+    end
+
+    # TODO: Bandaid.
+    def method_missing(mth, *args, &block)
+      @parsed_body.send(mth, *args, &block)
+    end
+
+    def respond_to_missing?(mth, *args)
+      mth.to_s =~ /http_(\d+)\?/ || @parsed_body.respond_to?(mth) || super
+    end
+  end
+end

data/lib/klient/version.rb

@@ -0,0 +1,3 @@
+module Klient
+  VERSION = "0.0.1"
+end

metadata

@@ -0,0 +1,178 @@
+--- !ruby/object:Gem::Specification
+name: klient
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- John Fitisoff
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-01-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.2.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.2.5
+- !ruby/object:Gem::Dependency
+  name: addressable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.5.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.5.1
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.7.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.7.0
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.8.21
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.8.21
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.16.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.16.1
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.11.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.11.3
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 12.3.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 12.3.1
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.7.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.7.0
+description: Experimental REST API client library.
+email: jfitisoff@yahoo.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/klient.rb
+- lib/klient/hash_methods.rb
+- lib/klient/klient.rb
+- lib/klient/resource.rb
+- lib/klient/resource_collection.rb
+- lib/klient/resource_methods.rb
+- lib/klient/response.rb
+- lib/klient/response_data.rb
+- lib/klient/version.rb
+homepage: https://github.com/jfitisoff/klient
+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.3.0
+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: Experimental REST API client library.
+test_files: []