assembla_api 0.1.2

data/lib/assembla_api/configuration.rb

@@ -0,0 +1,71 @@
+# encoding: utf-8
+
+require 'assembla_api/api/config'
+
+module Assembla
+  # Stores the configuration
+  class Configuration < API::Config
+
+    # Other adapters are :typhoeus, :patron, :em_synchrony, :excon, :test
+    property :adapter, default: :net_http
+
+    # By default, don't traverse the page links
+    property :auto_pagination, default: false
+
+    # Basic authentication
+    property :basic_auth
+
+    # By default, don't set an application key
+    property :client_id
+
+    # By default, don't set an application secret
+    property :client_secret
+
+    # By default, don't set an api key
+    property :api_key
+
+    # By default, don't set an api secret
+    property :api_secret
+
+    # By default, don't set a user oauth access token
+    property  :oauth_token
+
+    # The api endpoint used to connect to Assembla if none is set
+    property  :endpoint, default: 'https://api.assembla.com/v1'.freeze
+
+    # The web endpoint used to connect to Assembla if none is set
+    property  :site, default: 'https://www.assembla.com'.freeze
+
+    # The default SSL configuration
+    property  :ssl, default: {
+      :ca_file => File.expand_path('../ssl_certs/cacerts.pem', __FILE__)
+    }
+
+    # By default the Accept header will make a request for JSON
+    property  :mime_type
+
+    # The value sent in the http header for 'User-Agent' if none is set
+    property  :user_agent, default: "Assembla API Ruby Gem #{Assembla::VERSION::STRING}".freeze
+
+    # By default uses the Faraday connection options if none is set
+    property  :connection_options, default: {}
+
+    # Global repository name
+    property :repo
+
+    property :user
+
+    # TODO Portfolio
+    property :org
+
+    property :login
+
+    property :password
+
+    # By default display 30 resources
+    property :per_page, default: 30
+
+    # Add Faraday::RackBuilder to overwrite middleware
+    property :stack
+  end # Configuration
+end # Assembla

data/lib/assembla_api/connection.rb

@@ -0,0 +1,66 @@
+# encoding: utf-8
+
+module Assembla
+  # Specifies Http connection options
+  module Connection
+    extend self
+    include Assembla::Constants
+
+    ALLOWED_OPTIONS = [
+      :headers,
+      :url,
+      :params,
+      :request,
+      :ssl
+    ].freeze
+
+    def default_options(options = {})
+      accept = options[:headers] && options[:headers][:accept]
+      {
+        headers: {
+          ACCEPT         =>  accept || 'application/vnd.assembla.v1+json,' \
+                            'application/vnd.assembla.beta+json;q=0.5,' \
+                            'application/json;q=0.1',
+          ACCEPT_CHARSET => 'utf-8',
+          USER_AGENT     => options[:user_agent]
+        },
+        ssl: options[:ssl],
+        url: options[:endpoint]
+      }
+    end
+
+    def clear_cache
+      @connection = nil
+    end
+
+    def caching?
+      !@connection.nil?
+    end
+
+    # Exposes middleware builder to facilitate custom stacks and easy
+    # addition of new extensions such as cache adapter.
+    #
+    # @api public
+    def stack(options = {})
+      @stack ||= begin
+        builder_class = defined?(Faraday::RackBuilder) ? Faraday::RackBuilder : Faraday::Builder
+        builder_class.new(&Assembla.default_middleware(options))
+      end
+    end
+
+    # Creates http connection
+    #
+    # Returns a Fraday::Connection object
+    def connection(api, options = {})
+      connection_options = default_options(options)
+      clear_cache unless options.empty?
+      builder = api.stack ? api.stack : stack(options.merge!(api: api))
+      connection_options.merge!(builder: builder)
+      if ENV['DEBUG']
+        p "Connection options : \n"
+        pp connection_options
+      end
+      @connection ||= Faraday.new(connection_options)
+    end
+  end # Connection
+end # Assembla

data/lib/assembla_api/constants.rb

