client-api-builder 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 34ae348684b22669748f3dca2fc9866f2b87247da8452fc5b848e175c1ef74a8
+  data.tar.gz: 95e6b09d24e961c0ce20a6cc15d3fcdf858f47b2725151838cd8ea5d01df0965
+SHA512:
+  metadata.gz: e6dd7780a28eec364c787d209fbd37618c6c9f8c7262c1abaa2fbf90b419240657a77bd1a7523388f680643837839162c36a427ca3023ccee986d6f0c1ba3b43
+  data.tar.gz: 6b407cefa4e351149e881c6f19897f1566b0440684790f26b9df7636a151737c068efd23ced372b8cd0a306179dc6a4c3491de574fdaacdd8b5f90b0b03e5e93

data/.gitignore

@@ -0,0 +1,51 @@
+# rcov generated
+coverage
+coverage.data
+
+# rdoc generated
+rdoc
+
+# yard generated
+doc
+.yardoc
+
+# bundler
+.bundle
+
+# jeweler generated
+pkg
+
+# Have editor/IDE/OS specific files you need to ignore? Consider using a global gitignore: 
+#
+# * Create a file at ~/.gitignore
+# * Include files you want ignored
+# * Run: git config --global core.excludesfile ~/.gitignore
+#
+# After doing this, these files will be ignored in all your git projects,
+# saving you from having to 'pollute' every project you touch with them
+#
+# Not sure what to needs to be ignored for particular editors/OSes? Here's some ideas to get you started. (Remember, remove the leading # of the line)
+#
+# For MacOS:
+#
+.DS_Store
+
+# For TextMate
+#*.tmproj
+#tmtags
+
+# For emacs:
+*~
+\#*
+.\#*
+
+# For vim:
+*.swp
+
+# For redcar:
+#.redcar
+
+# For rubinius:
+#*.rbc
+
+*.gem

data/.ruby-gemset

@@ -0,0 +1 @@
+client-api-builder

data/.ruby-version

@@ -0,0 +1 @@
+2.7.1

data/Gemfile

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+source 'http://rubygems.org'
+
+gem 'inheritance-helper'
+
+group :development do
+  gem 'rake'
+  gem 'rubocop'
+end
+
+group :spec do
+  gem 'rspec'
+  gem 'simplecov'
+  gem 'webmock'
+end

data/Gemfile.lock

