rubycop 0.5.0

data/lib/rubycop/analyzer/policy.rb

@@ -0,0 +1,354 @@
+require 'set'
+
+module Rubycop
+  module Analyzer
+    class Policy
+      def initialize
+        @const_list = GrayList.new
+        initialize_const_blacklist
+      end
+
+      def inspect
+        '#<%s:0x%x>' % [self.class.name, object_id]
+      end
+
+      def blacklist_const(const)
+        @const_list.blacklist(const)
+      end
+
+      def const_allowed?(const)
+        @const_list.allow?(const)
+      end
+
+      def whitelist_const(const)
+        @const_list.whitelist(const)
+      end
+
+      def visit(node)
+        klass = node.class.ancestors.detect do |ancestor|
+          respond_to?("visit_#{ancestor.name.split('::').last}")
+        end
+        if klass
+          send("visit_#{klass.name.split('::').last}", node)
+        else
+          warn "unhandled node type: #{node.inspect}:#{node.class.name}"
+          true
+        end
+      end
+
+      def visit_Alias(node)
+        false # never allowed
+      end
+
+      def visit_Args(node)
+        node.elements.all? { |e| visit(e) }
+      end
+
+      def visit_Array(node)
+        node.elements.all? { |e| visit(e) }
+      end
+
+      def visit_Assoc(node)
+        visit(node.key) && visit(node.value)
+      end
+
+      def visit_Binary(node)
+        visit(node.lvalue) && visit(node.rvalue)
+      end
+
+      def visit_Block(node)
+        (node.params.nil? || visit(node.params)) && node.elements.all? { |e| visit(e) }
+      end
+
+      CALL_BLACKLIST = %w[
+        abort
+        alias_method
+        at_exit
+        autoload
+        binding
+        callcc
+        caller
+        class_eval
+        const_get
+        const_set
+        eval
+        exec
+        exit
+        fail
+        fork
+        gets
+        global_variables
+        instance_eval
+        load
+        loop
+        method
+        module_eval
+        open
+        readline
+        readlines
+        redo
+        remove_const
+        require
+        send
+        set_trace_func
+        sleep
+        spawn
+        srand
+        syscall
+        system
+        trap
+        undef
+        __callee__
+        __method__
+      ].to_set.freeze
+
+      def visit_Call(node)
+        !CALL_BLACKLIST.include?(node.identifier.token.to_s) && [node.target, node.arguments, node.block].compact.all? { |e| visit(e) }
+      end
+
+      def visit_Case(node)
+        visit(node.expression) && visit(node.block)
+      end
+
+      def visit_ChainedBlock(node)
+        node.elements.all? { |e| visit(e) } && node.blocks.all? { |e| visit(e) } && (node.params.nil? || visit(node.params))
+      end
+
+      def visit_Class(node)
+        visit(node.const) && (node.superclass.nil? || visit(node.superclass)) && visit(node.body)
+      end
+
+      def visit_ClassVariable(node)
+        false # never allowed
+      end
+
+      def visit_ClassVariableAssignment(node)
+        false # never allowed
+      end
+
+      def visit_Char(node)
+        true
+      end
+
+      def visit_Constant(node)
+        const_allowed?(node.token)
+      end
+
+      def visit_ConstantAssignment(node)
+        visit(node.lvalue) && visit(node.rvalue)
+      end
+
+      def visit_Defined(node)
+        false # never allowed (though it's probably safe)
+      end
+
+      def visit_Else(node)
+        node.elements.all? { |e| visit(e) }
+      end
+
+      def visit_ExecutableString(node)
+        false # never allowed
+      end
+
+      def visit_Float(node)
+        true
+      end
+
+      def visit_For(node)
+        visit(node.variable) && visit(node.range) && visit(node.statements)
+      end
+
+      def visit_GlobalVariable(node)
+        false # never allowed
+      end
+
+      def visit_GlobalVariableAssignment(node)
+        false # never allowed
+      end
+
+      def visit_Hash(node)
+        node.assocs.nil? || node.assocs.all? { |e| visit(e) }
+      end
+
+      def visit_Identifier(node)
+        !CALL_BLACKLIST.include?(node.token)
+      end
+
+      def visit_If(node)
+        visit(node.expression) && node.elements.all? { |e| visit(e) } && node.blocks.all? { |e| visit(e) }
+      end
+      alias_method :visit_Unless, :visit_If
+
+      def visit_IfMod(node)
+        visit(node.expression) && node.elements.all? { |e| visit(e) }
+      end
+      alias_method :visit_UnlessMod, :visit_IfMod
+
+      def visit_IfOp(node)
+        visit(node.condition) && visit(node.then_part) && visit(node.else_part)
+      end
+
+      def visit_InstanceVariable(node)
+        true
+      end
+
+      def visit_InstanceVariableAssignment(node)
+        visit(node.rvalue)
+      end
+
+      def visit_Integer(node)
+        true
+      end
+
+      KEYWORD_WHITELIST = %w[
+        false
+        nil
+        self
+        true
+      ].to_set.freeze
+
+      def visit_Keyword(node)
+        KEYWORD_WHITELIST.include?(node.token)
+      end
+
+      def visit_Label(node)
+        true
+      end
+
+      def visit_LocalVariableAssignment(node)
+        visit(node.rvalue)
+      end
+
+      def visit_Method(node)
+        [node.target, node.params, node.body].compact.all? { |e| visit(e) }
+      end
+
+      def visit_Module(node)
+        visit(node.const) && visit(node.body)
+      end
+
+      def visit_MultiAssignment(node)
+        visit(node.lvalue) && visit(node.rvalue)
+      end
+
+      def visit_MultiAssignmentList(node)
+        node.elements.all? { |e| visit(e) }
+      end
+
+      def visit_Params(node)
+        node.elements.all? { |e| visit(e) }
+      end
+
+      def visit_Program(node)
+        node.elements.all? { |e| visit(e) }
+      end
+
+      def visit_Range(node)
+        visit(node.min) && visit(node.max)
+      end
+
+      def visit_RescueMod(node)
+        node.elements.all? { |e| visit(e) } && visit(node.expression)
+      end
+
+      def visit_RescueParams(node)
+        node.elements.all? { |e| visit(e) }
+      end
+
+      def visit_SingletonClass(node)
+        visit(node.superclass) && visit(node.body)
+      end
+
+      def visit_SplatArg(node)
+        visit(node.arg)
+      end
+
+      def visit_Statements(node)
+        node.elements.all? { |e| visit(e) }
+      end
+
+      def visit_String(node)
+        # embedded strings can have statements in them, so check those
+        node.elements.reject { |e| e.is_a?(::String) }.all? { |e| visit(e) }
+      end
+
+      def visit_StringConcat(node)
+        node.elements.all? { |e| visit(e) }
+      end
+
+      def visit_Symbol(node)
+        true
+      end
+
+      def visit_Unary(node)
+        visit(node.operand)
+      end
+
+      def visit_Until(node)
+        false # never allowed
+      end
+      alias_method :visit_UntilMod, :visit_Until
+
+      def visit_When(node)
+        visit(node.expression) && node.elements.all? { |e| visit(e) }
+      end
+
+      def visit_While(node)
+        false # never allowed
+      end
+      alias_method :visit_WhileMod, :visit_While
+
+      private
+
+      CONST_BLACKLIST = %w[
+        ARGF
+        ARGV
+        Array
+        Base64
+        Class
+        Dir
+        ENV
+        Enumerable
+        Error
+        Exception
+        Fiber
+        File
+        FileUtils
+        GC
+        Gem
+        Hash
+        IO
+        IRB
+        Kernel
+        Module
+        Net
+        Object
+        ObjectSpace
+        OpenSSL
+        OpenURI
+        PLATFORM
+        Proc
+        Process
+        RUBY_COPYRIGHT
+        RUBY_DESCRIPTION
+        RUBY_ENGINE
+        RUBY_PATCHLEVEL
+        RUBY_PLATFORM
+        RUBY_RELEASE_DATE
+        RUBY_VERSION
+        Rails
+        STDERR
+        STDIN
+        STDOUT
+        String
+        TOPLEVEL_BINDING
+        Thread
+        VERSION
+      ].freeze
+
+      def initialize_const_blacklist
+        CONST_BLACKLIST.each { |const| blacklist_const(const) }
+      end
+    end
+  end
+end

