society 1.1.1 → 1.2.0

data/lib/society/version.rb

@@ -1,3 +1,3 @@
 module Society
-  VERSION = "1.1.1"
+  VERSION = "1.2.0"
 end

data/society.gemspec

@@ -6,11 +6,11 @@ require 'society/version'
 Gem::Specification.new do |spec|
   spec.name          = "society"
   spec.version       = Society::VERSION
-  spec.authors       = ["Coraline Ada Ehmke", "Kerri Miller"]
-  spec.email         = ["coraline@instructure.com", "kerrizor@gmail.com"]
+  spec.authors       = ["Coraline Ada Ehmke"]
+  spec.email         = ["coraline@instructure.com"]
   spec.summary       = %q{Social graph for Ruby objects}
-  spec.description   = %q{Social graph for Ruby objects}
-  spec.homepage      = "https://github.com/Bantik/society"
+  spec.description   = %q{Social graph for Ruby objects. Based on an original idea by Kerri Miller.}
+  spec.homepage      = "https://github.com/CoralineAda/society"
   spec.license       = "MIT"
 
   spec.files         = `git ls-files -z`.split("\x0")
@@ -26,7 +26,6 @@ Gem::Specification.new do |spec|
   spec.add_dependency "thor"
 
   spec.add_development_dependency "bundler", "~> 1.6"
-  spec.add_development_dependency "pry"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec"
   spec.add_development_dependency "simplecov"

data/spec/cli_spec.rb

@@ -5,7 +5,7 @@ describe Society::CLI do
 
   describe "#from" do
 
-    let(:parser) { Society::Parser.new(nil) }
+    let(:parser) { Society::Parser.new([]) }
 
     it "invokes Society with a path" do
       allow(parser).to receive(:report)

data/spec/object_graph_spec.rb

@@ -1,30 +1,224 @@
 require 'spec_helper'
 require 'analyst'
 
-describe Society::ObjectGraph do
+describe Society::Node do
+
+  let(:edge_a) { Society::Edge.new(to: "A", weight: 1) }
+  let(:edge_b) { Society::Edge.new(to: "B", weight: 1) }
+
+  describe "#initialize" do
+
+    it "returns a node object" do
+      node = Society::Node.new(name: "A", type: :class)
+      expect(node.class.name).to eq("Society::Node")
+    end
+
+    it "initializes its edges" do
+      node = Society::Node.new(name: "A", type: :class, edges: [edge_a, edge_b])
+      expect(node.edges.first.to).to eq("A")
+      expect(node.edges.first.weight).to eq(1)
+    end
+
+    it "initializes metainformation" do
+      node = Society::Node.new(name: "A", type: :class, meta: [true])
+      expect(node.meta).to match_array [true]
+    end
+
+  end
+
+  describe "#intersects?" do
+    let(:node)              { Society::Node.new(name: "A", type: :class) }
+    let(:nonintersecting_a) { Society::Node.new(name: "A", type: :module) }
+    let(:nonintersecting_b) { Society::Node.new(name: "B", type: :class) }
+    let(:intersecting)      { Society::Node.new(name: "A", type: :class) }
+
+    it "detects intersections iff name and type are the same" do
+      expect(node.intersects?(nonintersecting_a)).to eq(false)
+      expect(node.intersects?(nonintersecting_b)).to eq(false)
+      expect(node.intersects?(intersecting)).to eq(true)
+    end
+
+  end
+
+  describe "#+" do
+    let(:node_a) { Society::Node.new(name: "A", type: :class, edges: [edge_a]) }
+    let(:node_b) { Society::Node.new(name: "A", type: :class, edges: [edge_b]) }
+    let(:node_c) { Society::Node.new(name: "A", type: :class, unresolved: [edge_b]) }
+
+    it "allows addition of intersecting nodes, accumulating edges" do
+      node_d = node_a + node_b
+      expect(node_d.edges.sort_by(&:to)).to eq([edge_a, edge_b])
+
+      node_e = node_a + node_c
+      expect(node_e.edges).to eq([edge_a])
+      expect(node_e.unresolved).to eq([edge_b])
+    end
+
+    it "accumulates edges upon addition" do
+      node_d = node_b + node_a + node_b
+      expect(node_d.edges.map(&:to).sort).to match_array ["A", "B"]
+      expect(node_d.edges.sort_by(&:to).map(&:weight)).to match_array [1, 2]
+
+      node_e = node_a + node_b + node_a
+      expect(node_e.edges.map(&:to).sort).to match_array ["A", "B"]
+      expect(node_e.edges.sort_by(&:to).map(&:weight)).to match_array [2, 1]
+    end
+
+    it "treats addition against itself as a no-op" do
+      node_d = node_a + node_a
+      expect(node_d.object_id).to eq(node_a.object_id)
+    end
+
+  end
+
+  describe "#to_s" do
+    let(:node_a) { Society::Node.new(name: "A", type: :class, edges: [edge_a]) }
+
+    it "returns the node's name as a string" do
+      expect(node_a.to_s).to eq("A")
+    end
+  end
+
+end
+
+describe Society::Edge do
+
+  describe "#initialize" do
+    it "returns an edge object" do
+      expect(Society::Edge.new(to: "A").class.name).to eq("Society::Edge")
+    end
+
+    it "uses a default weight of 1 for an edge" do
+      expect(Society::Edge.new(to: "A").weight).to eq(1)
+    end
+
+    it "allows a weight to be specified" do
+      expect(Society::Edge.new(to: "A", weight: 3).weight).to eq(3)
+    end
+  end
+
+  describe "#+" do
+    let(:edge_a1) { Society::Edge.new(to: "A", weight: 1) }
+    let(:edge_a2) { Society::Edge.new(to: "A", weight: 2) }
+    let(:edge_b)  { Society::Edge.new(to: "B") }
+
+    it "adds the weights of two like edges" do
+      edge_a3 = edge_a1 + edge_a2
+      expect(edge_a3.weight).to eq(3)
+    end
+
+    it "returns nil if the edge targets are not aligned" do
+      edge_z = edge_a1 + edge_b
+      expect(edge_z).to eq(nil)
+    end
 
