codercmp 0.9.7

data/lib/codercompanion/java/java_parser.rb

@@ -0,0 +1,62 @@
+require_relative 'java'
+module CoderCompanion
+    module Java
+        class JavaParser < CoderCompanion::LanguageParser
+            
+            JAVA_EXTENSIONS     = ['.java']
+           
+            def initialize
+                Treetop.load(File.join(File.dirname(__FILE__), 'java_grammar'))
+                @parser = CoderCompanion::JavaParser.new
+                @tree_walker = CoderCompanion::Java::JavaTreeWalker.new
+            end
+
+            def parse(files)
+                results = []
+                files.each do |file|
+                    results << parse_file(file)
+                end
+                return results
+            end
+
+            def parse_file(file)
+                CoderCompanion::j_print_inline CoderCompanion::success_format '.'
+                data = File.open(file).read
+                tree = @parser.parse(data)
+                
+                if tree
+                    #puts tree.inspect
+                end
+                
+                # If the AST is nil then there was an error during parsing
+                # we need to report a simple error message to help the user
+                # if(tree.nil?)
+                #   raise Exception, "Parse error at offset: #{@@parser.index}"
+                # end
+
+                if !tree
+                  #puts @parser.terminal_failures
+                  error_string = "\nParse error"
+                  error_string += "\nExpected: #{(@parser.terminal_failures.collect {|f| f.expected_string}).join(", ")}"
+                  error_string += "\nwhile parsing file: #{file}"
+                  error_string += "\nat line #{@parser.failure_line}"
+                  error_string += "\nat column #{@parser.failure_column}"
+                  error_string += "\nIf your code is compilable, report a bug at:"
+                  error_string += "\nhttp://codercompanion.com/contact"
+                  raise CoderCompanion::CoderCompanionException, error_string
+                end
+                
+                ast = self.build_tree(tree)
+                {:type => 'source', :body => ast, :file_path => file}
+            end
+
+            def is_valid_file(ext)
+                return JAVA_EXTENSIONS.include?(ext)
+            end
+            
+            def build_tree(root_node)
+                root_node.build
+            end
+        end
+    end
+end

data/lib/codercompanion/java/java_tree_walker.rb

