haveapi-go-client 0.13.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d9a94df4ba98576591129b131154972fd9a42960b0fb85269f20dbb178d5d57c
+  data.tar.gz: 285063beca2e245611104a43a283893bf3bf1182e7b0275a93b876e7783717d9
+SHA512:
+  metadata.gz: 93767bf1ec0dc97ea788080d327899a6883f620f65e123c4f548c8e9d2e20494fc58011da1688128e2a34ea9299b7a63a4d7189240d6ed7e675d00e9c51daf3c
+  data.tar.gz: d41fb0d6f3b0786c1e3d58c8edcb66ad1ac24a0f7771586fb3474a8e62801e565e6d41d9685093657dab5a6c511632104b7f52b6ac5f75d01ab18f77d53ce9dd

data/.gitignore

@@ -0,0 +1 @@
+.gems

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+gemspec
+
+gem 'haveapi-client', path: '../ruby'

data/README.md

@@ -0,0 +1,64 @@
+HaveAPI Client Generator For Go
+-------------------------------
+HaveAPI-Go-Client generates a client library for accessing selected APIs built
+with the [HaveAPI framework](https://github.com/vpsfreecz/haveapi).
+
+## Installation
+
+    $ gem install 'haveapi-go-client'
+
+## CLI
+The generator is run against an API server that the resulting client should be
+able to work with. The generated client uses one selected API version. When
+the API server changes, the client has to be regenerated.
+
+```
+$ haveapi-go-client -h
+Usage: haveapi-go-client [options] <api url> <destination>
+        --version VERSION            Use specified API version
+        --module MODULE              Name of the generated Go module
+        --package PKG                Name of the generated Go package
+```
+
+For example:
+
+```
+$ haveapi-go-client https://api.vpsfree.cz ~/go/src/foo/client
+```
+
+## Usage
+The generated library can then be imported in your projects. For example,
+in a project with the following `go.mod`:
+
+```
+module foo
+```
+
+The client could be imported and used as:
+
+```go
+package main
+
+import (
+	"fmt"
+	"foo/client"
+)
+
+func main() {
+	api := client.New("https://api.vpsfree.cz")
+	api.SetBasicAuthentication("admin", "secret")
+
+	action := api.Cluster.PublicStats.Prepare()
+	resp, err := action.Call()
+
+	if err != nil {
+		fmt.Println(err)
+		return
+	}
+
+	fmt.Printf("%+v\n", resp)
+	fmt.Printf("%+v\n", resp.Response)
+	fmt.Printf("%+v\n", resp.Response.Cluster)
+	fmt.Printf("%+v\n", resp.Output)
+}
+```

data/bin/haveapi-go-client

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require 'haveapi/go_client/cli'
+HaveAPI::GoClient::Cli.run

data/haveapi-go-client.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'haveapi/go_client/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'haveapi-go-client'
+  spec.version       = HaveAPI::GoClient::VERSION
+  spec.authors       = ['Jakub Skokan']
+  spec.email         = ['jakub.skokan@vpsfree.cz']
+  spec.summary       =
+  spec.description   = 'Go client generator'
+  spec.homepage      = ''
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'rake'
+
+  spec.add_runtime_dependency 'haveapi-client', '~> 0.13.0'
+end

data/lib/haveapi/go_client/action.rb

@@ -0,0 +1,128 @@
+require 'haveapi/go_client/utils'
+
+module HaveAPI::GoClient
+  class Action
+    include Utils
+
+    # @return [Resource]
+    attr_reader :resource
+
+    # Name as returned by the API
+    # @return [String]
+    attr_reader :name
+
+    # Name aliases as returned by the API
+    # @return [Array<String>]
+    attr_reader :aliases
+
+    # Full action name, including resource
+    # @return [String]
+    attr_reader :full_dot_name
+
+    # Name for usage in Go
+    # @return [String]
+    attr_reader :go_name
+
+    # Data type for Go
+    # @return [String]
+    attr_reader :go_type
+
+    # @return [Metadata]
+    attr_reader :metadata
+
+    # @return [InputOutput]
+    attr_reader :input
+
+    # @return [InputOutput]
+    attr_reader :output
+
+    # @return [String]
+    attr_reader :http_method
+
+    # @return [String]
+    attr_reader :path
+
+    # Go type for invocation struct
+    # @return [String]
+    attr_reader :go_invocation_type
+
+    # Go type for request struct
+    # @return [String]
+    attr_reader :go_request_type
+
+    # Go type for response struct
+    # @return [String]
+    attr_reader :go_response_type
+
+    def initialize(resource, name, desc, prefix: nil)
+      @resource = resource
+      @name = name.to_s
+      @prefix = prefix
+      @aliases = desc[:aliases]
+      @full_dot_name = resource.full_dot_name + '#' + @name.capitalize
+      @go_name = camelize(name)
+      @go_type = full_go_type
+      @go_invocation_type = go_type + 'Invocation'
+      @go_request_type = go_type + 'Request'
+      @go_response_type = go_type + 'Response'
+      @input = desc[:input] && InputOutput.new(self, :io, :input, desc[:input])
+      @output = desc[:output] && InputOutput.new(self, :io, :output, desc[:output])
+      @http_method = desc[:method]
+      @path = desc[:path]
+      @metadata = desc[:meta] && Metadata.new(self, desc[:meta])
+      @blocking = desc[:blocking]
+    end
+
+    # Return action name with all aliases, camelized
+    # @return [Array<String>]
+    def all_names
+      yield(go_name)
+      aliases.each { |v| yield(camelize(v)) }
+    end
+
+    # @return [Boolean]
+    def has_path_params?
+      path =~ /\{[a-zA-Z\-_]+\}/
+    end
+
+    # @return [Boolean]
+    def has_input?
+      input && input.parameters.any?
+    end
+
+    # @return [Boolean]
+    def has_output?
+      output && output.parameters.any?
+    end
+
+    def input_output
+      %i(input output).select do |v|
+        send(v) && send(v).parameters.any?
+      end.map { |v| send(v) }
+    end
+
+    def blocking?
+      @blocking
+    end
+
+    def resolve_associations
+      input_output.each do |io|
+        io.resolve_associations
+      end
+
+      metadata && metadata.resolve_associations
+    end
+
+    protected
+    attr_reader :prefix
+
+    def full_go_type
+      names = []
+      names << camelize(prefix) if prefix
+      names << 'Action'
+      names.concat(resource.resource_path.map(&:go_name))
+      names << go_name
+      names.join('')
+    end
+  end
+end

data/lib/haveapi/go_client/api_version.rb

@@ -0,0 +1,21 @@
+module HaveAPI::GoClient
+  class ApiVersion
+    # @return [Array<Authentication::Base>]
+    attr_reader :auth_methods
+
+    # @return [String]
+    attr_reader :metadata_namespace
+
+    # @return [Array<Resource>]
+    attr_reader :resources
+
+    def initialize(desc)
+      @resources = desc[:resources].map { |k, v| Resource.new(self, k, v) }
+      @resources.each { |r| r.resolve_associations }
+      @auth_methods = desc[:authentication].map do |k, v|
+        AuthenticationMethods.new(self, k, v)
+      end
+      @metadata_namespace = desc[:meta][:namespace]
+    end
+  end
+end

data/lib/haveapi/go_client/authentication/base.rb

@@ -0,0 +1,13 @@
+module HaveAPI::GoClient
+  class Authentication::Base
+    # @param name [Symbol]
+    def self.register(name)
+      AuthenticationMethods.register(name, self)
+    end
+
+    # @param dst [String]
+    def generate(dst)
+      raise NotImplementedError
+    end
+  end
+end

data/lib/haveapi/go_client/authentication/basic.rb

@@ -0,0 +1,21 @@
+require 'haveapi/go_client/authentication/base'
+
+module HaveAPI::GoClient
+  class Authentication::Basic < Authentication::Base
+    register :basic
+
+    def initialize(api_version, name, desc)
+
+    end
+
+    def generate(gen)
+      ErbTemplate.render_to_if_changed(
+        'authentication/basic.go',
+        {
+          package: gen.package,
+        },
+        File.join(gen.dst, 'auth_basic.go')
+      )
+    end
+  end
+end

data/lib/haveapi/go_client/authentication/token.rb

@@ -0,0 +1,56 @@
+require 'haveapi/go_client/authentication/base'
+
+module HaveAPI::GoClient
+  class Authentication::Token < Authentication::Base
+    register :token
+
+    # HTTP header the token is sent in
+    # @return [String]
+    attr_reader :http_header
+
+    # Query parameter the token is sent in
+    # @return [String]
+    attr_reader :query_parameter
+
+    # Resource for token manipulation
+    # @return [Resource]
+    attr_reader :resource
+
+    def initialize(api_version, name, desc)
+      @http_header = desc[:http_header]
+      @query_parameter = desc[:query_parameter]
+      @resource = Resource.new(
+        api_version,
+        :token,
+        desc[:resources][:token],
+        prefix: 'auth_token',
+      )
+      resource.resolve_associations
+    end
+
+    def generate(gen)
+      ErbTemplate.render_to_if_changed(
+        'authentication/token.go',
+        {
+          package: gen.package,
+          auth: self,
+        },
+        File.join(gen.dst, 'auth_token.go')
+      )
+
+      resource.generate(gen)
+    end
+
+    # @return [Action]
+    def request_action
+      @request_action ||= resource.actions.detect { |a| a.name == 'request' }
+    end
+
+    # @return [Array<Action>]
+    def custom_actions
+      @custom_actions ||= resource.actions.reject do |a|
+        %w(request renew revoke).include?(a.name)
+      end
+    end
+  end
+end

data/lib/haveapi/go_client/authentication/unsupported.rb

@@ -0,0 +1,13 @@
+require 'haveapi/go_client/authentication/base'
+
+module HaveAPI::GoClient
+  class Authentication::Unsupported < Authentication::Base
+    def initialize(api_version, name, desc)
+      warn "Ignoring unsupported authentication method #{name}"
+    end
+
+    def generate(gen)
+
+    end
+  end
+end

data/lib/haveapi/go_client/authentication_methods.rb

@@ -0,0 +1,24 @@
+module HaveAPI::GoClient
+  module Authentication ; end
+
+  module AuthenticationMethods
+    # @param name [Symbol]
+    # @param klass [Class]
+    def self.register(name, klass)
+      @methods ||= {}
+      @methods[name] = klass
+    end
+
+    # @param name [String]
+    def self.get(name)
+      @methods[name.to_sym]
+    end
+
+    # @param api_version [ApiVersion]
+    # @param name [String]
+    def self.new(api_version, name, *args)
+      klass = get(name) || Authentication::Unsupported
+      klass.new(api_version, name, *args)
+    end
+  end
+end

data/lib/haveapi/go_client/cli.rb

@@ -0,0 +1,39 @@
+require 'haveapi/go_client'
+require 'optparse'
+
+module HaveAPI::GoClient
+  class Cli
+    def self.run
+      options = {
+        package: 'client',
+      }
+
+      parser = OptionParser.new do |opts|
+        opts.banner = "Usage: #{$0} [options] <api url> <destination>"
+
+        opts.on('--version VERSION', 'Use specified API version') do |v|
+          options[:version] = v
+        end
+
+        opts.on('--module MODULE', 'Name of the generated Go module') do |v|
+          options[:module] = v
+        end
+
+        opts.on('--package PKG', 'Name of the generated Go package') do |v|
+          options[:package] = v
+        end
+      end
+
+      parser.parse!
+
+      if ARGV.length != 2
+        warn 'Invalid arguments'
+        puts @global_opt.help
+        exit(false)
+      end
+
+      g = Generator.new(ARGV[0], ARGV[1], options)
+      g.generate
+    end
+  end
+end

data/lib/haveapi/go_client/erb_template.rb

@@ -0,0 +1,46 @@
+require 'erb'
+require 'fileutils'
+
+module HaveAPI::GoClient
+  class ErbTemplate
+    def self.render(name, vars)
+      t = new(name, vars)
+      t.render
+    end
+
+    def self.render_to(name, vars, path)
+      File.write("#{path}.new", render(name, vars))
+      File.rename("#{path}.new", path)
+    end
+
+    def self.render_to_if_changed(name, vars, path)
+      tmp_path = "#{path}.new"
+      File.write(tmp_path, render(name, vars))
+
+      if !File.exist?(path) || !FileUtils.identical?(path, tmp_path)
+        File.rename(tmp_path, path)
+
+      else
+        File.unlink(tmp_path)
+      end
+    end
+
+    def initialize(name, vars)
+      @_tpl = ERB.new(File.new(HaveAPI::GoClient.tpl(name)).read, 0, '-')
+
+      vars.each do |k, v|
+        if v.is_a?(Proc)
+          define_singleton_method(k, &v)
+        elsif v.is_a?(Method)
+          define_singleton_method(k) { |*args| v.call(*args) }
+        else
+          define_singleton_method(k) { v }
+        end
+      end
+    end
+
+    def render
+      @_tpl.result(binding)
+    end
+  end
+end

data/lib/haveapi/go_client/generator.rb

@@ -0,0 +1,65 @@
+require 'fileutils'
+require 'haveapi/client'
+
+module HaveAPI::GoClient
+  class Generator
+    # Destination directory
+    # @return [String]
+    attr_reader :dst
+
+    # Go module name
+    # @return [String]
+    attr_reader :module
+
+    # Go package name
+    # @return [String]
+    attr_reader :package
+
+    # @param url [String] API URL
+    # @param dst [String] destination directory
+    # @param opts [Hash]
+    # @option opts [String] :version
+    # @option opts [String] :module
+    # @option opts [String] :package
+    def initialize(url, dst, opts)
+      @dst = dst
+      @module = opts[:module]
+      @package = opts[:package]
+
+      conn = HaveAPI::Client::Communicator.new(url)
+      @api = ApiVersion.new(conn.describe_api(opts[:version]))
+    end
+
+    def generate
+      FileUtils.mkpath(dst)
+
+      if self.module
+        ErbTemplate.render_to_if_changed(
+          'go.mod',
+          {mod: self.module},
+          File.join(dst, 'go.mod')
+        )
+
+        @dst = File.join(dst, package)
+        FileUtils.mkpath(dst)
+      end
+
+      %w(client authentication request response types).each do |v|
+        ErbTemplate.render_to_if_changed(
+          "#{v}.go",
+          {
+            package: package,
+            api: api,
+          },
+          File.join(dst, "#{v}.go")
+        )
+      end
+
+      api.resources.each { |r| r.generate(self) }
+      api.auth_methods.each { |v| v.generate(self) }
+    end
+
+    protected
+    attr_reader :api
+  end
+end

data/lib/haveapi/go_client/input_output.rb

@@ -0,0 +1,48 @@
+require 'haveapi/go_client/utils'
+
+module HaveAPI::GoClient
+  class InputOutput
+    include Utils
+
+    # @return [Action]
+    attr_reader :action
+
+    # @return [Symbol]
+    attr_reader :role
+
+    # @return [Symbol]
+    attr_reader :direction
+
+    # @return [String]
+    attr_reader :layout
+
+    # @return [String]
+    attr_reader :namespace
+
+    # @return [Array<Parameter>]
+    attr_reader :parameters
+
+    # @return [String]
+    attr_reader :go_type
+
+    # @return [String]
+    attr_reader :go_namespace
+
+    def initialize(action, role, direction, desc, prefix: nil)
+      @action = action
+      @role = role
+      @direction = direction
+      @layout = desc[:layout]
+      @namespace = desc[:namespace]
+      @parameters = desc[:parameters].map do |k, v|
+        Parameter.new(role, direction, self, k.to_s, v)
+      end.compact
+      @go_type = action.go_type + (prefix ? prefix : '') + direction.to_s.capitalize
+      @go_namespace = camelize(desc[:namespace])
+    end
+
+    def resolve_associations
+      parameters.each { |p| p.resolve }
+    end
+  end
+end

data/lib/haveapi/go_client/metadata.rb

@@ -0,0 +1,63 @@
+module HaveAPI::GoClient
+  class Metadata
+    class Type
+      # @return [InputOutput, nil]
+      attr_reader :input
+
+      # @return [InputOutput, nil]
+      attr_reader :output
+
+      def initialize(action, type, desc)
+        @input = desc[:input] && InputOutput.new(
+          action,
+          :"#{type}_meta",
+          :input,
+          desc[:input],
+          prefix: "Meta#{type.to_s.capitalize}"
+        )
+        @output = desc[:output] && InputOutput.new(
+          action,
+          :"#{type}_meta",
+          :output,
+          desc[:output],
+          prefix: "Meta#{type.to_s.capitalize}"
+        )
+      end
+
+      def resolve_associations
+        input && input.resolve_associations
+        output && output.resolve_associations
+      end
+    end
+
+    # @return [Type, nil]
+    attr_reader :global
+
+    # @return [Type, nil]
+    attr_reader :object
+
+    def initialize(action, desc)
+      @global = desc[:global] && Type.new(action, :global, desc[:global])
+      @object = desc[:object] && Type.new(action, :object, desc[:object])
+    end
+
+    def resolve_associations
+      global && global.resolve_associations
+      object && object.resolve_associations
+    end
+
+    %i(global object).each do |type|
+      %i(input output).each do |dir|
+        define_method(:"has_#{type}_#{dir}?") do
+          t = send(type)
+          next(false) unless t
+
+          io = t.send(dir)
+          next(false) unless io
+
+          io.parameters.any?
+        end
+      end
+    end
+  end
+end

data/lib/haveapi/go_client/parameter.rb

@@ -0,0 +1,27 @@
+module HaveAPI::GoClient
+  module Parameters ; end
+
+  module Parameter
+    # @param klass [Class]
+    # @param block [Proc]
+    def self.register(klass, block)
+      @handlers ||= []
+      @handlers << [klass, block]
+    end
+
+    # @param role [Symbol]
+    # @param direction [Symbol]
+    # @param io [InputOutput]
+    # @param name [String]
+    # @param desc [Hash]
+    # @return [Parameters::Base, nil]
+    def self.new(role, direction, io, name, desc)
+      klass, _ =
+        @handlers.select do |klass, block|
+          block.call(role, direction, name, desc)
+        end.first
+
+      klass ? klass.new(io, name, desc) : nil
+    end
+  end
+end