rubycop 0.5.1 → 1.0.1

data/lib/ruby_cop/ruby/assoc.rb

@@ -0,0 +1,13 @@
+module RubyCop
+  module Ruby
+    class Assoc < Node
+      def initialize(key, value)
+        @key = key
+        @value = value
+      end
+
+      attr_reader :key
+      attr_reader :value
+    end
+  end
+end

data/lib/ruby_cop/ruby/blocks.rb

@@ -0,0 +1,21 @@
+module RubyCop
+  module Ruby
+    class Block < Statements
+      def initialize(statements, params=nil)
+        @params = params
+        super(statements)
+      end
+
+      attr_reader :params
+    end
+
+    class ChainedBlock < Block
+      def initialize(blocks, statements, params=nil)
+        @blocks = Array(blocks).compact
+        super(statements, params)
+      end
+
+      attr_reader :blocks
+    end
+  end
+end

data/lib/ruby_cop/ruby/call.rb

@@ -0,0 +1,31 @@
+module RubyCop
+  module Ruby
+    class Call < Node
+      def initialize(target, identifier, arguments=nil, block=nil)
+        @target     = target
+        @identifier = identifier
+        @arguments  = arguments
+        @block      = block
+      end
+
+      attr_reader :target
+      attr_reader :identifier
+      attr_accessor :arguments
+      attr_accessor :block
+
+      def assignment(rvalue, operator)
+        self.class.new(@target, Identifier.new("#{@identifier.token}=", @identifier.position), @arguments, @block)
+      end
+    end
+
+    class Alias < Node
+      def initialize(new_name, old_name)
+        @new_name = new_name
+        @old_name = old_name
+      end
+
+      attr_reader :new_name
+      attr_reader :old_name
+    end
+  end
+end

data/lib/ruby_cop/ruby/case.rb

@@ -0,0 +1,22 @@
+module RubyCop
+  module Ruby
+    class Case < Node
+      def initialize(expression, block)
+        @expression = expression
+        @block = block
+      end
+
+      attr_reader :expression
+      attr_reader :block
+    end
+
+    class When < ChainedBlock
+      def initialize(expression, statements, block=nil)
+        @expression = expression
+        super([block], statements)
+      end
+
+      attr_reader :expression
+    end
+  end
+end

data/lib/ruby_cop/ruby/constants.rb

@@ -0,0 +1,47 @@
+module RubyCop
+  module Ruby
+    class Constant < Identifier
+      attr_accessor :namespace
+
+      def assignment(rvalue, operator)
+        ConstantAssignment.new(self, rvalue, operator)
+      end
+
+      # def inspect
+      #   @namespace ? "#{@namespace.inspect}::#{@token}" : @token
+      # end
+    end
+
+    class Module < Node
+      def initialize(const, body)
+        @const = const
+        @body  = body
+      end
+
+      attr_reader :const
+      attr_reader :body
+    end
+
+    class Class < Node
+      def initialize(const, superclass, body)
+        @const = const
+        @superclass = superclass
+        @body = body
+      end
+
+      attr_reader :const
+      attr_reader :superclass
+      attr_reader :body
+    end
+
+    class SingletonClass < Node
+      def initialize(superclass, body)
+        @superclass = superclass
+        @body = body
+      end
+
+      attr_reader :superclass
+      attr_reader :body
+    end
+  end
+end

data/lib/ruby_cop/ruby/definitions.rb

@@ -0,0 +1,25 @@
+module RubyCop
+  module Ruby
+    class Method < Node
+      def initialize(target, identifier, params, body)
+        @target     = target
+        @identifier = identifier
+        @params     = params
+        @body       = body
+      end
+
+      attr_reader :target
+      attr_reader :identifier
+      attr_reader :params
+      attr_reader :body
+    end
+
+    class Defined < Node
+      def initialize(expression)
+        @expression = expression
+      end
+
+      attr_reader :expression
+    end
+  end
+end

data/lib/ruby_cop/ruby/for.rb

@@ -0,0 +1,15 @@
+module RubyCop
+  module Ruby
+    class For < Block
+      def initialize(variable, range, statements)
+        @variable = variable
+        @range = range
+        @statements = statements
+      end
+
+      attr_reader :variable
+      attr_reader :range
+      attr_reader :statements
+    end
+  end
+end

data/lib/ruby_cop/ruby/hash.rb

@@ -0,0 +1,11 @@
+module RubyCop
+  module Ruby
+    class Hash < Node
+      def initialize(assocs)
+        @assocs = assocs
+      end
+
+      attr_reader :assocs
+    end
+  end
+end

data/lib/ruby_cop/ruby/if.rb

@@ -0,0 +1,31 @@
+module RubyCop
+  module Ruby
+    class If < ChainedBlock
+      def initialize(expression, statements=nil, else_block=nil)
+        @expression = expression
+        super([else_block], statements, nil)
+      end
+      attr_reader :expression
+    end
+
+    class Unless < If
+    end
+
+    class Else < Block
+    end
+
+    class IfMod < Block
+      def initialize(expression, statements)
+        @expression = expression
+        super(statements)
+      end
+      attr_reader :expression
+    end
+
+    class UnlessMod < IfMod
+    end
+
+    class RescueMod < IfMod
+    end
+  end
+end

