pelusa 0.2.3 → 0.2.4

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    YjA3NTU1ZWZkNGViYTBmNTFhMmJmNGQ1MDZlNjQxNjcwYTJkMTA1ZQ==
-  data.tar.gz: !binary |-
-    NzEzMmJlNmE5N2ZhYTE3MjgyODMzMDgxMmEyMjYxMmFhYmZlZjBjOA==
-!binary "U0hBNTEy":
-  metadata.gz: !binary |-
-    MjFmZmQyNzRiZWI3YjU0ZjE1MTNkNjViMmE5YTFiMzEwMjhiYWU1MGNiMWVi
-    YTI1ZDhiMjkwZjYyNjBhNGJhMThlOGQ0ZjE4M2FmMDBhZjhmNWQwMjRiNTBk
-    ZDgwOGQ5NzAzZmFiNTdkOTMwMTBmNmNhMWUwMDc4ZjIyMmI0OTM=
-  data.tar.gz: !binary |-
-    ODI4ZGVkOWE5MTgzMzdiOWYyNmNmYzMxZTNkOTRhY2E4M2FjNGQyOTRlYTg4
-    NDhmOTVkMWI0OWJkZTlmNjk3MjViNWEzMmUxYTRhMzMxNzQ5ZmY4ZWNjYTk5
-    OWQxOGUzZjFjZTQyNmI1OWZkODE3YjRkODUwNDkzMzgzY2RjY2I=
+SHA1:
+  metadata.gz: 113e730ed13c034f23af12fe5991429d700e4849
+  data.tar.gz: eb5bcf324e5fc9de0ae2ae3c1b0a4605699122ae
+SHA512:
+  metadata.gz: 036db9f609c809992c3790b5988a3aa7ff5566d86cc6658cde3ba89af0884525a0f2e8268567d781be43ce034c4d09f366d50b6e6dcd1644be937c951def37e8
+  data.tar.gz: 948f926c35f9e580571db450b91c15103e1c6c106b0ab691efa1f7e93b58bdc9cdbed9f73c5c4d2b4713197295083b9e0d8791107c2335b2b73534e248b7ab7f

data/.gitignore

