mtrack 0.0.6 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c56fff84edc290d50cf54089be128d852f7cfc76
-  data.tar.gz: d788599143e95cbdc6a9502efb90151959a89c79
+  metadata.gz: b7d5ea4aa7136ed160c80c7c6e466ad9bd1ac740
+  data.tar.gz: 550043786f96f7223b185eaf3fd127e9745116cb
 SHA512:
-  metadata.gz: 58dbd4ecfb53098153e0bad97852c2dc39189378524a745b608e2cf4cc7fa6ac774cae170477f3a03d9be4a07455038b378c31783466ecf097a3e630c26aa728
-  data.tar.gz: 66099b22080f61ccc56007faad78e65cd78c84e320a42803bbbd356965ae74e692fb5626d27096b84a2aa81774b4b7aabec20692590a2355c33b9b3adafed537
+  metadata.gz: bc1c526fe0e5936825f9756c9f4f5b8c7d4577c6c22b100796e01aaa32004c9c01694efde3d4dd5b0a7f8995f7bb77430bb16fa334021643f9b5a1a14f2a022b
+  data.tar.gz: d10f0fc4dcba69e9704d4806c3cdbc17b6cbae7dd9beb6ed9ff5b193f63e78ec24262cd10bc932c9ac47da5204a6a94d98094e9525da40a70608f9c7485cb246

data/.ruby-version

@@ -1 +1 @@
-2.1.2
+2.1.3

data/Gemfile

@@ -2,15 +2,15 @@ source "https://rubygems.org"
 gemspec
 
 group :development do
-  gem "byebug", "~> 3.4.0"
+  gem "byebug", "~> 3.5.1"
   gem "guard-rspec", "~> 4.3.1"
-  gem "libnotify", "~> 0.8.3"
+  gem "libnotify", "~> 0.8.4"
   gem "pry", "~> 0.10.1"
 end
 
 group :development, :test do
-  gem "codeclimate-test-reporter", "~> 0.4.0"
+  gem "codeclimate-test-reporter", "~> 0.4.1"
   gem "rake", "~> 10.3.2"
   gem "rspec", "~> 3.1.0"
-  gem "simplecov", "~> 0.9.0"
+  gem "simplecov", "~> 0.9.1"
 end

data/README.md

