veye 0.0.9 → 0.1

data/lib/veye/api/github.rb

@@ -0,0 +1,77 @@
+module Veye
+  module API
+    # Api wrappers for Github endpoint
+    module Github
+      RESOURCE_PATH = '/github'
+      def self.encode_repo_key(repo_key)
+        repo_key.to_s.gsub(/\//, ':').gsub(/\./, '~')
+      end
+
+      def self.get_list(api_key, page = 1, lang = nil, privat = nil, org = nil, type = nil)
+        params = {
+          api_key: api_key,
+          page: page || 1
+        }
+        params[:lang] = lang.to_s.downcase if lang
+        unless private.nil?
+          params[:private] = privat == 'true' || privat == 't' || privat == true
+        end
+        params[:org_name] = org if org
+        params[:org_type] = type if type
+
+        github_api = Resource.new(RESOURCE_PATH)
+        qparams = { params: params }
+        github_api.resource.get(qparams) do |response, request, result|
+          JSONResponse.new(request, result, response)
+        end
+      end
+
+      def self.import_all(api_key, force = false)
+        params = { api_key: api_key }
+        params[:force] = force || false
+        qparams = { params: params }
+        github_api = Resource.new("#{RESOURCE_PATH}/sync")
+
+        github_api.resource.get(qparams) do |response, request, result|
+          JSONResponse.new(request, result, response)
+        end
+      end
+
+      def self.get_repo(api_key, repo_name, branch = nil, file = nil)
+        safe_repo_name = encode_repo_key(repo_name)
+        github_api = Resource.new("#{RESOURCE_PATH}/#{safe_repo_name}")
+        qparams = { api_key: api_key }
+        qparams[:branch] = branch unless branch.nil?
+        qparams[:file] = file unless file.nil?
+
+        github_api.resource.get({ params: qparams }) do |response, request, result|
+          JSONResponse.new(request, result, response)
+        end
+      end
+
+      def self.import_repo(api_key, repo_name, branch = nil, filename = nil)
+        safe_repo_name = encode_repo_key(repo_name)
+        github_api = Resource.new("#{RESOURCE_PATH}/#{safe_repo_name}")
+
+        params = { api_key: api_key }
+        params[:branch] = branch unless branch.nil?
+        params[:file] = filename unless filename.nil?
+
+        github_api.resource.post(params) do |response, request, result|
+          JSONResponse.new(request, result, response)
+        end
+      end
+
+      def self.delete_repo(api_key, repo_name, branch = nil)
+        safe_repo_key = encode_repo_key(repo_name)
+        qparams = { api_key: api_key }
+        qparams[:branch] = branch unless branch.nil?
+        github_api = Resource.new("#{RESOURCE_PATH}/#{safe_repo_key}")
+
+        github_api.resource.delete({params: qparams}) do |response, request, result|
+          JSONResponse.new(request, result, response)
+        end
+      end
+    end
+  end
+end

data/lib/veye/api/json_response.rb

@@ -2,55 +2,51 @@ require 'json'
 
 module Veye
   module API
+    # Unified API response class
     class JSONResponse
       attr_reader :code, :success, :message, :data, :url, :headers
       def initialize(request, result, response)
-         @url = request.url
-         @headers = request.headers
-         @code = result.code.to_i
-
-         response_data = JSON.parse(response)
-
-         @success, @message = success?(result, response_data)
-         @data = response_data
+        @url = request.url
+        @headers = request.headers
+        @code = result.code.to_i
+        response_data = JSON.parse(response)
+        @success, @message = success?(result)
+        @data = response_data
       end
 
-      def success?(result, response_data)
+      def success?(result)
         @code = result.code.to_i
         success = false
-         
-        case @code 
+        case @code
         when 200
           success = true
-          message = "fetched successfully"
+          message = 'fetched successfully'
         when 201
           success = true
-          message = "created successfully"
+          message = 'created successfully'
         when 400
-          message = "bad request - wrong parameters, data"
+          message = 'bad request - wrong parameters, data'
         when 401
-          message = "not authorized - add apikey or update settings file ~/.veye.rc"
+          message = 'not authorized - add apikey or update settings.'
         when 403
-          message = "forbidden - server refused execute query"
+          message = 'forbidden - server refused execute query'
         when 413
-          message = "request entity too big - use smaller data object"
+          message = 'request entity too big - use smaller data object'
         when 500
-          message = "internal server error - write to us"
+          message = 'internal server error - write to us'
         when 501
-          message = "not implemented - write to us"
+          message = 'not implemented - write to us'
         when 503
-          message = "service unavailable - temporary overloaded - write to us."
+          message = 'service unavailable - temporary overloaded - write to us'
         when 531
-          message = "not authorized - add apikey or update settings file ~/.veye.rc"
+          message = 'not authorized - add or update api key'
         else
           success = false
-          message = ""
+          message = ''
         end
 
-         return success, message
+        [success, message]
       end
-
-
     end
   end
 end

data/lib/veye/api/package.rb

@@ -0,0 +1,98 @@
+module Veye
+  module API
+    # Package API wrappers
+    module Package
+      RESOURCE_PATH = '/products'
+
+      def supported_languages
+        Set.new %w( Clojure Java Javascript Node.JS PHP Python Ruby R )
+      end
+
+      def self.encode_prod_key(prod_key)
+        prod_key.to_s.gsub(/\//, ':').gsub(/\./, '~')
+      end
+
+      def self.encode_language(lang)
+        lang.to_s.gsub(/\./, '').downcase
+      end
+
+      # returns package information
+      def self.get_package(prod_key, language)
+        lang = encode_language(language)
+        safe_prod_key = encode_prod_key(prod_key)
+        product_api = Resource.new "#{RESOURCE_PATH}/#{lang}/#{safe_prod_key}"
+        product_api.resource.get do |response, request, result|
+          JSONResponse.new(request, result, response)
+        end
+      end
+
+      def self.search(search_term, language = nil, group_id = nil, page = '1')
+        search_api = Resource.new "#{RESOURCE_PATH}/search/#{search_term}"
+
+        search_params = { q: search_term.to_s }
+        search_params[:lang] = encode_language(language) unless language.nil?
+        search_params[:g] = group_id unless group_id.nil?
+        if page.nil?
+          search_params[:page] = '1'
+        else
+          search_params[:page] = page.to_s
+        end
+
+        request_params = { params: search_params }
+        search_api.resource.get(request_params) do |response, request, result|
+          JSONResponse.new(request, result, response)
+        end
+      end
+
+      def self.get_follow_status(api_key, prod_key, language)
+        product_api = Resource.new(RESOURCE_PATH)
+        qparams = { params: { api_key: api_key } }
+        lang = encode_language(language)
+        safe_prod_key = encode_prod_key(prod_key)
+
+        path = "#{lang}/#{safe_prod_key}/follow.json"
+        product_api.resource[path].get(qparams) do |response, request, result|
+          Veye::API::JSONResponse.new(request, result, response)
+        end
+      end
+
+      def self.follow(api_key, prod_key, language)
+        api = Resource.new(RESOURCE_PATH)
+        qparams = { api_key: api_key }
+        lang = encode_language(language)
+        safe_prod_key = encode_prod_key(prod_key)
+
+        path = "/#{lang}/#{safe_prod_key}/follow.json"
+        api.resource[path].post(qparams) do |response, request, result|
+          JSONResponse.new(request, result, response)
+        end
+      end
+
+      def self.unfollow(api_key, prod_key, language)
+        api = Resource.new(RESOURCE_PATH)
+        qparams = { params: { api_key: api_key } }
+        lang = encode_language(language)
+        safe_prod_key = encode_prod_key(prod_key)
+
+        path = "/#{lang}/#{safe_prod_key}/follow.json"
+        api.resource[path].delete(qparams) do |response, request, result|
+          JSONResponse.new(request, result, response)
+        end
+      end
+
+      def self.get_references(prod_key, language, page = nil)
+        api = Resource.new(RESOURCE_PATH)
+        lang = encode_language(language).capitalize # endpoint bug
+        safe_prod_key = encode_prod_key(prod_key)
+
+        api_path = "/#{lang}/#{safe_prod_key}/references"
+        page_nr = page.to_s unless page.nil?
+        page_nr ||= 1
+        qparams = { params: { page: page_nr } }
+        api.resource[api_path].get(qparams) do |response, request, result|
+          JSONResponse.new(request, result, response)
+        end
+      end
+    end
+  end
+end

data/lib/veye/api/project.rb

@@ -0,0 +1,107 @@
+module Veye
+  module API
+    module Project
+      RESOURCE_PATH = "/projects"
+      MAX_FILE_SIZE = 500000 # ~ 500kB
+
+      #TODO: add throws
+      def self.check_file(filename)
+        file_path = File.absolute_path(filename)
+
+        unless File.exists?(file_path)
+          printf("%s: Cant read file `%s`",
+                 "Error".color(:red),
+                 "#{filename}".color(:yellow))
+          return nil
+        end
+
+        file_size = File.size(file_path)
+        unless file_size != 0 and file_size < MAX_FILE_SIZE
+          p "Size of file is not acceptable: 0kb < x <= #{MAX_FILE_SIZE/1000}kb"
+          return nil
+        end
+
+        file_path
+      end
+
+      def self.get_list(api_key)
+        project_api = Resource.new(RESOURCE_PATH)
+        qparams = {:params => {:api_key => api_key}}
+        project_api.resource.get(qparams) do |response, request, result|
+          JSONResponse.new(request, result, response)
+        end
+      end
+
+      def self.upload(api_key, filename)
+        project_api = Resource.new(RESOURCE_PATH)
+        file_path = check_file(filename)
+        return if file_path.nil?
+
+        file_obj = File.open(file_path, 'rb')
+        upload_data = {
+          :upload   => file_obj,
+          :api_key  => api_key
+        }
+
+        project_api.resource.post(upload_data) do |response, request, result, &block|
+          JSONResponse.new(request, result, response)
+        end
+      end
+
+      def self.update(api_key, project_key, filename)
+        project_api = Resource.new("#{RESOURCE_PATH}/#{project_key}")
+        file_path = check_file(filename)
+        return if file_path.nil?
+
+        file_obj = File.open(file_path, 'rb')
+        upload_data = {
+          :project_file   => file_obj,
+          :api_key        => api_key
+        }
+        project_api.resource.post(upload_data) do |response, request, result, &block|
+          JSONResponse.new(request, result, response)
+        end
+      end
+
+      def self.get_project(api_key, project_key)
+        if project_key.nil? or project_key.empty?
+          printf("%s: %s",
+                 "Error".color(:red),
+                 "Not valid project_key: `#{project_key}`")
+          return
+        end
+
+        project_api = Resource.new("#{RESOURCE_PATH}/#{project_key}")
+        qparams = {:params => {:api_key => api_key}}
+        project_api.resource.get(qparams) do |response, request, result|
+          JSONResponse.new(request, result, response)
+        end
+      end
+
+      def self.delete_project(api_key, project_key)
+        project_api = Resource.new("#{RESOURCE_PATH}/#{project_key}")
+        qparams = {:params => {:api_key => api_key}}
+
+        project_api.resource.delete(qparams) do |response, request, result|
+          JSONResponse.new(request, result, response)
+        end
+      end
+
+      #TODO: add throw exceptions
+      def self.get_licenses(api_key, project_key)
+        if project_key.nil? or project_key.empty?
+          printf("%s: %s",
+                 "Error".color(:red),
+                 "Not valid project_key: `#{project_key}`")
+          return
+        end
+        project_api = Resource.new("#{RESOURCE_PATH}/#{project_key}/licenses")
+        qparams = {:params => {:api_key => api_key}}
+        project_api.resource.get(qparams) do |response, request, result|
+          JSONResponse.new(request, result, response)
+        end
+      end
+
+    end
+  end
+end

data/lib/veye/api/resource.rb

@@ -1,20 +1,21 @@
-require 'rest_client'
+require 'rest-client'
 require_relative 'base_resource.rb'
 
-#for ssl keys:
-#openssl req -x509 -newkey rsa:2048 -keyout key.pem -out cert.pem -nodes
 module Veye
   module API
     class Resource < BaseResource
       def initialize(path = nil)
         super(path)
-        ssl_path = File.expand_path($global_options[:ssl_path])
-        timeout = $global_options[:timeout].to_i || 90
+        timeout_val = $global_options[:timeout].to_i
+        timeout = timeout_val if timeout_val > 0
+        timeout ||= 90
         open_timeout = $global_options[:open_timeout].to_i || 10
 
-        @resource = RestClient::Resource.new(@full_path,
-                                             timeout: timeout,
-                                             open_timeout: open_timeout)
+        @resource = RestClient::Resource.new(
+          @full_path,
+          timeout: timeout,
+          open_timeout: open_timeout,
+        )
       end
     end
   end

data/lib/veye/api/service.rb

@@ -0,0 +1,15 @@
+module Veye
+  module API
+    # API wrappers for Service endpoint
+    module Service
+      RESOURCE_PATH = '/services'
+
+      def self.ping
+        public_api = Resource.new "#{RESOURCE_PATH}/ping"
+        public_api.resource.get do |response, request, result|
+          JSONResponse.new(request, result, response)
+        end
+      end
+    end
+  end
+end

data/lib/veye/api/user.rb

@@ -0,0 +1,32 @@
+module Veye
+  module API
+    # API wrappers for User api
+    module User
+      RESOURCE_PATH = '/me'
+
+      def self.get_profile(api_key)
+        user_api = Resource.new RESOURCE_PATH
+        qparams = { params: { api_key: api_key } }
+
+        user_api.resource.get(qparams) do |response, request, result|
+          JSONResponse.new(request, result, response)
+        end
+      end
+
+      def self.get_favorites(api_key, page = 1)
+        fav_api = Resource.new "#{RESOURCE_PATH}/favorites"
+        page ||= 1
+        qparams = {
+          params: {
+            api_key: api_key,
+            page: page
+          }
+        }
+
+        fav_api.resource.get(qparams) do |response, request, result|
+          JSONResponse.new(request, result, response)
+        end
+      end
+    end
+  end
+end

data/lib/veye/api.rb

@@ -1,3 +1,23 @@
-require_relative 'api/resource.rb'
-require_relative 'api/json_response.rb'
+require_relative 'api/resource'
+require_relative 'api/json_response'
+require_relative 'api/package'
+require_relative 'api/project'
+require_relative 'api/github'
+require_relative 'api/service'
+require_relative 'api/user'
 
+# -- initialize global options
+# ps: command line interface overwrites those variables with init_enviroment
+$global_options = {
+  protocol: 'https',
+  server: 'www.versioneye.com',
+  path: 'api/v2',
+  port: nil,
+  timeout: 30
+}
+$global_options[:url] = Veye::API::Resource.build_url($global_options)
+
+module Veye
+  module API
+  end
+end

data/lib/veye/base_executor.rb

@@ -1,10 +1,9 @@
-
+# Base class that will bring many helpers into command classes.
 class BaseExecutor
   extend FormatHelpers
-  extend RepoHelpers
 
   def self.show_results(output_formats, results, options = {}, paging = nil)
-    format = options[:format]
+    format = options[:format] || 'pretty'
     self.supported_format?(output_formats, format)
     formatter = output_formats[format]
 
@@ -13,12 +12,17 @@ class BaseExecutor
     formatter.after(paging, options[:pagination])
   end
 
-  def self.catch_request_error(response, msg)
-    if response.nil? or not response.success
-      error_msg = sprintf("%s\n%s\n",
-                          "#{msg}".color(:red),
-                          "#{response.data}")
-      exit_now! error_msg
+  def self.valid_response?(response, msg)
+    if response.nil? || response.success != true
+      p "#{msg.to_s.color(:red)}: #{response.data}\n"
+      return false
     end
+
+    response.success
+  end
+
+  # OBSOLETE: use valid_response?
+  def self.catch_request_error(response, msg)
+    valid_response?(response, msg)
   end
 end

data/lib/veye/github/delete.rb

@@ -2,34 +2,24 @@ require_relative '../base_executor.rb'
 
 module Veye
   module Github
+    # Delete class include methods to cleanup projects imported from Github
     class Delete < BaseExecutor
-
       def self.delete_repo(api_key, repo_name, options)
-        github_api = API::Resource.new(RESOURCE_PATH)
-        qparams = {
-          :params => {
-            :api_key => api_key,
-            :branch => options[:branch]
-          }
-        }
-        response_data = nil
-        safe_repo_key = self.encode_repo_key(repo_name)
-        github_api.resource["/#{safe_repo_key}"].delete(qparams) do |response, request, result|
-          response_data = API::JSONResponse.new(request, result, response)
-        end
-        show_result(response_data)
-        response_data
+        response = Veye::API::Github.delete_repo(
+          api_key, repo_name, options[:branch]
+        )
+        show_result(response)
       end
 
       def self.show_result(response)
-        unless response.success
-          printf("Cant delete - %s\n%s\n", response.message.color(:red),
-                                           response.data['error'])
-        else
+        if response.success
           printf "Deleted\n".color(:green)
+        else
+          printf("Cant delete - %s\n%s\n",
+                 response.message.color(:red),
+                 response.data['error'])
         end
       end
     end
   end
 end
-

data/lib/veye/github/import.rb

@@ -3,8 +3,10 @@ require_relative '../base_executor.rb'
 
 module Veye
   module Github
+    # Import class includes methods to import projects from Github
+    # and will check a state of dependencies.
     class Import < BaseExecutor
-      @@output_formats = {
+      @output_formats = {
         'csv'     => Github::InfoCSV.new,
         'json'    => Github::InfoJSON.new,
         'pretty'  => Github::InfoPretty.new,
@@ -12,21 +14,12 @@ module Veye
       }
 
       def self.import_repo(api_key, repo_name, options)
-        github_api = API::Resource.new(RESOURCE_PATH)
-        results = nil
-        params = {api_key: api_key, branch: options[:branch]}
-        repo_name = encode_repo_key(repo_name)
-
-        github_api.resource["/#{repo_name}"].post(params) do |response, request, result|
-          results = API::JSONResponse.new(request, result, response)
-        end
-
+        results = Veye::API::Github.import_repo(
+          api_key, repo_name, options[:branch], options[:file]
+        )
         catch_request_error(results, "Can not find repository `#{repo_name}`")
-        show_results(@@output_formats, results.data, options, nil)
-        results
+        show_results(@output_formats, results.data, options, nil)
       end
-
     end
   end
 end
-

data/lib/veye/github/info.rb

@@ -3,8 +3,9 @@ require_relative '../base_executor.rb'
 
 module Veye
   module Github
+    # Info class includes methods to fetch the project info on VersionEye
     class Info < BaseExecutor
-      @@output_formats = {
+      @output_formats = {
         'csv'     => Github::InfoCSV.new,
         'json'    => Github::InfoJSON.new,
         'pretty'  => Github::InfoPretty.new,
@@ -12,19 +13,12 @@ module Veye
       }
 
       def self.get_repo(api_key, repo_name, options)
-        github_api = API::Resource.new(RESOURCE_PATH)
-        results = nil
-        qparams = {params: {api_key: api_key}}
-        safe_repo_name = self.encode_repo_key(repo_name)
-
-        github_api.resource["/#{safe_repo_name}"].get(qparams) do |response, request, result|
-          results = API::JSONResponse.new(request, result, response)
-        end
+        results = Veye::API::Github.get_repo(
+          api_key, repo_name, options[:branch], options[:file]
+        )
         catch_request_error(results, "Can not find repository `#{repo_name}`")
-        show_results @@output_formats, results.data, options
+        show_results @output_formats, results.data, options
       end
-
     end
   end
 end
-

data/lib/veye/github/list.rb

@@ -3,9 +3,9 @@ require_relative '../base_executor.rb'
 
 module Veye
   module Github
+    # List class includes methods to see importable Github repositories
     class List < BaseExecutor
-
-      @@output_formats = {
+      @output_formats = {
         'csv'     => Github::ListCSV.new,
         'json'    => Github::ListJSON.new,
         'pretty'  => Github::ListPretty.new,
@@ -13,25 +13,15 @@ module Veye
       }
 
       def self.get_list(api_key, options)
-        github_api = API::Resource.new(RESOURCE_PATH)
-        results = nil
-        params = {api_key: api_key}
-        params[:page]     = options[:page] || 1
-        params[:lang]     = options[:lang].to_s.downcase if options[:lang]
-        unless options[:private].nil?
-         params[:private]  = (options[:private] == 'true') || (options[:private] == 't')
-        end
-        params[:org_name] = options[:org] if options[:org]
-        params[:org_type] = options['org-type'] if options['org-type']
-
-        qparams = { :params => params }
-        github_api.resource.get(qparams) do |response, request, result|
-          results = API::JSONResponse.new(request, result, response)
+        results = Veye::API::Github.get_list(
+          api_key, options[:page], options[:lang],
+          options[:private], options[:org], options[:org_type]
+        )
+        if valid_response?(results, 'No repositories.')
+          paging = results.data['paging']
+          show_results(@output_formats, results.data, options, paging)
         end
-        catch_request_error(results, "No repositories.")
-        show_results @@output_formats, results.data, options, results.data['paging']
       end
     end
   end
 end
-