mutant 0.1.1 → 0.2.0

data/lib/mutant/matcher.rb

@@ -0,0 +1,55 @@
+module Mutant
+  # Abstract matcher to find ASTs to mutate
+  class Matcher
+    include Adamantium::Flat, Enumerable, AbstractType
+    extend DescendantsTracker
+
+    # Enumerate subjects
+    #
+    # @api private
+    #
+    # @return [undefined]
+    #
+    abstract_method :each
+
+    # Return identification
+    #
+    # @return [String
+    #
+    # @api private
+    #
+    abstract_method :identification
+
+    # Return matcher
+    #
+    # @param [String] input
+    #
+    # @return [nil]
+    #   returns nil as default implementation
+    #
+    # @api private
+    #
+    def self.parse(input)
+      nil
+    end
+
+    # Return match from string
+    #
+    # @param [String] input
+    #
+    # @return [Matcher]
+    #   returns matcher input if successful
+    #
+    # @return [nil]
+    #   returns nil otherwise
+    #
+    def self.from_string(input)
+      descendants.each do |descendant|
+        matcher = descendant.parse(input)
+        return matcher if matcher
+      end
+
+      nil
+    end
+  end
+end

data/lib/mutant/matcher/chain.rb

@@ -0,0 +1,66 @@
+module Mutant
+  class Matcher
+    # A chain of matchers
+    class Chain < self
+      include Equalizer.new(:matchers)
+
+      # Enumerate subjects
+      #
+      # @return [Enumerator<Subject]
+      #   returns subject enumerator if no block given
+      #
+      # @return [self]
+      #   returnns self otherwise
+      #
+      # @api private
+      #
+      def each(&block)
+        return to_enum unless block_given?
+
+        matchers.each do |matcher|
+          matcher.each(&block)
+        end
+
+        self
+      end
+
+      # Return the chain of matchers
+      #
+      # @return [Enumerable<Chain>]
+      #
+      # @api private
+      #
+      attr_reader :matchers
+
+      # Build matcher chain
+      #
+      # @param [Enumerable<Matcher>] matchers
+      #
+      # @return [Matcher]
+      #
+      # @api private
+      #
+      def self.build(matchers)
+        if matchers.length == 1
+          return matchers.first
+        end
+
+        new(matchers)
+      end
+
+    private
+
+      # Initialize chain matcher
+      #
+      # @param [Enumerable<Matcher>] matchers
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def initialize(matchers)
+        @matchers = matchers
+      end
+    end
+  end
+end

data/lib/mutant/matcher/method.rb

@@ -0,0 +1,173 @@
+module Mutant
+  class Matcher
+    # Matcher for subjects that are a specific method
+    class Method < self
+      include Adamantium::Flat, Equalizer.new(:identification)
+
+      # Parse a method string into filter
+      #
+      # @param [String] input
+      #
+      # @return [Matcher::Method]
+      #
+      # @api private
+      #
+      def self.parse(input)
+        Classifier.run(input)
+      end
+
+      # Enumerate matches
+      #
+      # @return [Enumerable]
+      #   returns enumerable when no block given
+      #
+      # @return [self]
+      #   returns self when block given
+      #
+      # @api private
+      # 
+      def each(&block)
+        return to_enum unless block_given?
+        subject.tap do |subject|
+          yield subject if subject
+        end
+
+        self
+      end
+
+      # Return scope
+      #
+      # @return [Class|Module]
+      #
+      # @api private
+      #
+      attr_reader :scope
+
+      # Return context
+      #
+      # @return [Context::Scope]
+      #
+      # @api private
+      #
+      attr_reader :context
+
+      # Return method name
+      #
+      # @return [String]
+      #
+      # @api private
+      #
+      attr_reader :method_name
+
+      # Test if method is public
+      #
+      # @return [true]
+      #   if method is public
+      #
+      # @retur [false]
+      #   otherwise
+      #
+      # @api private
+      #
+      abstract_method :public?
+
+    private
+
+      # Initialize method filter
+      #
+      # @param [Class|Module] scope
+      # @param [Symbol] method_name
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def initialize(scope, method_name)
+        @scope, @method_name = scope, method_name.to_sym
+        @context = Context::Scope.build(scope, source_path)
+        # FIXME: cache public private should not be needed, loader should not override visibility! (But does currently) :(
+        public?
+      end
+
+      # Return method
+      #
+      # @return [UnboundMethod, Method]
+      #
+      # @api private
+      #
+      abstract_method :method
+
+      # Return full ast
+      #
+      # @return [Rubinius::AST::Node]
+      #
+      # @api private
+      #
+      def ast
+        File.read(source_path).to_ast
+      end
+
+      # Return path to source
+      #
+      # @return [String]
+      #
+      # @api private
+      #
+      def source_path
+        source_location.first
+      end
+
+      # Return source file line
+      #
+      # @return [Integer]
+      #
+      # @api private
+      #
+      def source_line
+        source_location.last
+      end
+
+      # Return source location
+      #
+      # @return [Array]
+      #
+      # @api private
+      #
+      def source_location
+        method.source_location
+      end
+
+      # Return subject
+      #
+      # @return [Subject]
+      #   returns subject if there is a matched node
+      #
+      # @return [nil]
+      #   otherwise
+      #
+      # @api private
+      #
+      def subject
+        node = matched_node
+        return unless node
+        Subject.new(self, context, node)
+      end
+      memoize :subject
+
+      # Return matched node
+      #
+      # @return [Rubinus::AST::Node]
+      #
+      # @api private
+      #
+      def matched_node
+        last_match = nil
+        ast.walk do |predicate, node|
+          last_match = node if match?(node)
+          predicate
+        end
+        last_match
+      end
+    end
+  end
+end