-  let(:graph) { Struct.new(:nodes, :edges)}
-  let(:node) { Struct.new(:full_name) }
-  let(:edge) { Struct.new(:from, :to) }
+  end
+
+  describe "#+" do
+    let(:edge) { Society::Edge.new(to: "A", weight: 1) }
+
+    it "returns the name of the target node as a string" do
+      expect(edge.to_s).to eq("A")
+    end
+
+  end
 
-  let(:node_instance_1) { node.new("sample_node")}
-  let(:node_instance_2) { node.new("other_node")}
-  let(:edge_instance) { edge.new(node_instance_1, node_instance_2) }
+end
 
-  let(:graph) { Society::ObjectGraph.new(
-      nodes: [node_instance_1, node_instance_2],
-      edges: [edge_instance]
-    )
-  }
+describe Society::ObjectGraph do
+
+  let(:edge_a) { Society::Edge.new(to: "A") }
+  let(:edge_b) { Society::Edge.new(to: "B") }
+  let(:edge_d) { Society::Edge.new(to: "D") }
+
+  let(:node_a) { Society::Node.new(name: "A", type: :class, edges: [edge_b]) }
+  let(:node_b) { Society::Node.new(name: "B", type: :class, edges: [edge_d]) }
+  let(:node_c) { Society::Node.new(name: "C", type: :class, edges: [edge_d]) }
+  let(:node_d) { Society::Node.new(name: "D", type: :class, edges: [edge_a, edge_b]) }
 
   describe "#initialize" do
-    it "initializes its nodes" do
-      expect(graph.nodes.first.full_name).to eq "sample_node"
+
+    it "returns an ObjectGraph object" do
+      expect(Society::ObjectGraph.new.class.name).to eq("Society::ObjectGraph")
+    end
+
+    it "is empty by default" do
+      expect(Society::ObjectGraph.new).to eq([])
     end
