brief 0.0.5 → 1.0.0

data/lib/brief/github_client/request.rb

@@ -1,181 +0,0 @@
-require 'rubygems'
-require 'escape_utils'
-require 'uri_template'
-
-class Brief::GithubClient::Request
-
-  MissingArguments = Class.new(Exception)
-
-  attr_accessor :options, :user, :org, :repo, :params, :headers, :github_token
-
-  class << self
-    attr_accessor :_required_arguments
-  end
-
-  def self.requires *args
-    (self._required_arguments = args).uniq!
-  end
-
-  def self.required_arguments
-    Array(self._required_arguments).uniq
-  end
-
-  def initialize(options={}, &block)
-    @options = options.with_indifferent_access.dup
-    @client, @user, @org, @repo, @github_token = options.values_at(:client, :user,:org,:repo,:github_token)
-    @params   = options[:params] || {}
-    @headers  = options[:headers] || {}
-
-    instance_eval(&blk) if block_given?
-
-    assert_valid_arguments!
-  end
-
-  def required_arguments
-    Array(self.class._required_arguments)
-  end
-
-  def with_valid_arguments &blk
-    instance_eval(&blk) if block_given?
-    assert_valid_arguments!
-    self
-  end
-
-  def assert_valid_arguments!
-    return true if required_arguments.length > 0
-
-    valid = required_arguments.all? do |arg|
-      test = false
-      test = true if !!self.send(arg).present?
-      test = true if options.has_key?(arg)
-
-      test
-    end
-
-    raise MissingArguments unless valid
-  end
-
-  def to_object
-    req = self
-
-    response_wrapper = lambda do |r|
-      Brief::GithubClient::ResponseObject.new(r).with_request_object(req)
-    end
-
-    return object.map(&response_wrapper) if object.is_a?(Array)
-
-    response_wrapper.call(object)
-  end
-
-  def object
-    records
-  end
-
-  def refresh
-    @request = nil
-    self
-  end
-
-  def all
-    to_object
-  end
-
-  def create params={}
-    client.post_request(request_endpoint, params).request.run
-  end
-
-  def create_object params={}
-    resp = create(params)
-    Hashie::Mash.new(JSON.parse(resp.body))
-  end
-
-  def update record_id, params={}
-    client.update_request("#{ request_endpoint }/#{ record_id }", params).request.run
-  end
-
-  def update_object record_id, params={}
-    resp = update(record_id, params)
-    Hashie::Mash.new(JSON.parse(resp.body))
-  end
-
-  def destroy record_id, params={}
-    client.delete_request("#{ request_endpoint }/#{ record_id }").request.run
-  end
-
-  def show record_id, params={}
-    client.get_request("#{ request_endpoint }/#{ record_id }", params).to_object
-  end
-
-  def client
-    return @client if @client
-
-    if impersonate_user.present?
-      @client = Brief::GithubClient::Client.new(user: impersonate_user, headers: headers, github_token: github_token)
-    end
-
-    @client = Brief.github_client
-  end
-
-  def records
-    @records = request.records
-  end
-
-  def results
-    records
-  end
-
-  def result
-    records
-  end
-
-  def request_endpoint
-    options.fetch(:endpoint, endpoint)
-  end
-
-  def request refresh=false
-    @request = nil if refresh
-    @request ||= client.get_request(request_endpoint, params)
-  end
-
-  def organization_or_user
-    supplied_org || user
-  end
-
-  def user_or_organization
-    supplied_user || supplied_org
-  end
-
-  def org
-    organization_or_user
-  end
-
-  # The idea of 'supplied' means it was provided to the object
-  # and not calculated in any way.  This is used when determining
-  # the value for the endpoint, in the context of a github user vs github organization
-  def supplied_org
-    @org
-  end
-
-  def supplied_user
-    @user
-  end
-
-  def supplied_repo
-    @repo
-  end
-
-  protected
-    def github_token
-      @github_token || impersonate_user.try(:github_token) || Brief.config.github_token
-    end
-
-    def endpoint
-      "users/#{ user }"
-    end
-
-    def impersonate_user
-      if defined?(::User) && ::User.respond_to?(:find_by_github_nickname)
-        @impersonate_user ||= ::User.find_by_github_nickname(user)
-      end
-    end
-end

