codercmp 0.9.7

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f7eb5cfcf5bedbc117d1fd4f9f4d0c4283abf372
+  data.tar.gz: 590499c02a93be6bc554b245876fd728789b9506
+SHA512:
+  metadata.gz: 898f86b675cb21ed3cdba632f0d7978cc36f9d2ad52f3ea8d695badf9db9646537ee0ee60c5be27c6baf080fba33f1d3d4784523f73407e9ecbfc512c6bdaa32
+  data.tar.gz: 39b2dc40462b7fba5c0d673d314250ac4e6f46131e8a06376d601a71f3af093cfedc667cf7ad2419c0252d6c0cb37b95ea54446012aea4fbebcface0d832c7a9

data/bin/codercmp

@@ -0,0 +1,101 @@
+#!/usr/bin/env ruby
+lib_dir = File.join(File.dirname(__FILE__), '..', 'lib')
+$LOAD_PATH.unshift lib_dir if File.directory?(lib_dir)
+
+require 'codercompanion.rb'
+require 'codercompanion_version.rb'
+require "optparse"
+
+options = {}
+location = "." # Default to the current directory
+exclude = []
+test = false
+
+option_parser = OptionParser.new do |opts|
+    opts.banner = <<INFO
+     
+Usage: 
+    #{File.basename($PROGRAM_NAME)} [OPTIONS]   # See OPTIONS for the options available 
+
+Examples:
+    #{File.basename($PROGRAM_NAME)}                         # Run codercmp. Looks for codercmp.conf file in current working directory. 
+                                       Parses all eligible files in working directory tree
+    #{File.basename($PROGRAM_NAME)} -c FILE -d DIR          # Uses a specified configuration file [must end in .conf] and a directory 
+                                       to parse files e.g.: 'path_to/lib' 
+    #{File.basename($PROGRAM_NAME)} -x GLOB                 # Specifies a directory or file pattern to exclude.
+                                       where 'GLOB' could be a file, directory or pattern e.g. '-x vendor/bundle/**/*.rb'
+    #{File.basename($PROGRAM_NAME)} -x 'GLOB GLOB'          # Specify multiple file patterns or directories to exclude.   
+
+INFO
+    
+    opts.separator ""
+    opts.separator "OPTIONS:"
+
+    opts.on( "--directory DIRECTORY", "-d DIRECTORY", "Directory to find parsable files. The default is the current working directory.") do |directory|
+        location = directory
+    end
+
+    opts.on( "--config-file FILE", "-c FILE", "Configuration file to use; must end in '*.conf'. By default codercmp will look for 'codercmp.conf' in the current directory.") do |config|
+        correct_extension = config.match(/.*\.conf$/)
+        if !correct_extension
+            CoderCompanion::j_print CoderCompanion::error_format("The configuration file must end in .conf")
+            exit 1
+        end
+        options[:config_file] = config
+    end
+
+    opts.on( "--fresh", "-f" , "Delete caches and run a fresh pass on the source code.") do
+        options[:fresh_run] = true
+    end
+
+    opts.on( "--silent", "-s" , "Run codercmp without printing messages") do
+        options[:silent_run] = true
+    end
+
+    opts.on( "--[no-]color", "By default codercmp will show color. Specifiy --no-color to disable the color.") do |val|
+        options[:no_color] = !val
+    end
+
+    opts.on( "--show-output", "-o", "Display the output after parsing the project") do
+        options[:show_output] = true
+    end 
+    
+    opts.on( "--dry-run", "Performs dry run. Does not actually upload data. The purpose of this command is to test the parsing of your files. " +
+                "Becomes even more useful when used with --show-output to see the result of the parse") do
+        options[:dry_run] = true
+    end
+
+    opts.on( "--exclude FILES", "-x FILES", "This is to used to exclude files. Specify a list of files seperated by a space (wrapped in \" quotations).") do |files|
+        multiple_files = files.split(/\s+/)
+        multiple_files.each do |file|
+            exclude += Dir.glob(file.gsub(/\/$/, '')) 
+        end
+    end
+
+    opts.on( "--languages", "-l", "Get the supported languages") do
+        CoderCompanion.display_supported_languages
+        exit 0
+    end
+
+    opts.separator "Common Options:"
+    
+    opts.on( "-h", "--help", "Show this message." ) do
+        puts opts
+        exit 0
+    end
+
+    opts.on( "--version", "-v", "Find out the version of codercmp you are running") do
+        puts CoderCompanion::VERSION
+        exit 0
+    end
+end
+
+option_parser.parse!
+
+options[:exclude] = exclude
+begin
+    CoderCompanion::start(options, location)
+rescue CoderCompanion::CoderCompanionException => e
+    CoderCompanion::j_print CoderCompanion::error_format(e.message)
+    exit 1
+end

