mutant 0.5.17 → 0.5.18

data/lib/mutant/cli/classifier.rb

@@ -1,139 +0,0 @@
-# encoding: utf-8
-
-module Mutant
-  class CLI
-    # A classifier for input strings
-    class Classifier
-      include AbstractType, Adamantium::Flat, Concord.new(:cache, :match)
-
-      include Equalizer.new(:identifier)
-
-      SCOPE_NAME_PATTERN = /[A-Za-z][A-Za-z\d_]*/.freeze
-      SCOPE_OPERATOR     = '::'.freeze
-      CBASE_PATTERN      = /\A#{SCOPE_OPERATOR}/.freeze
-
-      METHOD_NAME_PATTERN = Regexp.union(
-        /[A-Za-z_][A-Za-z\d_]*[!?=]?/,
-        *OPERATOR_METHODS.map(&:to_s)
-      ).freeze
-
-      SCOPE_PATTERN = /
-        (?:#{SCOPE_OPERATOR})?#{SCOPE_NAME_PATTERN}
-        (?:#{SCOPE_OPERATOR}#{SCOPE_NAME_PATTERN})*
-      /x.freeze
-
-      REGISTRY = {}
-
-      # Register classifier
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
-      def self.register(regexp)
-        REGISTRY[regexp] = self
-      end
-      private_class_method :register
-
-      # Return constant
-      #
-      # @param [String] location
-      #
-      # @return [Class|Module]
-      #
-      # @api private
-      #
-      def self.constant_lookup(location)
-        location.sub(CBASE_PATTERN, EMPTY_STRING).split(SCOPE_OPERATOR)
-          .reduce(Object) do |parent, name|
-          parent.const_get(name, nil)
-        end
-      end
-
-      # Return matchers for input
-      #
-      # @param [Cache] cache
-      # @param [String] pattern
-      #
-      # @return [Matcher]
-      #   if a classifier handles the input
-      #
-      # @raise [RuntimeError]
-      #   otherwise
-      #
-      # @api private
-      #
-      def self.run(cache, pattern)
-        matches = find(pattern)
-        case matches.length
-        when 0
-          raise Error, "No matcher handles: #{pattern.inspect}"
-        when 1
-          klass, match = matches.first
-          klass.new(cache, match).matcher
-        else
-          raise Error, "More than one matcher found for: #{pattern.inspect}"
-        end
-      end
-
-      # Find classifiers
-      #
-      # @param [String] input
-      #
-      # @return [Classifier]
-      #   if classifier can be found
-      #
-      # @return [nil]
-      #   otherwise
-      #
-      # @api private
-      #
-      def self.find(input)
-        REGISTRY.each_with_object([]) do |(regexp, klass), matches|
-          match = regexp.match(input)
-          if match
-            matches << [klass, match]
-          end
-        end
-      end
-      private_class_method :find
-
-      # Enumerate subjects
-      #
-      # @return [self]
-      #   if block given
-      #
-      # @return [Enumerator<Subject>]
-      #   otherwise
-      #
-      # @api private
-      #
-      def each(&block)
-        return to_enum unless block_given?
-        matcher.each(&block)
-        self
-      end
-
-      # Return identifier
-      #
-      # @return [String]
-      #
-      # @api private
-      #
-      def identifier
-        match.to_s
-      end
-      memoize :identifier
-
-      # Return matcher
-      #
-      # @return [Matcher]
-      #
-      # @api private
-      #
-      abstract_method :matcher
-      private :matcher
-
-    end # Classifier
-  end # CLI
-end # Mutant

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

@@ -1,105 +0,0 @@
-# encoding: utf-8
-
-module Mutant
-  class CLI
-    class Classifier
-
-      # Explicit method classifier
-      class Method < self
-
-        TABLE = {
-          '.' => Matcher::Methods::Singleton,
-          '#' => Matcher::Methods::Instance
-        }.freeze
-
-        REGEXP = /
-          \A
-            (?<scope_name>#{SCOPE_PATTERN})
-            (?<scope_symbol>[.#])
-            (?<method_name>#{METHOD_NAME_PATTERN})
-          \z
-        /x.freeze
-
-        register(REGEXP)
-
-        # Return method matcher
-        #
-        # @return [Matcher::Method]
-        #
-        # @api private
-        #
-        def matcher
-          methods_matcher.matcher.build(cache, scope, method)
-        end
-        memoize :matcher
-
-      private
-
-        # Return method
-        #
-        # @return [Method, UnboundMethod]
-        #
-        # @api private
-        #
-        def method
-          methods_matcher.methods.detect do |method|
-            method.name == method_name
-          end or raise NameError, "Cannot find method #{identifier}"
-        end
-        memoize :method, freezer: :noop
-
-        # Return scope name
-        #
-        # @return [String]
-        #
-        # @api private
-        #
-        def scope_name
-          match[__method__]
-        end
-
-        # Return scope
-        #
-        # @return [Class, Method]
-        #
-        # @api private
-        #
-        def scope
-          Classifier.constant_lookup(scope_name)
-        end
-
-        # Return method name
-        #
-        # @return [String]
-        #
-        # @api private
-        #
-        def method_name
-          match[__method__].to_sym
-        end
-
-        # Return scope symbol
-        #
-        # @return [Symbol]
-        #
-        # @api private
-        #
-        def scope_symbol
-          match[__method__]
-        end
-
-        # Return matcher class
-        #
-        # @return [Class:Mutant::Matcher]
-        #
-        # @api private
-        #
-        def methods_matcher
-          TABLE.fetch(scope_symbol).new(cache, scope)
-        end
-        memoize :methods_matcher
-
-      end # Method
-    end # Classifier
-  end # CLI
-end # Mutant

data/lib/mutant/cli/classifier/namespace.rb

@@ -1,49 +0,0 @@
-# encoding: utf-8
-
-module Mutant
-  class CLI
-    class Classifier
-
-      # Namespace classifier
-      class Namespace < self
-
-        # Return matcher
-        #
-        # @return [Matcher]
-        #
-        # @api private
-        #
-        def matcher
-          self.class::MATCHER.new(cache, namespace)
-        end
-
-      private
-
-        # Return namespace
-        #
-        # @return [Class, Module]
-        #
-        # @api private
-        #
-        def namespace
-          Classifier.constant_lookup(match[__method__].to_s)
-        end
-
-        # Recursive namespace classifier
-        class Recursive < self
-          REGEXP  = /\A(?<namespace>#{SCOPE_PATTERN})\*\z/.freeze
-          MATCHER = Matcher::Namespace
-          register(REGEXP)
-        end # Recursive
-
-        # Recursive namespace classifier
-        class Flat < self
-          REGEXP  = /\A(?<namespace>#{SCOPE_PATTERN})\z/.freeze
-          MATCHER = Matcher::Scope
-          register(REGEXP)
-        end # Flat
-
-      end # Namespace
-    end # Classifier
-  end # CLI
-end # Mutant

data/spec/unit/mutant/cli/classifier/method_spec.rb

@@ -1,77 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Mutant::CLI::Classifier::Method, '#each' do
-
-  let(:object)           { described_class.run(cache, input) }
-  let(:cache)            { Mutant::Cache.new                   }
-  let(:instance_method)  { '::TestApp::Literal#string'         }
-  let(:singleton_method) { '::TestApp::Literal.string'         }
-  let(:unknown_method)   { '::TestApp::Literal#unknown'        }
-
-  context 'with a block' do
-    subject { object.each {} }
-
-    context 'with an instance method name' do
-      let(:input) { instance_method }
-
-      it_behaves_like 'a command method'
-
-      it 'yield an instance subject' do
-        expect { |block| object.each(&block) }
-          .to yield_with_args(Mutant::Subject::Method::Instance)
-      end
-    end
-
-    context 'with an singleton method name' do
-      let(:input) { singleton_method }
-
-      it_behaves_like 'a command method'
-
-      it 'yield an instance subject' do
-        expect { |block| object.each(&block) }
-          .to yield_with_args(Mutant::Subject::Method::Singleton)
-      end
-    end
-
-    context 'with an unknown method' do
-      let(:input) { unknown_method }
-
-      it 'raises an exception' do
-        expect { subject }
-          .to raise_error(NameError, "Cannot find method #{input}")
-      end
-    end
-  end
-
-  context 'without a block' do
-    subject { object.each }
-
-    context 'with an instance method name' do
-      let(:input) { instance_method }
-
-      it 'returns an enumerator' do
-        should be_instance_of(to_enum.class)
-      end
-
-      it 'yield an instance subject' do
-        expect { |block| subject.each(&block) }
-          .to yield_with_args(Mutant::Subject::Method::Instance)
-      end
-    end
-
-    context 'with an singleton method name' do
-      let(:input) { singleton_method }
-
-      it 'returns an enumerator' do
-        should be_instance_of(to_enum.class)
-      end
-
-      it 'yield an instance subject' do
-        expect { |block| subject.each(&block) }
-          .to yield_with_args(Mutant::Subject::Method::Singleton)
-      end
-    end
-  end
-end

data/spec/unit/mutant/cli/classifier/namespace/flat_spec.rb

@@ -1,58 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Mutant::CLI::Classifier::Namespace::Flat, '#each' do
-  let(:object)            { described_class.run(cache, input) }
-  let(:cache)             { Mutant::Cache.new                   }
-  let(:known_namespace)   { '::TestApp::Literal'                }
-  let(:unknown_namespace) { '::TestApp::Object'                 }
-
-  context 'with a block' do
-    subject { object.each {} }
-
-    context 'with a known namespace' do
-      let(:input) { known_namespace }
-
-      it_behaves_like 'a command method'
-
-      it 'yield method subjects' do
-        expect { |block| object.each(&block) }
-          .to yield_control.exactly(7).times
-      end
-    end
-
-    context 'with an unknown namespace' do
-      let(:input) { unknown_namespace }
-
-      it 'raises an exception' do
-        expect { subject }.to raise_error(NameError)
-      end
-    end
-  end
-
-  context 'without a block' do
-    subject { object.each }
-
-    context 'with a known namespace' do
-      let(:input) { known_namespace }
-
-      it 'returns an enumerator' do
-        should be_instance_of(to_enum.class)
-      end
-
-      it 'yield an instance subject' do
-        expect { |block| object.each(&block) }
-          .to yield_control.exactly(7).times
-      end
-    end
-
-    context 'with an unknown namespace' do
-      let(:input) { unknown_namespace }
-
-      it 'raises an exception when #each is called' do
-        expect { subject.each {} }.to raise_error(NameError)
-      end
-    end
-  end
-end

data/spec/unit/mutant/cli/classifier/namespace/recursive_spec.rb

@@ -1,58 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Mutant::CLI::Classifier::Namespace::Recursive, '#each' do
-  let(:object)            { described_class.run(cache, "#{input}*") }
-  let(:cache)             { Mutant::Cache.new                         }
-  let(:known_namespace)   { '::TestApp::Literal'                      }
-  let(:unknown_namespace) { '::TestApp::Object'                       }
-
-  context 'with a block' do
-    subject { object.each {} }
-
-    context 'with a known namespace' do
-      let(:input) { known_namespace }
-
-      it_behaves_like 'a command method'
-
-      it 'yield method subjects' do
-        expect { |block| object.each(&block) }
-          .to yield_control.exactly(7).times
-      end
-    end
-
-    context 'with an unknown namespace' do
-      let(:input) { unknown_namespace }
-
-      it 'raises an exception' do
-        expect { subject }.to raise_error(NameError)
-      end
-    end
-  end
-
-  context 'without a block' do
-    subject { object.each }
-
-    context 'with a known namespace' do
-      let(:input) { known_namespace }
-
-      it 'returns an enumerator' do
-        should be_instance_of(to_enum.class)
-      end
-
-      it 'yield an instance subject' do
-        expect { |block| object.each(&block) }
-          .to yield_control.exactly(7).times
-      end
-    end
-
-    context 'with an unknown namespace' do
-      let(:input) { unknown_namespace }
-
-      it 'raises an exception when #each is called' do
-        expect { subject.each {} }.to raise_error(NameError)
-      end
-    end
-  end
-end