@@ -0,0 +1,74 @@
+module Assembla
+  module Constants
+    extend self
+
+    # Response headers
+    RATELIMIT_REMAINING = 'X-RateLimit-Remaining'.freeze
+
+    RATELIMIT_LIMIT = 'X-RateLimit-Limit'.freeze
+
+    CONTENT_TYPE = 'Content-Type'.freeze
+
+    CONTENT_LENGTH = 'content-length'.freeze
+
+    CACHE_CONTROL = 'cache-control'.freeze
+
+    ETAG = 'ETag'.freeze
+
+    SERVER = 'Server'.freeze
+
+    DATE = 'Date'.freeze
+
+    LOCATION = 'Location'.freeze
+
+    USER_AGENT = 'User-Agent'.freeze
+
+    ACCEPT = 'Accept'.freeze
+
+    ACCEPT_CHARSET = 'Accept-Charset'.freeze
+
+    OAUTH_SCOPES = 'X-Oauth-Scopes'.freeze
+
+    ACCEPTED_OAUTH_SCOPES = 'X-Accepted-Oauth-Scopes'.freeze
+
+    # Link headers
+    HEADER_LINK = "Link".freeze
+
+    HEADER_NEXT = "X-Next".freeze
+
+    HEADER_LAST = "X-Last".freeze
+
+    META_REL = "rel".freeze
+
+    META_LAST = "last".freeze
+
+    META_NEXT = "next".freeze
+
+    META_FIRST = "first".freeze
+
+    META_PREV = "prev".freeze
+
+    PARAM_PAGE = "page".freeze
+
+    PARAM_PER_PAGE = "per_page".freeze
+
+    PARAM_START_PAGE = "start_page".freeze
+
+    class ToolTypes
+      MILESTONES = 9
+      STANDUP = 10
+      TICKETS  = 13
+      FILES = 18
+      MESSAGES = 21
+      WIKI = 23
+      WEBHOOKS = 112
+      GIT = 128
+      SSH = 200
+      # TODO add all tools
+      ALL = [ MESSAGES, TICKETS, MILESTONES, FILES, STANDUP, GIT, WIKI, WEBHOOKS,
+        SSH
+       ]
+    end
+
+  end # Constants
+end # Assembla

data/lib/assembla_api/core_ext/array.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+class Array # :nodoc:
+
+  # Returns a new arrray with keys removed
+  #
+  def except(*keys)
+    self.dup.except!(*keys)
+  end unless method_defined? :except
+
+  # Similar to except but modifies self
+  #
+  def except!(*items)
+    copy = self.dup
+    copy.reject! { |item| items.include? item }
+    copy
+  end unless method_defined? :except!
+
+  # Selects a hash from the arguments list
+  #
+  def extract_options!
+    last.is_a?(::Hash) ? pop : {}
+  end unless method_defined? :extract_options!
+
+end # Array

data/lib/assembla_api/core_ext/hash.rb

@@ -0,0 +1,92 @@
+# encoding: utf-8
+
+class Hash # :nodoc:
+
+  # Returns a new hash with keys removed
+  #
+  def except(*items)
+    self.dup.except!(*items)
+  end unless method_defined? :except
+
+  # Similar to except but modifies self
+  #
+  def except!(*keys)
+    copy = self.dup
+    keys.each { |key| copy.delete!(key) }
+    copy
+  end unless method_defined? :except!
+
+  # Returns a new hash with all the keys converted to symbols
+  #
+  def symbolize_keys
+    inject({}) do |hash, (key, value)|
+      hash[(key.to_sym rescue key) || key] = value
+      hash
+    end
+  end unless method_defined? :symbolize_keys
+
+  # Similar to symbolize_keys but modifies self
+  #
+  def symbolize_keys!
+    hash = symbolize_keys
+    hash.each do |key, val|
+      hash[key] = case val
+        when Hash
+          val.symbolize_keys!
+        when Array
+          val.map do |item|
+            item.is_a?(Hash) ? item.symbolize_keys! : item
+          end
+        else
+          val
+        end
+    end
+    return hash
+  end unless method_defined? :symbolize_keys!
+
+  # Returns hash collapsed into a query string
+  #
+  def serialize
+    self.map { |key, val| [key, val].join("=") }.join("&")
+  end unless method_defined? :serialize
+
+  # Searches for all deeply nested keys
+  #
+  def deep_keys
+    keys = self.keys
+    keys.each do |key|
+      if self[key].is_a?(Hash)
+        keys << self[key].deep_keys.compact.flatten
+        next
+      end
+    end
+    keys.flatten
+  end unless method_defined? :deep_keys
+
+  # Returns true if the given key is present inside deeply nested hash
+  #
+  def deep_key?(key)
+    self.deep_keys.include? key
+  end unless method_defined? :deep_key?
+
+  # Recursively merges self with other hash and returns new hash.
+  #
+  def deep_merge(other, &block)
+    dup.deep_merge!(other, &block)
+  end unless method_defined? :deep_merge
+
+  # Similar as deep_merge but modifies self
+  #
+  def deep_merge!(other, &block)
+    other.each_pair do |key, val|
+      tval = self[key]
+      if tval.is_a?(Hash) && val.is_a?(Hash)
+        self[key] = tval.deep_merge(val)
+      else
+        self[key] = block && tval ? block.call(k, tval, val) : val
+      end
+    end
+    self
+  end unless method_defined? :deep_merge!
+
+end # Hash