@@ -4,13 +4,12 @@
 [![Build Status](http://img.shields.io/travis/gdeoliveira/mtrack.svg)][travis]
 [![Code Climate](http://img.shields.io/codeclimate/github/gdeoliveira/mtrack.svg)][codeclimate]
 [![Test Coverage](http://img.shields.io/codeclimate/coverage/github/gdeoliveira/mtrack.svg)][codeclimate]
-[![Dependency Status](https://gemnasium.com/gdeoliveira/mtrack.svg)][gemnasium]
+[![Dependency Status](http://img.shields.io/gemnasium/gdeoliveira/mtrack.svg)][gemnasium]
 [![Inline docs](http://inch-ci.org/github/gdeoliveira/mtrack.svg?branch=master)][inch-ci]
 
 [gem]: https://rubygems.org/gems/mtrack
 [travis]: http://travis-ci.org/gdeoliveira/mtrack
 [codeclimate]: https://codeclimate.com/github/gdeoliveira/mtrack
-[gemnasium]: https://gemnasium.com/gdeoliveira/mtrack
 [gemnasium]: https://gemnasium.com/gdeoliveira/mtrack#development-dependencies
 [inch-ci]: http://inch-ci.org/github/gdeoliveira/mtrack
 
@@ -42,6 +41,8 @@ To track a group of methods within a Module (or a Class).
 require "mtrack"
 
 module Stooges
+  extend MTrack::Mixin
+
   def shemp; end
 
   track_methods do
@@ -60,6 +61,8 @@ Methods can be grouped using an optional name.
 require "mtrack"
 
 module Numbers
+  extend MTrack::Mixin
+
   def zero; end
 
   track_methods :integers do
@@ -109,6 +112,8 @@ abstraction for the state machine.
 require "mtrack"
 
 class SimpleStateMachine
+  extend MTrack::Mixin
+
   class << self
     private
 

data/lib/mtrack.rb

@@ -1,4 +1,2 @@
-require "mtrack/module_mixin"
+require "mtrack/mixin"
 require "mtrack/version"
-
-Module.send(:include, MTrack::ModuleMixin)

data/lib/mtrack/mixin.rb

@@ -0,0 +1,182 @@
+require "mtrack/state"
+
+module MTrack
+  ##
+  # This module provides the #track_methods method to Classes or Modules that
+  # mix it in. It also enables the extended Class or Module to pass tracked
+  # methods to its subclasses and submodules.
+  module Mixin
+    class << self
+      private
+
+      ##
+      # call-seq:
+      #   extended(submodule) => submodule
+      #
+      # Initializes a State variable on the Class or Module that extended Mixin.
+      #
+      # Returns passed +submodule+.
+      def extended(submodule)
+        submodule.instance_eval { @__mtrack__ ||= State.new }
+        submodule
+      end
+
+      ##
+      # call-seq:
+      #   newly_defined_methods(mod, old_methods) => set
+      #
+      # Calculates the difference between +mod+'s currently defined public
+      # methods and +old_methods+.
+      #
+      # Returns a set with the result.
+      def newly_defined_methods(mod, old_methods)
+        (mod.public_instance_methods(false) - old_methods).map(&:to_sym).to_set
+      end
+
+      ##
+      # call-seq:
+      #   save_tracked_methods(mod, group_name, tracked) => nil
+      #
+      # Saves +tracked+ methods for +mod+ under a +group_name+.
+      #
+      # Returns a +nil+ value.
+      def save_tracked_methods(mod, group_name, tracked)
+        mod.instance_variable_get(:@__mtrack__)[group_name].merge_tracked tracked unless tracked.empty?
+        nil
+      end
+
+      ##
+      # call-seq:
+      #   track_methods_for(mod, group_name) => set
+      #   track_methods_for(mod, group_name) {|| ... } => set
+      #
+      # Sets up an MTrack::State instance for +mod+.
+      #
+      # If a block is provided all the methods defined within the block will be
+      # tracked under the +group_name+ parameter.
+      #
+      # Returns a set containing the methods that were defined within the block.
+      def track_methods_for(mod, group_name, &b)
+        old_methods = mod.public_instance_methods false
+
+        begin
+          mod.module_eval &b if block_given?
+        ensure
+          tracked = newly_defined_methods(mod, old_methods)
+          save_tracked_methods(mod, group_name, tracked)
+        end
+
+        tracked
+      end
+    end
+
+    public
+
+    ##
+    # call-seq:
+    #   tracked_methods(group_name = nil) => set
+    #
+    # Returns a set containing the currently tracked methods for a +group_name+.
+    #
+    #   class C
+    #     extend MTrack::Mixin
+    #     track_methods :my_group do
+    #       def method_1; end
+    #       def method_2; end
+    #     end
+    #   end
+    #
+    #   C.tracked_methods :my_group  #=> #<Set: {:method_1, :method_2}>
+    def tracked_methods(group_name = nil)
+      @__mtrack__.tracked group_name
+    end
+
+    private
+
+    ##
+    # call-seq:
+    #   included(submodule) => submodule
+    #
+    # Sets this state as a super-state of the +submodule+ (Class or Module) that
+    # has included the current Module.
+    #
+    # Returns passed +submodule+.
+    def included(submodule)
+      state = @__mtrack__
+      submodule.instance_eval do
+        extend Mixin
+        @__mtrack__.add_super_state state
+      end
+      submodule
+    end
+
+    ##
+    # call-seq:
+    #   inherited(submodule) => submodule
+    #
+    # Sets this state as a super-state of the +submodule+ (Class) that has
+    # inherited from the current Class.
+    #
+    # Returns passed +submodule+.
+    alias_method :inherited, :included
+
+    ##
+    # call-seq:
+    #   method_added(name) => name
+    #
+    # Allows method +name+ to be displayed on #tracked_methods once again after
+    # being disabled by a call to #method_undefined.
+    #
+    # Returns passed +name+.
+    def method_added(name)
+      @__mtrack__.delete_undefined name
+    end
+
+    ##
+    # call-seq:
+    #   method_removed(name) => name
+    #
+    # Stops tracking method +name+ in the current Class or Module.
+    #
+    # Returns passed +name+.
+    def method_removed(name)
+      @__mtrack__.delete_tracked name
+    end
+
+    ##
+    # call-seq:
+    #   method_undefined(name) => name
+    #
+    # Stops tracking method +name+ in the current Class or Module and prevents
+    # homonymous methods tracked in super-states from being displayed as
+    # #tracked_methods.
+    #
+    # Returns passed +name+.
+    def method_undefined(name)
+      @__mtrack__.delete_tracked name
+      @__mtrack__.add_undefined name
+    end
+
+    ##
+    # call-seq:
+    #   track_methods(group_name = nil) => set
+    #   track_methods(group_name = nil) {|| ... } => set
+    #
+    # If a block is provided all the methods defined within the block will be
+    # tracked under the optional +group_name+ parameter.
+    #
+    # Returns a set containing the methods that were defined within the block.
+    #
+    #   class C
+    #     extend MTrack::Mixin
+    #     track_methods do
+    #       def method_1; end
+    #       track_methods(:inner_group_1) { def method_2; end }
+    #       def method_3; end
+    #     end
+    #   end  #=> #<Set: {:method_1, :method_2, :method_3}>
+    def track_methods(group_name = nil, &b)
+      Mixin.send(:track_methods_for, self, group_name, &b)
+    end
+  end
+end

data/lib/mtrack/version.rb

@@ -4,6 +4,7 @@
 # even through a hierarchy of inclusion and/or inheritance.
 #
 #   module M
+#     extend MTrack::Mixin
 #     track_methods { def method_1; end }
 #   end
 #
@@ -20,5 +21,5 @@
 module MTrack
 
   # Current version of MTrack.
-  VERSION = "0.0.6"
+  VERSION = "1.0.0"
 end

data/spec/lib/mtrack/mixin_spec.rb

@@ -0,0 +1,405 @@
+require "spec_helper"
+
+METHOD_DEFINITION = proc {}
+
+describe MTrack::Mixin do
+  describe "#track_methods" do
+    it "is added after extending #{described_class}" do
+      mod = ::Module.new
+      expect(mod.private_methods.map(&:to_sym)).not_to include(:track_methods)
+      mod.module_eval { extend MTrack::Mixin }
+      expect(mod.private_methods.map(&:to_sym)).to include(:track_methods)
+    end
+
+    context "no block given" do
+      it "returns an empty set" do
+        mod = ::Module.new.module_eval do
+          extend MTrack::Mixin
+          track_methods :group
+        end
+        expect(mod).to be_a(Set)
+        expect(mod).to be_empty
+      end
+    end
+  end
+
+  describe "hierarchy" do
+    let(:base_module_1) do
+      Module.new.tap do |m|
+        m.module_eval do
+          extend MTrack::Mixin
+          define_method :unt_1, METHOD_DEFINITION
+          track_methods { define_method :meth, METHOD_DEFINITION }
+          track_methods :numbers do
+            track_methods(:odd) { define_method :one, METHOD_DEFINITION }
+            track_methods(:even) { define_method :two, METHOD_DEFINITION }
+          end
+          define_method :unt_2, METHOD_DEFINITION
+        end
+      end
+    end
+  
+    let(:base_module_2) do
+      Module.new.tap do |m|
+        m.module_eval do
+          extend MTrack::Mixin
+          define_method :unt_2, METHOD_DEFINITION
+          track_methods { define_method :meth, METHOD_DEFINITION }
+          track_methods :numbers do
+            track_methods(:even) { define_method :two, METHOD_DEFINITION }
+            track_methods(:odd) { define_method :three, METHOD_DEFINITION }
+          end
+          define_method :unt_3, METHOD_DEFINITION
+        end
+      end
+    end
+  
+    let(:base_module_3) do
+      Module.new.tap do |m|
+        m.module_eval do
+          extend MTrack::Mixin
+          define_method :unt_3, METHOD_DEFINITION
+          track_methods { define_method :meth, METHOD_DEFINITION }
+          track_methods :numbers do
+            track_methods(:odd) { define_method :three, METHOD_DEFINITION }
+            track_methods(:even) { define_method :four, METHOD_DEFINITION }
+          end
+          define_method :unt_4, METHOD_DEFINITION
+        end
+      end
+    end
+  
+    let(:sub_module_1) do
+      bm_1 = base_module_1
+      bm_2 = base_module_2
+      Module.new.tap do |m|
+        m.module_eval do
+          include bm_1
+          define_method :unt_4, METHOD_DEFINITION
+          track_methods { define_method :meth, METHOD_DEFINITION }
+          track_methods :numbers do
+            track_methods(:even) { define_method :four, METHOD_DEFINITION }
+            track_methods(:odd) { define_method :five, METHOD_DEFINITION }
+          end
+          define_method :unt_5, METHOD_DEFINITION
+          include bm_2
+        end
+      end
+    end
+  
+    let(:sub_module_2) do
+      bm_3 = base_module_3
+      Module.new.tap do |m|
+        m.module_eval do
+          extend MTrack::Mixin
+          define_method :unt_5, METHOD_DEFINITION
+          track_methods { define_method :meth, METHOD_DEFINITION }
+          include bm_3
+          track_methods :numbers do
+            track_methods(:odd) { define_method :five, METHOD_DEFINITION }
+            track_methods(:even) { define_method :six, METHOD_DEFINITION }
+          end
+          define_method :unt_6, METHOD_DEFINITION
+        end
+      end
+    end
+  
+    let(:super_class) do
+      sm_1 = sub_module_1
+      Class.new.tap do |c|
+        c.class_eval do
+          include sm_1
+          define_method :unt_6, METHOD_DEFINITION
+          track_methods { define_method :meth, METHOD_DEFINITION }
+          track_methods :numbers do
+            track_methods(:even) { define_method :six, METHOD_DEFINITION }
+            track_methods(:odd) { define_method :seven, METHOD_DEFINITION }
+          end
+          define_method :unt_7, METHOD_DEFINITION
+        end
+      end
+    end
+  
+    let(:sub_class) do
+      sm_2 = sub_module_2
+      sc = super_class
+      Class.new(sc).tap do |c|
+        c.class_eval do
+          define_method :unt_7, METHOD_DEFINITION
+          track_methods { define_method :meth, METHOD_DEFINITION }
+          track_methods :numbers do
+            track_methods(:odd) { define_method :seven, METHOD_DEFINITION }
+            track_methods(:even) { define_method :eight, METHOD_DEFINITION }
+          end
+          define_method :unt_8, METHOD_DEFINITION
+          include sm_2
+        end
+      end
+    end
+
+    context "base module 1" do
+      subject { base_module_1 }
+  
+      it "tracks methods" do
+        expect(subject.tracked_methods).to match_array([:meth])
+        expect(subject.tracked_methods(:numbers)).to match_array([:one, :two])
+        expect(subject.tracked_methods(:odd)).to match_array([:one])
+        expect(subject.tracked_methods(:even)).to match_array([:two])
+      end
+  
+      it "untracks removed methods" do
+        subject.module_eval { remove_method :meth }
+        expect(subject.tracked_methods).to be_empty
+      end
+  
+      it "untracks undefined methods" do
+        subject.module_eval { undef_method :meth }
+        expect(subject.tracked_methods).to be_empty
+  
+        subject.module_eval { define_method :meth, METHOD_DEFINITION }
+        expect(subject.tracked_methods).to be_empty
+      end
+    end
+  
+    context "base module 2" do
+      subject { base_module_2 }
+  
+      it "tracks methods" do
+        expect(subject.tracked_methods).to match_array([:meth])
+        expect(subject.tracked_methods(:numbers)).to match_array([:two, :three])
+        expect(subject.tracked_methods(:even)).to match_array([:two])
+        expect(subject.tracked_methods(:odd)).to match_array([:three])
+      end
+  
+      it "untracks removed methods" do
+        subject.module_eval { remove_method :meth }
+        expect(subject.tracked_methods).to be_empty
+      end
+  
+      it "untracks undefined methods" do
+        subject.module_eval { undef_method :meth }
+        expect(subject.tracked_methods).to be_empty
+  
+        subject.module_eval { define_method :meth, METHOD_DEFINITION }
+        expect(subject.tracked_methods).to be_empty
+      end
+    end
+  
+    context "base module 3" do
+      subject { base_module_3 }
+  
+      it "tracks methods" do
+        expect(subject.tracked_methods).to match_array([:meth])
+        expect(subject.tracked_methods(:numbers)).to match_array([:three, :four])
+        expect(subject.tracked_methods(:odd)).to match_array([:three])
+        expect(subject.tracked_methods(:even)).to match_array([:four])
+      end
+  
+      it "untracks removed methods" do
+        subject.module_eval { remove_method :meth }
+        expect(subject.tracked_methods).to be_empty
+      end
+  
+      it "untracks undefined methods" do
+        subject.module_eval { undef_method :meth }
+        expect(subject.tracked_methods).to be_empty
+  
+        subject.module_eval { define_method :meth, METHOD_DEFINITION }
+        expect(subject.tracked_methods).to be_empty
+      end
+    end
+  
+    context "sub module 1" do
+      subject { sub_module_1 }
+  
+      it "tracks methods" do
+        expect(subject.tracked_methods).to match_array([:meth])
+        expect(subject.tracked_methods(:numbers)).to match_array([:one, :two, :three, :four, :five])
+        expect(subject.tracked_methods(:odd)).to match_array([:one, :three, :five])
+        expect(subject.tracked_methods(:even)).to match_array([:two, :four])
+      end
+  
+      it "untracks removed methods" do
+        subject.module_eval { remove_method :meth }
+        expect(subject.tracked_methods).to match_array([:meth])
+  
+        base_module_1.module_eval { remove_method :meth }
+        expect(subject.tracked_methods).to match_array([:meth])
+  
+        base_module_2.module_eval { remove_method :meth }
+        expect(subject.tracked_methods).to be_empty
+      end
+  
+      it "untracks undefined methods" do
+        subject.module_eval { undef_method :meth }
+        expect(subject.tracked_methods).to be_empty
+  
+        subject.module_eval { define_method :meth, METHOD_DEFINITION }
+        expect(subject.tracked_methods).to match_array([:meth])
+      end
+    end
+  
+    context "sub module 2" do
+      subject { sub_module_2 }
+  
+      it "tracks methods" do
+        expect(subject.tracked_methods).to match_array([:meth])
+        expect(subject.tracked_methods(:numbers)).to match_array([:three, :four, :five, :six])
+        expect(subject.tracked_methods(:odd)).to match_array([:three, :five])
+        expect(subject.tracked_methods(:even)).to match_array([:four, :six])
+      end
+  
+      it "untracks removed methods" do
+        base_module_3.module_eval { remove_method :meth }
+        expect(subject.tracked_methods).to match_array([:meth])
+  
+        subject.module_eval { remove_method :meth }
+        expect(subject.tracked_methods).to be_empty
+      end
+  
+      it "untracks undefined methods" do
+        subject.module_eval { undef_method :meth }
+        expect(subject.tracked_methods).to be_empty
+  
+        subject.module_eval { define_method :meth, METHOD_DEFINITION }
+        expect(subject.tracked_methods).to match_array([:meth])
+      end
+    end
+  
+    context "super class" do
+      subject { super_class }
+  
+      it "tracks methods" do
+        expect(subject.tracked_methods).to match_array([:meth])
+        expect(subject.tracked_methods(:numbers)).to match_array([:one, :two, :three, :four, :five, :six, :seven])
+        expect(subject.tracked_methods(:odd)).to match_array([:one, :three, :five, :seven])
+        expect(subject.tracked_methods(:even)).to match_array([:two, :four, :six])
+      end
+  
+      it "untracks removed methods" do
+        subject.class_eval { remove_method :meth }
+        expect(subject.tracked_methods).to match_array([:meth])
+  
+        sub_module_1.module_eval { remove_method :meth }
+        expect(subject.tracked_methods).to match_array([:meth])
+  
+        base_module_2.module_eval { remove_method :meth }
+        expect(subject.tracked_methods).to match_array([:meth])
+  
+        base_module_1.module_eval { remove_method :meth }
+        expect(subject.tracked_methods).to be_empty
+      end
+  
+      it "untracks undefined methods" do
+        subject.module_eval { undef_method :meth }
+        expect(subject.tracked_methods).to be_empty
+  
+        subject.module_eval { define_method :meth, METHOD_DEFINITION }
+        expect(subject.tracked_methods).to match_array([:meth])
+      end
+    end
+  
+    context "sub class" do
+      subject { sub_class }
+  
+      it "tracks methods" do
+        expect(subject.tracked_methods).to match_array([:meth])
+        expect(subject.tracked_methods(:numbers)).to match_array([:one, :two, :three, :four, :five, :six, :seven, :eight])
+        expect(subject.tracked_methods(:odd)).to match_array([:one, :three, :five, :seven])
+        expect(subject.tracked_methods(:even)).to match_array([:two, :four, :six, :eight])
+      end
+  
+      it "untracks removed methods" do
+        base_module_1.module_eval { remove_method :meth }
+        expect(subject.tracked_methods).to match_array([:meth])
+  
+        base_module_2.module_eval { remove_method :meth }
+        expect(subject.tracked_methods).to match_array([:meth])
+  
+        base_module_3.module_eval { remove_method :meth }
+        expect(subject.tracked_methods).to match_array([:meth])
+  
+        sub_module_1.module_eval { remove_method :meth }
+        expect(subject.tracked_methods).to match_array([:meth])
+  
+        sub_module_2.module_eval { remove_method :meth }
+        expect(subject.tracked_methods).to match_array([:meth])
+  
+        super_class.class_eval { remove_method :meth }
+        expect(subject.tracked_methods).to match_array([:meth])
+  
+        subject.class_eval { remove_method :meth }
+        expect(subject.tracked_methods).to be_empty
+      end
+  
+      it "untracks undefined methods" do
+        subject.module_eval { undef_method :meth }
+        expect(subject.tracked_methods).to be_empty
+  
+        subject.module_eval { define_method :meth, METHOD_DEFINITION }
+        expect(subject.tracked_methods).to match_array([:meth])
+      end
+    end
+  
+    context "partially defined" do
+      context "module" do
+        it "tracks methods" do
+          m = ::Module.new
+  
+          expect do
+            m.module_eval do
+              extend MTrack::Mixin
+              track_methods do
+                define_method :meth_1, METHOD_DEFINITION
+                define_method :meth_2, METHOD_DEFINITION
+                raise "Unexpected error"
+                define_method :meth_3, METHOD_DEFINITION
+                define_method :meth_4, METHOD_DEFINITION
+              end
+            end
+          end.to raise_error(RuntimeError, "Unexpected error")
+  
+          expect(m.public_instance_methods(false).map(&:to_sym)).to match_array([:meth_1, :meth_2])
+          expect(m.tracked_methods).to match_array([:meth_1, :meth_2])
+        end
+      end
+  
+      context "class" do
+        it "tracks methods" do
+          c = ::Class.new
+  
+          expect do
+            c.class_eval do
+              extend MTrack::Mixin
+              track_methods do
+                define_method :meth_1, METHOD_DEFINITION
+                define_method :meth_2, METHOD_DEFINITION
+                raise "Unexpected error"
+                define_method :meth_3, METHOD_DEFINITION
+                define_method :meth_4, METHOD_DEFINITION
+              end
+            end
+          end.to raise_error(RuntimeError, "Unexpected error")
+  
+          expect(c.public_instance_methods(false).map(&:to_sym)).to match_array([:meth_1, :meth_2])
+          expect(c.tracked_methods).to match_array([:meth_1, :meth_2])
+        end
+      end
+    end
+  
+    context "inclusion" do
+      it "adds #{described_class} to submodule" do
+        bm_1 = base_module_1
+        m = ::Module.new.module_eval { include bm_1 }
+        expect(m.tracked_methods).to match_array([:meth])
+      end
+    end
+  
+    context "inheritance" do
+      it "adds #{described_class} to subclass" do
+        c = ::Class.new(super_class)
+        expect(c.tracked_methods).to match_array([:meth])
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mtrack
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 1.0.0
 platform: ruby
 authors:
 - Gabriel de Oliveira
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-19 00:00:00.000000000 Z
+date: 2014-10-03 00:00:00.000000000 Z
 dependencies: []
 description: MTrack extends the functionality of modules and classes and enables them
   to define public methods within groups. These methods can then be queried back even
@@ -28,14 +28,12 @@ files:
 - README.md
 - Rakefile
 - lib/mtrack.rb
-- lib/mtrack/core.rb
-- lib/mtrack/module_mixin.rb
+- lib/mtrack/mixin.rb
 - lib/mtrack/state.rb
 - lib/mtrack/state/group.rb
 - lib/mtrack/version.rb
 - mtrack.gemspec
-- spec/lib/mtrack/core_spec.rb
-- spec/lib/mtrack/module_mixin_spec.rb
+- spec/lib/mtrack/mixin_spec.rb
 - spec/lib/mtrack/state/group_spec.rb
 - spec/lib/mtrack/state_spec.rb
 - spec/lib/mtrack/version_spec.rb
@@ -62,13 +60,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.1
+rubygems_version: 2.4.2
 signing_key: 
 specification_version: 4
 summary: Group and track methods on classes and modules.
 test_files:
-- spec/lib/mtrack/core_spec.rb
-- spec/lib/mtrack/module_mixin_spec.rb
+- spec/lib/mtrack/mixin_spec.rb
 - spec/lib/mtrack/state/group_spec.rb
 - spec/lib/mtrack/state_spec.rb
 - spec/lib/mtrack/version_spec.rb

data/lib/mtrack/core.rb

@@ -1,111 +0,0 @@
-require "mtrack/state"
-
-module MTrack
-
-  ##
-  # Implements the core tracking functionality of the gem by extending those
-  # Modules and Classes that use MTrack::ModuleMixin#track_methods. Additionally
-  # it will extend Modules and Classes that include a Module that is tracking
-  # methods and Classes that inherit from a Class that is tracking methods.
-  module Core
-    class << self
-      private
-
-      ##
-      # call-seq:
-      #   extended(submodule) => submodule
-      #
-      # Initializes a State variable on the Class or Module that extended Core.
-      #
-      # Returns passed +submodule+.
-      def extended(submodule)
-        submodule.instance_eval { @__mtrack__ ||= State.new }
-        submodule
-      end
-    end
-
-    ##
-    # call-seq:
-    #   tracked_methods(group_name = nil) => set
-    #
-    # Returns a set containing the currently tracked methods for a +group_name+.
-    #
-    #   class C
-    #     track_methods :my_group do
-    #       def method_1; end
-    #       def method_2; end
-    #     end
-    #   end
-    #
-    #   C.tracked_methods :my_group  #=> #<Set: {:method_1, :method_2}>
-    def tracked_methods(group_name = nil)
-      @__mtrack__.tracked group_name
-    end
-
-    private
-
-    ##
-    # call-seq:
-    #   included(submodule) => submodule
-    #
-    # Sets this state as a super-state of the +submodule+ (Class or Module) that
-    # has included the current Module.
-    #
-    # Returns passed +submodule+.
-    def included(submodule)
-      state = @__mtrack__
-      submodule.instance_eval do
-        extend Core
-        @__mtrack__.add_super_state state
-      end
-      submodule
-    end
-
-    ##
-    # call-seq:
-    #   inherited(submodule) => submodule
-    #
-    # Sets this state as a super-state of the +submodule+ (Class) that has
-    # inherited from the current Class.
-    #
-    # Returns passed +submodule+.
-    alias_method :inherited, :included
-
-    ##
-    # call-seq:
-    #   method_added(name) => name
-    #
-    # Allows method +name+ to be displayed on #tracked_methods once again after
-    # being disabled by a call to #method_undefined.
-    #
-    # Returns passed +name+.
-    def method_added(name)
-      @__mtrack__.delete_undefined name
-    end
-
-    ##
-    # call-seq:
-    #   method_removed(name) => name
-    #
-    # Stops tracking method +name+ in the current Class or Module.
-    #
-    # Returns passed +name+.
-    def method_removed(name)
-      @__mtrack__.delete_tracked name
-    end
-
-    ##
-    # call-seq:
-    #   method_undefined(name) => name
-    #
-    # Stops tracking method +name+ in the current Class or Module and prevents
-    # homonymous methods tracked in super-states from being displayed as
-    # #tracked_methods.
-    #
-    # Returns passed +name+.
-    def method_undefined(name)
-      @__mtrack__.delete_tracked name
-      @__mtrack__.add_undefined name
-    end
-  end
-end

data/lib/mtrack/module_mixin.rb

@@ -1,90 +0,0 @@
-require "set"
-
-require "mtrack/core"
-
-module MTrack
-
-  ##
-  # Provides the #track_methods method to all Classes and Modules by being mixed
-  # into the +Module+ class.
-  module ModuleMixin
-    class << self
-      private
-
-      ##
-      # call-seq:
-      #   newly_defined_methods(mod, old_methods) => set
-      #
-      # Calculates the difference between +mod+'s currently defined public
-      # methods and +old_methods+.
-      #
-      # Returns a set with the result.
-      def newly_defined_methods(mod, old_methods)
-        (mod.public_instance_methods(false) - old_methods).map(&:to_sym).to_set
-      end
-
-      ##
-      # call-seq:
-      #   save_tracked_methods(mod, group_name, tracked) => nil
-      #
-      # Saves +tracked+ methods for +mod+ under a +group_name+.
-      #
-      # Returns a +nil+ value.
-      def save_tracked_methods(mod, group_name, tracked)
-        mod.instance_variable_get(:@__mtrack__)[group_name].merge_tracked tracked unless tracked.empty?
-        nil
-      end
-
-      ##
-      # call-seq:
-      #   track_methods_for(mod, group_name) => set
-      #   track_methods_for(mod, group_name) {|| ... } => set
-      #
-      # Sets up an MTrack::State instance for +mod+.
-      #
-      # If a block is provided all the methods defined within the block will be
-      # tracked under the +group_name+ parameter.
-      #
-      # Returns a set containing the methods that were defined within the block.
-      def track_methods_for(mod, group_name, &b)
-        old_methods = mod.public_instance_methods false
-
-        begin
-          mod.module_eval &b if block_given?
-        ensure
-          tracked = newly_defined_methods(mod, old_methods)
-          save_tracked_methods(mod, group_name, tracked)
-        end
-
-        tracked
-      end
-    end
-
-    private
-
-    ##
-    # call-seq:
-    #   track_methods(group_name = nil) => set
-    #   track_methods(group_name = nil) {|| ... } => set
-    #
-    # Sets up an MTrack::State instance for this Class or Module and extends it
-    # using MTrack::Core.
-    #
-    # If a block is provided all the methods defined within the block will be
-    # tracked under the optional +group_name+ parameter.
-    #
-    # Returns a set containing the methods that were defined within the block.
-    #
-    #   class C
-    #     track_methods do
-    #       def method_1; end
-    #       track_methods(:inner_group_1) { def method_2; end }
-    #       def method_3; end
-    #     end
-    #   end  #=> #<Set: {:method_1, :method_2, :method_3}>
-    def track_methods(group_name = nil, &b)
-      extend Core
-      ModuleMixin.send(:track_methods_for, self, group_name, &b)
-    end
-  end
-end

data/spec/lib/mtrack/core_spec.rb

@@ -1,377 +0,0 @@
-require "spec_helper"
-
-METHOD_DEFINITION = proc {}
-
-describe MTrack::Core do
-  let(:base_module_1) do
-    Module.new.tap do |m|
-      m.module_eval do
-        define_method :unt_1, METHOD_DEFINITION
-        track_methods { define_method :meth, METHOD_DEFINITION }
-        track_methods :numbers do
-          track_methods(:odd) { define_method :one, METHOD_DEFINITION }
-          track_methods(:even) { define_method :two, METHOD_DEFINITION }
-        end
-        define_method :unt_2, METHOD_DEFINITION
-      end
-    end
-  end
-
-  let(:base_module_2) do
-    Module.new.tap do |m|
-      m.module_eval do
-        define_method :unt_2, METHOD_DEFINITION
-        track_methods { define_method :meth, METHOD_DEFINITION }
-        track_methods :numbers do
-          track_methods(:even) { define_method :two, METHOD_DEFINITION }
-          track_methods(:odd) { define_method :three, METHOD_DEFINITION }
-        end
-        define_method :unt_3, METHOD_DEFINITION
-      end
-    end
-  end
-
-  let(:base_module_3) do
-    Module.new.tap do |m|
-      m.module_eval do
-        define_method :unt_3, METHOD_DEFINITION
-        track_methods { define_method :meth, METHOD_DEFINITION }
-        track_methods :numbers do
-          track_methods(:odd) { define_method :three, METHOD_DEFINITION }
-          track_methods(:even) { define_method :four, METHOD_DEFINITION }
-        end
-        define_method :unt_4, METHOD_DEFINITION
-      end
-    end
-  end
-
-  let(:sub_module_1) do
-    bm_1 = base_module_1
-    bm_2 = base_module_2
-    Module.new.tap do |m|
-      m.module_eval do
-        include bm_1
-        define_method :unt_4, METHOD_DEFINITION
-        track_methods { define_method :meth, METHOD_DEFINITION }
-        track_methods :numbers do
-          track_methods(:even) { define_method :four, METHOD_DEFINITION }
-          track_methods(:odd) { define_method :five, METHOD_DEFINITION }
-        end
-        define_method :unt_5, METHOD_DEFINITION
-        include bm_2
-      end
-    end
-  end
-
-  let(:sub_module_2) do
-    bm_3 = base_module_3
-    Module.new.tap do |m|
-      m.module_eval do
-        define_method :unt_5, METHOD_DEFINITION
-        track_methods { define_method :meth, METHOD_DEFINITION }
-        include bm_3
-        track_methods :numbers do
-          track_methods(:odd) { define_method :five, METHOD_DEFINITION }
-          track_methods(:even) { define_method :six, METHOD_DEFINITION }
-        end
-        define_method :unt_6, METHOD_DEFINITION
-      end
-    end
-  end
-
-  let(:super_class) do
-    sm_1 = sub_module_1
-    Class.new.tap do |c|
-      c.class_eval do
-        include sm_1
-        define_method :unt_6, METHOD_DEFINITION
-        track_methods { define_method :meth, METHOD_DEFINITION }
-        track_methods :numbers do
-          track_methods(:even) { define_method :six, METHOD_DEFINITION }
-          track_methods(:odd) { define_method :seven, METHOD_DEFINITION }
-        end
-        define_method :unt_7, METHOD_DEFINITION
-      end
-    end
-  end
-
-  let(:sub_class) do
-    sm_2 = sub_module_2
-    sc = super_class
-    Class.new(sc).tap do |c|
-      c.class_eval do
-        define_method :unt_7, METHOD_DEFINITION
-        track_methods { define_method :meth, METHOD_DEFINITION }
-        track_methods :numbers do
-          track_methods(:odd) { define_method :seven, METHOD_DEFINITION }
-          track_methods(:even) { define_method :eight, METHOD_DEFINITION }
-        end
-        define_method :unt_8, METHOD_DEFINITION
-        include sm_2
-      end
-    end
-  end
-
-  context "base module 1" do
-    subject { base_module_1 }
-
-    it "tracks methods" do
-      expect(subject.tracked_methods).to match_array([:meth])
-      expect(subject.tracked_methods(:numbers)).to match_array([:one, :two])
-      expect(subject.tracked_methods(:odd)).to match_array([:one])
-      expect(subject.tracked_methods(:even)).to match_array([:two])
-    end
-
-    it "untracks removed methods" do
-      subject.module_eval { remove_method :meth }
-      expect(subject.tracked_methods).to be_empty
-    end
-
-    it "untracks undefined methods" do
-      subject.module_eval { undef_method :meth }
-      expect(subject.tracked_methods).to be_empty
-
-      subject.module_eval { define_method :meth, METHOD_DEFINITION }
-      expect(subject.tracked_methods).to be_empty
-    end
-  end
-
-  context "base module 2" do
-    subject { base_module_2 }
-
-    it "tracks methods" do
-      expect(subject.tracked_methods).to match_array([:meth])
-      expect(subject.tracked_methods(:numbers)).to match_array([:two, :three])
-      expect(subject.tracked_methods(:even)).to match_array([:two])
-      expect(subject.tracked_methods(:odd)).to match_array([:three])
-    end
-
-    it "untracks removed methods" do
-      subject.module_eval { remove_method :meth }
-      expect(subject.tracked_methods).to be_empty
-    end
-
-    it "untracks undefined methods" do
-      subject.module_eval { undef_method :meth }
-      expect(subject.tracked_methods).to be_empty
-
-      subject.module_eval { define_method :meth, METHOD_DEFINITION }
-      expect(subject.tracked_methods).to be_empty
-    end
-  end
-
-  context "base module 3" do
-    subject { base_module_3 }
-
-    it "tracks methods" do
-      expect(subject.tracked_methods).to match_array([:meth])
-      expect(subject.tracked_methods(:numbers)).to match_array([:three, :four])
-      expect(subject.tracked_methods(:odd)).to match_array([:three])
-      expect(subject.tracked_methods(:even)).to match_array([:four])
-    end
-
-    it "untracks removed methods" do
-      subject.module_eval { remove_method :meth }
-      expect(subject.tracked_methods).to be_empty
-    end
-
-    it "untracks undefined methods" do
-      subject.module_eval { undef_method :meth }
-      expect(subject.tracked_methods).to be_empty
-
-      subject.module_eval { define_method :meth, METHOD_DEFINITION }
-      expect(subject.tracked_methods).to be_empty
-    end
-  end
-
-  context "sub module 1" do
-    subject { sub_module_1 }
-
-    it "tracks methods" do
-      expect(subject.tracked_methods).to match_array([:meth])
-      expect(subject.tracked_methods(:numbers)).to match_array([:one, :two, :three, :four, :five])
-      expect(subject.tracked_methods(:odd)).to match_array([:one, :three, :five])
-      expect(subject.tracked_methods(:even)).to match_array([:two, :four])
-    end
-
-    it "untracks removed methods" do
-      subject.module_eval { remove_method :meth }
-      expect(subject.tracked_methods).to match_array([:meth])
-
-      base_module_1.module_eval { remove_method :meth }
-      expect(subject.tracked_methods).to match_array([:meth])
-
-      base_module_2.module_eval { remove_method :meth }
-      expect(subject.tracked_methods).to be_empty
-    end
-
-    it "untracks undefined methods" do
-      subject.module_eval { undef_method :meth }
-      expect(subject.tracked_methods).to be_empty
-
-      subject.module_eval { define_method :meth, METHOD_DEFINITION }
-      expect(subject.tracked_methods).to match_array([:meth])
-    end
-  end
-
-  context "sub module 2" do
-    subject { sub_module_2 }
-
-    it "tracks methods" do
-      expect(subject.tracked_methods).to match_array([:meth])
-      expect(subject.tracked_methods(:numbers)).to match_array([:three, :four, :five, :six])
-      expect(subject.tracked_methods(:odd)).to match_array([:three, :five])
-      expect(subject.tracked_methods(:even)).to match_array([:four, :six])
-    end
-
-    it "untracks removed methods" do
-      base_module_3.module_eval { remove_method :meth }
-      expect(subject.tracked_methods).to match_array([:meth])
-
-      subject.module_eval { remove_method :meth }
-      expect(subject.tracked_methods).to be_empty
-    end
-
-    it "untracks undefined methods" do
-      subject.module_eval { undef_method :meth }
-      expect(subject.tracked_methods).to be_empty
-
-      subject.module_eval { define_method :meth, METHOD_DEFINITION }
-      expect(subject.tracked_methods).to match_array([:meth])
-    end
-  end
-
-  context "super class" do
-    subject { super_class }
-
-    it "tracks methods" do
-      expect(subject.tracked_methods).to match_array([:meth])
-      expect(subject.tracked_methods(:numbers)).to match_array([:one, :two, :three, :four, :five, :six, :seven])
-      expect(subject.tracked_methods(:odd)).to match_array([:one, :three, :five, :seven])
-      expect(subject.tracked_methods(:even)).to match_array([:two, :four, :six])
-    end
-
-    it "untracks removed methods" do
-      subject.class_eval { remove_method :meth }
-      expect(subject.tracked_methods).to match_array([:meth])
-
-      sub_module_1.module_eval { remove_method :meth }
-      expect(subject.tracked_methods).to match_array([:meth])
-
-      base_module_2.module_eval { remove_method :meth }
-      expect(subject.tracked_methods).to match_array([:meth])
-
-      base_module_1.module_eval { remove_method :meth }
-      expect(subject.tracked_methods).to be_empty
-    end
-
-    it "untracks undefined methods" do
-      subject.module_eval { undef_method :meth }
-      expect(subject.tracked_methods).to be_empty
-
-      subject.module_eval { define_method :meth, METHOD_DEFINITION }
-      expect(subject.tracked_methods).to match_array([:meth])
-    end
-  end
-
-  context "sub class" do
-    subject { sub_class }
-
-    it "tracks methods" do
-      expect(subject.tracked_methods).to match_array([:meth])
-      expect(subject.tracked_methods(:numbers)).to match_array([:one, :two, :three, :four, :five, :six, :seven, :eight])
-      expect(subject.tracked_methods(:odd)).to match_array([:one, :three, :five, :seven])
-      expect(subject.tracked_methods(:even)).to match_array([:two, :four, :six, :eight])
-    end
-
-    it "untracks removed methods" do
-      base_module_1.module_eval { remove_method :meth }
-      expect(subject.tracked_methods).to match_array([:meth])
-
-      base_module_2.module_eval { remove_method :meth }
-      expect(subject.tracked_methods).to match_array([:meth])
-
-      base_module_3.module_eval { remove_method :meth }
-      expect(subject.tracked_methods).to match_array([:meth])
-
-      sub_module_1.module_eval { remove_method :meth }
-      expect(subject.tracked_methods).to match_array([:meth])
-
-      sub_module_2.module_eval { remove_method :meth }
-      expect(subject.tracked_methods).to match_array([:meth])
-
-      super_class.class_eval { remove_method :meth }
-      expect(subject.tracked_methods).to match_array([:meth])
-
-      subject.class_eval { remove_method :meth }
-      expect(subject.tracked_methods).to be_empty
-    end
-
-    it "untracks undefined methods" do
-      subject.module_eval { undef_method :meth }
-      expect(subject.tracked_methods).to be_empty
-
-      subject.module_eval { define_method :meth, METHOD_DEFINITION }
-      expect(subject.tracked_methods).to match_array([:meth])
-    end
-  end
-
-  context "partially defined" do
-    context "module" do
-      it "tracks methods" do
-        m = ::Module.new
-
-        expect do
-          m.module_eval do
-            track_methods do
-              define_method :meth_1, METHOD_DEFINITION
-              define_method :meth_2, METHOD_DEFINITION
-              raise "Unexpected error"
-              define_method :meth_3, METHOD_DEFINITION
-              define_method :meth_4, METHOD_DEFINITION
-            end
-          end
-        end.to raise_error(RuntimeError, "Unexpected error")
-
-        expect(m.public_instance_methods(false).map(&:to_sym)).to match_array([:meth_1, :meth_2])
-        expect(m.tracked_methods).to match_array([:meth_1, :meth_2])
-      end
-    end
-
-    context "class" do
-      it "tracks methods" do
-        c = ::Class.new
-
-        expect do
-          c.class_eval do
-            track_methods do
-              define_method :meth_1, METHOD_DEFINITION
-              define_method :meth_2, METHOD_DEFINITION
-              raise "Unexpected error"
-              define_method :meth_3, METHOD_DEFINITION
-              define_method :meth_4, METHOD_DEFINITION
-            end
-          end
-        end.to raise_error(RuntimeError, "Unexpected error")
-
-        expect(c.public_instance_methods(false).map(&:to_sym)).to match_array([:meth_1, :meth_2])
-        expect(c.tracked_methods).to match_array([:meth_1, :meth_2])
-      end
-    end
-  end
-
-  context "inclusion" do
-    it "adds #{described_class} to submodule" do
-      bm_1 = base_module_1
-      m = ::Module.new.module_eval { include bm_1 }
-      expect(m.tracked_methods).to match_array([:meth])
-    end
-  end
-
-  context "inheritance" do
-    it "adds #{described_class} to subclass" do
-      c = ::Class.new(super_class)
-      expect(c.tracked_methods).to match_array([:meth])
-    end
-  end
-end

data/spec/lib/mtrack/module_mixin_spec.rb

@@ -1,13 +0,0 @@
-require "spec_helper"
-
-describe MTrack::ModuleMixin do
-  describe "#track_methods" do
-    context "no block given" do
-      it "returns an empty set" do
-        ret_val = ::Module.new.module_eval { track_methods :group }
-        expect(ret_val).to be_a(Set)
-        expect(ret_val).to be_empty
-      end
-    end
-  end
-end