cognitive_distance 0.0.1.pre

data/lib/cognitive_distance/presenters.rb

@@ -0,0 +1,2 @@
+require 'cognitive_distance/presenters/graph_to_dot'
+

data/lib/cognitive_distance/presenters/graph_to_dot.rb

@@ -0,0 +1,11 @@
+module CognitiveDistance::Presenters
+  class GraphToDot
+    def present graph, name='graphname', &label
+      label ||= lambda { |v| v.to_s }
+      "digraph #{name.to_s.inspect} {\n" + graph.inject("") { |str, (v1,v2)|
+        str << "#{label[v1].inspect} -> #{label[v2].inspect};\n"
+      } + "}"
+    end
+  end
+end
+

data/lib/cognitive_distance/structures.rb

@@ -0,0 +1,9 @@
+require 'cognitive_distance/structures/missing_call_context'
+require 'cognitive_distance/structures/call_node'
+require 'cognitive_distance/structures/call_node_root'
+require 'cognitive_distance/structures/call_tree' 
+require 'cognitive_distance/structures/graph'
+
+module CognitiveDistance::Structures
+end
+

data/lib/cognitive_distance/structures/call_node.rb

@@ -0,0 +1,74 @@
+module CognitiveDistance::Structures
+  class CallNode
+    include Enumerable
+
+    NO_CONTEXT = MissingCallContext.new.freeze
+    attr_reader :children, :parent
+    attr_accessor :trace_file, :trace_line, :trace_class,
+                  :trace_method, :trace_binding
+
+    def initialize par=nil
+      @parent = par
+      @children = []
+      yield self if block_given?
+    end
+
+    # Create a new call node, add it to children and return it
+    def push! k, m, f, l, b
+      CallNode.new(self) do |node|
+        node.trace_file    = f
+        node.trace_line    = l
+        node.trace_class   = k
+        node.trace_method  = m
+        node.trace_binding = b
+      end.tap do |node|
+        children << node
+      end
+    end
+
+    # TODO: Maybe we shouldn't blindly assume that the pop! belongs
+    # to us?
+    def pop! *args # k, m, f, l, b
+      parent
+    end
+
+    def context
+      @context ||= create_context
+      @context
+    end
+
+    def each &block
+      return enum_for(:each) unless block
+      yield self
+      children.each do |node|
+        node.each(&block)
+      end
+      self
+    end
+
+    def empty?
+      children.empty?
+    end
+
+    def size
+      children.inject(children.size) { |s,c| s + c.size }
+    end
+
+    def freeze
+      context # Ensure context is set
+      children.each(&:freeze)
+      children.freeze
+      super
+    end
+
+    def to_a
+      [self, children.map(&:to_a)]
+    end
+
+  private
+    def create_context
+      trace_binding.eval("self") rescue NO_CONTEXT
+    end
+  end
+end
+

data/lib/cognitive_distance/structures/call_node_root.rb

@@ -0,0 +1,29 @@
+module CognitiveDistance::Structures
+  # Some special behavior on root
+  class CallNodeRoot < CallNode
+    # We never go looking for the parents of root.
+    def pop! *args
+      self
+    end
+
+    # A root node does not correspond to a trace line, thus has
+    # no context, ever.
+    def context
+      NO_CONTEXT
+    end
+
+    # Do the same as CallNode, except we don't yield self.
+    def each &block
+      return enum_for(:each) unless block
+      children.each do |node|
+        node.each(&block)
+      end
+      self
+    end
+
+    # Do the same as CallNode, except we don't include self.
+    def to_a
+      @children.map(&:to_a)
+    end
+  end
+end

data/lib/cognitive_distance/structures/call_tree.rb

@@ -0,0 +1,34 @@
+require 'forwardable'
+
+module CognitiveDistance::Structures
+  class CallTree
+    extend Forwardable
+    include Enumerable
+
+    def_delegators :@root, :empty?, :size, :to_a, :each
+    attr_reader :root
+
+    def initialize
+      @root = CallNodeRoot.new
+      @current_node = @root
+    end
+
+    def called k, m, f, l, b
+      # Set the current node to the node given back
+      @current_node = @current_node.push! k, m, f, l, b
+      self
+    end
+
+    def returned k, m, f, l, b
+      # Set the current node to the node given back
+      @current_node = @current_node.pop! k, m, f, l, b
+      self
+    end
+
+    def freeze
+      @root.freeze
+      @current_node = @root
+      super
+    end
+  end
+end

data/lib/cognitive_distance/structures/graph.rb

