artifactory 0.0.1 → 1.0.0

data/Rakefile

@@ -1 +1,6 @@
-require "bundler/gem_tasks"
+require 'bundler/gem_tasks'
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/artifactory.gemspec

@@ -4,20 +4,25 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'artifactory/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "artifactory"
+  spec.name          = 'artifactory'
   spec.version       = Artifactory::VERSION
-  spec.authors       = ["Sascha Bates", "Fletcher Nichol"]
-  spec.email         = ["sascha@brattyredhead.com", "fnichol@nichol.ca"]
-  spec.description   = %q{A Ruby interface for Artifactory}
-  spec.summary       = spec.description
-  spec.homepage      = "http://ProjectXY.github.io/artifactory"
-  spec.license       = "MIT"
+  spec.author        = 'Seth Vargo'
+  spec.email         = 'sethvargo@gmail.com'
+  spec.description   = 'A Ruby client for Artifactory'
+  spec.summary       = 'Artifactory is a simple, lightweight Ruby client for ' \
+                       'interacting with the Artifactory and Artifactory Pro ' \
+                       'APIs.'
+  spec.homepage      = 'https://github.com/opscode/artifactory-client'
+  spec.license       = 'Apache 2.0'
 
   spec.files         = `git ls-files`.split($/)
   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.require_paths = ['lib']
 
-  spec.add_development_dependency "bundler", "~> 1.3"
-  spec.add_development_dependency "rake"
+  spec.add_dependency 'httpclient', '~> 2.3'
+  spec.add_dependency 'i18n',       '~> 0.5'
+
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'rake'
 end

data/lib/artifactory.rb

@@ -1,5 +1,77 @@
-require "artifactory/version"
+require 'artifactory/version'
 
 module Artifactory
-  # Your code goes here...
+  autoload :Client,       'artifactory/client'
+  autoload :Configurable, 'artifactory/configurable'
+  autoload :Defaults,     'artifactory/defaults'
+  autoload :Error,        'artifactory/errors'
+  autoload :Util,         'artifactory/util'
+
+  module Collection
+    autoload :Artifact, 'artifactory/collections/artifact'
+    autoload :Base,     'artifactory/collections/base'
+  end
+
+  module Resource
+    autoload :Artifact,   'artifactory/resources/artifact'
+    autoload :Base,       'artifactory/resources/base'
+    autoload :Build,      'artifactory/resources/build'
+    autoload :Plugin,     'artifactory/resources/plugin'
+    autoload :Repository, 'artifactory/resources/repository'
+    autoload :System,     'artifactory/resources/system'
+    autoload :User,       'artifactory/resources/user'
+  end
+
+  class << self
+    include Artifactory::Configurable
+
+    #
+    # The root of the Artifactory gem. This method is useful for finding files
+    # relative to the root of the repository.
+    #
+    # @return [Pathname]
+    #
+    def root
+      @root ||= Pathname.new(File.expand_path('../../', __FILE__))
+    end
+
+    #
+    # API client object based off the configured options in {Configurable}.
+    #
+    # @return [Artifactory::Client]
+    #
+    def client
+      unless defined?(@client) && @client.same_options?(options)
+        @client = Artifactory::Client.new(options)
+      end
+
+      @client
+    end
+
+    #
+    # Delegate all methods to the client object, essentially making the module
+    # object behave like a {Client}.
+    #
+    def method_missing(m, *args, &block)
+      if client.respond_to?(m)
+        client.send(m, *args, &block)
+      else
+        super
+      end
+    end
+
+    #
+    # Delegating +respond_to+ to the {Client}.
+    #
+    def respond_to_missing?(m, include_private = false)
+      client.respond_to?(m) || super
+    end
+  end
 end
+
+require 'i18n'
+I18n.enforce_available_locales = false
+I18n.load_path << Dir[Artifactory.root.join('locales', '*.yml').to_s]
+
+# Load the initial default values
+Artifactory.setup

data/lib/artifactory/client.rb