data/lib/mutant/matcher/method/classifier.rb

@@ -0,0 +1,126 @@
+module Mutant
+  class Matcher
+    class Method < self
+      # A classifier for input strings
+      class Classifier
+        include Adamantium::Flat
+
+        TABLE = {
+          '.' => Matcher::Method::Singleton,
+          '#' => Matcher::Method::Instance
+        }.freeze
+
+        SCOPE_FORMAT = /\A([^#.]+)(\.|#)(.+)\z/.freeze
+
+        # Positions of captured regexp groups
+        # Freezing fixnums to avoid their singleton classes are patched.
+        SCOPE_NAME_POSITION       = 1.freeze
+        SCOPE_SYMBOL_POSITION  = 2.freeze
+        METHOD_NAME_POSITION   = 3.freeze
+
+        private_class_method :new
+
+        # Run classifier
+        #
+        # @param [String] input
+        #
+        # @return [Matcher::Method]
+        #   returns matcher when input is in 
+        #
+        # @return [nil]
+        #   returns nil otherwise
+        #
+        # @api private
+        #
+        def self.run(input)
+          match = SCOPE_FORMAT.match(input)
+          return unless match
+          new(match).matcher
+        end
+
+        # Return method matcher
+        #
+        # @return [Matcher::Method]
+        #
+        # @api private
+        #
+        def matcher
+          matcher_class.new(scope, method_name)
+        end
+
+        # Return match
+        #
+        # @return [Matche]
+        #
+        # @api private
+        #
+        attr_reader :match
+
+      private
+
+        # Initialize matcher
+        #
+        # @param [MatchData] match
+        #
+        # @api private
+        #
+        def initialize(match)
+          @match = match
+        end
+
+        # Return scope 
+        #
+        # @return [Class|Module]
+        #
+        # @api private
+        #
+        def scope
+          scope_name.gsub(%r(\A::), '').split('::').inject(::Object) do |parent, name|
+            parent.const_get(name)
+          end
+        end
+        memoize :scope
+
+        # Return scope name
+        #
+        # @return [String]
+        #
+        # @api private
+        #
+        def scope_name
+          match[SCOPE_NAME_POSITION]
+        end
+
+        # Return method name
+        #
+        # @return [String]
+        #
+        # @api private
+        #
+        def method_name
+          match[METHOD_NAME_POSITION].to_sym
+        end
+
+        # Return scope symbol
+        #
+        # @return [Symbol]
+        #
+        # @api private
+        #
+        def scope_symbol
+          match[SCOPE_SYMBOL_POSITION]
+        end
+
+        # Return matcher class
+        #
+        # @return [Class:Mutant::Matcher]
+        #
+        # @api private
+        #
+        def matcher_class
+          TABLE.fetch(scope_symbol)
+        end
+      end
+    end
+  end
+end

data/lib/mutant/matcher/method/instance.rb

@@ -0,0 +1,67 @@
+module Mutant
+  class Matcher
+    class Method < self
+      # Matcher for instance methods
+      class Instance < self
+
+
+        # Return identification
+        #
+        # @return [String]
+        #
+        # @api private
+        #
+        def identification
+          "#{scope.name}##{method_name}"
+        end
+
+        # Test if method is public
+        #
+        # @return [true]
+        #   if method is public
+        #
+        # @return [false]
+        #   otherwise
+        #
+        # @api private
+        #
+        def public?
+          scope.public_method_defined?(method_name)
+        end
+        memoize :public?
+
+      private
+
+        # Check if node is matched
+        #
+        # @param [Rubinius::AST::Node] node
+        #
+        # @return [true]
+        #   returns true if node matches method
+        #
+        # @return [false]
+        #   returns false if node NOT matches method
+        #
+        # @api private
+        #
+        def match?(node)
+          node.line  == source_line &&
+          node.class == Rubinius::AST::Define  &&
+          node.name  == method_name
+        end
+
+        # Return method instance
+        #
+        # @return [UnboundMethod]
+        #
+        # @api private
+        #
+        def method
+          scope.instance_method(method_name)
+        end
+        memoize :method, :freezer => :noop
+
+      end
+    end
+  end
+end