data/lib/ruby_cop/ruby/list.rb

@@ -0,0 +1,15 @@
+module RubyCop
+  module Ruby
+    class List < Node
+      def initialize(elements=nil)
+        @elements = Array(elements).compact # TODO: compact might cause problems here
+      end
+
+      attr_reader :elements
+
+      def add(element)
+        @elements.push(element)
+      end
+    end
+  end
+end

data/lib/ruby_cop/ruby/node.rb

@@ -0,0 +1,9 @@
+module RubyCop
+  module Ruby
+    class Node
+      def accept(visitor)
+        visitor.visit(self)
+      end
+    end
+  end
+end

data/lib/ruby_cop/ruby/operators.rb

@@ -0,0 +1,52 @@
+module RubyCop
+  module Ruby
+    class Operator < Node
+    end
+
+    class Unary < Operator
+      def initialize(operator, operand)
+        @operator = operator
+        @operand  = operand
+      end
+
+      attr_reader :operator
+      attr_reader :operand
+
+      # def inspect
+      #   "#{@operator}(#{@operand.inspect})"
+      # end
+    end
+
+    class Binary < Operator
+      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 IfOp < Operator
+      def initialize(condition, then_part, else_part)
+        @condition = condition
+        @then_part = then_part
+        @else_part = else_part
+      end
+
+      attr_reader :condition
+      attr_reader :then_part
+      attr_reader :else_part
+
+      # def inspect
+      #   "#{@condition.inspect} ? #{@then_part.inspect} : #{@else_part.inspect}"
+      # end
+    end
+  end
+end

data/lib/ruby_cop/ruby/params.rb

@@ -0,0 +1,21 @@
+module RubyCop
+  module Ruby
+    class Params < List
+      def initialize(params, optionals, rest, block)
+        super((Array(params) + Array(optionals) << rest << block).flatten.compact)
+      end
+    end
+
+    class RescueParams < List
+      def initialize(types, var)
+        if types
+          errors = Ruby::Array.new(types)
+          errors = Ruby::Assoc.new(errors, var) if var
+          super(errors)
+        else
+          super()
+        end
+      end
+    end
+  end
+end

data/lib/ruby_cop/ruby/position.rb

@@ -0,0 +1,13 @@
+module RubyCop
+  module Ruby
+    class Position
+      def initialize(lineno, column)
+        @lineno = lineno
+        @column = column
+      end
+
+      attr_reader :lineno
+      attr_reader :column
+    end
+  end
+end

data/lib/ruby_cop/ruby/range.rb

@@ -0,0 +1,15 @@
+module RubyCop
+  module Ruby
+    class Range < Node
+      def initialize(min, max, exclude_end)
+        @min = min
+        @max = max
+        @exclude_end = exclude_end
+      end
+
+      attr_reader :min
+      attr_reader :max
+      attr_reader :exclude_end
+    end
+  end
+end

data/lib/ruby_cop/ruby/statements.rb

@@ -0,0 +1,32 @@
+module RubyCop
+  module Ruby
+    class Statements < List
+      # def inspect
+      #   @elements.collect { |e| e.inspect }.join
+      # end
+
+      def to_block(params)
+        Block.new(@elements, params)
+      end
+
+      def to_chained_block(blocks=nil, params=nil)
+        ChainedBlock.new(blocks, @elements, params)
+      end
+
+      def to_program(src, filename)
+        Program.new(src, filename, @elements)
+      end
+    end
+
+    class Program < Statements
+      def initialize(src, filename, statements)
+        @src = src
+        @filename = filename
+        super(statements)
+      end
+
+      attr_reader :src
+      attr_reader :filename
+    end
+  end
+end

data/lib/ruby_cop/ruby/string.rb

@@ -0,0 +1,24 @@
+module RubyCop
+  module Ruby
+    class StringConcat < List
+    end
+
+    class String < List
+      # def inspect
+      #   @elements.join.inspect
+      # end
+    end
+
+    class DynaSymbol < String
+    end
+
+    class ExecutableString < String
+      def to_dyna_symbol
+        DynaSymbol.new(@elements)
+      end
+    end
+
+    class Regexp < String
+    end
+  end
+end

data/lib/ruby_cop/ruby/tokens.rb

@@ -0,0 +1,44 @@
+module RubyCop
+  module Ruby
+    class Token < Node
+      def initialize(token, position)
+        @token    = token
+        @position = position
+      end
+
+      attr_reader :token
+      attr_reader :position
+
+      # def inspect
+      #   "#{@token}<t>"
+      # end
+    end
+
+    class Integer < Token
+    end
+
+    class Float < Token
+    end
+
+    class Char < Token
+    end
+
+    class Label < Token
+    end
+
+    class Symbol < Token
+      # def inspect
+      #   ":#{@token.inspect}"
+      # end
+    end
+
+    class Keyword < Token
+    end
+
+    class Identifier < Token
+      def assignment(rvalue, operator)
+        LocalVariableAssignment.new(self, rvalue, operator)
+      end
+    end
+  end
+end