data/lib/brief/github_client/request_wrapper.rb

@@ -1,121 +0,0 @@
-module Brief::GithubClient
-
-  class RequestWrapper
-    attr_accessor :request,:headers,:params,:type, :method
-
-    class << self
-      attr_accessor :request_cache, :response_cache
-    end
-
-    self.request_cache ||= Brief::GithubClient.request_cache
-    self.response_cache ||= Brief::GithubClient.response_cache
-
-    def initialize(type,params,headers)
-      @type = type
-      @params = params
-      @headers = headers
-      @method = :get
-
-      @cache_key = Digest::MD5.hexdigest([params.to_json, type].to_json)
-    end
-
-    def url
-      "https://api.github.com/#{ type }"
-    end
-
-    def request
-      if method == :get
-        @request = Typhoeus::Request.new  url,
-                                          method: method,
-                                          headers: request_headers,
-                                          params: params
-      else
-        @request = Typhoeus::Request.new url,
-                                         method: method,
-                                         headers: request_headers,
-                                         body: JSON.generate(params)
-      end
-    end
-
-    def get
-      @method = :get
-      self
-    end
-
-    def update
-      @method = :patch
-      self
-    end
-
-    def post
-      @method = :post
-      self
-    end
-
-    def create
-      @method = :post
-      self
-    end
-
-    def delete
-      @method = :delete
-      self
-    end
-
-    def request_headers
-      if method == :get && cached_etag.present? && cached_etag.length > 1
-        if Brief::GithubClient.enable_caching
-          @headers["If-None-Match"] = cached_etag.split('|').first
-          @headers["If-Modified-Since"] = cached_etag.split('|').last
-        end
-      end
-
-      @headers
-    end
-
-    def cached_etag
-      Brief::GithubClient.enable_caching ? self.class.request_cache[cache_key] : nil
-    end
-
-    def cache_key
-      @cache_key
-    end
-
-    def cached?
-      response.headers.try(:[],"Status") == "304 Not Modified"
-    end
-
-    def response
-      return @response if @response
-
-      @response = request.run
-
-      if Brief::GithubClient.enable_caching && response.headers.try(:[],"Status") == "200 OK"
-        self.class.request_cache[cache_key] = "#{response.headers.try(:[],"Etag")}|#{ response.headers.try(:[],"Last-Modified") }"
-        self.class.response_cache[cache_key] = response.body
-      end
-
-      @response
-    end
-
-    def result
-      @result ||= JSON.parse(response_body)
-    end
-
-    def response_body
-      return response.body unless  Brief::GithubClient.enable_caching
-
-      self.class.response_cache.fetch(cache_key) do
-        response.body
-      end
-    end
-
-    def records
-      result
-    end
-
-    def to_object
-      Hashie::Mash.new(result)
-    end
-  end
-end

data/lib/brief/github_client/response_object.rb