data/lib/codercompanion/api.rb

@@ -0,0 +1,47 @@
+module CoderCompanion
+    class API
+        def initialize()
+            # puts CoderCompanion::config
+        end
+
+        def upload(file)
+            response = nil
+            begin
+                response = RestClient.post(CoderCompanion::config["host"] + '/update_project.json', :myfile => File.new(file),# /Users/oseghale/Projects/JinglePage/JingleParser/test_upload.jingle'), 
+                                            :access_key => CoderCompanion::config["project"]["access_key"], :access_id => CoderCompanion::config["user"]["access_id"]) { |response, request, result, &block|
+                    return response.code || nil 
+                }
+            rescue
+                return CoderCompanion::GENERIC_ERROR
+                
+            end
+            
+        end
+
+        def get_temporary_access_key
+            begin 
+                RestClient.post("#{CoderCompanion::config["host"]}/project/get_temporary_access_key.json", 
+                            :access_key => CoderCompanion::config["project"]["access_key"], 
+                            :access_id => CoderCompanion::config["user"]["access_id"]) { |response, request, result, &block|
+                    return (response.code == CoderCompanion::STATUS_OK) ? response : nil
+                }
+            rescue
+                return nil
+            end
+        end
+
+        def notify_s3_upload(key)
+            begin 
+                RestClient.post("#{CoderCompanion::config["host"]}/project/notify_project_upload.json", 
+                            :s3_key => key,
+                            :access_key => CoderCompanion::config["project"]["access_key"], 
+                            :access_id => CoderCompanion::config["user"]["access_id"]) { |response, request, result, &block|
+                    return (response.code == CoderCompanion::STATUS_OK) ? response : nil
+                }
+            rescue
+                return nil
+            end
+
+        end
+    end
+end

data/lib/codercompanion/cachehandler.rb

@@ -0,0 +1,94 @@
+module CoderCompanion
+    class CacheHandler
+        CACHE_DIR = './codercompanion_cache_data'
+        
+        # @return [Object]
+        attr_accessor :file_cache
+       
+        def initialize
+            @file_cache = {}
+        end
+         
+        # @return [File, nil]
+        def open_cache
+            file = nil
+            begin
+                file = File.open(CACHE_DIR + '/cache.data')
+            rescue
+                CoderCompanion::warning_format("Could not find cache")
+            end
+            file
+        end
+
+        # @param fresh_run [Boolean] should we use cache for this run?
+        def load_cache(fresh_run)
+            if !CoderCompanion.dry_run?
+                if fresh_run
+                    delete_cache
+                else
+                    find_cache    
+                end
+            end
+        end
+
+        # @param [String] file_path
+        # @return [Boolean]
+        def is_file_modified?(file_path)
+            cache = encrypt(File.open(file_path).read)
+            if self.file_cache && self.file_cache[ file_path ] && (self.file_cache[ file_path ] == cache)
+                return false
+            end
+            true
+        end
+        
+        def delete_cache
+            if !CoderCompanion.dry_run?
+                begin
+                    File.delete(CACHE_DIR + '/cache.data')
+                    CoderCompanion::j_print CoderCompanion::warning_format("Running a fresh sesh")
+                rescue
+                    CoderCompanion::j_print CoderCompanion::warning_format("No cache to delete. Running a fresh sesh")
+                end
+            end
+        end
+
+        # @param [String] file_path
+        def update_cache_path(file_path)
+            if !CoderCompanion.dry_run?
+                if !self.file_cache
+                    self.file_cache = {}
+                end
+                self.file_cache[file_path] = encrypt(File.open(file_path).read)
+            end
+        end
+
+        # @return [nil]
+        def write_cached_data
+            if !CoderCompanion.dry_run?
+                if !Dir.exists?(CACHE_DIR)
+                    Dir.mkdir(CACHE_DIR)
+                end
+                File.open(CACHE_DIR + '/cache.data', 'w+') do |f| 
+                    f.write(self.file_cache.to_json)
+                end 
+            end
+        end
+
+        # @return [JSON]
+        def find_cache
+            begin
+                file = open_cache
+                self.file_cache = JSON.parse(file.read)
+            rescue
+                CoderCompanion::j_print CoderCompanion::warning_format("Cache not found running a fresh sesh")
+            end
+            nil
+        end
+
+        private
+
+        def encrypt(file)
+            return Digest::SHA1.hexdigest(file)
+        end
+    end
+end 

data/lib/codercompanion/codercompanion_exception.rb

