veye 0.0.9 → 0.1

data/lib/veye/github/search.rb

@@ -3,32 +3,24 @@ require_relative '../base_executor.rb'
 
 module Veye
   module Github
+    # Search - find projects on Github
     class Search < BaseExecutor
-      @@output_formats = {
+      @output_formats = {
         'csv'     => Github::SearchCSV.new,
         'json'    => Github::SearchJSON.new,
         'pretty'  => Github::SearchPretty.new,
         'table'   => Github::SearchTable.new
       }
 
+      # TODO: add missing tests + API call test
       def self.search(api_key, search_term, options)
-        github_api = API::Resource.new(RESOURCE_PATH)
-        results = nil
-        params = {api_key: api_key, q: search_term}
-        params[:langs] = options[:lang] unless options[:lang].nil?
-        params[:users] = options[:user] unless options[:user].nil?
-        params[:page]  = options[:page] || "1"
-        qparams = {params: params}
-
-        github_api.resource["/search"].get(qparams) do |response, request, result|
-          results = API::JSONResponse.new(request, result, response)
-        end
-
-        catch_request_error(results, "No match")
-        show_results(@@output_formats, results.data, options, results.data['paging'])
-        results
+        results = Veye::API::Github.search(
+          api_key, search_term, options[:lang], options[:user], options[:page]
+        )
+        catch_request_error(results, 'No match')
+        paging_dt = results.data['paging']
+        show_results(@output_formats, results.data, options, paging_dt)
       end
     end
   end
 end
-

data/lib/veye/github/sync.rb

@@ -2,30 +2,21 @@ require_relative '../base_executor.rb'
 
 module Veye
   module Github
+    # Sync class is responsible for updating info on VersionEye
     class Sync < BaseExecutor
       def self.import_all(api_key, options)
-        github_api = API::Resource.new(RESOURCE_PATH)
-        response_data = nil
-        params = {api_key: api_key}
-        params[:force] = options[:force] unless options[:force].nil?
-
-        qparams = {params: params}
-        github_api.resource['/sync'].get(qparams) do |response, request, result|
-          response_data = API::JSONResponse.new(request, result, response)
-        end
-
-        catch_request_error(response_data, "Can not import repositories from Github")
-        show_result(response_data)
-        return response_data
+        response = Veye::API::Github.import_all(api_key, options[:force])
+        catch_request_error(response, 'Can not import repositories from Github')
+        show_result(response)
       end
 
       def self.show_result(response)
-        unless response.data["changed"]
-          printf("%s - %s\n",
-                 "No changes.".color(:red),
-                 "Use `force` flag if you want to reload everything.")
-        else
+        if response.data['changed']
           printf "Imported. #{response.data['msg']}\n".color(:green)
+        else
+          printf("%s - %s\n",
+                 'No changes.'.color(:red),
+                 'Use `force` flag if you want to reload everything.')
         end
       end
     end

data/lib/veye/github.rb

@@ -8,7 +8,7 @@ require_relative 'github/delete.rb'
 require_relative 'views/github.rb'
 
 module Veye
+  # commands for the Github API on VersionEye
   module Github
-    RESOURCE_PATH = "/github"
   end
 end

data/lib/veye/helpers/format_helpers.rb

@@ -1,16 +1,26 @@
 require 'rainbow/ext/string'
 
+# FormatHelpers module includes common helper functions
+# for output rendering.
 module FormatHelpers
   def supported_format?(output_formats, format)
+    formats_attached?(output_formats) && format_exists?(output_formats, format)
+  end
+
+  def formats_attached?(output_formats)
     if output_formats.nil?
-      exit_now! "Executor doesnt have any formattor defined."
+      p 'Executor doesnt have any formattor defined.'.color(:red)
     end
-    unless output_formats.has_key?(format)
-      msg = "This command doesnt support output format: `#{format}`\n".color(:red)
+    !output_formats.nil?
+  end
+
+  def format_exists?(output_formats, format)
+    unless output_formats.key?(format)
+      msg = "Unsupported output format: `#{format}`\n".color(:red)
       msg += "Supported formats: #{output_formats.keys.join(', ')}\n"
-      exit_now! msg
+      p msg
+      return false
     end
     true
   end
-
 end

data/lib/veye/package/follow.rb

@@ -2,63 +2,40 @@ require_relative '../base_executor.rb'
 
 module Veye
   module Package
+    # Manage a following status of the software library
     class Follow < BaseExecutor
-      def self.parse_prod_key(prod_key)
-        tokens = prod_key.to_s.split('/')
-        lang = Package.encode_language(tokens.first)
-        safe_prod_key = Package.encode_prod_key(tokens.drop(1).join("/"))
-        [lang, safe_prod_key]
+      def self.show_result(response)
+        result = response.data
+        return if result.nil?
+        printf(
+          "Following `%s`: %s\n",
+          result['prod_key'],
+          result['follows'].to_s.color(:green)
+        )
       end
 
-      def self.get_follow_status(prod_key, api_key)
-        product_api = API::Resource.new(RESOURCE_PATH)
-        results = nil
-        qparams = {:params => {:api_key => api_key}}
-        lang, safe_prod_key = parse_prod_key(prod_key)
-        product_api.resource[
-          "#{lang}/#{safe_prod_key}/follow.json"].get(qparams) do |response, request, result|
-
-          results = API::JSONResponse.new(request, result, response)
+      def self.get_follow_status(package_key, api_key)
+        prod_key, lang = Package.parse_key(package_key)
+        results = Veye::API::Package.get_follow_status(api_key, prod_key, lang)
+        if valid_response?(results, 'Didnt get any response.')
+          show_result(results)
         end
-
-        catch_request_error(results, "Didnt get any response.")
-        show_result(results)
-        results
       end
 
-      def self.follow(prod_key, api_key)
-        product_api = API::Resource.new(RESOURCE_PATH)
-        results = nil
-        qparams = {:api_key => api_key}
-        lang, safe_prod_key = parse_prod_key(prod_key)
-        product_api.resource[
-          "/#{lang}/#{safe_prod_key}/follow.json"].post(qparams) do |response, request, result|
-          results = API::JSONResponse.new(request, result, response)
+      def self.follow(package_key, api_key)
+        prod_key, lang = Package.parse_key(package_key)
+        results = Veye::API::Package.follow(api_key, prod_key, lang)
+        if valid_response?(results, 'Cant follow.')
+          show_result(results)
         end
-        catch_request_error(results, "Cant follow.")
-        show_result(results)
-        results
       end
 
-      def self.unfollow(prod_key, api_key)
-        product_api = API::Resource.new(RESOURCE_PATH)
-        results = nil
-        qparams = {:params => {:api_key => api_key}}
-        lang, safe_prod_key = parse_prod_key(prod_key)
-        product_api.resource[
-          "/#{lang}/#{safe_prod_key}/follow.json"].delete(qparams) do |response, request, result|
-          results = API::JSONResponse.new(request, result, response)
+      def self.unfollow(package_key, api_key)
+        prod_key, lang = Package.parse_key(package_key)
+        results = Veye::API::Package.unfollow(api_key, prod_key, lang)
+        if valid_response?(results, 'Cant unfollow.')
+          show_result(results)
         end
-
-        catch_request_error(results, "Cant unfollow.")
-        show_result(results)
-        results
-      end
-
-      def self.show_result(response)
-        result = response.data
-        return if result.nil?
-        printf "Following `#{result['prod_key']}`: #{result['follows']}\n".color(:green)
       end
     end
   end

data/lib/veye/package/info.rb

@@ -3,8 +3,9 @@ require_relative '../base_executor.rb'
 
 module Veye
   module Package
+    # View an detailed information of the package.
     class Info < BaseExecutor
-      @@output_formats = {
+      @output_formats = {
         'csv'       => Package::InfoCSV.new,
         'json'      => Package::InfoJSON.new,
         'pretty'    => Package::InfoPretty.new,
@@ -12,32 +13,14 @@ module Veye
       }
 
       def self.get_package(package_key, options = {})
-        product_api = API::Resource.new(RESOURCE_PATH)
-        tokens = package_key.to_s.split('/')
-        lang = Package.encode_language(tokens.first)
-        safe_prod_key = Package.encode_prod_key(tokens.drop(1).join("/"))
-        results = nil
-
-        if lang.nil? or safe_prod_key.nil?
-          msg =  %Q[
-            You missed language or product key.
-            Example: clojure/ztellman/aleph, which as required structure <prog lang>/<product_code>
-          ]
-          error_msg = sprintf("%s. \n%s",
-                               "Error: Malformed key.".color(:red),
-                               msg)
-          exit_now!(error_msg)
-        end
-
-        product_api.resource["/#{lang}/#{safe_prod_key}"].get do |response, request, result, &block|
-          results = API::JSONResponse.new(request, result, response)
+        prod_key, lang = Package.parse_key(package_key)
+        results = Veye::API::Package.get_package(prod_key, lang)
+        err_msg = "Didnt find any package with product_key: `#{package_key}`"
+        if valid_response?(results, err_msg)
+          paging = results.data['paging']
+          show_results(@output_formats, results.data, options, paging)
         end
-
-        catch_request_error(results, "Didnt find any package with product_key: `#{package_key}`")
-        show_results(@@output_formats, results.data, options, results.data['paging'])
-        return results
       end
     end
-
   end
 end

data/lib/veye/package/references.rb

@@ -3,52 +3,25 @@ require_relative '../base_executor.rb'
 
 module Veye
   module Package
+    # Commands to view package references
     class References < BaseExecutor
-      @@output_formats = {
+      @output_formats = {
         'csv'       => Package::ReferencesCSV.new,
         'json'      => Package::ReferencesJSON.new,
         'pretty'    => Package::ReferencesPretty.new,
         'table'     => Package::ReferencesTable.new
       }
 
-      def self.validate_input!(lang, safe_prod_key)
-        if lang.nil? or safe_prod_key.nil?
-          msg =  %Q[
-            You missed language or product key.
-            Example: clojure/ztellman/aleph, which as required structure
-            <prog lang>/<product_code>
-          ]
-          error_msg = sprintf("%s. \n%s",
-                               "Error: Malformed key.".color(:red),
-                               msg)
-          exit_now!(error_msg)
-        end
-      end
-
       def self.get_references(package_key, options = {})
-        product_api = API::Resource.new(RESOURCE_PATH)
-
-        tokens = package_key.to_s.split('/')
-        lang = Package.encode_language(tokens.first).capitalize #endpoint bug
-
-        safe_prod_key = Package.encode_prod_key(tokens.drop(1).join("/"))
-        validate_input!(lang, safe_prod_key)
-
-        api_path = "/#{lang}/#{safe_prod_key}/references"
-        page_nr = options[:page] || "1"
-        qparams = {params: {page: page_nr}}
-        results = nil
-
-        product_api.resource[api_path].get(qparams) do |response, request, result, &block|
-          results = API::JSONResponse.new(request, result, response)
+        prod_key, lang = Package.parse_key(package_key)
+        results = Veye::API::Package.get_references(
+          prod_key, lang, options[:page]
+        )
+        if valid_response?(results, "No references for: `#{package_key}`")
+          paging = results.data['paging']
+          show_results(@output_formats, results.data, options, paging)
         end
-
-        catch_request_error(results, "No references for: `#{package_key}`")
-        show_results(@@output_formats, results.data, options, results.data['paging'])
-        return results
-
       end
     end
   end
 end
-

data/lib/veye/package/search.rb

@@ -3,36 +3,26 @@ require_relative '../base_executor.rb'
 
 module Veye
   module Package
+    # This class includes commands for Package search and
+    # presentation renderers.
     class Search < BaseExecutor
-      @@output_formats = {
-          'csv'       => Package::SearchCSV.new,
-          'json'      => Package::SearchJSON.new,
-          'pretty'    => Package::SearchPretty.new,
-          'table'     => Package::SearchTable.new
+      @output_formats = {
+        'csv'       => Package::SearchCSV.new,
+        'json'      => Package::SearchJSON.new,
+        'pretty'    => Package::SearchPretty.new,
+        'table'     => Package::SearchTable.new
       }
 
       def self.search(search_term, options)
-        search_api = Veye::API::Resource.new "#{RESOURCE_PATH}/search"
-        language = options[:language]
-        group_id = options["group-id"]
-        page = options[:page] || "1"
-        results = nil
-        search_params = {:q => search_term.to_s}
-
-        search_params[:lang] = Package.encode_language(language) unless language.nil?
-        search_params[:g] = group_id unless group_id.nil?
-        search_params[:page] = page unless page.nil?
-
-        request_params = {:params => search_params}
-        search_api.resource["/#{search_term}"].get(request_params) do |response, request, result, &block|
-          results = API::JSONResponse.new(request, result, response)
+        results = Veye::API::Package.search(
+          search_term, options[:language], options['group-id'], options[:page]
+        )
+        if valid_response?(results, "No results for `#{search_term}`")
+          show_results(@output_formats,
+                       results.data, options,
+                       results.data['paging'])
         end
-
-        catch_request_error(results, "No results for `${search_term}`")
-        show_results(@@output_formats, results.data, options, results.data['paging'])
-        return results
       end
     end
-
   end
 end

data/lib/veye/package.rb

@@ -12,13 +12,21 @@ module Veye
       Set.new ["Clojure", "Java", "Javascript", "Node.JS", "PHP", "Python", "Ruby", "R"]
     end
 
-    def self.encode_prod_key(prod_key)
-      prod_key = prod_key.to_s
-      prod_key.gsub(/\//, ":").gsub(/\./, "~")
-    end
+    def self.parse_key(package_key)
+      tokens = package_key.to_s.split('/')
+      lang = tokens.first
+      prod_key = tokens.drop(1).join("/")
+
+      if lang.nil? or prod_key.nil?
+        msg =  %Q[
+          You missed language or product key.
+          Example: clojure/ztellman/aleph, as structured <prog lang>/<product_code>
+        ]
+        printf("%s. \n%s", "Error: Malformed key.".color(:red), msg)
+        exit
+      end
 
-    def self.encode_language(lang)
-      lang.gsub(/\./, "").downcase
+      [prod_key, lang]
     end
   end
 end

data/lib/veye/pagination.rb

@@ -1,6 +1,8 @@
 require_relative 'pagination/show.rb'
 
 module Veye
+  # Pagination module includes rendering methods to render
+  # pagination information
   module Pagination
     #add module constants here
   end

data/lib/veye/project/check.rb

@@ -3,146 +3,69 @@ require_relative '../base_executor.rb'
 
 module Veye
   module Project
+    # Check class includes methods to check and upload project files
     class Check < BaseExecutor
       extend FormatHelpers
 
-      @@output_formats = {
-        "csv"       => Project::InfoCSV.new,
-        "json"      => Project::InfoJSON.new,
-        "pretty"    => Project::InfoPretty.new,
-        "table"     => Project::InfoTable.new,
-        "md"        => Project::InfoMarkdown.new
+      @output_formats = {
+        'csv'       => Project::InfoCSV.new,
+        'json'      => Project::InfoJSON.new,
+        'pretty'    => Project::InfoPretty.new,
+        'table'     => Project::InfoTable.new,
+        'md'        => Project::InfoMarkdown.new
       }
 
-      @@dependency_output_formats = {
-        "csv"       => Project::DependencyCSV.new,
-        "json"      => Project::DependencyJSON.new,
-        "pretty"    => Project::DependencyPretty.new,
-        "table"     => Project::DependencyTable.new,
-        "md"        => Project::DependencyMarkdown.new
+      @dependency_output_formats = {
+        'csv'       => Project::DependencyCSV.new,
+        'json'      => Project::DependencyJSON.new,
+        'pretty'    => Project::DependencyPretty.new,
+        'table'     => Project::DependencyTable.new,
+        'md'        => Project::DependencyMarkdown.new
       }
 
       def self.get_list(api_key, options)
-        project_api = API::Resource.new(RESOURCE_PATH)
-        qparams = {:params => {:api_key => api_key}}
-        results = nil
-        project_api.resource.get(qparams) do |response, request, result|
-          results = API::JSONResponse.new(request, result, response)
-        end
-
-        catch_request_error(results, "Can not read list of projects.")
-        show_results(@@output_formats, results.data, options)
-        results
+        results = Veye::API::Project.get_list(api_key)
+        catch_request_error(results, 'Can not read list of projects.')
+        show_results(@output_formats, results.data, options)
       end
 
       def self.upload(filename, api_key, options)
-        results = {:success => false}
-        file_path = File.absolute_path(filename)
-
-        unless File.exists?(file_path)
-          error_msg = sprintf("%s: Cant read file `%s`",
-                              "Error".color(:red),
-                              "#{filename}".color(:yellow))
-          exit_now!(error_msg)
-        end
-
-        file_size = File.size(file_path)
-        unless file_size != 0 and file_size < MAX_FILE_SIZE
-          exit_now!("Size of file is not acceptable: 0kb < x <= #{MAX_FILE_SIZE/1000}kb")
-        end
-
-        project_api = API::Resource.new(RESOURCE_PATH)
-        puts "built new project_api successfully"
-
-        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|
-          results = API::JSONResponse.new(request, result, response)
-        end
-
-        catch_request_error(results, "Upload failed.")
-        show_results(@@output_formats, results.data, options)
+        results = Veye::API::Project.upload(api_key, filename)
+        catch_request_error(results, 'Upload failed.')
+        show_results(@output_formats, results.data, options)
         show_dependencies(results.data, options)
-        results
       end
 
       def self.update(project_key, filename, api_key, options)
-        results = {:success => false}
-        file_path = File.absolute_path(filename)
-
-        unless File.exists?(file_path)
-          error_msg = sprintf("%s: Cant read file `%s`",
-                              "Error".color(:red),
-                              "#{filename}".color(:yellow)
-                             )
-          exit_now!(error_msg)
-        end
-
-        file_size = File.size(file_path)
-        unless file_size != 0 and file_size < MAX_FILE_SIZE
-          exit_now!(" The size of file is not acceptable: 0kb < x <= #{MAX_FILE_SIZE/1000}kb")
-        end
-
-        project_api = API::Resource.new("#{RESOURCE_PATH}/#{project_key}")
-        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|
-          results = API::JSONResponse.new(request, result, response)
-        end
-        catch_request_error(results, "Re-upload failed.")
-        show_results(@@output_formats, results.data, options)
+        results = Veye::API::Project.update(api_key, project_key, filename)
+        catch_request_error(results, 'Re-upload failed.')
+        show_results(@output_formats, results.data, options)
         show_dependencies(results.data, options)
-        results
       end
-      def self.get_project(project_key, api_key, options)
-        results = nil
-        project_api = API::Resource.new(RESOURCE_PATH)
-
-        if project_key.nil? or project_key.empty?
-          error_msg = sprintf("%s: %s",
-                             "Error".color(:red),
-                             "Not valid project_key: `#{project_key}`")
-          exit_now! error_msg
-        end
-
-        project_url = "/#{project_key}"
-        qparams = {:params => {:api_key => api_key}}
-        project_api.resource[project_url].get(qparams) do |response, request, result|
-          results = API::JSONResponse.new(request, result, response)
-        end
 
-        catch_request_error(results, "Cant read information about project: `#{project_key}`")
-        show_results(@@output_formats, results.data, options)
+      def self.get_project(project_key, api_key, options)
+        results = Veye::API::Project.get_project(api_key, project_key)
+        err_msg = "No data for the project: `#{project_key}`"
+        catch_request_error(results, err_msg)
+        show_results(@output_formats, results.data, options)
         show_dependencies(results.data, options)
-        results
       end
 
       def self.delete_project(project_key, api_key)
-        project_api = Veye::API::Resource.new(RESOURCE_PATH)
-        qparams = {:params => {:api_key => api_key}}
-        results = nil
-
-        project_api.resource["/#{project_key}"].delete(qparams) do |response, request, result|
-          results = API::JSONResponse.new(request, result, response)
-        end
-        catch_request_error(results, "Cant delete project: `#{project_key}`")
-        show_message(results, "Deleted", "Cant delete.")
-        results
+        results = Veye::API::Project.delete_project(api_key, project_key)
+        err_msg = "Failed to delete project: `#{project_key}`"
+        catch_request_error(results, err_msg)
+        show_message(results, 'Deleted', 'Cant delete.')
       end
 
+      #-- layout helpers
       def self.show_dependencies(results, options)
         format = options[:format]
+        format ||= 'pretty'
         return if format == 'json'
-        self.supported_format?(@@dependency_output_formats, format)
+        self.supported_format?(@dependency_output_formats, format)
 
-        formatter = @@dependency_output_formats[format]
+        formatter = @dependency_output_formats[format]
 
         formatter.before
         formatter.format results['dependencies']
@@ -150,15 +73,14 @@ module Veye
       end
 
       def self.show_message(results, success_msg, fail_msg)
-        unless results.success
+        if results.success
+          printf "#{success_msg}\n".color(:green)
+        else
           printf("Error: %s\n%s\n",
-                 fail_message.color(:red),
+                 fail_msg.color(:red),
                  response.data['error'])
-        else
-          printf "#{success_msg}\n".color(:green)
         end
       end
     end
   end
 end
-

data/lib/veye/project/license.rb

@@ -0,0 +1,23 @@
+require_relative '../views/project.rb'
+require_relative '../base_executor.rb'
+
+module Veye
+  module Project
+    # Licence class holds commands for checking licenses in the project.
+    class License < BaseExecutor
+      @output_formats = {
+        'csv'     => Project::LicenceCSV.new,
+        'json'    => Project::LicenceJSON.new,
+        'pretty'  => Project::LicencePretty.new,
+        'table'   => Project::LicenceTable.new
+      }
+
+      def self.get_licenses(project_key, api_key, options)
+        results = Veye::API::Project.get_licenses(api_key, project_key)
+        err_msg = "Cant access a information for project `#{project_key}`."
+        catch_request_error(results, err_msg)
+        show_results(@output_formats, results.data, options)
+      end
+    end
+  end
+end

data/lib/veye/project.rb

@@ -1,9 +1,10 @@
 require_relative 'project/check.rb'
-require_relative 'project/licence.rb'
+require_relative 'project/license.rb'
 
 module Veye
+  # Project module includes commands for managing
+  # projects on VersionEye and presenting results
+  # on command line.
   module Project
-    RESOURCE_PATH = "/projects"
-    MAX_FILE_SIZE = 500000 # ~ 500kB
   end
 end