@@ -0,0 +1,114 @@
+module CoderCompanion
+    module Java
+        class JavaTreeWalker < CoderCompanion::TreeWalker
+            def is_array_or_list(string)
+                ret = ""
+                if string.match(/(?<=<)([\w]+)(?=>)/) 
+                    ret = string.match(/(?<=<)([\w]+)(?=>)/)[0]
+                elsif string.match(/([\w]+)(?=\[\]\[\])/)
+                    ret = string.match(/([\w]+)(?=\[\]\[\])/)[0]
+                elsif string.match(/([\w]+)(?=\[\])/ ) 
+                    ret = string.match(/([\w]+)(?=\[\])/ )[0]
+                else
+                    ret = remove_generics(string)
+                end
+                ret
+            end
+
+            def remove_generics(value)
+                loop do 
+                    has_generics = value.match(/[<>]/)
+                    if has_generics
+                        value = value.gsub(/(<[^<>]*>)/, '')
+                    else
+                        break
+                    end
+                end
+                return value
+            end
+
+            def create_uploadable(results)
+                obj = {}
+                results.each do |source|
+                    cache_handler = CoderCompanion.cache_handler
+                    modified = cache_handler.is_file_modified?(source[:file_path])
+                    cache_handler.update_cache_path(source[:file_path])
+                    source[:body].each do |element|
+                        if (element[:type] == "class_definition" || element[:type] == "enum_definition" || element[:type] == "interface_definition")
+                            obj[element[:value]] = create_class_obj(element, element[:value], obj, modified)
+                            obj[element[:value]][:modified] = modified
+                        end
+                    end
+                end
+                return obj
+            end
+
+            
+
+            def create_class_obj(param, name_of_class, obj, modified)
+                class_object = {}
+                if param[:inherits_from] != ""
+                    class_object[:inheritsfrom] = [param[:inherits_from]]
+                end
+                if param[:implements] && param[:implements].length > 0
+                    class_object[:implements] = param[:implements]
+                end
+                method_list = []
+                variable_list = []
+                constant_list = []
+                hasa = []
+                ownsa = []
+                associatedto = []
+                enum_constants = []
+                class_type = nil
+                if param[:type]
+                    class_type = param[:type].gsub(/_definition/, '')     
+                end 
+                param[:class_elements].each do |class_el|
+                    case class_el[:type]
+                    when "enum_constant"
+                        variable_list << class_el[:value]
+                    when "method_definition"
+                        method_list << class_el[:value] + ":" + class_el[:return_type]
+                        if class_el[:params].count > 0
+                            class_el[:params].each do |p|
+                                param_type = is_array_or_list(p[:type])
+                                if !hasa.index(param_type) && !associatedto.index(param_type)
+                                    associatedto << param_type
+                                end
+                            end
+                        end
+                    when "variable_definition"
+                        return_type = is_array_or_list(class_el[:return_type])
+                        variable_type = class_el[:variable_type]
+                        variable_string = class_el[:value] + ":" + class_el[:return_type]
+                        if variable_type.match(/constant/)
+                            constant_list << variable_string 
+                        else  
+                            variable_list <<  variable_string
+                        end
+                        generic_less = remove_generics(return_type)
+                        hasa << generic_less if !hasa.index(generic_less)
+                        associatedto - [generic_less] if associatedto.index(generic_less)
+
+                    when "class_definition", "enum_definition", "interface_definition"
+                        name = name_of_class + "::" + class_el[:value]
+                        ownsa << name
+                        associatedto - [name] if associatedto.index(name)
+                        obj[name] = create_class_obj(class_el, name, obj, modified) 
+                        obj[name][:modified] = modified
+                    end
+                end
+                class_object[:classname] = name_of_class
+                class_object[:variables] = variable_list
+                class_object[:methods] = method_list
+                class_object[:constants] = constant_list
+                class_object[:hasa] = hasa if hasa.count > 0
+                class_object[:ownsa] = ownsa if ownsa.count > 0
+                class_object[:isassociatedto] = associatedto if associatedto.count > 0
+                class_object[:classtype] = class_type unless class_type.nil?
+                return {:classobject => class_object}
+            end 
+        end
+    end
+end

data/lib/codercompanion/language_parser.rb

@@ -0,0 +1,54 @@
+module CoderCompanion
+    class LanguageParser
+
+        # @return [TreeWalker]
+        attr_reader :tree_walker
+
+        # Parses and creates the json that will be uploaded
+        # @param [String] dir_name
+        # @return [Hash]
+        def create_project_json(dir_name)
+            files = get_parseable_files(dir_name)
+            CoderCompanion::j_print CoderCompanion::notification_format("Parsing files...")
+            results = parse(files)
+            CoderCompanion::j_print CoderCompanion::success_format("\nSuccessfully parsed source code")
+            tree_walker.create_uploadable(results)
+        end
+
+        # Parse the files 
+        # @param [Array<String>] files
+        def parse(files)
+            raise NotImplementedError, "#{self.class}: 'parse' must be overridden"
+        end
+    
+        private
+
+        # @param [String] dir_name
+        # @return [Array<String>]       
+        def get_parseable_files(dir_name)
+            files = construct_array(dir_name, [])
+            return files
+        end
+
+        def construct_array(dir_name, res_arr)
+            Dir.foreach(dir_name) do |item|
+                next if item == '.' or item == '..'
+                path = File.join(dir_name, item).gsub(/^(\.\/)?/, '') # Remove the leading ./ in the file name
+                next if CoderCompanion.excluded.include?(path)
+                if File.directory?(path)
+                    construct_array(path, res_arr)
+                else
+                    if(is_valid_file(File.extname(path) ) )
+                        CoderCompanion::j_print CoderCompanion::notification_format("Queued for parsing: #{path}")
+                        res_arr << path
+                    end
+                end
+            end
+            return res_arr
+        end
+            
+        def is_valid_file(ext)
+            raise NotImplementedError, "#{self.class}: 'is_valid_file' must be overridden"
+        end
+    end
+end

data/lib/codercompanion/languages.rb