-    it "initializes its edges"  do
-      expect(graph.edges.first.to.full_name).to eq "other_node"
+
+    it "allows several nodes to be given" do
+      expect(Society::ObjectGraph.new(node_a, node_b).first).to eq(node_a)
+    end
+
+    it "allows a list of nodes to be given" do
+      expect(Society::ObjectGraph.new([node_a, node_b]).first).to eq(node_a)
+    end
+
+  end
+
+  describe "#+" do
+
+    let(:node_a2) { Society::Node.new(name: "A", type: :class, edges: [edge_b, edge_d]) }
+
+    let(:graph_a) { Society::ObjectGraph.new([node_a]) }
+    let(:graph_b) { Society::ObjectGraph.new([node_b]) }
+    let(:graph_c) { Society::ObjectGraph.new([node_a2, node_c, node_d]) }
+
+    it "treats addition of an empty graph as a no-op" do
+      expect(graph_a + Society::ObjectGraph.new).to eq(graph_a)
+    end
+
+    it "does not modify nodes when none intersect" do
+      expect(graph_a + graph_b).to eq([node_a, node_b])
+    end
+
+    it "sums nodes which intersect" do
+      graph_d = graph_a + graph_c
+      node = graph_d.select { |node| node.name == "A" }.first
+
+      expect(graph_d.length).to eq(3)
+      expect(node.edges.select { |n| n.to == "B" }.first.weight ).to eq(2)
+    end
+
+  end
+
+  describe "#<<" do
+
+    let(:node_a2) { Society::Node.new(name: "A", type: :class, edges: [edge_b, edge_d]) }
+    let(:graph_a) { Society::ObjectGraph.new([node_a]) }
+
+    it "returns a new graph object without mutating the original" do
+      graph_b = graph_a << node_b
+      expect(graph_a.length).to eq(1)
+      expect(graph_b.object_id).not_to eq(graph_a.object_id)
+    end
+
+    it "sums nodes which intersect" do
+      graph_b = graph_a << node_a2
+      node = graph_b.select { |node| node.name == "A" }.first
+      expect(node.edges.select { |n| n.to == "B" }.first.weight ).to eq(2)
+    end
+
+  end
+
+  describe "#to_h" do
+
+    let(:graph_a) { Society::ObjectGraph.new([node_a]) }
+
+    it "returns a hash representing the graph" do
+      expect(graph_a.to_h).to eq({node_a.name => node_a.edges})
+    end
+
+  end
+
+  describe "#to_json" do
+
+    let(:graph_a) { Society::ObjectGraph.new([node_a]) }
+
+    it "returns a json string representing the graph" do
+      expect(graph_a.to_json).to eq('{"A":{"B":1}}')
     end
 
   end
 
-end
+end

data/spec/parser_spec.rb

@@ -1,36 +1,227 @@
 require 'spec_helper'
 
 describe Society::Parser do
+  let(:source)            { "class Ship; end" }
+  let(:nested_source)     { "module Ship; class Anchor; end; end;" }
+  let(:inherited_source)  { "class Carrier < Ship; end" }
+  let(:namespaced_source) { "class Ship::Anchor; end" }
 
-  describe "::for_files" do
+  describe "::for_source" do
+
+    context "listing nodes" do
+      it "returns a parser object" do
+        expect(Society::Parser.for_source(source).class.name).to eq("Society::Parser")
+      end
+
+      it "will accept multiple source strings" do
+        expect(Society::Parser.for_source(source, nested_source).class.name).to eq("Society::Parser")
+      end
+
+      it "parses simple source trees" do
+        expect(Society::Parser.for_source(source).classes).to eq(["Ship"])
+      end
+
+      it "parses source trees with inheritance" do
+        expect(Society::Parser.for_source(inherited_source).classes).to eq(["Carrier"])
+      end
+
+      it "parses namespaced nodes" do
+        expect(Society::Parser.for_source(nested_source).classes).to eq(["Ship", "Ship::Anchor"])
+        expect(Society::Parser.for_source(namespaced_source).classes).to eq(["Ship::Anchor"])
+      end
+
+      it "tracks if a node is a class or module" do
+        parser = Society::Parser.for_source(nested_source)
+        expect(parser.graph.select { |node| node.name == "Ship" }.first.type).to eq(:module)
+        expect(parser.graph.select { |node| node.name == "Ship::Anchor" }.first.type).to eq(:class)
+      end
 