@@ -3,3 +3,4 @@
 Gemfile.lock
 pkg/*
 .rbx
+.ruby-version

data/.travis.yml

@@ -1,4 +1,2 @@
-env:
- - RBXOPT=-X19
 rvm:
-  - rbx
+  - rbx-2.2.6

data/Gemfile

@@ -3,5 +3,5 @@ source "http://rubygems.org"
 # Specify your gem's dependencies in pelusa.gemspec
 gemspec
 gem 'rake'
-
+gem 'rubinius-melbourne'
 gem 'minitest'

data/bin/pelusa

@@ -1,12 +1,6 @@
 #!/usr/bin/env ruby
 $:.unshift(File.dirname(__FILE__) + '/../lib')
 
-warning = %q{Pelusa needs Rubinius to run in 1.9 mode.
-Please either `export RBXOPT=-X19` before running it or compile Rubinius with
-1.9 support enabled by default.}
-
-abort warning unless Rubinius.ruby19?
-
 require 'pelusa'
 
 cli = Pelusa::Cli.new(ARGV)

data/lib/pelusa/analyzer.rb

@@ -39,12 +39,12 @@ module Pelusa
     # Returns an Array of Class nodes.
     def extract_classes(ast)
       classes = []
-      if ast.is_a?(Rubinius::AST::Class) || ast.is_a?(Rubinius::AST::Module)
+      if ast.is_a?(Rubinius::ToolSets::Runtime::ToolSet::AST::Class) || ast.is_a?(Rubinius::ToolSets::Runtime::ToolSet::AST::Module)
         classes << ast
       end
 
       ast.walk do |continue, node|
-        if node.is_a?(Rubinius::AST::Class) || node.is_a?(Rubinius::AST::Module)
+        if node.is_a?(Rubinius::ToolSets::Runtime::ToolSet::AST::Class) || node.is_a?(Rubinius::ToolSets::Runtime::ToolSet::AST::Module)
           classes << node
         end
         true

data/lib/pelusa/class_analyzer.rb

@@ -16,7 +16,7 @@ class Pelusa::ClassAnalyzer
 
   # Public: Returns the type of container being examined (class or module).
   def type
-    @klass.is_a?(Rubinius::AST::Class) ? "class" : "module"
+    @klass.is_a?(Rubinius::ToolSets::Runtime::ToolSet::AST::Class) ? "class" : "module"
   end
 
   # Public: Analyzes a class with a series of lints.

data/lib/pelusa/lint/case_statements.rb

@@ -23,7 +23,7 @@ module Pelusa
 
       def iterate_lines!(klass)
         ClassAnalyzer.walk(klass) do |node|
-          if node.is_a?(Rubinius::AST::Case)
+          if node.is_a?(Rubinius::ToolSets::Runtime::ToolSet::AST::Case)
             @violations << node.line
           end
         end

data/lib/pelusa/lint/collection_wrappers.rb

@@ -28,9 +28,9 @@ module Pelusa
         array_values = {}
 
         ClassAnalyzer.walk(klass) do |node|
-          if node.is_a?(Rubinius::AST::InstanceVariableAssignment) &&
-            (node.value.is_a?(Rubinius::AST::ArrayLiteral) ||
-             node.value.is_a?(Rubinius::AST::EmptyArray))
+          if node.is_a?(Rubinius::ToolSets::Runtime::ToolSet::AST::InstanceVariableAssignment) &&
+            (node.value.is_a?(Rubinius::ToolSets::Runtime::ToolSet::AST::ArrayLiteral) ||
+             node.value.is_a?(Rubinius::ToolSets::Runtime::ToolSet::AST::EmptyArray))
             array_assignments[node] = true
             array_values[node.name] = true
           end
@@ -41,10 +41,10 @@ module Pelusa
             # if this is where we assign the node for the first time, good
             unless array_assignments[node]
               # otherwise, if it's an instance variable assignment, verboten!
-              if node.is_a?(Rubinius::AST::InstanceVariableAssignment)
+              if node.is_a?(Rubinius::ToolSets::Runtime::ToolSet::AST::InstanceVariableAssignment)
                 @violations << node.line
               # or if we access any other ivars
-              elsif node.is_a?(Rubinius::AST::InstanceVariableAccess) &&
+              elsif node.is_a?(Rubinius::ToolSets::Runtime::ToolSet::AST::InstanceVariableAccess) &&
                 !array_values[node.name]
                 @violations << node.line
               end

data/lib/pelusa/lint/demeter_law.rb

@@ -23,7 +23,7 @@ module Pelusa
 
       def iterate_lines!(klass)
         ClassAnalyzer.walk(klass) do |node|
-          if node.is_a?(Rubinius::AST::Send) && node.receiver.is_a?(Rubinius::AST::Send)
+          if node.is_a?(Rubinius::ToolSets::Runtime::ToolSet::AST::Send) && node.receiver.is_a?(Rubinius::ToolSets::Runtime::ToolSet::AST::Send)
             @violations << node.line unless white_listed?(node.receiver.name)
           end
         end

data/lib/pelusa/lint/else_clauses.rb

@@ -23,9 +23,9 @@ module Pelusa
 
       def iterate_lines!(klass)
         ClassAnalyzer.walk(klass) do |node|
-          if node.is_a?(Rubinius::AST::If)
-            has_body = node.body && !node.body.is_a?(Rubinius::AST::NilLiteral)
-            has_else = node.else && !node.else.is_a?(Rubinius::AST::NilLiteral)
+          if node.is_a?(Rubinius::ToolSets::Runtime::ToolSet::AST::If)
+            has_body = node.body && !node.body.is_a?(Rubinius::ToolSets::Runtime::ToolSet::AST::NilLiteral)
+            has_else = node.else && !node.else.is_a?(Rubinius::ToolSets::Runtime::ToolSet::AST::NilLiteral)
 
             if has_body && has_else
               @violations << node.else.line

data/lib/pelusa/lint/eval_usage.rb

@@ -32,7 +32,7 @@ module Pelusa
       end
 
       def eval_violation?(node)
-        node.is_a?(Rubinius::AST::SendWithArguments) && node.name == :eval && node.receiver.is_a?(Rubinius::AST::Self)
+        node.is_a?(Rubinius::ToolSets::Runtime::ToolSet::AST::SendWithArguments) && node.name == :eval && node.receiver.is_a?(Rubinius::ToolSets::Runtime::ToolSet::AST::Self)
       end
 
     end

data/lib/pelusa/lint/indentation_level.rb

@@ -26,7 +26,7 @@ module Pelusa
         # contain > 1 indentation levels
         # this method totally fails the IndentationLevel level lint :P
         ClassAnalyzer.walk(klass) do |node|
-          if node.is_a?(Rubinius::AST::Define)
+          if node.is_a?(Rubinius::ToolSets::Runtime::ToolSet::AST::Define)
             # we're inside a method body, so see if we indent anywhere
             ClassAnalyzer.walk(node) do |inner_node|
               if inner_body = get_body_from_node[inner_node]
@@ -53,7 +53,7 @@ module Pelusa
 
       def get_body_from_node
         lambda do |node|
-          if node.respond_to?(:body) && !node.body.is_a?(Rubinius::AST::NilLiteral)
+          if node.respond_to?(:body) && !node.body.is_a?(Rubinius::ToolSets::Runtime::ToolSet::AST::NilLiteral)
              node.body
           elsif node.respond_to?(:else)
              node.else

data/lib/pelusa/lint/instance_variables.rb

@@ -27,7 +27,7 @@ module Pelusa
 
       def iterate_lines!(klass)
         ClassAnalyzer.walk(klass) do |node|
-          if node.is_a?(Rubinius::AST::InstanceVariableAccess) || node.is_a?(Rubinius::AST::InstanceVariableAssignment)
+          if node.is_a?(Rubinius::ToolSets::Runtime::ToolSet::AST::InstanceVariableAccess) || node.is_a?(Rubinius::ToolSets::Runtime::ToolSet::AST::InstanceVariableAssignment)
             @ivars << node.name
           end
         end

data/lib/pelusa/lint/many_arguments.rb

@@ -27,7 +27,7 @@ module Pelusa
 
       def iterate_lines!(klass)
         ClassAnalyzer.walk(klass) do |node|
-          if node.is_a?(Rubinius::AST::Define) && node.arguments.total_args > limit
+          if node.is_a?(Rubinius::ToolSets::Runtime::ToolSet::AST::Define) && node.arguments.total_args > limit
             @violations << node.name
           end
         end

data/lib/pelusa/lint/properties.rb

@@ -23,7 +23,7 @@ module Pelusa
 
       def iterate_lines!(klass)
         ClassAnalyzer.walk(klass) do |node|
-          if node.is_a?(Rubinius::AST::Send)
+          if node.is_a?(Rubinius::ToolSets::Runtime::ToolSet::AST::Send)
             if [:attr_accessor, :attr_writer, :attr_reader].include? node.name
               @violations << node.line
             end

data/lib/pelusa/runner.rb

@@ -36,7 +36,7 @@ module Pelusa
     #
     # Returns a Rubinius::Melbourne parser.
     def parser
-      Rubinius::Melbourne19
+      ::Rubinius::ToolSets.current::ToolSet::Melbourne
     end
   end
 end

data/lib/pelusa/version.rb

@@ -1,3 +1,3 @@
 module Pelusa
-  VERSION = "0.2.3"
+  VERSION = "0.2.4"
 end

data/test/pelusa/analyzer_test.rb

@@ -5,7 +5,7 @@ module Pelusa
     describe '#analyze' do
       describe 'with a multi-expression AST' do
         before do
-          @ast = """
+          @ast = Pelusa.to_ast """
             class Foo
               def bar
                 123
@@ -23,7 +23,7 @@ module Pelusa
                 2.7
               end
             end
-          """.to_ast
+          """
 
           lints = stub
           @analyzer = Analyzer.new([Lint::LineRestriction], RubyReporter, "foo.rb")
@@ -40,13 +40,13 @@ module Pelusa
 
       describe 'with a single-expression AST' do
         before do
-          @ast = """
+          @ast = Pelusa.to_ast """
             class Foo
               def bar
                 123
               end
             end
-          """.to_ast
+          """
 
           lints = stub
           @analyzer = Analyzer.new([Lint::LineRestriction], RubyReporter, "foo.rb")

data/test/pelusa/class_analyzer_test.rb

@@ -25,13 +25,13 @@ module Pelusa
       describe "#type" do
         it "returns the type module for modules" do
           # hacky!
-          @klass.stubs(:is_a?).with(Rubinius::AST::Class).returns(true)
+          @klass.stubs(:is_a?).with(Rubinius::ToolSets::Runtime::ToolSet::AST::Class).returns(true)
           @analyzer.type.must_equal "class"
         end
 
         it "returns the type module for modules" do
           # hacky!
-          @klass.stubs(:is_a?).with(Rubinius::AST::Class).returns(false)
+          @klass.stubs(:is_a?).with(Rubinius::ToolSets::Runtime::ToolSet::AST::Class).returns(false)
           @analyzer.type.must_equal "module"
         end
       end

data/test/pelusa/lint/case_statements_test.rb

@@ -10,12 +10,12 @@ module Pelusa
       describe '#check' do
         describe 'when the class does not use switch statements' do
           it 'returns a SuccessAnalysis' do
-            klass = """
+            klass = Pelusa.to_ast """
             class Foo
               def initialize
                 return nil
               end
-            end""".to_ast
+            end"""
 
             analysis = @lint.check(klass)
             analysis.successful?.must_equal true
@@ -24,14 +24,14 @@ module Pelusa
 
         describe 'when the class uses case statements' do
           it 'returns a FailureAnalysis' do
-            klass = """
+            klass = Pelusa.to_ast """
             class Foo
               def initialize
                 case foo
                   when bar
                 end
               end
-            end""".to_ast
+            end"""
 
             analysis = @lint.check(klass)
             analysis.failed?.must_equal true

data/test/pelusa/lint/collection_wrappers_test.rb

@@ -10,12 +10,12 @@ module Pelusa
       describe '#check' do
         describe 'when the class is not a collection wrapper with more instance variables' do
           it 'returns a SuccessAnalysis' do
-            klass = """
+            klass = Pelusa.to_ast """
             class Foo
               def initialize
                 @things = []
               end
-            end""".to_ast
+            end"""
 
             analysis = @lint.check(klass)
             analysis.successful?.must_equal true
@@ -24,12 +24,12 @@ module Pelusa
 
         describe 'when the class has no ivars' do
           it 'returns a SuccessAnalysis' do
-            klass = """
+            klass = Pelusa.to_ast """
             class Foo
               def initialize
                 things = []
               end
-            end""".to_ast
+            end"""
 
             analysis = @lint.check(klass)
             analysis.successful?.must_equal true
@@ -38,13 +38,13 @@ module Pelusa
 
         describe 'when the class mixes collection ivars with others' do
           it 'returns a FailureAnalysis' do
-            klass = """
+            klass = Pelusa.to_ast """
             class Foo
               def initialize
                 @things = []
                 @foo = 'bar'
               end
-            end""".to_ast
+            end"""
 
             analysis = @lint.check(klass)
             analysis.failed?.must_equal true
@@ -53,13 +53,13 @@ module Pelusa
 
         describe 'when the class has multiple array assignments' do
           it 'returns a FailureAnalysis' do
-            klass = """
+            klass = Pelusa.to_ast """
             class Foo
               def initialize
                 @things = []
                 @foos = []
               end
-            end""".to_ast
+            end"""
 
             analysis = @lint.check(klass)
             analysis.failed?.must_equal false
@@ -68,14 +68,14 @@ module Pelusa
 
         describe 'when the class has multiple array and other assignments' do
           it 'returns a FailureAnalysis' do
-            klass = """
+            klass = Pelusa.to_ast """
             class Foo
               def initialize
                 @things = []
                 @foos = []
                 @foo = 'bar'
               end
-            end""".to_ast
+            end"""
 
             analysis = @lint.check(klass)
             analysis.failed?.must_equal true

data/test/pelusa/lint/demeter_law_test.rb

@@ -10,13 +10,13 @@ module Pelusa
       describe '#check' do
         describe 'when the class respects Demeter law' do
           it 'returns a SuccessAnalysis' do
-            klass = """
+            klass = Pelusa.to_ast """
             class Foo
               def initialize
                 foo = 'hey'.upcase
                 foo.downcase
               end
-            end""".to_ast
+            end"""
 
             analysis = @lint.check(klass)
             analysis.successful?.must_equal true
@@ -25,12 +25,12 @@ module Pelusa
 
         describe 'when the class does not respect Demeter law' do
           it 'returns a FailureAnalysis' do
-            klass = """
+            klass = Pelusa.to_ast """
             class Foo
               def initialize
                 foo = 'hey'.upcase.downcase
               end
-            end""".to_ast
+            end"""
 
             analysis = @lint.check(klass)
             analysis.failed?.must_equal true
@@ -39,12 +39,12 @@ module Pelusa
 
         describe 'when instantiating a class' do
           it 'returns a SuccessAnalysis' do
-            klass = """
+            klass = Pelusa.to_ast """
             class Foo
               def execute
                 Bar.new.execute
               end
-            end""".to_ast
+            end"""
 
             analysis = @lint.check(klass)
             analysis.successful?.must_equal true
@@ -53,36 +53,36 @@ module Pelusa
 
         describe 'when chaining whitelisted operations' do
           it 'returns a SuccessAnalysis for chained operations from Enumerable' do
-            klass = """
+            klass = Pelusa.to_ast """
             class Foo
               def execute
                 [1,2,3].map(&:object_id).each {|i| i}
               end
-            end""".to_ast
+            end"""
 
             analysis = @lint.check(klass)
             analysis.successful?.must_equal true
           end
 
           it 'returns a SuccessAnalysis when chaining methods from Fixnum' do
-            klass = """
+            klass = Pelusa.to_ast """
             class Foo
               def execute
                 1 + 2 + 3 + 4
               end
-            end""".to_ast
+            end"""
 
             analysis = @lint.check(klass)
             analysis.successful?.must_equal true
           end
 
           it 'returns a SuccessAnalysis for chained operations from Object' do
-            klass = """
+            klass = Pelusa.to_ast """
             class Foo
               def execute
                 Object.new.to_s.inspect
               end
-            end""".to_ast
+            end"""
 
             analysis = @lint.check(klass)
             analysis.successful?.must_equal true
@@ -93,12 +93,12 @@ module Pelusa
               {"whitelist" => "Object, Kernel, Hash, Enumerable"}
             )
 
-            klass = """
+            klass = Pelusa.to_ast """
             class Foo
               def execute
                 {'a' => 2}.merge.each_pair {|k, v|}
               end
-            end""".to_ast
+            end"""
 
             analysis = @lint.check(klass)
             analysis.successful?.must_equal true
@@ -111,24 +111,24 @@ module Pelusa
               {"allow_conversions" => true}
             )
 
-            klass = """
+            klass = Pelusa.to_ast """
             class Foo
               def execute
                 {'a' => 2}.merge({}).to_hash.as_json
               end
-            end""".to_ast
+            end"""
 
             analysis = @lint.check(klass)
             analysis.successful?.must_equal true
           end
 
           it 'returns a FailureAnalysis for conversions if not allowed' do
-            klass = """
+            klass = Pelusa.to_ast """
             class Foo
               def execute
                 {'a' => 2}.merge({}).to_hash
               end
-            end""".to_ast
+            end"""
 
             analysis = @lint.check(klass)
             analysis.successful?.must_equal false

data/test/pelusa/lint/else_clauses_test.rb

@@ -10,7 +10,7 @@ module Pelusa
       describe '#check' do
         describe 'when the class does not use else clauses' do
           it 'returns a SuccessAnalysis' do
-            klass = """
+            klass = Pelusa.to_ast """
             class Foo
               def initialize
                 if 3
@@ -20,7 +20,7 @@ module Pelusa
                   3
                 end
               end
-            end""".to_ast
+            end"""
 
             analysis = @lint.check(klass)
             analysis.successful?.must_equal true
@@ -29,7 +29,7 @@ module Pelusa
 
         describe 'when the class uses else clauses' do
           it 'returns a FailureAnalysis' do
-            klass = """
+            klass = Pelusa.to_ast """
             class Foo
               def initialize
                 if 3
@@ -38,7 +38,7 @@ module Pelusa
                   9
                 end
               end
-            end""".to_ast
+            end"""
 
             analysis = @lint.check(klass)
             analysis.failed?.must_equal true

data/test/pelusa/lint/eval_usage_test.rb

@@ -16,7 +16,7 @@ class WithoutEval
   end
 end
 RUBY
-            klass = klass_str.to_ast
+            klass = Pelusa.to_ast klass_str
             analysis = @lint.check(klass)
             analysis.successful?.must_equal true
           end
@@ -31,7 +31,7 @@ class WithEval
   end
 end
 RUBY
-            klass = klass_str.to_ast
+            klass = Pelusa.to_ast klass_str
             analysis = @lint.check(klass)
             analysis.failed?.must_equal true
           end
@@ -47,7 +47,7 @@ class WithEvalUse
   end
 end
 RUBY
-            klass = klass_str.to_ast
+            klass = Pelusa.to_ast klass_str
             analysis = @lint.check(klass)
             analysis.successful?.must_equal true
           end

data/test/pelusa/lint/indentation_level_test.rb

@@ -10,14 +10,14 @@ module Pelusa
       describe '#check' do
         describe 'when the class has one method with one or less indentation levels' do
           it 'returns a SuccessAnalysis' do
-            klass = """
+            klass = Pelusa.to_ast """
             class Foo
               def initialize
                 if 9
                   3
                 end
               end
-            end""".to_ast
+            end"""
 
             analysis = @lint.check(klass)
             analysis.successful?.must_equal true
@@ -26,7 +26,7 @@ module Pelusa
 
         describe 'when the class has one method with more than one indentation level' do
           it 'returns a FailureAnalysis' do
-            klass = """
+            klass = Pelusa.to_ast """
             class Foo
               def initialize
                 if 9
@@ -35,7 +35,7 @@ module Pelusa
                   end
                 end
               end
-            end""".to_ast
+            end"""
 
             analysis = @lint.check(klass)
             analysis.failed?.must_equal true
@@ -44,7 +44,7 @@ module Pelusa
 
         describe "when there is method which produces nested list" do
           it 'returns a FailureAnalysis' do
-            klass = """
+            klass = Pelusa.to_ast """
             class Foo
               def initialize
                 if test
@@ -55,7 +55,7 @@ module Pelusa
                   ]
                 end
               end
-            end""".to_ast
+            end"""
 
             analysis = @lint.check klass
             analysis.failed?.must_equal true

data/test/pelusa/lint/instance_variables_test.rb

@@ -10,13 +10,13 @@ module Pelusa
       describe '#check' do
         describe 'when the class uses less than 3 ivars' do
           it 'returns a SuccessAnalysis' do
-            klass = """
+            klass = Pelusa.to_ast """
             class Foo
               def initialize
                 @foo = 1
                 @bar = 2
               end
-            end""".to_ast
+            end"""
 
             analysis = @lint.check(klass)
             analysis.successful?.must_equal true
@@ -25,14 +25,14 @@ module Pelusa
 
         describe 'when the class has more than 50 lines' do
           it 'returns a FailureAnalysis' do
-            klass = """
+            klass = Pelusa.to_ast """
             class Foo
               def initialize
                 @foo = 1
                 @bar = 2
                 @baz = 3
               end
-            end""".to_ast
+            end"""
 
             analysis = @lint.check(klass)
             analysis.failed?.must_equal true

data/test/pelusa/lint/line_restriction_test.rb

@@ -10,11 +10,11 @@ module Pelusa
       describe '#check' do
         describe 'when the class has less than 50 lines' do
           it 'returns a SuccessAnalysis' do
-            klass = """
+            klass = Pelusa.to_ast """
             class Foo
               attr_accessor :foo
               attr_accessor :bar
-            end""".to_ast
+            end"""
 
             analysis = @lint.check(klass)
             analysis.successful?.must_equal true
@@ -23,12 +23,12 @@ module Pelusa
 
         describe 'when the class has more than 50 lines' do
           it 'returns a FailureAnalysis' do
-            klass = """
+            klass = Pelusa.to_ast """
             class Foo
               attr_accessor :foo
               #{"\n" * 80}
               attr_accessor :bar
-            end""".to_ast
+            end"""
 
             analysis = @lint.check(klass)
             analysis.failed?.must_equal true

data/test/pelusa/lint/long_identifiers_test.rb

@@ -10,12 +10,12 @@ module Pelusa
       describe '#check' do
         describe 'when the class contains no long identifiers' do
           it 'returns a SuccessAnalysis' do
-            klass = """
+            klass = Pelusa.to_ast """
             class Foo
               def initialize
                 not_long_identifier = nil
               end
-            end""".to_ast
+            end"""
 
             analysis = @lint.check(klass)
             analysis.successful?.must_equal true
@@ -24,12 +24,12 @@ module Pelusa
 
         describe 'when the class contains a long identifier' do
           it 'returns a FailureAnalysis' do
-            klass = """
+            klass = Pelusa.to_ast """
             class Foo
               def initialize
                 it_is_long_identifier = nil
               end
-            end""".to_ast
+            end"""
 
             analysis = @lint.check(klass)
             analysis.failed?.must_equal true

data/test/pelusa/lint/many_arguments_test.rb

@@ -10,7 +10,7 @@ module Pelusa
       describe '#check' do
         describe 'when the class contains only method definitions with a small number of arguments' do
           it 'returns a SuccessAnalysis' do
-            klass = """
+            klass = Pelusa.to_ast """
             class Foo
               def bar(dog)
                 return dog
@@ -21,7 +21,7 @@ module Pelusa
               def bam(dog, cat, fish)
                 return dog + cat + fish
               end
-            end""".to_ast
+            end"""
 
             analysis = @lint.check(klass)
             analysis.successful?.must_equal true
@@ -30,12 +30,12 @@ module Pelusa
 
         describe 'when the class contains a method definition with many arguments' do
           it 'returns a FailureAnalysis' do
-            klass = """
+            klass = Pelusa.to_ast """
             class Foo
               def bar(dog, cat, fish, lobster)
                 x = 2
               end
-            end""".to_ast
+            end"""
 
             analysis = @lint.check(klass)
             analysis.failed?.must_equal true

data/test/pelusa/lint/properties_test.rb

@@ -10,7 +10,7 @@ module Pelusa
       describe '#check' do
         describe 'when the class does not use getters, setters or properties' do
           it 'returns a SuccessAnalysis' do
-            klass = """
+            klass = Pelusa.to_ast """
             class Foo
               def initialize
                 @name = 'john'
@@ -19,7 +19,7 @@ module Pelusa
               def name
                 @name
               end
-            end""".to_ast
+            end"""
 
             analysis = @lint.check(klass)
             analysis.successful?.must_equal true
@@ -28,11 +28,11 @@ module Pelusa
 
         describe 'when the class uses getters, setters or properties' do
           it 'returns a FailureAnalysis' do
-            klass = """
+            klass = Pelusa.to_ast """
             class Foo
               attr_accessor :name
               attr_reader :foo
-            end""".to_ast
+            end"""
 
             analysis = @lint.check(klass)
             analysis.failed?.must_equal true

data/test/pelusa/lint/short_identifiers_test.rb

@@ -10,12 +10,12 @@ module Pelusa
       describe '#check' do
         describe 'when the class contains no short identifiers' do
           it 'returns a SuccessAnalysis' do
-            klass = """
+            klass = Pelusa.to_ast """
             class Foo
               def initialize
                 foo = 3
               end
-            end""".to_ast
+            end"""
 
             analysis = @lint.check(klass)
             analysis.successful?.must_equal true
@@ -24,13 +24,13 @@ module Pelusa
 
         describe 'when the class contains short identifier from reserved list' do
           it 'returns a SuccessAnalysis' do
-            klass = """
+            klass = Pelusa.to_ast """
             class Foo
               def initialize
                 id = 2
                 pp id
               end
-            end""".to_ast
+            end"""
 
             analysis = @lint.check(klass)
             analysis.successful?.must_equal true
@@ -39,12 +39,12 @@ module Pelusa
 
         describe 'when the class contains a short identifier' do
           it 'returns a FailureAnalysis' do
-            klass = """
+            klass = Pelusa.to_ast """
             class Foo
               def initialize
                 x = 2
               end
-            end""".to_ast
+            end"""
 
             analysis = @lint.check(klass)
             analysis.failed?.must_equal true

data/test/test_helper.rb

@@ -5,3 +5,9 @@ require 'mocha/setup'
 require 'pelusa'
 
 FIXTURES_PATH = File.dirname(__FILE__) + '/fixtures'
+
+module Pelusa
+  def self.to_ast(string)
+    ::Rubinius::ToolSets.current::ToolSet::Melbourne.parse_string(string)
+  end
+end

metadata

@@ -1,31 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: pelusa
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.2.4
 platform: ruby
 authors:
 - Josep M. Bach
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-19 00:00:00.000000000 Z
+date: 2015-01-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
+  name: mocha
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: !binary |-
-          MA==
-  name: mocha
+        version: '0'
+  type: :development
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: !binary |-
-          MA==
-  prerelease: false
-  type: :development
+        version: '0'
 description: Static analysis Lint-type tool to improve your OO Ruby code
 email:
 - josep.m.bach@gmail.com
@@ -34,10 +32,10 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .pelusa.yml
-- .rvmrc
-- .travis.yml
+- ".gitignore"
+- ".pelusa.yml"
+- ".rvmrc"
+- ".travis.yml"
 - Gemfile
 - Rakefile
 - Readme.md
@@ -99,31 +97,26 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
-      version: !binary |-
-        MA==
+      version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
-      version: !binary |-
-        MA==
+      version: '0'
 requirements: []
 rubyforge_project: pelusa
-rubygems_version: 2.0.6
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Static analysis Lint-type tool to improve your OO Ruby code
 test_files:
-- test/pelusa_test.rb
-- test/test_helper.rb
 - test/pelusa/analysis_test.rb
 - test/pelusa/analyzer_test.rb
 - test/pelusa/class_analyzer_test.rb
 - test/pelusa/cli_test.rb
 - test/pelusa/configuration_test.rb
-- test/pelusa/runner_test.rb
 - test/pelusa/lint/case_statements_test.rb
 - test/pelusa/lint/collection_wrappers_test.rb
 - test/pelusa/lint/demeter_law_test.rb
@@ -137,3 +130,6 @@ test_files:
 - test/pelusa/lint/properties_test.rb
 - test/pelusa/lint/short_identifiers_test.rb
 - test/pelusa/reporters/ruby_reporter_test.rb
+- test/pelusa/runner_test.rb
+- test/pelusa_test.rb
+- test/test_helper.rb