data/lib/rubycop/analyzer/ruby.rb

@@ -0,0 +1,24 @@
+require 'rubycop/analyzer/ruby/node'
+
+require 'rubycop/analyzer/ruby/list'
+require 'rubycop/analyzer/ruby/array'
+require 'rubycop/analyzer/ruby/args'
+require 'rubycop/analyzer/ruby/assignment'
+require 'rubycop/analyzer/ruby/assoc'
+require 'rubycop/analyzer/ruby/statements'
+require 'rubycop/analyzer/ruby/blocks'
+require 'rubycop/analyzer/ruby/call'
+require 'rubycop/analyzer/ruby/case'
+require 'rubycop/analyzer/ruby/tokens'
+require 'rubycop/analyzer/ruby/constants'
+require 'rubycop/analyzer/ruby/definitions'
+require 'rubycop/analyzer/ruby/for'
+require 'rubycop/analyzer/ruby/hash'
+require 'rubycop/analyzer/ruby/if'
+require 'rubycop/analyzer/ruby/operators'
+require 'rubycop/analyzer/ruby/params'
+require 'rubycop/analyzer/ruby/position'
+require 'rubycop/analyzer/ruby/range'
+require 'rubycop/analyzer/ruby/string'
+require 'rubycop/analyzer/ruby/variables'
+require 'rubycop/analyzer/ruby/while'