@@ -0,0 +1,222 @@
+require 'httpclient'
+require 'json'
+require 'rexml/document'
+require 'uri'
+
+module Artifactory
+  #
+  # Client for the Artifactory API.
+  #
+  # @see http://www.jfrog.com/confluence/display/RTF/Artifactory+REST+API
+  #
+  class Client
+    class << self
+      #
+      # @private
+      #
+      def proxy(klass)
+        namespace = klass.name.split('::').last.downcase
+        klass.singleton_methods(false).each do |name|
+          define_method("#{namespace}_#{name}") do |*args|
+            if args.last.is_a?(Hash)
+              args.last[:client] = self
+            else
+              args << { client: self }
+            end
+
+            klass.send(name, *args)
+          end
+        end
+      end
+    end
+
+    include Artifactory::Configurable
+
+    proxy Resource::Artifact
+    proxy Resource::Repository
+    proxy Resource::User
+    proxy Resource::System
+
+    #
+    # Create a new Artifactory Client with the given options. Any options
+    # given take precedence over the default options.
+    #
+    # @return [Artifactory::Client]
+    #
+    def initialize(options = {})
+      # Use any options given, but fall back to the defaults set on the module
+      Artifactory::Configurable.keys.each do |key|
+        value = if options[key].nil?
+          Artifactory.instance_variable_get(:"@#{key}")
+        else
+          options[key]
+        end
+
+        instance_variable_set(:"@#{key}", value)
+      end
+    end
+
+    #
+    # Determine if the given options are the same as ours.
+    #
+    # @return [Boolean]
+    #
+    def same_options?(opts)
+      opts.hash == options.hash
+    end
+
+    #
+    # Make a HTTP GET request
+    #
+    # @param [String] path
+    #   the path to get, relative to {Defaults.endpoint}
+    #
+    def get(path, *args, &block)
+      request(:get, path, *args, &block)
+    end
+
+    #
+    # Make a HTTP POST request
+    #
+    # @param [String] path
+    #   the path to post, relative to {Defaults.endpoint}
+    #
+    def post(path, *args, &block)
+      request(:post, path, *args, &block)
+    end
+
+    #
+    # Make a HTTP PUT request
+    #
+    # @param [String] path
+    #   the path to put, relative to {Defaults.endpoint}
+    #
+    def put(path, *args, &block)
+      request(:put, path, *args, &block)
+    end
+
+    #
+    # Make a HTTP PATCH request
+    #
+    # @param [String] path
+    #   the path to patch, relative to {Defaults.endpoint}
+    #
+    def patch(path, *args, &block)
+      request(:patch, path, *args, &block)
+    end
+
+    #
+    # Make a HTTP DELETE request
+    #
+    # @param [String] path
+    #   the path to delete, relative to {Defaults.endpoint}
+    #
+    def delete(path, *args, &block)
+      request(:delete, path, *args, &block)
+    end
+
+    #
+    # Make a HTTP HEAD request
+    #
+    # @param [String] path
+    #   the path to head, relative to {Defaults.endpoint}
+    #
+    def head(path, *args, &block)
+      request(:head, path, *args, &block)
+    end
+
+    #
+    # The actually HTTPClient agent.
+    #
+    # @return [HTTPClient]
+    #
+    def agent
+      @agent ||= begin
+        agent = HTTPClient.new(endpoint)
+
+        agent.agent_name = user_agent
+
+        # Check if authentication was given
+        if username && password
+          agent.set_auth(endpoint, username, password)
+
+          # https://github.com/nahi/httpclient/issues/63#issuecomment-2377919
+          agent.www_auth.basic_auth.challenge(endpoint)
+        end
+
+        # Check if proxy settings were given
+        if proxy
+          agent.proxy = proxy
+        end
+
+        agent
+      end
+    end
+
+    #
+    # Make an HTTP reequest with the given verb and path.
+    #
+    # @param [String, Symbol] verb
+    #   the HTTP verb to use
+    # @param [String] path
+    #   the absolute or relative URL to use, expanded relative to {Defaults.endpoint}
+    #
+    # @return [Object]
+    #
+    def request(verb, path, *args, &block)
+      url = URI.parse(path)
+
+      # Don't merge absolute URLs
+      unless url.absolute?
+        url = URI.parse(File.join(endpoint, path)).to_s
+      end
+
+      # Covert the URL back into a string
+      url = url.to_s
+
+      # Make the actual request
+      response = agent.send(verb, url, *args, &block)
+
+      case response.status.to_i
+      when 200..399
+        parse_response(response)
+      when 400
+        raise Error::BadRequest.new(url: url, body: response.body)
+      when 401
+        raise Error::Unauthorized.new(url: url)
+      when 403
+        raise Error::Forbidden.new(url: url)
+      when 404
+        raise Error::NotFound.new(url: url)
+      when 405
+        raise Error::MethodNotAllowed.new(url: url)
+      when 500..600
+        raise Error::ConnectionError.new(url: url, body: response.body)
+      end
+    rescue SocketError, Errno::ECONNREFUSED, EOFError
+      raise Error::ConnectionError.new(url: url, body: <<-EOH.gsub(/^ {8}/, ''))
+        The server is not currently accepting connections.
+      EOH
+    end
+
+
+    #
+    # Parse the response object and manipulate the result based on the given
+    # +Content-Type+ header. For now, this method only parses JSON, but it
+    # could be expanded in the future to accept other content types.
+    #
+    # @param [HTTP::Message] response
+    #   the response object from the request
+    #
+    # @return [String, Hash]
+    #   the parsed response, as an object
+    #
+    def parse_response(response)
+      if response.headers['Content-Type'].include?('json')
+        JSON.parse(response.body)
+      else
+        response.body
+      end
+    end
+  end
+end

