rubycop 0.5.1 → 1.0.1

data/lib/rubycop/analyzer/policy.rb

@@ -1,356 +0,0 @@
-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
-        dup
-        fail
-        fork
-        gets
-        global_variables
-        instance_eval
-        load
-        loop
-        method
-        module_eval
-        open
-        readline
-        readlines
-        redo
-        remove_const
-        retry
-        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

@@ -1,24 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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