travis-client 0.1.0 → 3.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0a0bddd722e4ae995e3de90e49acbddf490ad585
+  data.tar.gz: 9999fab5a24471c4ee087b9fa316280bc8013eba
+SHA512:
+  metadata.gz: 2b4b77d90db34513776340d0b194c9c6cf80feacfbba2cb60f1e0f003e5ef9c38e6095c8620e1ae43a8ddcddef1458ac12aff06491890464af857201b0a5dc70
+  data.tar.gz: 31fd825d35fb2df20bcefc8928b2a7f218d753580cf7e0a0f04a2d44533c7ca8dedd9dad56a1eed32b5c98e2b018e14cf2fa141cdf795f56894292273119b1ed

data/.gitignore

@@ -1,2 +1,4 @@
-Gemfile.lock
-*.gem
+.yardoc
+.coverage
+.DS_Store
+doc

data/.rspec

@@ -1,2 +1,3 @@
---color
---format nested
+--require spec_helper
+--colour
+--tty

data/.travis.yml

@@ -1,9 +1,2 @@
-rvm:
-  - 1.8.7
-  - 1.9.2
-  - 1.9.3
-  - ree
-  - rbx
-  - jruby
-  - ruby-head
-
+rvm: 2.3
+script: bundle exec rspec

data/.yardopts

@@ -0,0 +1,2 @@
+--charset utf-8
+lib/**/*.rb

data/Gemfile

@@ -1,4 +1,2 @@
-source :gemcutter
-
+source 'https://rubygems.org'
 gemspec
-

data/Gemfile.lock