-    it "returns a parser object" do
-      expect(Society::Parser.for_files('./spec/fixtures/for_parser_spec').class.name).to eq("Society::Parser")
     end
 
-    it "initializes the parser with an Analyzer object" do
-      expect(Society::Parser.for_files('./spec/fixtures/for_parser_spec').analyzer.class.name).to eq("Analyst::Parser")
+    context "detecting edges" do
+      let(:source) { "class Ship; def initialize; @engine = Engine.new; end; end; class Engine; end;" }
+      let(:namespaced_source) { "class Ship; def initialize; @engine = Engine::Diesel.new; end; end; class Engine::Diesel; end" }
+      let(:unknown_edge_source) { "class Ship; def initialize; @engine = Engine::UFO.new; end; end" }
+
+      it "detects simple edges for classes" do
+        graph = Society::Parser.for_source(source).graph
+        edge  = graph.first.edges.first
+        expect(edge.class.name).to eq("Society::Edge")
+        expect(graph.first.edges.map(&:to)).to eq(["Engine"])
+      end
+
+      it "detects simple edges for namespaced classes" do
+        expect(Society::Parser.for_source(namespaced_source).graph.first.edges.map(&:to)).to eq(["Engine::Diesel"])
+      end
+
+      it "rejects edges which point to nodes of which it is unaware" do
+        expect(Society::Parser.for_source(unknown_edge_source).graph.first.edges.empty?).to eq(true)
+      end
     end
 
-  end
+    context "detecting activerecord edges from belongs_to, has_many and through" do
+      let(:source) {
+        <<-CODE
+          class Assembly < ActiveRecord::Base
+            has_many :manifests
+            has_many :parts, through: :manifests
+          end
+
+          class Manifest < ActiveRecord::Base
+            belongs_to :assembly
+            belongs_to :part
+          end
+
+          class Part < ActiveRecord::Base
+            has_many :manifests
+            has_many :assemblies, through: :manifests
+          end
+        CODE
+      }
+
+      let(:parser)   { Society::Parser.for_source(source) }
+      let(:assembly) { parser.graph.detect {|c| c.name == "Assembly" } }
+      let(:manifest) { parser.graph.detect {|c| c.name == "Manifest" } }
+      let(:part)     { parser.graph.detect {|c| c.name == "Part" } }
+
+      it "records `has_many` and `has_many through:` associations" do
+        expect(assembly.edges.map(&:to).sort).to match_array %w(Manifest Part)
+        expect(part.edges.map(&:to).sort).to match_array %w(Assembly Manifest)
+      end
 
-  describe "::for_source" do
+      it "records `belongs_to` associations" do
+        expect(manifest.edges.map(&:to).sort).to match_array %w(Assembly Part)
+      end
+    end
 