@@ -0,0 +1,4 @@
+module CoderCompanion
+    class CoderCompanionException < StandardError
+    end
+end

data/lib/codercompanion/common/common.rb

@@ -0,0 +1,44 @@
+module CoderCompanion
+    module Common
+        class SourceFile < Treetop::Runtime::SyntaxNode
+            def build
+                els = nil
+                elements.each do |e|
+                    els = e.build if e.respond_to? :build
+                end
+                return {:type => 'source', :value => els}
+            end
+        end
+
+        class Body < Treetop::Runtime::SyntaxNode
+            def build
+                els = []
+                elements[0].elements.each do |e|
+                    built = e.build if e.respond_to? :build
+                    els.push(built) if built
+                end
+                return {:type => 'body', :value => els}
+            end
+        end
+
+        class Method < Treetop::Runtime::SyntaxNode
+            def build
+                els = []
+                elements.each do |e|
+                    built = e.build if e.respond_to? :build
+                    els.push built if built
+                end
+                return {:type => :method, :value => els}
+            end
+        end
+
+        class Identifier < Treetop::Runtime::SyntaxNode
+            def build
+                text_value
+            end
+        end
+
+        class WhiteSpace < Treetop::Runtime::SyntaxNode
+        end
+    end
+end

data/lib/codercompanion/common/literals.rb

@@ -0,0 +1,58 @@
+module CoderCompanion
+    module Common
+
+        class BooleanLiteral < Treetop::Runtime::SyntaxNode
+        end
+
+        class Literal < Treetop::Runtime::SyntaxNode
+        end
+
+        class IntegerLiteral < Treetop::Runtime::SyntaxNode
+            def build
+                {:type => :integer, :value => text_value}
+            end
+        end
+
+        class FloatLiteral < Treetop::Runtime::SyntaxNode
+            def build
+                {:type => :float, :value => text_value}
+            end
+        end
+
+        class StringLiteral < Treetop::Runtime::SyntaxNode
+            def build
+                {:type => :string, :value => text_value}
+            end
+        end
+
+        class ArrayLiteral < Treetop::Runtime::SyntaxNode
+            
+            def build
+                els = []
+                elements.map do |e| 
+                    if e.respond_to? :first_element
+                        els.push(e.elements[1].build)
+                    end
+                    els += e.build if e.respond_to? :build
+                    # els.push(e.text_value) if e.respond_to? :build
+                end
+                {:type => :array, :value => els}
+            end
+        end
+
+        class RestOfElements < Treetop::Runtime::SyntaxNode
+            def build
+                els = []
+                elements.map do |e|
+                    if e.respond_to? :another_element
+                        e.elements.map do |f|
+                            els.push(f.build) if f.respond_to? :build
+                        end
+                    end
+                end
+                els
+            end
+        end
+        
+    end
+end

data/lib/codercompanion/common_namespace.rb

@@ -0,0 +1,2 @@
+require 'codercompanion/common/common'
+require 'codercompanion/common/literals'

data/lib/codercompanion/cpp/cpp_parser.rb

@@ -0,0 +1,31 @@
+module CoderCompanion
+    module Cpp
+        class CppParser < CoderCompanion::LanguageParser
+           
+            CPP_EXTENSIONS      = ['.h', '.hpp']
+    
+            def initialize
+                @tree_walker = CoderCompanion::Cpp::CppTreeWalker.new
+            end
+                  
+            def parse(files)
+                raise NotImplementedError, "cpp parser is not yet implemented"
+=begin
+                begin
+                    results = RbGCCXML.parse(files, :cxxflags => ["--debug", "-stdlib=libstdc++"])
+                    return [results]
+                rescue RuntimeError => e
+                    CoderCompanion::j_print CoderCompanion::error_format("An error occured while parsing your code.")
+                    exit
+                end
+=end
+            end
+
+            private
+
+            def is_valid_file(ext)
+                return CPP_EXTENSIONS.include?(ext)
+            end
+        end
+    end
+end

data/lib/codercompanion/cpp/cpp_tree_walker.rb

@@ -0,0 +1,20 @@
+module CoderCompanion
+    module Cpp
+        class CppTreeWalker < CoderCompanion::TreeWalker
+            def create_uploadable(results)
+                obj = {}
+                namespace = results.first
+                namespace.classes.each do |klass|
+                    modified = CoderCompanion::CacheHandler.is_file_modified?(klass.file)
+                    CoderCompanion::CacheHandler.update_cache_path(klass.file)
+
+                    obj[klass] = build_class(klass, modified)
+                end
+            end
+
+            def build_class(klass, modified)
+                puts klass.name
+            end
+        end
+    end
+end