@@ -0,0 +1,23 @@
+module CoderCompanion
+    module Languages
+        JAVA    = {key: 'Java', annotation_required: false}
+        RUBY    = {key: 'Ruby', annotation_required: true,  valid_annotation: [CoderCompanion::Ruby::RubyAnnotations::YARD]}
+        CPP     = {key: 'C++',  annotation_required: false}
+
+        class << self
+            # Returns the supported languages
+            # @return [Array<Hash>]
+            def supported_languages
+                [JAVA, RUBY] #update this when we support other languages
+            end
+
+            # Tells us if a specific language is supported
+            # @param [String] language the language to check
+            # @return [Boolean]
+            def is_supported?(language)
+                supported_languages.each {|lang| return true if lang[:key] == language}
+                false
+            end
+        end
+    end
+end

data/lib/codercompanion/parser_factory.rb

@@ -0,0 +1,27 @@
+module CoderCompanion
+    class ParserFactory
+
+        private_class_method :new
+
+        # @param [String] language
+        # @return [CoderCompanion::LanguageParser]
+        def self.get_parser(language)
+            case(language)
+            when Languages::RUBY[:key]
+                return CoderCompanion::Ruby::RubyParser.new 
+=begin #Uncomment when we add c++ and java
+            when Languages::CPP[:key]
+                return CoderCompanion::Cpp::CppParser.new
+=end
+            when Languages::JAVA[:key]
+                return CoderCompanion::Java::JavaParser.new
+            else
+                message = CoderCompanion::error_format("The language (#{language}) specified in your config file is either" + 
+                                    " invalid or currently not supported. To see a list of supported languages run: codercmp --language\n") +
+                                    CoderCompanion::error_format("More information at: ") +
+                                    CoderCompanion::error_url_format("http://codercompanion.com/#/how-it-works")
+                raise CoderCompanionException.new message
+            end
+        end
+    end
+end

data/lib/codercompanion/ruby/ruby_annotations.rb

@@ -0,0 +1,8 @@
+module CoderCompanion
+    module Ruby
+        module RubyAnnotations
+            YARD = "Yard"
+            RDOC = "RDoc"
+        end
+    end
+end

data/lib/codercompanion/ruby/ruby_parser.rb

@@ -0,0 +1,45 @@
+require 'byebug'
+require 'rdoc/rdoc'
+module CoderCompanion
+    module Ruby
+        class RubyParser < LanguageParser
+           
+            # @return [Array<String>] 
+            RUBY_EXTENSTIONS    = ['.rb']
+          
+            def initialize
+                @tree_walker = CoderCompanion::Ruby::RubyTreeWalker.new
+            end
+            
+            # @param [Array<String>] files
+            # @return [Array<Hash>]
+            def parse(files)
+                # initialize rdoc if we are parsing with it
+                results = []
+                files.each do |file|
+                    results << parse_file(file)
+                end
+                return results
+            end
+
+            private
+
+            # Checks if the file with extension is valid for parsing
+            #
+            # @param [String] ext
+            # @return [Boolean]
+            def is_valid_file(ext)
+                return RUBY_EXTENSTIONS.include?(ext)
+            end
+
+            # @param [String] file
+            # @return [Hash]
+            def parse_file(file)
+                YARD::Registry.clear
+                YARD.parse(file)
+                results = YARD::Registry.all(:root, :module, :class, :method, :classvariable)
+                {:type => 'source', :body => results, :file_path => file}
+            end
+        end
+    end
+end

data/lib/codercompanion/ruby/ruby_tree_walker.rb

