assembla_api 0.1.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 544c0b5cf90c28355fa82a7c6705f1ac875a1ce2
+  data.tar.gz: 8d97d3258aa5ae4fef0838249c7230de0f00fe26
+SHA512:
+  metadata.gz: 3068a96928b8169a1a0dce98ec74a905203b8160774e84f744649bfcc60dacd1b9d2b6a4ad920524429071c9231dc8a6fe8c9994a1a6721e123b796797c243ca
+  data.tar.gz: 830a2513a480adb5922289325df0c5e4527dea53284bba6422d76407899b908183174dd708e5c88131bd9b23bc9f5e8b705e903485a831152ac6085caff760dd

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2014 Assembla
+
+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/Rakefile

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+#RSpec::Core::RakeTask.new(:spec) do |spec|
+#  spec.pattern = FileList['spec/**/*_spec.rb']
+#end
+
+FileList['tasks/**/*.rake'].each(&method(:import))
+
+#desc 'Run all specs on CI'
+#task ci: [:spec, :features, 'coveralls:push']
+
+desc 'Load gem inside irb console'
+task :console do
+  require 'irb'
+  require 'irb/completion'
+  require File.join(__FILE__, '../lib/assembla_api')
+  ARGV.clear
+  IRB.start
+end

data/lib/assembla_api.rb

@@ -0,0 +1,130 @@
+# encoding: utf-8
+
+require 'faraday'
+require 'assembla_api/version'
+require 'assembla_api/configuration'
+require 'assembla_api/constants'
+require 'assembla_api/utils/url'
+require 'assembla_api/connection'
+require 'assembla_api/deprecation'
+require 'assembla_api/core_ext/ordered_hash'
+require 'assembla_api/ext/faraday'
+require 'assembla_api/middleware'
+
+module Assembla
+  LIBNAME = 'assembla_api'
+
+  LIBDIR = File.expand_path("../#{LIBNAME}", __FILE__)
+
+  class << self
+    def included(base)
+      base.extend ClassMethods
+    end
+
+    # Alias for Assembla::Client.new
+    #
+    # @param [Hash] options
+    #   the configuration options
+    #
+    # @return [Assembla::Client]
+    #
+    # @api public
+    def new(options = {}, &block)
+      Client.new(options, &block)
+    end
+
+    # Default middleware stack that uses default adapter as specified
+    # by configuration setup
+    #
+    # @return [Proc]
+    #
+    # @api private
+    def default_middleware(options = {})
+      Middleware.default(options)
+    end
+
+    # Delegate to Assembla::Client
+    #
+    # @api private
+    def method_missing(method_name, *args, &block)
+      if new.respond_to?(method_name)
+        new.send(method_name, *args, &block)
+      elsif configuration.respond_to?(method_name)
+        Assembla.configuration.send(method_name, *args, &block)
+      else
+        super
+      end
+    end
+
+    def respond_to?(method_name, include_private = false)
+      new.respond_to?(method_name, include_private) ||
+      configuration.respond_to?(method_name) ||
+      super(method_name, include_private)
+    end
+  end
+
+  module ClassMethods
+
+    # Requires internal libraries
+    #
+    # @param [String] prefix
+    #   the relative path prefix
+    # @param [Array[String]] libs
+    #   the array of libraries to require
+    #
+    # @return [self]
+    def require_all(prefix, *libs)
+      libs.each do |lib|
+        require "#{File.join(prefix, lib)}"
+      end
+    end
+
+    # The client configuration
+    #
+    # @return [Configuration]
+    #
+    # @api public
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    # Configure options
+    #
+    # @example
+    #   Assembla.configure do |c|
+    #     c.some_option = true
+    #   end
+    #
+    # @yield the configuration block
+    # @yieldparam configuration [Assembla::Configuration]
+    #   the configuration instance
+    #
+    # @return [nil]
+    #
+    # @api public
+    def configure
+      yield configuration
+    end
+  end
+
+  extend ClassMethods
+
+  require_all LIBDIR,
+    'authorization',
+    'validations',
+    'normalizer',
+    'parameter_filter',
+    'api',
+    'client',
+    'pagination',
+    'request',
+    'response',
+    'response_wrapper',
+    'error',
+    'mime_type',
+    'page_links',
+    'paged_request',
+    'page_iterator',
+    'params_hash'
+
+end # Assembla

data/lib/assembla_api/api.rb