@@ -0,0 +1,68 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    addressable (2.7.0)
+      public_suffix (>= 2.0.2, < 5.0)
+    ast (2.4.1)
+    crack (0.4.5)
+      rexml
+    diff-lcs (1.4.4)
+    docile (1.3.2)
+    hashdiff (1.0.1)
+    inheritance-helper (0.1.5)
+    parallel (1.19.2)
+    parser (2.7.1.4)
+      ast (~> 2.4.1)
+    public_suffix (4.0.6)
+    rainbow (3.0.0)
+    rake (13.0.1)
+    regexp_parser (1.7.1)
+    rexml (3.2.4)
+    rspec (3.9.0)
+      rspec-core (~> 3.9.0)
+      rspec-expectations (~> 3.9.0)
+      rspec-mocks (~> 3.9.0)
+    rspec-core (3.9.2)
+      rspec-support (~> 3.9.3)
+    rspec-expectations (3.9.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.9.0)
+    rspec-mocks (3.9.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.9.0)
+    rspec-support (3.9.3)
+    rubocop (0.87.1)
+      parallel (~> 1.10)
+      parser (>= 2.7.1.1)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.7)
+      rexml
+      rubocop-ast (>= 0.1.0, < 1.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 1.4.0, < 2.0)
+    rubocop-ast (0.1.0)
+      parser (>= 2.7.0.1)
+    ruby-progressbar (1.10.1)
+    simplecov (0.18.5)
+      docile (~> 1.1)
+      simplecov-html (~> 0.11)
+    simplecov-html (0.12.2)
+    unicode-display_width (1.7.0)
+    webmock (3.11.1)
+      addressable (>= 2.3.6)
+      crack (>= 0.3.2)
+      hashdiff (>= 0.4.0, < 2.0.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  inheritance-helper
+  rake
+  rspec
+  rubocop
+  simplecov
+  webmock
+
+BUNDLED WITH
+   2.1.4

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 dougyouch
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,2 @@
+# client-api-builder
+Utility for creating methods to make api calls

data/client-api-builder.gemspec

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+Gem::Specification.new do |s|
+  s.name        = 'client-api-builder'
+  s.version     = '0.1.0'
+  s.licenses    = ['MIT']
+  s.summary     = 'Develop Client API libraries faster'
+  s.description = 'Utility for constructing API clients'
+  s.authors     = ['Doug Youch']
+  s.email       = 'dougyouch@gmail.com'
+  s.homepage    = 'https://github.com/dougyouch/client-api-builder'
+  s.files       = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+end

data/lib/client-api-builder.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module ClientApiBuilder
+  class Error < StandardError; end
+  class UnexpectedResponse < Error
+    attr_reader :response
+
+    def initialize(msg, response)
+      super(msg)
+      @response = response
+    end
+  end
+
+  autoload :Router, 'client_api_builder/router'
+  autoload :QueryParams, 'client_api_builder/query_params'
+
+  module NetHTTP
+    autoload :Request, 'client_api_builder/net_http_request'
+  end
+end

data/lib/client_api_builder/net_http_request.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+require 'net/http'
+
+module ClientApiBuilder
+  module NetHTTP
+    module Request
+      # Copied from https://ruby-doc.org/stdlib-2.7.1/libdoc/net/http/rdoc/Net/HTTP.html
+      METHOD_TO_NET_HTTP_CLASS = {
+        copy: Net::HTTP::Copy,
+        delete: Net::HTTP::Delete,
+        get: Net::HTTP::Get,
+        head: Net::HTTP::Head,
+        lock: Net::HTTP::Lock,
+        mkcol: Net::HTTP::Mkcol,
+        move: Net::HTTP::Move,
+        options: Net::HTTP::Options,
+        patch: Net::HTTP::Patch,
+        post: Net::HTTP::Post,
+        propfind: Net::HTTP::Propfind,
+        proppatch: Net::HTTP::Proppatch,
+        put: Net::HTTP::Put,
+        trace: Net::HTTP::Trace,
+        unlock: Net::HTTP::Unlock
+      }
+
+      def request(method:, uri:, body:, headers:, connection_options:)
+        request = METHOD_TO_NET_HTTP_CLASS[method].new(uri.request_uri, headers)
+        request.body = body if body
+
+        Net::HTTP.start(uri.hostname, uri.port, connection_options.merge(use_ssl: uri.scheme == 'https')) do |http|
+          http.request(request)
+        end
+      end
+    end
+  end
+end

data/lib/client_api_builder/query_params.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+require 'cgi'
+
+module ClientApiBuilder
+  module QueryParams
+    module_function
+
+    def to_query(data, namespace = nil, name_value_separator = '=', param_separator = '&')
+      case data
+      when Hash
+        to_query_from_hash(data, (namespace ? CGI.escape(namespace) : nil), name_value_separator).join(param_separator)
+      when Array
+        to_query_from_array(data, (namespace ? "#{CGI.escape(namespace)}[]" : '[]'), name_value_separator).join(param_separator)
+      else
+        if namespace
+          "#{CGI.escape(namespace)}#{name_value_separator}#{CGI.escape(data.to_s)}"
+        else
+          CGI.escape(data.to_s)
+        end
+      end
+    end
+
+    def to_query_from_hash(hsh, namespace, name_value_separator)
+      query_params = []
+
+      hsh.each do |key, value|
+        case value
+        when Array
+          array_namespace = namespace ? "#{namespace}[#{CGI.escape(key.to_s)}][]" : "#{CGI.escape(key.to_s)}[]"
+          query_params += to_query_from_array(value, array_namespace, name_value_separator)
+        when Hash
+          hash_namespace = namespace ? "#{namespace}[#{CGI.escape(key.to_s)}]" : "#{CGI.escape(key.to_s)}"
+          query_params += to_query_from_hash(value, hash_namespace, name_value_separator)
+        else
+          query_name = namespace ? "#{namespace}[#{CGI.escape(key.to_s)}]" : "#{CGI.escape(key.to_s)}"
+          query_params << "#{query_name}#{name_value_separator}#{CGI.escape(value.to_s)}"
+        end
+      end
+
+      query_params
+    end
+
+    def to_query_from_array(array, namespace, name_value_separator)
+      query_params = []
+
+      array.each do |value|
+        case value
+        when Hash
+          query_params += to_query_from_hash(value, namespace, name_value_separator)
+        when Array
+          query_params += to_query_from_array(value, "#{namespace}[]", name_value_separator)
+        else
+          query_params << "#{namespace}#{name_value_separator}#{CGI.escape(value.to_s)}"
+        end
+      end
+
+      query_params
+    end
+  end
+end

data/lib/client_api_builder/router.rb

@@ -0,0 +1,268 @@
+# frozen_string_literal: true
+require 'inheritance-helper'
+
+module ClientApiBuilder
+  module Router
+    def self.included(base)
+      base.extend InheritanceHelper::Methods
+      base.extend ClassMethods
+      base.include ::ClientApiBuilder::NetHTTP::Request
+      base.attr_reader :response
+    end
+
+    module ClassMethods
+      REQUIRED_BODY_HTTP_METHODS = [
+        :post,
+        :put,
+        :patch
+      ]
+
+      def default_options
+        {
+          base_url: nil,
+          headers: {},
+          connection_options: {},
+          query_builder: Hash.method_defined?(:to_query) ? :to_query : :query_params
+        }.freeze
+      end
+
+      def base_url(url = nil)
+        return default_options[:base_url] unless url
+
+        add_value_to_class_method(:default_options, base_url: url)
+      end
+
+      def query_builder(builder = nil)
+        return default_options[:query_builder] unless builder
+
+        add_value_to_class_method(:default_options, query_builder: builder)
+      end
+
+      def header(name, value)
+        headers = default_options[:headers].dup
+        headers[name] = value
+        add_value_to_class_method(:default_options, headers: headers)
+      end
+
+      def connection_option(name, value)
+        connection_options = default_options[:connection_options].dup
+        connection_options[name] = value
+        add_value_to_class_method(:default_options, connection_options: connection_options)
+      end
+
+      def headers
+        default_options[:headers]
+      end
+
+      def connection_options
+        default_options[:connection_options]
+      end
+
+      def build_query(query)
+        case query_builder
+        when :to_query
+          query.to_query
+        when :query_params
+          ClientApiBuilder::QueryParams.to_query(query)
+        else
+          query_builder.call(query)
+        end
+      end
+
+      def http_method(method_name)
+        case method_name.to_s
+        when /^(?:post|create|add|insert)/i
+          :post
+        when /^(?:put|update|modify|change)/i
+          :put
+        when /^(?:delete|remove)/i
+          :delete
+        else
+          :get
+        end
+      end
+
+      def requires_body?(http_method, options)
+        return !options[:no_body] if options.key?(:no_body)
+        return options[:has_body] if options.key?(:has_body)
+
+        REQUIRED_BODY_HTTP_METHODS.include?(http_method)
+      end
+
+      def get_hash_arguments(hsh)
+        arguments = []
+        hsh.each do |k, v|
+          case v
+          when Symbol
+            hsh[k] = "__||#{v}||__"
+            arguments << v
+          when Hash
+            arguments += get_hash_arguments(v)
+          when Array
+            arguments += get_array_arguments(v)
+          end
+        end
+        arguments
+      end
+
+      def get_array_arguments(list)
+        arguments = []
+        list.each_with_index do |v, idx|
+          case v
+          when Symbol
+            list[idx] = "__||#{v}||__"
+            arguments << v
+          when Hash
+            arguments += get_hash_arguments(v)
+          when Array
+            arguments += get_array_arguments(v)
+          end
+        end
+        arguments
+      end
+
+      def get_arguments(value)
+        case value
+        when Hash
+          get_hash_arguments(value)
+        when Array
+          get_array_arguments(value)
+        else
+          []
+        end
+      end
+
+      def generate_route_code(method_name, path, options = {})
+        http_method = options[:method] || http_method(method_name)
+
+        path_arguments = []
+        path.gsub!(/:([a-z0-9_]+)/i) do |_|
+          path_arguments << $1
+          "#\{#{$1}\}"
+        end
+
+        has_body_param = options[:body].nil? && requires_body?(http_method, options)
+
+        query =
+          if options[:query]
+            query_arguments = get_arguments(options[:query])
+            str = options[:query].inspect
+            str.gsub!(/"__\|\|(.+?)\|\|__"/) { $1 }
+            str
+          else
+            query_arguments = []
+            'nil'
+          end
+
+        body =
+          if options[:body]
+            has_body_param = false
+            body_arguments = get_arguments(options[:body])
+            str = options[:body].inspect
+            str.gsub!(/"__\|\|(.+?)\|\|__"/) { $1 }
+            str
+          else
+            body_arguments = []
+            has_body_param ? 'body' : 'nil'
+          end
+
+        query_arguments.map!(&:to_s)
+        body_arguments.map!(&:to_s)
+        named_arguments = path_arguments + query_arguments + body_arguments
+        named_arguments.uniq!
+
+        expected_response_codes =
+          if options[:expected_response_codes]
+            options[:expected_response_codes]
+          elsif options[:expected_response_code]
+            [options[:expected_response_code]]
+          else
+            []
+          end
+        expected_response_codes.map!(&:to_s)
+
+        method_args = named_arguments.map { |arg_name| "#{arg_name}:" }
+        method_args += ['body:'] if has_body_param
+        method_args += ['**__options__', '&block']
+
+        code = "def #{method_name}(" + method_args.join(', ') + ")\n"
+        code += "  __path__ = \"#{path}\"\n"
+        code += "  __query__ = #{query}\n"
+        code += "  __body__ = #{body}\n"
+        code += "  __expected_response_codes__ = #{expected_response_codes.inspect}\n"
+        code += "  __uri__ = build_uri(__path__, __query__, __options__)\n"
+        code += "  __body__ = build_body(__body__, __options__)\n"
+        code += "  __headers__ = build_headers(__options__)\n"
+        code += "  __connection_options__ = build_connection_options(__options__)\n"
+        code += "  @response = request(method: #{http_method.inspect}, uri: __uri__, body: __body__, headers: __headers__, connection_options: __connection_options__)\n"
+        code += "  expected_response_code!(@response, __expected_response_codes__, __options__)\n"
+        code += "  handle_response(@response, __options__, &block)\n"
+        code += "end\n"
+        code
+      end
+
+      def route(method_name, path, options = {})
+        self.class_eval generate_route_code(method_name, path, options), __FILE__, __LINE__
+      end
+    end
+
+    def base_url(options)
+      self.class.base_url
+    end
+
+    def build_headers(options)
+      if options[:headers]
+        self.class.headers.merge(options[:headers])
+      else
+        self.class.headers
+      end
+    end
+
+    def build_connection_options(options)
+      if options[:connection_options]
+        self.class.connection_options.merge(options[:connection_options])
+      else
+        self.class.connection_options
+      end
+    end
+
+    def build_query(query, options)
+      query.merge!(options[:query]) if options[:query]
+      self.class.build_query(query)
+    end
+
+    def build_body(body, options)
+      return unless body
+      return body if body.is_a?(String)
+
+      body.merge!(options[:body]) if options[:body]
+      body.to_json
+    end
+
+    def build_uri(path, query, options)
+      uri = URI(base_url(options) + path)
+      uri.query = build_query(query, options) if query
+      uri
+    end
+
+    def expected_response_code!(response, expected_response_codes, options)
+      return if expected_response_codes.empty? && response.kind_of?(Net::HTTPSuccess)
+      return if expected_response_codes.include?(response.code)
+
+      raise(::ClientApiBuilder::UnexpectedResponse.new("unexpected response code #{response.code}", response))
+    end
+
+    def parse_response(response, options)
+      response.body && JSON.parse(response.body)
+    end
+
+    def handle_response(response, options, &block)
+      data = parse_response(response, options)
+      if block
+        instance_exec(data, &block)
+      else
+        data
+      end
+    end
+  end
+end

data/script/console

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH << File.expand_path('../lib', __dir__)
+require 'client-api-builder'
+require 'irb'
+IRB.start(__FILE__)

metadata

@@ -0,0 +1,55 @@
+--- !ruby/object:Gem::Specification
+name: client-api-builder
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Doug Youch
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-05-05 00:00:00.000000000 Z
+dependencies: []
+description: Utility for constructing API clients
+email: dougyouch@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".ruby-gemset"
+- ".ruby-version"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- client-api-builder.gemspec
+- lib/client-api-builder.rb
+- lib/client_api_builder/net_http_request.rb
+- lib/client_api_builder/query_params.rb
+- lib/client_api_builder/router.rb
+- script/console
+homepage: https://github.com/dougyouch/client-api-builder
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key:
+specification_version: 4
+summary: Develop Client API libraries faster
+test_files: []