data/lib/artifactory/collections/artifact.rb

@@ -0,0 +1,12 @@
+module Artifactory
+  class Collection::Artifact < Collection::Base
+    #
+    # Create a new artifact collection.
+    #
+    # @param (see Collection::Base#initialize)
+    #
+    def initialize(parent, options = {}, &block)
+      super(Resource::Artifact, parent, options, &block)
+    end
+  end
+end

data/lib/artifactory/collections/base.rb

@@ -0,0 +1,49 @@
+module Artifactory
+  class Collection::Base
+    #
+    # Create a new collection object (proxy).
+    #
+    # @param [Class] klass
+    #   the child class object
+    # @param [Object] parent
+    #   the parent object who created the collection
+    # @param [Hash] options
+    #   the list of options given by the parent
+    # @param [Proc] block
+    #   the block to evaluate for the instance
+    #
+    def initialize(klass, parent, options = {}, &block)
+      @klass   = klass
+      @parent  = parent
+      @options = options
+      @block   = block
+    end
+
+    #
+    # Use method missing to delegate methods to the class object or instance
+    # object.
+    #
+    def method_missing(m, *args, &block)
+      if klass.respond_to?(m)
+        if args.last.is_a?(Hash)
+          args.last.merge(options)
+        end
+
+        klass.send(m, *args, &block)
+      else
+        instance.send(m, *args, &block)
+      end
+    end
+
+    private
+
+    attr_reader :klass
+    attr_reader :parent
+    attr_reader :options
+    attr_reader :block
+
+    def instance
+      @instance ||= parent.instance_eval(&block)
+    end
+  end
+end

data/lib/artifactory/configurable.rb

@@ -0,0 +1,73 @@
+module Artifactory
+  #
+  # A re-usable class containing configuration information for the {Client}. See
+  # {Defaults} for a list of default values.
+  #
+  module Configurable
+    class << self
+      #
+      # The list of configurable keys.
+      #
+      # @return [Array<Symbol>]
+      #
+      def keys
+        @keys ||= [
+          :endpoint,
+          :username,
+          :password,
+          :proxy,
+          :user_agent,
+        ]
+      end
+    end
+
+    #
+    # Create one attribute getter and setter for each key.
+    #
+    Artifactory::Configurable.keys.each do |key|
+      attr_accessor key
+    end
+
+    #
+    # Set the configuration for this config, using a block.
+    #
+    # @example Configure the API endpoint
+    #   Artifactory.configure do |config|
+    #     config.endpoint = "http://www.my-artifactory-server.com/artifactory"
+    #   end
+    #
+    def configure
+      yield self
+    end
+
+    #
+    # Reset all configuration options to their default values.
+    #
+    # @example Reset all settings
+    #   Artifactory.reset!
+    #
+    # @return [self]
+    #
+    def reset!
+      Artifactory::Configurable.keys.each do |key|
+        instance_variable_set(:"@#{key}", Defaults.options[key])
+      end
+      self
+    end
+    alias_method :setup, :reset!
+
+    private
+
+    #
+    # The list of configurable keys, as an options hash.
+    #
+    # @return [Hash]
+    #
+    def options
+      map = Artifactory::Configurable.keys.map do |key|
+        [key, instance_variable_get(:"@#{key}")]
+      end
+      Hash[map]
+    end
+  end
+end