-    let(:source) { "class Ship; end" }
+    context "detecting activerecord edges with `class_name` specified" do
+      let(:source) {<<-CODE
+          class Post < ActiveRecord::Base
+            belongs_to :author, :class_name => "User"
+            belongs_to :editor, :class_name => "User"
+          end
+
+          class User < ActiveRecord::Base
+            has_many :authored_posts, :foreign_key => "author_id", :class_name => "Post"
+            has_many :edited_posts, :foreign_key => "editor_id", :class_name => "Post"
+          end
+        CODE
+      }
+
+      let(:parser)   { Society::Parser.for_source(source) }
+      let(:user)     { parser.graph.detect {|c| c.name == "User" } }
+      let(:post)     { parser.graph.detect {|c| c.name == "Post" } }
+
+      it "records belongs_to's" do
+        expect(post.edges.map(&:to)).to match_array %w(User)
+        expect(post.edges.map(&:weight)).to match_array [2]
+      end
+
+      it "records has_many's" do
+        expect(user.edges.map(&:to)).to match_array %w(Post)
+        expect(user.edges.map(&:weight)).to match_array [2]
+      end
+    end
+
+    context "detecting activerecord edges with `class_name` or `source` specified" do
+      let(:source) { <<-CODE
+        class Post < ActiveRecord::Base
+          has_many :post_authorings, :foreign_key => :authored_post_id
+          has_many :authors, :through => :post_authorings, :source => :post_author
+          belongs_to :editor, :class_name => "User"
+        end
+
+        class User < ActiveRecord::Base
+          has_many :post_authorings, :foreign_key => :post_author_id
+          has_many :authored_posts, :through => :post_authorings
+          has_many :edited_posts, :foreign_key => :editor_id, :class_name => "Post"
+        end
+
+        class PostAuthoring < ActiveRecord::Base
+          belongs_to :post_author, :class_name => "User"
+          belongs_to :authored_post, :class_name => "Post"
+        end
+      CODE
+      }
+
+      let(:parser)         { Society::Parser.for_source(source) }
+      let(:user)           { parser.graph.detect {|c| c.name == "User" } }
+      let(:post)           { parser.graph.detect {|c| c.name == "Post" } }
+      let(:post_authoring) { parser.graph.detect {|c| c.name == "PostAuthoring" } }
+
+      it "handles `source` and `class_name` correctly" do
+        expect(post.edges.map(&:to).sort).to match_array %w(PostAuthoring User)
+        expect(post.edges.sort_by(&:to).map(&:weight)).to match_array [1, 2]
+      end
+
+      it "handles `through` and `class_name` correctly" do
+        expect(user.edges.map(&:to).sort).to match_array %w(PostAuthoring Post)
+        expect(user.edges.sort_by(&:to).map(&:weight)).to match_array [1, 2]
+      end
+
+      it "handles `class_name` correctly" do
+        expect(post_authoring.edges.map(&:to).sort).to match_array %w(Post User)
+      end
+    end
+
+    context "detecting activerecord edges with polymorphic associations" do
+      let(:source) { <<-CODE
+        class Picture < ActiveRecord::Base
+          belongs_to :imageable, polymorphic: true
+        end
+
+        class Employee < ActiveRecord::Base
+          has_many :pictures, as: :imageable
+        end
+
+        class Product < ActiveRecord::Base
+          has_many :pictures, as: :imageable
+        end
+      CODE
+      }
+
+      let(:parser)   { Society::Parser.for_source(source) }
+      let(:picture)  { parser.graph.detect {|c| c.name == "Picture" } }
+      let(:employee) { parser.graph.detect {|c| c.name == "Employee" } }
+      let(:product)  { parser.graph.detect {|c| c.name == "Product" } }
+
+      it "records the `polymorphic: true` side of the association" do
+        expect(picture.edges.map(&:to).sort).to match_array %w(Employee Product)
+      end
+
+      it "records the `as: :something` side of the asociation" do
+        expect(employee.edges.map(&:to).sort).to match_array %w(Picture)
+        expect(product.edges.map(&:to).sort).to match_array %w(Picture)
+      end
+
+    end
+
+  end
+
+  describe "::for_files" do
 
     it "returns a parser object" do
-      expect(Society::Parser.for_source(source).class.name).to eq("Society::Parser")
+      expect(Society::Parser.for_files('./spec/fixtures/for_parser_spec').class.name).to eq("Society::Parser")
+      expect(Society::Parser.for_files('./spec/fixtures/for_parser_spec').classes).to eq(["Whaler"])
     end
 
-    it "initializes the parser with an Analyzer object" do
-      expect(Society::Parser.for_source(source).analyzer.class.name).to eq("Analyst::Parser")
+  end
+
+  describe "#initialize" do
+    it "returns a parser object" do
+      expect(Society::Parser.new([]).class.name).to eq("Society::Parser")
     end
+  end
 
+  describe "#graph" do
+    it "returns a graph object" do
+      expect(Society::Parser.new([]).graph.class.name).to eq("Society::ObjectGraph")
+    end
   end
 
   describe "#report" do
 
-    let(:parser) { Society::Parser.new(nil) }
+    let(:parser) { Society::Parser.new([]) }
     let(:formatter) { double.as_null_object }
 
     before do