@@ -0,0 +1,373 @@
+# encoding: utf-8
+
+require 'assembla_api/configuration'
+require 'assembla_api/mime_type'
+require 'assembla_api/rate_limit'
+require 'assembla_api/core_ext/hash'
+require 'assembla_api/core_ext/array'
+require 'assembla_api/null_encoder'
+
+require 'assembla_api/request/verbs'
+
+require 'assembla_api/api/actions'
+require 'assembla_api/api/factory'
+require 'assembla_api/api/arguments'
+
+module Assembla
+  # Core class responsible for api interface operations
+  class API
+    extend Assembla::ClassMethods
+    include Constants
+    include Authorization
+    include MimeType
+    include Request::Verbs
+    include RateLimit
+
+    attr_reader *Assembla.configuration.property_names
+
+    attr_accessor *Validations::VALID_API_KEYS
+
+    attr_accessor :current_options
+
+    # Callback to update current configuration options
+     class_eval do
+       Assembla.configuration.property_names.each do |key|
+         define_method "#{key}=" do |arg|
+           self.instance_variable_set("@#{key}", arg)
+           self.current_options.merge!({:"#{key}" => arg})
+         end
+       end
+     end
+
+    # Create new API
+    #
+    # @api public
+    def initialize(options={}, &block)
+      setup(options)
+      yield_or_eval(&block) if block_given?
+    end
+
+    def yield_or_eval(&block)
+      return unless block
+      block.arity > 0 ? yield(self) : self.instance_eval(&block)
+    end
+
+    # Configure options and process basic authorization
+    #
+    # @api private
+    def setup(options={})
+      options = Assembla.configuration.fetch.merge(options)
+      self.current_options = options
+      Assembla.configuration.property_names.each do |key|
+        send("#{key}=", options[key])
+      end
+      process_basic_auth(options[:basic_auth])
+    end
+
+    # Extract login and password from basic_auth parameter
+    #
+    def process_basic_auth(auth)
+      case auth
+      when String
+        self.login, self.password = auth.split(':', 2)
+      when Hash
+        self.login    = auth[:login]
+        self.password = auth[:password]
+      end
+    end
+
+    # List of before callbacks
+    #
+    # @api public
+    def self.before_callbacks
+      @before_callbacks ||= []
+    end
+
+    # List of after callbacks
+    #
+    # @api public
+    def self.after_callbacks
+      @after_callbacks ||= []
+    end
+
+    # Before request filter
+    #
+    # @api public
+    def self.before_request(callback, params = {})
+      before_callbacks << params.merge(callback: callback)
+    end
+
+    # After request filter
+    #
+    # @api public
+    def self.after_request(callback, params = {})
+      after_callbacks << params.merge(callback: callback)
+    end
+
+    class << self
+      attr_reader :root
+      alias_method :root?, :root
+    end
+
+    def self.root!
+      @root = true
+    end
+
+    def self.inherited(child_class)
+      before_callbacks.reverse_each { |callback|
+        child_class.before_callbacks.unshift(callback)
+      }
+      after_callbacks.reverse_each { |callback|
+        child_class.after_callbacks.unshift(callback)
+      }
+      extend_with_actions(child_class)
+      unless child_class.instance_variable_defined?(:@root)
+        child_class.instance_variable_set(:@root, false)
+      end
+      super
+    end
+
+    root!
+
+    def self.internal_methods
+      api = self
+      api = api.superclass until api.root?
+      api.public_instance_methods(true)
+    end
+
+    def self.extra_methods
+      ['actions']
+    end
+
+    # Find all the api methods that should be considred by
+    # request callbacks.
+    #
+    # @return [Set]
+    #
+    # @api private
+    def self.request_methods
+      @request_methods ||= begin
+        methods = (public_instance_methods(true) -
+                   internal_methods +
+                   public_instance_methods(false)).uniq.map(&:to_s)
+        Set.new(methods - extra_methods)
+      end
+    end
+
+    def self.clear_request_methods!
+      @request_methods = nil
+    end
+
+    def self.method_added(method_name)
+      method_name = method_name.to_s.gsub(/_with(out)?_callback_.*$/, '')
+      # Only subclasses matter
+      return if self.root?
+      return if extra_methods.include?(method_name)
+      # Only public methods are of interest
+      return unless request_methods.include?(method_name)
+      # Do not redefine
+      return if (@__methods_added ||= []).include?(method_name)
+
+      class_name     = self.name.to_s.split('::').last.downcase
+      with_method    = "#{method_name}_with_callback_#{class_name}"
+      without_method = "#{method_name}_without_callback_#{class_name}"
+
+      return if public_method_defined?(with_method)
+
+      [method_name, with_method, without_method].each do |met|
+        @__methods_added << met
+      end
+      return if public_method_defined?(with_method)
+
+      define_method(with_method) do |*args, &block|
+        send(:execute, without_method, *args, &block)
+      end
+      alias_method without_method, method_name
+      alias_method method_name, with_method
+      clear_request_methods!
+    end
+
+    # Filter callbacks based on kind
+    #
+    # @param [Symbol] kind
+    #   one of :before or :after
+    #
+    # @return [Array[Hash]]
+    #
+    # @api private
+    def filter_callbacks(kind, action_name)
+      matched_callbacks = self.class.send("#{kind}_callbacks").select do |callback|
+        callback[:only].nil? || callback[:only].include?(action_name)
+      end
+    end
+
+    # Run all callbacks associated with this action
+    #
+    # @apram [Symbol] action_name
+    #
+    # @api private
+    def run_callbacks(action_name, &block)
+      filter_callbacks(:before, action_name).each { |hook| send hook[:callback] }
+      yield if block_given?
+      filter_callbacks(:after, action_name).each { |hook| send hook[:callback] }
+    end
+
+    # Execute action
+    #
+    # @param [Symbol] action
+    #
+    # @api private
+    def execute(action, *args, &block)
+      action_name = action.to_s.gsub(/_with(out)?_callback_.*$/, '')
+      result = nil
+      run_callbacks(action_name) do
+        result = send(action, *args, &block)
+      end
+      result
+    end
+
+    # Responds to attribute query or attribute clear
+    #
+    # @api private
+    def method_missing(method_name, *args, &block) # :nodoc:
+      case method_name.to_s
+      when /^(.*)\?$/
+        return !!send($1.to_s)
+      when /^clear_(.*)$/
+        send("#{$1.to_s}=", nil)
+      else
+        super
+      end
+    end
+
+    # Acts as setter and getter for api requests arguments parsing.
+    #
+    # Returns Arguments instance.
+    #
+    def arguments(args=(not_set = true), options={}, &block)
+      if not_set
+        @arguments
+      else
+        @arguments = Arguments.new(options.merge!(api: self)).parse(*args, &block)
+      end
+    end
+
+    # Scope for passing request required arguments.
+    #
+    def with(args)
+      case args
+      when Hash
+        set args
+      when /.*\/.*/i
+        user, repo = args.split('/')
+        set :user => user, :repo => repo
+      else
+        ::Kernel.raise ArgumentError, 'This api does not support passed in arguments'
+      end
+    end
+
+    # Set a configuration option for a given namespace
+    #
+    # @param [String] option
+    # @param [Object] value
+    # @param [Boolean] ignore_setter
+    #
+    # @return [self]
+    #
+    # @api public
+    def set(option, value=(not_set=true), ignore_setter=false, &block)
+      raise ArgumentError, 'value not set' if block and !not_set
+      return self if !not_set and value.nil?
+
+      if not_set
+        set_options option
+        return self
+      end
+
+      if respond_to?("#{option}=") and not ignore_setter
+        return __send__("#{option}=", value)
+      end
+
+      define_accessors option, value
+      self
+    end
+
+    # Defines a namespace
+    #
+    # @param [Array[Symbol]] names
+    #   the name for the scope
+    #
+    # @return [self]
+    #
+    # @api public
+    def self.namespace(*names)
+      options = names.last.is_a?(Hash) ? names.pop : {}
+      names   = names.map(&:to_sym)
+      name    = names.pop
+      return if public_method_defined?(name)
+
+      class_name = extract_class_name(name, options)
+      define_method(name) do |*args, &block|
+        options = args.last.is_a?(Hash) ? args.pop : {}
+        API::Factory.new(class_name, current_options.merge(options), &block)
+      end
+      self
+    end
+
+    # Extracts class name from options
+    #
+    # @param [Hash] options
+    # @option options [String] :full_name
+    #   the full name for the class
+    # @option options [Boolean] :root
+    #   if the class is at the root or not
+    #
+    # @return [String]
+    #
+    # @api private
+    def self.extract_class_name(name, options)
+      converted  = options.fetch(:full_name, name).to_s
+      converted  = converted.split('_').map(&:capitalize).join
+      class_name = options.fetch(:root, false) ? '': "#{self.name}::"
+      class_name += converted
+      class_name
+    end
+
+    private
+
+    # Set multiple options
+    #
+    # @api private
+    def set_options(options)
+      unless options.respond_to?(:each)
+        raise ArgumentError, 'cannot iterate over value'
+      end
+      options.each { |key, value| set(key, value) }
+    end
+
+    # Define setters and getters
+    #
+    # @api private
+    def define_accessors(option, value)
+      setter = proc { |val|  set option, val, true }
+      getter = proc { value }
+
+      define_singleton_method("#{option}=", setter) if setter
+      define_singleton_method(option, getter) if getter
+    end
+
+    # Dynamically define a method for setting request option
+    #
+    # @api private
+    def define_singleton_method(method_name, content=Proc.new)
+      (class << self; self; end).class_eval do
+        undef_method(method_name) if method_defined?(method_name)
+        if String === content
+          class_eval("def #{method_name}() #{content}; end")
+        else
+          define_method(method_name, &content)
+        end
+      end
+    end
+  end # API
+end # Assembla