data/lib/assembla_api/core_ext/ordered_hash.rb

@@ -0,0 +1,107 @@
+# encoding: utf-8
+
+module Assembla
+  module CoreExt #:nodoc:
+
+    if RUBY_VERSION >= '1.9'
+      class OrderedHash < ::Hash; end
+    else
+      class OrderedHash < ::Hash
+        attr_accessor :order
+
+        class << self
+          def [](*args)
+            hsh = OrderedHash.new
+            if Hash == args[0]
+              hsh.replace args[0]
+            elsif (args.size % 2) != 0
+              pp args
+              raise ArgumentError, "odd number of elements for Hash"
+            else
+              0.step(args.size - 1, 2) do |a|
+                b = a + 1
+                hsh[args[a]] = args[b]
+              end
+            end
+            hsh
+          end
+        end
+
+        def initialize(*args, &block)
+          super
+          @order = []
+        end
+
+        def []=(key, value)
+          @order.push key unless member?(key)
+          super key, value
+        end
+
+        def ==(hsh2)
+          return false if @order != hsh2.order
+          super hsh2
+        end
+
+        def clear
+          @order = []
+          super
+        end
+
+        def delete(key)
+          @order.delete key
+          super
+        end
+
+        def each_key
+          @order.each { |k| yield k }
+          self
+        end
+
+        def each_value
+          @order.each { |k| yield self[k] }
+          self
+        end
+
+        def each
+          @order.each { |k| yield k, self[k] }
+          self
+        end
+        alias :each_pair :each
+
+        def delete_if
+          @order.clone.each { |k| delete k if yield }
+          self
+        end
+
+        def values
+          ary = []
+          @order.each { |k| ary.push self[k] }
+          ary
+        end
+
+        def keys
+          @order
+        end
+
+        def replace(hsh2)
+          @order = hsh2.keys
+          super hsh2
+        end
+
+        def shift
+          key = @order.first
+          key ? [key, delete(key)] : super
+        end
+
+        def class
+          Hash
+        end
+
+        def __class__
+          OrderedHash
+        end
+      end # OrderedHash
+    end
+
+  end # CoreExt
+end # Assembla

data/lib/assembla_api/deprecation.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+
+module Assembla
+
+  DEPRECATION_PREFIX = "[AssemblaAPI] Deprecation warning:"
+
+  class << self
+
+    attr_writer :deprecation_tracker
+
+    def deprecation_tracker
+      @deprecation_tracker ||= []
+    end
+
+    # Displays deprecation message to the user.
+    # Each message is printed once.
+    def deprecate(method, alternate_method=nil)
+      return if deprecation_tracker.include? method
+      deprecation_tracker << method
+
+      message = <<-NOTICE
+#{DEPRECATION_PREFIX}
+
+* #{method} is deprecated.
+NOTICE
+      if alternate_method
+        message << <<-ADDITIONAL
+* please use #{alternate_method} instead.
+ADDITIONAL
+      end
+      warn_deprecation(message)
+    end
+
+    def warn_deprecation(message)
+      send :warn, message
+    end
+  end
+
+end # Assembla