data/lib/rubycop/analyzer/ruby/args.rb

@@ -0,0 +1,28 @@
+module Rubycop
+  module Analyzer
+    module Ruby
+      class Args < List
+        attr_reader :block
+
+        def add_block(block)
+          @block = block
+        end
+
+        def to_array
+          Array.new(@elements)
+        end
+      end
+
+      class Arg < Node
+        def initialize(arg)
+          @arg = arg
+        end
+
+        attr_reader :arg
+      end
+
+      class SplatArg < Arg
+      end
+    end
+  end
+end

data/lib/rubycop/analyzer/ruby/array.rb

@@ -0,0 +1,11 @@
+module Rubycop
+  module Analyzer
+    module Ruby
+      class Array < List
+        # def inspect
+        #   '[%s]' % @elements.collect { |e| e.inspect }.join(', ')
+        # end
+      end
+    end
+  end
+end

data/lib/rubycop/analyzer/ruby/assignment.rb

@@ -0,0 +1,45 @@
+module Rubycop
+  module Analyzer
+    module Ruby
+      class Assignment < Node
+        def initialize(lvalue, rvalue, operator)
+          @lvalue   = lvalue
+          @rvalue   = rvalue
+          @operator = operator
+        end
+
+        attr_reader :lvalue
+        attr_reader :rvalue
+        attr_reader :operator
+
+        # def inspect
+        #   "#{@lvalue.inspect} #{@operator} #{@rvalue.inspect}"
+        # end
+      end
+
+      class ClassVariableAssignment < Assignment
+      end
+
+      class ConstantAssignment < Assignment
+      end
+
+      class GlobalVariableAssignment < Assignment
+      end
+
+      class InstanceVariableAssignment < Assignment
+      end
+
+      class LocalVariableAssignment < Assignment
+      end
+
+      class MultiAssignment < Assignment
+      end
+
+      class MultiAssignmentList < List
+        def assignment(rvalue, operator)
+          MultiAssignment.new(self, rvalue, operator)
+        end
+      end
+    end
+  end
+end