@@ -0,0 +1,59 @@
+PATH
+  remote: .
+  specs:
+    travis-client (3.0.0)
+      addressable (~> 2.5)
+      http (~> 2.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    addressable (2.5.0)
+      public_suffix (~> 2.0, >= 2.0.2)
+    diff-lcs (1.2.5)
+    docile (1.1.5)
+    domain_name (0.5.20170223)
+      unf (>= 0.0.5, < 1.0.0)
+    http (2.2.1)
+      addressable (~> 2.3)
+      http-cookie (~> 1.0)
+      http-form_data (~> 1.0.1)
+      http_parser.rb (~> 0.6.0)
+    http-cookie (1.0.3)
+      domain_name (~> 0.5)
+    http-form_data (1.0.1)
+    http_parser.rb (0.6.0)
+    json (2.0.2)
+    public_suffix (2.0.5)
+    rspec (3.5.0)
+      rspec-core (~> 3.5.0)
+      rspec-expectations (~> 3.5.0)
+      rspec-mocks (~> 3.5.0)
+    rspec-core (3.5.4)
+      rspec-support (~> 3.5.0)
+    rspec-expectations (3.5.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.5.0)
+    rspec-mocks (3.5.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.5.0)
+    rspec-support (3.5.0)
+    simplecov (0.12.0)
+      docile (~> 1.1.0)
+      json (>= 1.8, < 3)
+      simplecov-html (~> 0.10.0)
+    simplecov-html (0.10.0)
+    unf (0.1.4)
+      unf_ext
+    unf_ext (0.0.7.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  rspec (~> 3.5)
+  simplecov (~> 0.12)
+  travis-client!
+
+BUNDLED WITH
+   1.14.6

data/lib/travis/client.rb

@@ -1,109 +1,25 @@
-require 'ostruct'
-require 'optparse'
-require 'hirb'
-
-require 'travis/api'
-require 'travis/client/repositories'
+# frozen_string_literal: true
+require 'addressable/uri'
+require 'addressable/template'
+require 'http'
+require 'json'
 
 module Travis
-
-   # Travis Command Line Client
-
-  class Client
-
-    # Tries to guess the repository based on the git remote urls
-    # and prints its status.
-    # If several remote repositories are defined it will display
-    # the status of each of them. 
-    def self.status
-      ARGV[0] = 'repositories'
-      slugs = target_repository_slugs()
-      if slugs.length > 1
-        ARGV << "--slugs=#{target_repository_slugs().join(',')}"
-      else
-        ARGV << "--slug=#{target_repository_slugs().first}"
-      end
-      Repositories.new.run
-    end
-
-    # Handles the given options and executes the requested command 
-    def run
-      handle_options()
-      execute_operation()
-    end
-
-  private
-
-    # Returns the list of repository slugs based on the current 
-    # directory git remote repositories.
-    #
-    # @return [Array<String>]
-    def self.target_repository_slugs
-      %x[git remote -v].scan(/(?:\:|\/)([^\:\/]+\/[^\:\/]+)\.git/m).flatten.uniq
-    end
-
-    # Initializes and return the options as an OpenStruct instance
-    #
-    # @return [OpenStruct]
-    def options 
-      @options ||= OpenStruct.new
-    end
-
-    # Sets the options and creates the help layout.
-    def handle_options
-      OptionParser.new do |opts|
-        opts.banner = 'Travis CI Command Line Client'
-
-        setup_help(opts) {|opts|
-          opts.separator ''
-          opts.separator 'Supported Options:'
-          client_options().each {|option| opts.on(*option)}
-          opts.on_tail('--help', '-h', '-H', 'display this help message.') do
-            $stdout.print opts
-            exit
-          end
-        }
-      end.parse!
-    end
-   
-    # Sets up the custom help sections
-    #
-    # @param [OpenParser] opts The options parser
-    def setup_help(opts)
-      opts.separator ''
-      opts.separator <<-USAGE
-Usage:
-   travis repositories|repos|rep|r {options}
-   travis status|stat|s {options}
-      USAGE
-      opts.separator ''
-      opts.separator <<-FURTHER_HELP
-Furhter Help:
-    travis {command} --help
-      FURTHER_HELP
-
-      yield(opts)
-    end
-
-    # Retuns the default options
-    #
-    # @return [Array<String>]
-    def client_options 
-      []
-    end
-
-    # Starts the execution of the previousy requested
-    # command or rise and exception if the target operation
-    # to be executed can not be identified.
-    def execute_operation
-      unless options().target
-        raise 'Nothing to do ...'      
-      end
-
-      self.send(options().target)
-    end
-
+  module Client
+    require 'travis/client/version'
+
+    require 'travis/client/action'
+    require 'travis/client/connection'
+    require 'travis/client/context'
+    require 'travis/client/entity'
+    require 'travis/client/error'
+    require 'travis/client/link'
+    require 'travis/client/session'
+
+    require 'travis/client/collection'
+    require 'travis/client/unknown'
   end
 
+  extend Client::Context
+  self.default_endpoint = 'https://api.travis-ci.org'
 end
-

data/lib/travis/client/action.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+module Travis::Client
+  class Action
+    class Template < Struct.new(:method, :uri_template, :mandatory, :optional, :body_params)
+      def map_params(params, prefix)
+        params.map { |key, value| map_pair(key.to_s, value, prefix).to_h }.inject({}, &:merge)
+      end
+
+      def map_pair(key, value, prefix)
+        return                                             if value.nil?
+        return entity_params(key, value)                   if value.is_a? Entity
+        return map_pair("#{prefix}.#{key}", value, prefix) if !params.include?(key) and params.include?("#{prefix}.#{key}")
+
+        if value.is_a? Hash and !body_params.include? key
+          return value.map { |k,v| map_pair("#{prefix}.#{k}", v, prefix).to_h }.inject(&:merge)
+        end
+
+        if mandatory.include? key or optional.include? key
+          value = prepare_segment(value)
+        else
+          value = prepare_json(value)
+        end
+
+        { key => value }
+      end
+
+      def prepare_segment(value)
+        case value
+        when Array then value.map { |v| prepare_segment(v) }.join(',')
+        else value.to_s
+        end
+      end
+
+      def prepare_json(value)
+        value
+      end
+
+      def entity_params(key, value)
+        result = {}
+        params.each do |param|
+          next unless param =~ /^#{key}\.(.+)$/
+          next unless value.respond_to? $1
+          result[param] = value.public_send($1)
+        end
+        result[key] = value if result.empty?
+        result
+      end
+
+      def uri(params)
+        uri_template.expand(params)
+      end
+
+      def payload(params)
+        params.reject { |k,_| mandatory.include? k or optional.include? k }
+      end
+
+      def params
+        @params ||= mandatory + optional + body_params
+      end
+
+      def accept_everything?
+        method != 'GET' and body_params.empty?
+      end
+
+      def possible_params(prefix)
+        [mandatory, optional + body_params].
+          map { |list| list.map { |p| p.sub(/^#{prefix}\./, '').inspect }.join(',') if list.any? }.
+          compact.join(', optionally ')
+      end
+    end
+
+    METHOD_ORDER = ['GET', 'PATCH', 'DELETE', 'PUT', 'POST']
+
+    attr_reader :resource_type, :name, :templates
+
+    def initialize(base_href, resource_type, name)
+      @resource_type, @name = resource_type, name
+      @base_href            = Addressable::URI.parse(base_href)
+      @templates            = []
+    end
+
+    def call(session, params)
+      method, url, payload = request_for(params)
+      raise ArgumentError, "parameters don't match action, possible parameters: #{possible_params}, given: #{params.keys.map { |k| k.to_s.inspect }.join(', ')}" unless method
+      session.request(method, url, payload)
+    end
+
+    def possible_params
+      templates.map { |t| t.possible_params(resource_type) }.join('; or ')
+    end
+
+    def accepted_types
+      templates.flat_map { |t| t.mandatory.map { |k| k.split('.', 2).first if k.include? '.' }.compact }.uniq
+    end
+
+    def instance_action?(prefix)
+      prefix = "#{prefix}."
+      templates.any? do |template|
+        template.mandatory.any? { |key| key.start_with? prefix }
+      end
+    end
+
+    def request_for(params)
+      params = { params['@type'] => params } if params.is_a? Entity and params['@type']
+      params = params.to_h
+
+      templates.each do |template|
+        mapped = template.map_params(params, resource_type)
+        next unless template.mandatory.all? { |k| mapped.include? k }
+        next unless template.accept_everything? or mapped.keys.all? { |k| template.params.include? k }
+        return [template.method, template.uri(mapped), template.payload(mapped)]
+      end
+      false
+    end
+
+    def add_template(method, pattern, accepted_params = nil)
+      uri_template = Addressable::Template.new(@base_href.join(pattern).to_s)
+      template     = Template.new(method, uri_template, [], [], Array(accepted_params))
+      pattern.scan(/\{(\W?)(?:([^\}]+))\}/) do |prefix, params|
+        list   = prefix == '?' ? template.optional : template.mandatory
+        list.concat(params.split(','))
+      end
+      templates << template
+      templates.sort_by { |t| [METHOD_ORDER.index(t.method) || METHOD_ORDER.size, -t.mandatory.size, t.optional.size] }
+      self
+    end
+  end
+end

data/lib/travis/client/collection.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+module Travis::Client
+  class Collection < Entity
+    include Enumerable
+
+    def paginates?
+      !!@payload['@pagination']
+    end
+
+    def offset
+      pagination_info['offset'] || 0
+    end
+
+    def on_page
+      @on_page ||= Array(@payload[collection_key])
+    end
+
+    def last_page?
+      pagination_info.fetch('is_last', true)
+    end
+
+    def first_page?
+      pagination_info.fetch('is_first', true)
+    end
+
+    def collection_key
+      @collection_key ||= begin
+        session.fetch(@href) if @payload.keys.all? { |k| k.start_with? '@' }
+        @payload.keys.detect { |k| !k.start_with?('@') and self[k].is_a? Array }
+      end
+    end
+
+    def size
+      pagination_info['count'] || on_page.size
+    end
+
+    def next_page
+      pagination_info['next']&.fetch
+    end
+
+    def previous_page
+      pagination_info['prev']&.fetch
+    end
+
+    def first_page
+      return self if first_page?
+      pagination_info['first']&.fetch
+    end
+
+    def last_page
+      return self if last_page?
+      pagination_info['last']&.fetch
+    end
+
+    def each(&block)
+      return enum_for(:each) unless block
+      on_page.each(&block)
+      next_page&.each(&block)
+      self
+    end
+
+    def pagination_info
+      @pagination_info ||= @payload['@pagination'] || {}
+    end
+  end
+end

data/lib/travis/client/connection.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+module Travis::Client
+  class Connection
+    Env                    = Struct.new(:request_method, :uri, :params, :response, :meta_data)
+    DEFAULT_HEADERS        = {
+      "Travis-API-Version" => "3",
+      "Accept"             => "application/json",
+      "User-Agent"         => "Travis/#{VERSION} Ruby/#{RUBY_VERSION}" }
+    PREDEFINED             = {
+      'home'               => { '@type' => 'resource', 'attributes' => ['config', 'errors', 'resources'] },
+      'resource'           => { '@type' => 'resource', 'attributes' => ['actions', 'attributes', 'representations', 'permissions'] },
+      'template'           => { '@type' => 'resource', 'attributes' => ['request_method', 'uri_template', 'accepted_params'] }}
+
+    private_constant :DEFAULT_HEADERS, :PREDEFINED
+
+    attr_reader :request_headers, :service_index, :resource_types, :error_types, :mixin, :actions, :http_factory, :access_token
+
+    def initialize(endpoint: Travis.default_endpoint, request_headers: {}, access_token: nil, http_factory: HTTP)
+      @request_headers, @mixin                = DEFAULT_HEADERS.merge(request_headers).freeze, Module.new
+      @error_types, @resource_types, @actions = {}, {}, {}
+      @before_callbacks, @after_callbacks     = [], []
+      @session_factory, @http_factory         = Class.new(Session), http_factory
+      @access_token                           = access_token
+      @default_session                        = create_session
+
+      yield self if block_given?
+
+      load_resource(PREDEFINED, endpoint)
+      @service_index = @default_session.request(:get, endpoint)
+      load_resource(service_index.resources, endpoint)
+      load_errors(service_index.errors)
+      define_actions
+
+      @session_factory.include(@mixin)
+    end
+
+    def create_session(**options)
+      options[:access_token] ||= access_token
+      @session_factory.new(self, **options)
+    end
+
+    def before_request(callback = Proc.new)
+      @before_callbacks << callback
+    end
+
+    def after_request(callback = Proc.new)
+      @after_callbacks << callback
+    end
+
+    def notify(method, uri, params)
+      env = Env.new(method, uri, params, nil, {})
+      @before_callbacks.each { |c| c.call(env) }
+      env.response = yield
+      @after_callbacks.each { |c| c.call(env) }
+      env.response
+    end
+
+    def action(resource_type, action_name)
+      actions.
+        fetch(resource_type.to_s) { raise ArgumentError, 'unknown resource type' }.
+        fetch(action_name.to_s)   { raise ArgumentError, 'unknown action'        }
+    end
+
+    private def add_action(base_href, type, name, templates)
+      action              = Action.new(base_href, type, name)
+      actions[type]     ||= {}
+      actions[type][name] = action
+      templates.each { |t| action.add_template(t.request_method, t.uri_template, t.accepted_params)}
+    end
+
+    private def load_resource(resources, base_href)
+      resources.each do |type, definition|
+        factory = resource_types.fetch(type) { resource_types[type] = Class.new(superclass_for(type, definition)) }
+        Array(definition['attributes']).each { |attribute| factory.add_attribute(attribute) }
+        Hash(definition['actions']).each { |key, value| add_action(base_href, type, key, Array(value)) }
+      end
+    end
+
+    private def superclass_for(type, definition)
+      return Error if type == 'error'
+      definition['attributes'] == [type] ? Collection : Entity
+    end
+
+    private def load_errors(errors)
+      errors.each do |type, definition|
+        factory = error_types.fetch(type) {  error_types[type] = Class.new(resource_types.fetch('error')) }
+        Array(definition['additional_attributes']).each { |attribute| factory.add_attribute(attribute) }
+        factory.default_message = definition['default_message']
+      end
+    end
+
+    private def define_actions
+      actions.each do |resource_type, mapping|
+        factory = resource_types[resource_type]
+        mapping.each do |name, action|
+          factory.add_action(resource_type, name, action)
+          action.accepted_types.each { |t| resource_types[t].add_related_action(t, resource_type, name, action) if t != resource_type and resource_types.include? t }
+          @mixin.module_eval { define_method("#{resource_type}_#{name}") { |params={}| action.call(session, params) }} unless @mixin.method_defined? "#{resource_type}_#{name}"
+          @mixin.module_eval { define_method("#{name}_#{resource_type}") { |params={}| action.call(session, params) }} unless @mixin.method_defined? "#{name}_#{resource_type}"
+        end
+      end
+    end
+  end
+end