rlint 0.0.1

data/bin/rlint

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'rlint'

data/lib/parser.rb

@@ -0,0 +1,149 @@
+require 'report'
+
+class Parser
+	attr_reader :reports
+	def initialize
+		@reports = []
+	end
+	
+	def see(line, file, num_line)
+		@file = file
+		@line = line
+		@num_line = num_line
+
+		check_line
+	end
+
+	def set_rule(rule)
+		@rule = rule
+	end
+
+	private
+
+	def check_line
+		check_def_line if line_is_def
+		check_simple_line if simple_line?
+		check_class_line if is_a_class?
+	end
+
+	def check_def_line
+		check_method_name		
+		check_parameters
+		check_optional_parameters if has_optional_parameters?
+		check_columns
+	end
+	
+	def check_class_line
+		check_class_name
+		check_columns
+	end
+
+	def check_simple_line
+		# Ignore lines with 'end' and only newline.
+		return if @line.match(/^(\n)+$|^(\t)+\n$|^(.)*end$/)
+		check_columns
+		check_method_call
+		check_columns
+	end
+
+	def line_is_def
+		return (@line.match(/def /))? true : false
+	end
+
+	def simple_line?
+		return (@line.match(/def |class |module /))? false : true
+	end
+	
+	def is_a_class?
+		return (@line.match(/class |module /))? true : false
+	end
+
+	def has_optional_parameters?
+		return (@line.match(/\w+(.)*=(.)*[\{|"|d+]/))? true : false
+	end
+
+	def check_method_name
+		if !@line.match(@rule.method_name_rule)
+			report = Report.new()
+			report.line = @line
+			report.file = @file
+			report.num_line = @num_line
+			report.error = "Method isn't agreement with 'method name rule'"
+			@reports << report
+		end
+	end
+	
+	def check_class_name
+		if !@line.match(@rule.class_name_rule)
+			report = Report.new()
+			report.line = @line
+			report.file = @file
+			report.num_line = @num_line
+			report.error = "Class/Module name isn't in accordance with rule."
+			@reports << report
+		end
+	end
+
+	def check_optional_parameters
+		if !@line.match(@rule.optional_parameter_rule)
+			report = Report.new()
+			report.line = @line
+			report.file = @file
+			report.num_line = @num_line
+			report.error = "Optional parameter isn't agreement with 'optional parameter rule'"
+			@reports << report
+		end
+	end
+
+	def check_parameters
+		if !@line.match(/\?/)
+			basic_method
+		else	
+			ask_method
+		end	
+	end
+	
+	def basic_method
+		if !@line.match(@rule.parameter_rule)
+			report = Report.new()
+			report.line = @line
+			report.file = @file
+			report.num_line = @num_line
+			report.error = "Parameter isn't agreement with 'parameter rule'"
+			@reports << report
+		end
+	end
+	
+	def ask_method
+		if !@line.match(@rule.ask_method_rule)
+			report = Report.new()
+			report.line = @line
+			report.file = @file
+			report.num_line = @num_line
+			report.error = "Parameter isn't agreement with 'ask method rule'"
+			@reports << report
+		end
+	end
+
+	def check_columns
+		if !@rule.check_columns(@line)
+			report = Report.new()
+			report.line = @line
+			report.file = @file
+			report.num_line = @num_line
+			report.error = "This line exceeded columns limit: #{@rule.column_width_rule}."
+			@reports << report
+		end
+	end
+	
+	def check_method_call
+		if !@line.match(@rule.method_call_rule)
+			report = Report.new()
+			report.line = @line
+			report.file = @file
+			report.num_line = @num_line
+			report.error = "Incorrect method call."
+			@reports << report
+		end
+	end
+end

data/lib/report.rb

@@ -0,0 +1,10 @@
+class Report
+	attr_accessor :line, :num_line, :error, :file 
+
+	def to_s
+		"#{@error}\n".color(:red) + 
+		"#{@file}".color(:yellow) + " - line #{@num_line}: #{@line.gsub(/\t/,'')}
+"
+	end
+end
+

data/lib/rlint.rb

@@ -0,0 +1,33 @@
+require 'rubygems'
+require 'runner'
+require 'optparse'
+
+options = {}
+opts = OptionParser.new do |opt|
+	opt.banner = "Usage: rlint.rb [options]"
+	
+	opt.on("-d dir", "--dir", "Code to analizy") do |f|
+		options[:dir] = f
+	end
+	
+	opt.on("-r rule", "--rule", "File with rules") do |r|
+		options[:rule] = r
+	end
+	
+	#opt.on_tail("-h", "--help", "Help") do
+	#	puts opt
+	#	exit
+	#end
+end#.parse!
+
+# Don't allow empty args
+if ARGV.empty?
+    puts opts
+	exit -1
+end
+
+opts.parse!(ARGV)
+
+Runner.run(options[:dir], options[:rule])
+
+

data/lib/rule.rb

@@ -0,0 +1,119 @@
+class Rule
+	attr_reader :method_name_rule, :optional_parameter_rule, :parameter_rule, :column_width_rule
+	attr_reader :ask_method_rule, :method_call_rule, :class_name_rule
+	attr_reader :tabs_size
+	
+	def snakecase_method(value=true)
+		if value
+			@method_name_rule = /def ([a-z]|\_|\?|\!)*(\(| |\n)/
+		else
+			@method_name_rule = /def ([a-z]|\?|\!)*(\(| |\n)/
+		end
+	end
+
+	def parameters(whitespace)
+		if whitespace
+			@parameter_rule = /\(\w+\)|\(\w+\, (\w+|\w+\, |\w+(.)*=(.)*[\{|\}|\"|\'|\[|\]])*\)|^def (\w+$|\w+\(\)$)/
+		else
+			@parameter_rule = /\((\w+|\,|\w+(.)*\=\{(.)*\})*\)/
+		end
+	end
+	
+	#
+	# Ask method rule
+	# 
+	# 0 -> 'def method?' or 'def method? a' or def method?(a, b)'   - OK
+	# 1 -> 'def method?' or 'def method?(a)' or 'def method?(a,b)'  - OK
+	# 2 -> 'def method?' or 'def method?(a)' or 'def method?(a, b)' - OK
+	# 3 -> 'def method?' or 'def method? a' or 'def method? a, b'   - OK
+	#
+	def ask_method(mode)
+		case mode
+			when 0
+				@ask_method_rule = /^def (\w+\?$|\w+\? \w+$|\w+\?\((\w+|\, \w+)*\)$)/
+			when 1
+				@ask_method_rule = /^def (\w+\?$|\w+\?\(\w+\)$|\w+\?\((\w+|\, \w+)*\)$)/
+			when 2
+				@ask_method_rule = /^def (\w+\?$|\w+\?\(\w+\)$|\w+\?\((\w+|\, \w+)*\)$)/
+			when 3
+				@ask_method_rule = /^def (\w+\?$|\w+\?\\w+\$|\w+\? (\w+|\, \w+)*$)/
+		end		
+	end
+
+	#
+	# Optional parameter ruler
+	# 
+	# Example
+	#
+	# 0 -> 'def method(a,b={})'   - OK
+	# 1 -> 'def method(a,b = {})' - OK
+	# 2 -> 'def method(a,b= {})'  - OK
+	# 3 -> 'def method(a,b ={})'  - OK
+	#
+	def optional_parameter(whitespace)
+		case whitespace
+			when 0
+				@optional_parameter_rule = /([a-z]|\_)*\=[\{|\"|\d+]/
+			when 1
+				@optional_parameter_rule = /([a-z]|\_)* \= [\{|\"|\d+]/
+			when 2
+				@optional_parameter_rule = /([a-z]|\_)*\= [\{|\"|\d+]/
+			when 3
+				@optional_parameter_rule = /([a-z]|\_)* \=[\{|\"|\d+]/
+		end
+	end
+
+	def column_width(width)
+		@column_width_rule = width 
+	end
+
+	def tabs_size(value)
+		@tabs_size = value
+	end
+
+	def check_columns(line)
+		if !@tabs_size.nil?
+			whitespace = ' ' * @tabs_size
+			new_line = line.gsub(/\t/, whitespace)
+			return new_line.size <= @column_width_rule
+		else
+			return line.size <= @column_width_rule
+		end
+	end
+	
+	#
+	# 0 -> 'method(a)' or 'method(a,b)' 
+	# 1 -> 'method(a)' or 'method(a, b)'
+	# 2 -> 'method a' or 'method(a,b)'
+	# 3 -> 'method a' or 'method(a, b)'
+	# 4 -> 'method a' or 'method a,b'
+	# 5 -> 'method a' or 'method a, b'
+	#
+	def method_call(mode)
+		case mode
+			when 0
+				@method_call_rule = /^\w+\((\w+|\,\w+)*\)/
+			when 1
+				@method_call_rule = /^\w+\((\w+|\, \w+)*\)/
+			when 2
+				@method_call_rule = /^\w+ \w+$|^\w+\((\w+\,)+\w+\)$/
+			when 3
+				@method_call_rule = /^\w+ \w+$|^\w+\((\w+\, )+\w+\)$/
+			when 4
+				@method_call_rule = /^\w+ (\w+|\,)*$/
+			when 5
+				@method_call_rule = /^\w+ (\w+|\, )*$/
+		end
+	end
+	
+	def class_name(mode)
+		case mode
+			when :camel
+				@class_name_rule = /^class ([A-Z][a-z]*)*$/
+			when :snake
+				@class_name_rule = /^class [A-Z][a-z]*\_[a-z]*$/
+			when :camel_snake
+				@class_name_rule = /^class [A-Z][a-z]*\_[A-Z][a-z]*$/
+		end
+	end
+end

data/lib/runner.rb

@@ -0,0 +1,88 @@
+require 'rubygems'
+require 'rainbow'
+require 'rule'
+require 'parser'
+require 'fileutils'
+require 'stringio'
+
+class Runner
+	include ObjectSpace
+	def self.run(locate, rule)
+		@n_line = 0
+		@total_line = 0
+		@parser = Parser.new
+		
+		my_rule = file_to_rule(rule) 
+		
+		self.read(locate, my_rule)
+		
+		self.report
+	end
+	
+	def self.report
+		puts
+		puts "Total of lines analyzed: ".color(:yellow) + "#{@total_line}".color(:red)
+		puts "Unconformities found: ".color(:yellow) + "#{@parser.reports.size}".color(:red)
+		puts
+		
+		@parser.reports.each do |error|
+			puts error
+		end
+	end 
+	
+	private
+	
+	def self.read(locate, rule)
+		if File.directory?(locate)
+			self.directory(locate, rule)
+		else
+			file(locate, rule)	
+		end
+	end
+	
+	def self.file(f, rule)
+		File.open(f, "r") do |infile|
+			while (line = infile.gets)
+				@n_line += 1
+				@parser.set_rule(rule)
+				@parser.see(line, f, @n_line)
+			end
+		end
+		@total_line += @n_line
+		@n_line = 0
+	end
+	
+	def self.directory(locate, rule)
+		dir = Dir.new(locate)
+  		dir.each do |f|
+  			next if f.to_s.match(/^\.\.$|^\.$/)
+  			  			
+  			if !File.file?(f)
+				self.directory("#{locate}/"+f, rule)
+			else
+				file(f, rule)	
+			end
+   		end
+	end
+	
+	def self.file_to_rule(rule) 
+		if File.extname(rule) == ".rb"
+			require rule
+			ObjectSpace.each_object(Rule) do |obj|
+				return obj
+			end
+		else
+			str = ""
+			File.open(rule, "r") do |f|
+				while (line = f.gets)
+					str += line
+				end
+			end
+			eval(str.to_s)
+			
+			ObjectSpace.each_object(Rule) do |obj|
+				return obj
+			end
+		end
+	end
+end

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification 
+name: rlint
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Rodrigo Mello Nardi
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-01-03 00:00:00 -02:00
+default_executable: 
+dependencies: []
+
+description: 
+email: rodrigomellonardi@gmail.com
+executables: 
+- rlint
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/report.rb
+- lib/runner.rb
+- lib/parser.rb
+- lib/rule.rb
+- lib/rlint.rb
+has_rdoc: true
+homepage: http://rubyhideoutprogramming.blogspot.com/
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Rlint is a coding standard analyzer. Used to check method/class name pattern, columns limit and others.(like Pylint)
+test_files: []
+