@@ -0,0 +1,77 @@
+module CognitiveDistance::Structures
+  class Graph
+    include Enumerable
+
+    def initialize
+      # The keys are the out-bound vertex
+      @links = {}
+    end
+
+    def link from, *tos
+      @links[from] ||= []
+      @links[from] += tos
+      self
+    end
+
+    def bilink n1, n2
+      link n1, n2
+      link n2, n1
+      self
+    end
+
+    # Really?
+    def vertices
+      @links.inject([]) { |vs, (n, ns)|
+        vs << n << ns
+      }.flatten.uniq
+    end
+
+    def edges vertex=nil
+      @links.inject([]) { |es, (n, ns)|
+        es + (ns.map { |n2| [n, n2] })
+      }
+    end
+    alias :to_a :edges
+
+    def any_edges vertex
+      edges.select { |(n1,n2)| n1 == vertex || n2 == vertex }
+    end
+
+    def in_edges vertex
+      edges.select { |(n1,n2)| n2 == vertex }
+    end
+
+    # We could improve this because the keys of @links indicate the
+    # out-bound edges for a given vertex, but for now let's go with
+    # consistent
+    def out_edges vertex
+      edges.select { |(n1,n2)| n1 == vertex }
+    end
+
+    def empty?
+      @links.empty?
+    end
+
+    def each &block
+      edges.each &block
+    end
+
+    # Two graphs are equal if they have the same edges and vertices
+    # As our graphs do not contain any unlinked vertices, we can get by
+    # with testing mutual inclusion of edges
+    def == other
+      return true if equal?(other) # save some time
+      return false unless other.respond_to?(:to_a)
+      e1s = to_a
+      e2s = other.to_a
+      e1s.size == e2s.size && e1s.all? { |e1| e2s.include? e1 }
+    end
+
+    # Duck-typing through `to_a` isn't enough, you actually have to be an instance
+    # of Graph (or an instance of a subclass)
+    def eql? other
+      Graph === other && self == other
+    end
+  end
+end
+

data/lib/cognitive_distance/structures/missing_call_context.rb

@@ -0,0 +1,10 @@
+module CognitiveDistance::Structures
+  # Stupid simple class to ensure that when we use object identity
+  # comparisons, we always get false with this.
+  class MissingCallContext
+    def equal? anything
+      false
+    end
+  end
+end
+

data/lib/cognitive_distance/tracer.rb

@@ -0,0 +1,32 @@
+module CognitiveDistance
+  class Tracer
+    def initialize measured
+      @traced = measured
+    end
+
+    def trace *args, &block
+      __with_kernel_trace__ do
+        @traced.__send__ *args, &block
+      end
+    end
+
+  private
+    def __with_kernel_trace__
+      tree = CognitiveDistance::Structures::CallTree.new
+      # Ruby, I love you. Even if exceptions are raised, or catch/throw is
+      # employed, you still give me a 'return' event as the stack unwinds.
+      # *hug*
+      Kernel.set_trace_func lambda { |ev, fn, no, meth, bind, klass|
+        case ev
+        when 'call'
+          tree.called klass, meth, fn, no, bind
+        when 'return'
+          tree.returned klass, meth, fn, no, bind
+        end
+      }
+      yield rescue nil
+      ::Kernel.set_trace_func nil
+      tree
+    end
+  end
+end

data/lib/cognitive_distance/transforms.rb

@@ -0,0 +1,5 @@
+require 'cognitive_distance/transforms/call_tree_to_module_boundary_graph'
+
+module CognitiveDistance::Transforms
+end
+

data/lib/cognitive_distance/transforms/call_tree_to_module_boundary_graph.rb

@@ -0,0 +1,30 @@
+module CognitiveDistance::Transforms
+  class CallTreeToModuleBoundaryGraph
+    def self.transform tree
+      new.transform(tree)
+    end
+
+    def transform tree
+      CognitiveDistance::Structures::Graph.new.tap do |graph|
+        link_nodes graph, tree.to_a
+      end
+    end
+
+  private
+    def link_nodes graph, node_arr, prefix=""
+      node_arr.each do |parent, children|
+        link_boundary_crossings graph, parent, children, "#{prefix}\t"
+      end
+   end
+
+    def link_boundary_crossings graph, parent, children, prefix=""
+      children.each do |(child, _)|
+        if !parent.context.equal?(child.context)
+          graph.link parent, child
+        end
+      end
+      link_nodes graph, children, prefix
+    end
+  end
+end
+

data/lib/cognitive_distance/version.rb

@@ -0,0 +1,3 @@
+module CognitiveDistance
+  VERSION = "0.0.1.pre"
+end

data/spec/cognitive_distance/measurements/distinct_module_hops_spec.rb