@@ -0,0 +1,229 @@
+module CoderCompanion
+    module Ruby
+        class RubyTreeWalker < CoderCompanion::TreeWalker
+            
+            # @param [Array<Hash>] results
+            # @return [Hash] 
+            def create_uploadable(results)
+                return build(results) 
+            end
+            
+            # @param results [Array<Hash>] the results from parsing the code
+            # @return [Hash]
+            def build(results)
+                obj = {}
+                results.each do |source|
+                    cache_handler = CoderCompanion.cache_handler
+                    modified = cache_handler.is_file_modified?(source[:file_path])
+                    cache_handler.update_cache_path(source[:file_path])
+
+                    if source[:body][0].root?
+                        source[:body][0].children.each do |child|
+
+                            # puts child
+                            if (child.type == :class || child.type == :module)
+                                child_name = child.path
+                                obj[child_name] = build_class_or_module(child, modified, obj)
+                            end
+                        end
+                    end
+                    # puts res
+
+                end
+
+                post_process_object(obj)
+                #ap obj
+                return obj
+            end
+            
+            
+            private
+
+            # For all inherited update with the fully qualified namespace
+            # @param [Hash] object
+            # @return [nil]
+            def post_process_object(object)
+                object.each do |outer_key, outer_value|
+                    class_object = outer_value[:classobject]
+                    post_process_class_attribute :inheritsfrom, object, outer_key, outer_value, class_object
+                    post_process_class_attribute :hasa, object, outer_key, outer_value, class_object
+                    post_process_class_attribute :isassociatedto, object, outer_key, outer_value, class_object
+                end
+            end
+            
+            # @param attrib [Symbol] The attribute to post process e.g. inheritsfrom, hasa, etc
+            def post_process_class_attribute attrib, object, outer_key, outer_value, class_object
+                index = 0
+                class_object[attrib].each do |entry|
+
+                    # Keep track of the best fit for inheritance
+                    most_likely_match = nil
+                    max = -1
+                    object.each do |inner_key, inner_value|
+                        if inner_key.match(/::#{entry}$/)
+                            new_num = compare_namespaces outer_key, inner_key
+                            
+                            # If the new comparison has more matches than the previous
+                            # it becaomes the new most_likely_match
+                            if new_num > max
+                                max = new_num
+                                most_likely_match = inner_key
+                            end
+                        end
+                    end
+
+                    class_object[attrib][index] = most_likely_match if most_likely_match
+                    index += 1
+                end
+                
+            end
+
+            # Compares an namespaces to determine to correct match for the inheritance
+            #
+            # @param [String] subclass
+            # @param [String] parentclass
+            # @return [Number]
+            def compare_namespaces subclass, parentclass
+                subclass_namespace = subclass.split('::')
+                parentclass_namespace = parentclass.split('::')
+
+                count = 0
+                index = 0
+                subclass_namespace.each do |section|
+                    count += 1 if section == parentclass_namespace[index]
+                    index += 1
+                end
+
+                return count
+            end
+
+            def build_class_or_module(object, modified, ret_obj)
+                ret = ret_obj[object.path] ? ret_obj[object.path][:classobject] : {}
+                method_list = ret.count > 0 ? ret[:methods] : []
+                variable_list = ret.count > 0 ? ret[:variables] : []
+                constant_list = ret.count > 0 ? ret[:constants] : []
+                hasa = ret.count > 0 ? ret[:hasa] : []
+                ownsa = ret.count > 0 ? ret[:ownsa] : []
+                isassociatedto = ret.count > 0 ? ret[:isassociatedto] : []
+                inherits_from = ret.count > 0 ? ret[:inheritsfrom] : []
+                class_type = ret.count > 0 ? ret[:classtype] : object.type
+
+                i = 0;
+
+                object.inheritance_tree.each do |obj|
+                    inherits_from << obj.path.to_s if i != 0
+                    i += 1
+                end
+
+                object.instance_attributes.each do |key, val| 
+                    # puts key
+                    type = '*'
+                    type = val[:read].tag('return').type.to_s if val[:read] && val[:read].tag('return')
+                    type = val[:write].tag('return').type.to_s if val[:write] && val[:write].tag('return')
+                    variable_list << key.to_s + ' : ' + type
+
+                    hasa << type
+                end
+
+                object.cvars.each do |cvar|
+                    return_type = cvar.tag('return') ? ' : ' + cvar.tag('return').type.to_s : ''
+                    variable_list << cvar.name.to_s.gsub(/@@/, '') + return_type
+                end
+
+                object.constants.each do |constant|
+                    return_type = constant.tag('return') ? ' : ' + constant.tag("return").type.to_s : ''
+                    constant_list << constant.name.to_s + return_type
+                end
+
+                object.children.each do |child|
+                    case child.type
+                    when :method
+                        is_instance_attr = false
+                        is_getter = true
+                        method_name = child.name
+                        params = ''
+                        first_param = true
+                        return_type = '*'
+                        object.instance_attributes.each do |key, value|
+                            # if value[:read] =~ method_name.to_s.gsub('=', '')
+                            #   puts value[:read]
+                            # end
+                            if value[:read]
+                                if value[:read].name.to_s == method_name.to_s
+                                    is_instance_attr = true
+                                    is_getter = true
+                                    break
+                                end
+                            end
+                            if value[:write]
+                                if value[:write].name.to_s == method_name.to_s
+                                    is_instance_attr = true
+                                    is_getter = false
+                                    break
+                                end
+                            end
+                        end
+                        parameter_array = child.parameters
+                        parameter_array.each do |par|
+                            param_name = par[0]
+                            type = '*'
+                            
+                            child.tags('param').each do |str|
+                                type = str.types[0] if str.name == param_name && str.types
+                                if type != '*'
+                                    isassociatedto << type if !isassociatedto.index(type) && !ownsa.index(type) && !hasa.index(type)
+                                    break
+                                end
+                            end
+
+                            if first_param
+                                first_param = false
+                            else
+                                params += ', '
+                            end
+                            params += type + ' ' if type
+                            params += param_name
+                            
+                        end
+                       
+                        # If there is a return type return the types concat'ed by | (ruby doesn't restrict your return type) 
+                        if child.tag('return') && child.tag('return').types
+                            return_type = child.tag('return') ? child.tag('return').types.join(" | ") : return_type
+                        end
+
+                        if is_instance_attr && is_getter
+                            method_list << child.name.to_s + '() : ' +  return_type
+                        elsif is_instance_attr && !is_getter
+                            param_name = child.parameters[0][0]
+                            method_list << child.name.to_s + '(' + return_type + ' ' + param_name + ') : nil'
+
+                            isassociatedto.splice(isassociatedto.index(return_type)) if isassociatedto.index(return_type)
+                            hasa << return_type if !ownsa.index(return_type)
+                        else
+                            method_list << child.name.to_s + '(' + params + ') : ' + return_type
+                        end
+                    
+                    when :class, :module
+                        # puts 'here'
+                        child_name = child.path
+
+                        hasa.splice(hasa.index(child_name)) if hasa.index(child_name)
+                        isassociatedto.splice(isassociatedto.index(child_name)) if isassociatedto.index(child_name)
+                        ownsa << child_name
+                        ret_obj[child_name] = build_class_or_module(child, modified, ret_obj)
+                    end
+                end
+                ret[:classname] = object.path
+                ret[:inheritsfrom] = inherits_from
+                ret[:methods] = method_list
+                ret[:variables] = variable_list
+                ret[:constants] = constant_list
+                ret[:isassociatedto] = isassociatedto
+                ret[:hasa] = hasa
+                ret[:ownsa] = ownsa
+                ret[:classtype] = class_type
+                return {:classobject => ret, :modified => modified}
+            end
+        end
+    end
+end

data/lib/codercompanion/s3_client.rb

@@ -0,0 +1,32 @@
+module CoderCompanion
+    class S3Client
+
+        # @return [Aws::S3::Client]
+        attr_reader :client 
+
+        # @return [Aws::S3::Resource]
+        attr_reader :resource 
+
+        # @return [String]
+        attr_reader :s3_bucket
+
+        def initialize params
+            @client = Aws::S3::Client.new(
+                :access_key_id => params[:access_key_id],
+                :secret_access_key => params[:secret_access_key],
+                :session_token  => params[:session_token],
+                :region => params[:region]
+            )
+            @resource = Aws::S3::Resource.new(client: @client)
+            @s3_bucket = params[:s3_bucket]
+        end
+
+        # @param local_file_path [String]
+        def put_object local_file_path, key
+            path =  File.expand_path(local_file_path)
+            obj = resource.bucket(s3_bucket).object(key)
+            response = obj.upload_file(path, { server_side_encryption: "AES256"})
+            return response
+        end
+    end
+end

data/lib/codercompanion/tree_walker.rb

@@ -0,0 +1,8 @@
+module CoderCompanion
+    class TreeWalker
+        # @param [Array<Hash>] results The result hash to be converted into an uploadeable
+        def create_uploadable(results)
+            raise NotImplementedError, "#{self.class}: 'create_uploadable' must be overriden"
+        end
+    end
+end