@@ -1,50 +0,0 @@
-module Brief::GithubClient
-  class ResponseObject < Hashie::Mash
-
-    def url_fields
-      keys.grep(/_url/).inject({}) do |memo,field|
-        memo[field] = self.send(field)
-        memo
-      end
-    end
-
-    def with_request_class obj
-      @request_class = obj if obj
-      self
-    end
-
-    def with_request_object obj
-      @request_object = obj if obj
-      self
-    end
-
-    def request_object
-      @request_object
-    end
-
-    def request_class
-      @request_class || Brief::GithubClient::Request
-    end
-
-    def fetch(relationship, params={})
-      if endpoint_for(relationship)
-        endpoint_url  = endpoint_for(relationship)
-        tmpl          = URITemplate.new(endpoint_url)
-        request_class.new(client: request_object.client, endpoint: tmpl.expand(params))
-      end
-    end
-
-    def endpoint_for(relationship)
-      url = url_for(relationship)
-      url && url.gsub(%r{https://api.github.com/},'')
-    end
-
-    def url_for(relationship)
-      field ="#{ relationship }_url"
-
-      if has_key?(field)
-        send(field)
-      end
-    end
-  end
-end

data/lib/brief/github_client/single_repository.rb

@@ -1,9 +0,0 @@
-module Brief::GithubClient
-  class SingleRepository < Request
-    requires :org, :repo
-
-    def endpoint
-      "repos/#{ org }/#{ repo }"
-    end
-  end
-end

data/lib/brief/github_client/user_activity.rb

@@ -1,16 +0,0 @@
-module Brief::GithubClient
-  class UserActivity < Request
-    requires :user
-
-    def endpoint
-      "users/#{user}/events"
-    end
-
-    def organization_repos
-      all.select do |item|
-        item.repo && item.repo.name.try(:match,org) rescue false
-      end
-    end
-
-  end
-end

data/lib/brief/github_client/user_gists.rb

@@ -1,9 +0,0 @@
-module Brief::GithubClient
-  class UserGists < Request
-    requires :user
-
-    def endpoint
-      "users/#{ user }/gists"
-    end
-  end
-end

data/lib/brief/github_client/user_info.rb

@@ -1,9 +0,0 @@
-module Brief::GithubClient
-  class UserInfo < Request
-    requires :user
-
-    def endpoint
-      "users/#{ user }"
-    end
-  end
-end

data/lib/brief/github_client/user_issues.rb

@@ -1,13 +0,0 @@
-module Brief::GithubClient
-  class UserIssues < Request
-    requires :user
-
-    def endpoint
-      "users/#{ user }/issues"
-    end
-
-    def params
-      @params.merge(sort:"updated")
-    end
-  end
-end

data/lib/brief/github_client/user_organizations.rb

@@ -1,9 +0,0 @@
-module Brief::GithubClient
-  class UserOrganizations < Request
-    requires :user
-
-    def endpoint
-      "users/#{ user }/orgs"
-    end
-  end
-end

data/lib/brief/github_client/user_repositories.rb

@@ -1,9 +0,0 @@
-module Brief::GithubClient
-  class UserRepositories < Request
-    requires :user
-
-    def endpoint
-      "users/#{ user }/repos"
-    end
-  end
-end

data/lib/brief/github_client.rb

@@ -1,43 +0,0 @@
-module Brief::GithubClient
-  def self.default_organization
-    Brief.profile.github_organization
-  end
-
-  def self.default_github_token
-    Brief.profile.github_token
-  end
-
-  # Brief.github_client is useful for backend apps where there is a Brief configuration profile
-  Brief.define_singleton_method(:github_client) do
-    Brief::GithubClient::Client.new(github_token: Brief.profile.github_token)
-  end
-
-  class << self
-    attr_accessor :request_cache,
-                  :response_cache,
-                  :enable_caching
-  end
-
-  self.request_cache ||= {}
-  self.response_cache ||= {}
-  self.enable_caching = false
-
-  def self.clear_caches!
-    self.request_cache = {}
-    self.response_cache = {}
-  end
-end
-
-require 'brief/github_client/authentication'
-require 'brief/github_client/client'
-require 'brief/github_client/request'
-require 'brief/github_client/request_wrapper'
-require 'brief/github_client/response_object'
-require 'brief/github_client/commands'
-require 'brief/github_client/issues'
-require 'brief/github_client/issue_labels'
-require 'brief/github_client/repository_issues'
-require 'brief/github_client/repository_milestones'
-require 'brief/github_client/repository_labels'
-require 'brief/github_client/milestone_issues'
-require 'brief/github_client/user_issues'

data/lib/brief/handlers/base.rb

@@ -1,62 +0,0 @@
-module Brief
-  module Handlers
-    class Base
-      attr_accessor :element, :prepared
-
-      def initialize(element)
-        @element = element
-      end
-
-      def method_missing meth, *args, &block
-        if element.respond_to?(meth)
-          return element.send(meth, *args, &block)
-        end
-
-        super
-      end
-
-      def content
-        element.content
-      end
-
-      def document
-        get_manager.try :document
-      end
-
-      def document_settings
-        document.try(:settings)
-      end
-
-      def get_manager &block
-        if block_given?
-          @get_manager = block
-        end
-
-        @get_manager && @get_manager.call()
-      end
-
-      def parent &block
-        if block_given?
-          @find_parent_block = block
-        end
-
-        @find_parent_block && @find_parent_block.call(element.parent_id)
-      end
-
-      # Your handler should implement this method, the goal is to transform the
-      # element we are passed into an object that is suitable for whatever integration
-      # you have planned for it.  For example, preparing the necessary attributes for
-      # a submission to github issues or milestones
-      def prepare!
-        @prepared ||= begin
-                        element
-                      end
-      end
-
-      # Do whatever you want to do with the prepared element
-      def handle!
-        prepare!
-      end
-    end
-  end
-end

data/lib/brief/handlers/github_issue.rb

@@ -1,41 +0,0 @@
-module Brief
-  module Handlers
-    class GithubIssue < Base
-      def prepare!
-        @prepared ||= begin
-                        if github_api_issue.present?
-                          element.issue_url = github_api_issue.url
-                          element.issue_number = github_api_issue.number
-                        else
-                          element.issue_url = create_in_github_api.url
-                          element.issue_number = github_api_issue.number
-                        end
-
-                        element
-                      end
-      end
-
-      def create_in_github_api
-        issues_api.create_object(body: body, title: title, milestone: milestone)
-      end
-
-      def body
-        element.content
-      end
-
-      def milestone
-        parent && parent.milestone_number
-      end
-
-      def issues_api refresh=false
-        Brief.repository_issues.tap do |api|
-          refresh ? api.refresh : api
-        end
-      end
-
-      def github_api_issue
-        issues_api(true).all.detect {|issue| issue.title == title }
-      end
-    end
-  end
-end

data/lib/brief/handlers/github_milestone.rb

@@ -1,37 +0,0 @@
-module Brief
-  module Handlers
-    class GithubMilestone < Base
-      def prepare!
-        @prepared ||= begin
-                        if github_api_milestone.present?
-                          element.milestone_url = github_api_milestone.url
-                          element.milestone_number = github_api_milestone.number
-                        else
-                          element.milestone_url = create_in_github_api.url
-                          element.milestone_number = github_api_milestone.number
-                        end
-
-                        element
-                      end
-      end
-
-      def create_in_github_api
-        @github_api_milestone ||= milestones_api.create_object(body: body, title: title)
-      end
-
-      def body
-        document.parser.content_lines_under(title).reject(&:blank?).join("\n")
-      end
-
-      def milestones_api refresh=false
-        Brief.repository_milestones.tap do |api|
-          refresh ? api.refresh : api
-        end
-      end
-
-      def github_api_milestone
-        @github_api_milestone ||= milestones_api(true).all.detect {|milestone| milestone.title == element.title }
-      end
-    end
-  end
-end

data/lib/brief/handlers/github_wiki.rb

@@ -1,11 +0,0 @@
-module Brief
-  module Handlers
-    class GithubWiki < Base
-      def prepare!
-        @prepared ||= begin
-                        element
-                      end
-      end
-    end
-  end
-end

data/lib/brief/line.rb

@@ -1,69 +0,0 @@
-module Brief
-  class Line
-    attr_reader :_content,
-                :number,
-                :code
-
-    attr_accessor :raw
-
-    HeadingRegex      = /^#+\s*/
-    CodeBlockRegex    = /^\s*```/
-
-    def initialize(content, number, code=false)
-      @_content = content
-      @number = number + 1
-      @code = code
-    end
-
-    def to_s
-      content
-    end
-
-    def type
-      case
-      when code?
-        "content"
-      when _content.match(HeadingRegex)
-        "heading"
-      when _content.match(CodeBlockRegex)
-        "code_block_marker"
-      else
-        "content"
-      end
-    end
-
-    def content
-      _content.gsub(HeadingRegex, '')
-    end
-
-    def raw
-      @raw || _content
-    end
-
-    def heading?
-      !code? && type == "heading"
-    end
-
-    def level
-      _content.match(HeadingRegex).to_s.count('#')
-    end
-
-    def sort_index
-      [level, number]
-    end
-
-    def line_number
-      number
-    end
-
-    def content?
-      type == "content" || type == "code_block_marker"
-    end
-
-    def code?
-      !!@code
-    end
-
-  end
-end
-