@@ -0,0 +1,52 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+describe CognitiveDistance::Measurements::DistinctModuleHops do
+  def get_meta_class klass
+    klass.class_eval "class << self; self; end"
+  end
+
+  def make_node ctx
+    mock = CognitiveDistance::Structures::CallNode.new
+    mock.trace_class = ctx
+    def mock.context
+      trace_class
+    end
+    mock
+  end
+
+  before do
+    graph = @graph = CognitiveDistance::Structures::Graph.new
+    # Stub out transform
+    klass = get_meta_class(CognitiveDistance::Transforms::CallTreeToModuleBoundaryGraph)
+    klass.send(:alias_method, :transform_orig, :transform)
+    klass.send(:define_method, :transform) { |*_| graph }
+    @measurement = CognitiveDistance::Measurements::DistinctModuleHops.new
+    n1, n2, n3 = 3.times.map { |i| make_node "module #{i}" }
+    n4 = make_node("module 0") # A different object, but the same context
+    @graph.link n1, n2, n3
+    @graph.link n4, n2
+  end
+
+  after do
+    klass = get_meta_class(CognitiveDistance::Transforms::CallTreeToModuleBoundaryGraph)
+    klass.send(:remove_method, :transform)
+    klass.send(:alias_method, :transform, :transform_orig)
+    klass.send(:remove_method, :transform_orig)
+  end
+
+  it "only counts distinct module boundary crossings" do
+    tree = MiniTest::Mock.new
+    @measurement.measure(tree).must_equal 2
+  end
+
+  it "measures an object trace directly" do
+    # Even though this does create a real trace, we're still intercepting
+    # the transformation, so we can honey badger away.
+    CognitiveDistance::Measurements::DistinctModuleHops.measure("test", :length).must_equal 2
+  end
+
+  it "registers its measurement" do
+    CognitiveDistance::Measurements.measure_distinct_module_hops("test", :length).must_equal 2
+  end
+end
+

data/spec/cognitive_distance/measurements/measurement_spec.rb

@@ -0,0 +1,44 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+describe CognitiveDistance::Measurements::Measurement do
+  it "registers a named measurement" do
+    class Foobar
+      extend CognitiveDistance::Measurements::Measurement
+      register :lameness
+    end
+    CognitiveDistance::Measurements.must_respond_to :measure_lameness
+  end
+
+  it "performs the registered measurement" do
+    class Foobaz
+      extend CognitiveDistance::Measurements::Measurement
+      register :suckiness
+
+      class << self
+        attr_reader :received_args
+        def measure *args
+          @received_args = args
+        end
+      end
+    end
+    CognitiveDistance::Measurements.measure_suckiness('foo', 'bar', 'blarg')
+    Foobaz.received_args.must_equal ['foo', 'bar', 'blarg']
+  end
+
+  it "allows a measurement method to be defined" do
+    class Fooboss
+      extend CognitiveDistance::Measurements::Measurement
+      register :unfortunately, :most_unfortunate
+
+      class << self
+        attr_reader :received_args
+        def most_unfortunate *args
+          @received_args = args
+        end
+      end
+    end
+    CognitiveDistance::Measurements.measure_unfortunately(:x, :y, :z)
+    Fooboss.received_args.must_equal [:x, :y, :z]
+  end
+end
+

data/spec/cognitive_distance/measurements/module_hops_spec.rb

@@ -0,0 +1,54 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+describe CognitiveDistance::Measurements::ModuleHops do
+  def get_meta_class klass
+    klass.class_eval "class << self; self; end"
+  end
+
+  before do
+    graph = @graph = MiniTest::Mock.new
+    # Stub out transform
+    klass = get_meta_class(CognitiveDistance::Transforms::CallTreeToModuleBoundaryGraph)
+    klass.send(:alias_method, :transform_orig, :transform)
+    klass.send(:define_method, :transform) { |*_| graph }
+    @measurement = CognitiveDistance::Measurements::ModuleHops.new
+  end
+
+  after do
+    klass = get_meta_class(CognitiveDistance::Transforms::CallTreeToModuleBoundaryGraph)
+    klass.send(:remove_method, :transform)
+    klass.send(:alias_method, :transform, :transform_orig)
+    klass.send(:remove_method, :transform_orig)
+  end
+
+  it "only counts all module boundary crossings" do
+    tree = MiniTest::Mock.new
+    @graph.expect :edges, [
+      [ "module 1", "module 2" ],
+      [ "module 1", "module 4" ],
+      [ "module 1", "module 2" ]
+    ]
+    @measurement.measure(tree).must_equal 3
+  end
+
+  it "measures an object trace directly" do
+    @graph.expect :edges, [
+      [ "module 1", "module 2" ],
+      [ "module 1", "module 4" ],
+      [ "module 1", "module 2" ]
+    ]
+    # Even though this does create a real trace, we're still intercepting
+    # the transformation, so we can honey badger away.
+    CognitiveDistance::Measurements::ModuleHops.measure("test", :length).must_equal 3
+  end
+
+  it "registers its measurement" do
+    @graph.expect :edges, [
+      [ "module 1", "module 2" ],
+      [ "module 1", "module 4" ],
+      [ "module 1", "module 2" ]
+    ]
+    CognitiveDistance::Measurements.measure_module_hops("test", :length).must_equal 3
+  end
+end
+