fathom 0.3.7 → 0.5.0

data/spec/fathom/behaviors/context_behavior_spec.rb

@@ -0,0 +1,15 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+include Fathom
+
+describe ContextBehavior do
+  it "should be able to set a default_class" do
+    @class = Class.new do
+      extend Plugins
+      plugin ContextBehavior
+      default_class Hash
+    end
+    obj = @class.new
+    obj.object.should eql({})
+  end
+end

data/spec/fathom/behaviors/plugins_spec.rb

@@ -0,0 +1,80 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+include Fathom
+
+module PluginDemoModule
+  module InstanceMethods
+    def special_instance_method
+      :special_instance_method
+    end
+  end
+  
+  module ClassMethods
+    def special_class_method
+      :special_class_method
+    end
+    
+    def special_configuration_method
+      @especially_configured = true
+    end
+    
+    attr_reader :especially_configured
+  end
+  
+  def self.configure(mod)
+    mod.special_configuration_method
+  end
+end
+
+module PlainDemoModule
+  def plain_instance_method
+    :plain_instance_method
+  end
+end
+
+
+describe Plugins do
+
+  before do
+    @class = Class.new do
+      extend Plugins
+      plugin PluginDemoModule
+    end
+  end
+  
+  after(:all) do
+    Object.send(:remove_const, :PluginDemoModule)
+    Object.send(:remove_const, :PlainDemoModule)
+  end
+  
+  it "should have a plugins array" do
+    @class.plugins.should eql([PluginDemoModule])
+  end
+  
+  it "should be able to add a new plugin" do
+    @class.plugins.should eql([PluginDemoModule])
+  end
+  
+  it "should make the ClassMethods available to the class" do
+    @class.special_class_method.should eql(:special_class_method)
+  end
+  
+  it "should make the InstanceMethods available on an instance" do
+    obj = @class.new
+    obj.special_instance_method.should eql(:special_instance_method)
+  end
+  
+  it "should include a plain module if it is not a Plugin (has InstanceMethods)" do
+    @class = Class.new do
+      extend Plugins
+      plugin PlainDemoModule
+    end
+    obj = @class.new
+    obj.plain_instance_method.should eql(:plain_instance_method)
+  end
+  
+  it "should have called the configure method in the plugin" do
+    @class.especially_configured.should be_true
+  end
+  
+end

data/spec/fathom/contexts/network_population_spec.rb

@@ -0,0 +1,55 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+include Fathom
+
+describe NetworkPopulation do
+  
+  # ====================
+  # = General Behavior =
+  # ====================
+  context "when acting like a context generally" do
+    before {@class = NetworkPopulation}
+    it_should_behave_like "a context"
+    
+    it "should have a default_class of Network" do
+      @context = NetworkPopulation.new
+      @context.object.should be_a(Network)
+    end
+  end
+  
+  # ==================
+  # = YAML Importing =
+  # ==================
+  context "when importing records from YAML" do
+    before do
+      @network = Network.new
+      @context = NetworkPopulation.new(@network)
+    end
+
+    it "should mixin the NetworkBuilder to the network" do
+      @context.object.should_receive(:extend).with(NetworkBuilder).and_return(true)
+      @context.object.stub(:from_hash) { true }
+      @context.import_records_from_yaml
+    end
+    
+    it "should expose from_hash on the network object" do
+      @network.should_not respond_to(:from_hash)
+      @context.import_records_from_yaml
+      @network.should respond_to(:from_hash)
+    end
+
+    it "should be able to take a filename and process that." do
+      yaml_contents = YAML.load(network_contents_in_yaml)
+      YAML.should_receive(:load_file).with(network_contents_in_yaml_filename).and_return(yaml_contents)
+      @context.import_records_from_yaml(:filename => network_contents_in_yaml_filename)
+    end
+    
+    it "should rely on from_hash to convert the loaded YAML values into a serialized network" do
+      yaml_contents = YAML.load(network_contents_in_yaml)
+      @network.should_receive(:from_hash).with(yaml_contents).and_return(true)
+      @context.import_records_from_yaml(:filename => network_contents_in_yaml_filename)
+    end
+    
+  end
+  
+end

data/spec/fathom/contexts/network_traversal_spec.rb

@@ -0,0 +1,11 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+include Fathom
+
+describe NetworkTraversal do
+  
+  # context "when searching a directed graph" do
+  #   before do
+  #     @edges = 
+  # end
+end

data/spec/fathom/data/adjacency_matrix_spec.rb

@@ -0,0 +1,42 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+include Fathom
+
+describe AdjacencyMatrix do
+  before do
+    @am = AdjacencyMatrix.new
+  end
+  
+  it "should use an efficient data storage method, a Hash that defaults to 0" do
+    store = @am.send(:instance_variable_get, :@store)
+    store.should be_a(Hash)
+    store[:not_indexed].should eql(0)
+  end
+  
+  it "should take an arbitrary default for the store" do
+    am = AdjacencyMatrix.new(:arbitrary)
+    store = am.send(:instance_variable_get, :@store)
+    store[:not_indexed].should eql(:arbitrary)
+  end
+  
+  it "should take a parent and child argument to get or set a value in the store" do
+    lambda{@am[1]}.should raise_error(ArgumentError, /wrong number of arguments/)
+    @am[1,1] = 1
+    @am[1,1].should eql(1)
+  end
+  
+  it "should be an Enumerable" do
+    AdjacencyMatrix.included_modules.should be_include(Enumerable)
+  end
+  
+  it "should enumerate on the store" do
+    @am[1,1] = 1
+    @am[2,1] = 1
+    @am.map.to_a.should eql([[[1, 1], 1], [[2, 1], 1]])
+    @am.each do |(parent, child), value|
+      child.should eql(1)
+      value.should eql(1)
+      [1,2].should be_include(parent)
+    end
+  end
+end

data/spec/fathom/data/definition_spec.rb

@@ -0,0 +1,19 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+include Fathom
+
+describe Definition do
+
+  it "should initialize a for accessor" do
+    Definition.should have_an_initialization_accessor_for(:for)
+  end
+  
+  it "should initialize a given accessor" do
+    Definition.should have_an_initialization_accessor_for(:given)
+  end
+  
+  it "should initialize a table accessor" do
+    Definition.should have_an_initialization_accessor_for(:table)
+  end
+  
+end

data/spec/fathom/data/edge_spec.rb

@@ -0,0 +1,77 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+include Fathom
+
+describe Edge do
+  
+  it "should initialize a is_directed accessor" do
+    Edge.should have_an_initialization_accessor_for(:is_directed)
+  end
+  
+  it "should default the edge to true" do
+    edge = Edge.new
+    edge.is_directed.should be_true
+  end
+  
+  it "should initialize a parent accessor" do
+    edge = Edge.new(:parent => :value)
+    edge.parent.should ==(Variable.new(:name => :value))
+    edge.parent = :value2
+    edge.parent.should ==(Variable.new(:name => :value2))
+  end
+  
+  it "should initialize a child accessor" do
+    edge = Edge.new(:child => :value)
+    edge.child.should ==(Variable.new(:name => :value))
+    edge.child = :value2
+    edge.child.should ==(Variable.new(:name => :value2))
+  end
+  
+  it "should be equal by variables" do
+    v1 = Variable.new(:name => :v1)
+    v2 = Variable.new(:name => :v2)
+    e1 = Edge.new(:parent => v1, :child => v2)
+    e2 = Edge.new(:parent => v1, :child => v2)
+    e1.should ==(e2)
+  end
+  
+  it "should ensure the parent and child are a variables" do
+    edge = Edge.new :parent => :v1, :child => :v2
+    edge.parent.should ==(Variable.new(:name => :v1))
+    edge.child.should ==(Variable.new(:name => :v2))
+  end
+  
+  context "when inferring an Edge" do
+    it "should be able to infer an Edge from an Edge" do
+      edge = Edge.new :parent => :v1, :child => :v2
+      inferred = Edge.infer(edge)
+      inferred.should eql(edge)
+    end
+    
+    it "should be able to infer an Edge from an Array, [parent, child]" do
+      v1 = Variable.infer(:v1)
+      v2 = Variable.infer(:v2)
+      edge = Edge.infer([v1, v2])
+      edge.should be_a(Edge)
+      edge.parent.should eql(v1)
+      edge.child.should eql(v2)
+    end
+    
+    it "should be able to take more than one parameter and use that as a parent, child indicator" do
+      v1 = Variable.infer(:v1)
+      v2 = Variable.infer(:v2)
+      edge = Edge.infer(v1, v2)
+      edge.should be_a(Edge)
+      edge.parent.should eql(v1)
+      edge.child.should eql(v2)
+    end
+    
+    it "should be able to infer an Edge from a Hash" do
+      edge = Edge.infer :parent => :p, :child => :c
+      edge.parent.should be_a(Variable)
+      edge.parent.name.should eql(:p)
+      edge.child.should be_a(Variable)
+      edge.child.name.should eql(:c)
+    end
+  end
+end

data/spec/fathom/data/network_spec.rb

@@ -0,0 +1,72 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+include Fathom
+
+describe Network do
+  
+  it "should initialize a name accessor" do
+    Network.should have_an_initialization_accessor_for(:name)
+  end
+  
+  it "should initialize a variables accessor" do
+    Network.should have_an_initialization_accessor_for(:variables)
+  end
+  
+  it "should default the variables to an array" do
+    Network.new.variables.should eql([])
+  end
+  
+  it "should extend Enumerable" do
+    Network.ancestors.should be_include(Enumerable)
+  end
+  
+  it "should enumerate over the variables" do
+    n = Network.new :variables => [1,2,3]
+    n.map.to_a.should eql([1,2,3])
+  end
+
+  it "should initialize a properties accessor" do
+    Network.should have_an_initialization_accessor_for(:properties)
+  end
+  
+  it "should default the properties to an Array" do
+    Network.new.properties.should eql([])
+  end
+
+  it "should initialize an edges accessor" do
+    Network.should have_an_initialization_accessor_for(:edges)
+  end
+  
+  it "should default the edges to an Array" do
+    Network.new.edges.should eql([])
+  end
+  
+  it "should initialize a definitions accessor" do
+    Network.should have_an_initialization_accessor_for(:definitions)
+  end
+  
+  it "should default the definitions to an Array" do
+    Network.new.definitions.should eql([])
+  end
+  
+  context "when using the Enumerator" do
+    before do
+      @n = Network.new :variables => [1,2,3]
+      @variables = @n.variables 
+    end
+    
+    it "should be able to iterate on the variables" do
+      @n.each {|v| @variables.should be_include(v)}
+    end
+  
+    it "should have each_variable as an alias to each" do
+      @n.each_variable {|v| @variables.should be_include(v)}
+    end
+  
+    it "should use the variable enumeration for the Enumerable" do
+      @n.map {|v| v }.should eql([1,2,3])
+    end
+  end
+  
+end
+

data/spec/fathom/data/outcome_spec.rb

@@ -0,0 +1,17 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+include Fathom
+
+describe Outcome do
+  
+  it "should initialize a value accessor" do
+    Outcome.should have_an_initialization_accessor_for(:value)
+  end
+  
+  it "should have an infer constructor" do
+    outcome = Outcome.infer(:some_value)
+    outcome.should be_a(Outcome)
+    outcome.value.should eql(:some_value)
+  end
+
+end

data/spec/fathom/data/property_spec.rb

@@ -0,0 +1,17 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+include Fathom
+
+describe Property do
+  
+  it "should initialize a value accessor" do
+    Property.should have_an_initialization_accessor_for(:value)
+  end
+  
+  it "should have an infer constructor" do
+    property = Property.infer(:some_value)
+    property.should be_a(Property)
+    property.value.should eql(:some_value)
+  end
+
+end

data/spec/fathom/data/variable_spec.rb

@@ -0,0 +1,101 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+include Fathom
+
+describe Variable do
+  
+  # ==================
+  # = Initialization =
+  # ==================
+  it "should have an attributes getter, built from initialization" do
+    v = Variable.new(some: :value)
+    v.attributes.delete(:id)
+    v.attributes.should eql({:some => :value, :prior_odds => [0.5, 0.5]})
+  end
+  
+  it "should initialize a name accessor" do
+    Variable.should have_an_initialization_accessor_for(:name)
+  end
+  
+  it "should have an underscored_name" do
+    v = Variable.new(:name => "a Very special name, don't you think?")
+    v.underscored_name.should eql("a_very_special_name__don_t_you_think_")
+  end
+  
+  it "should initialize a properties accessor" do
+    Variable.should have_an_initialization_accessor_for(:properties)
+  end
+  
+  it "should initialize an outcomes accessor" do
+    Variable.should have_an_initialization_accessor_for(:outcomes)
+  end
+  
+  it "should default the outcomes to [true, false]" do
+    v = Variable.new
+    v.outcomes.should eql([true, false])
+  end
+  
+  it "should initialize a prior_odds accessor" do
+    Variable.should have_an_initialization_accessor_for(:prior_odds)
+  end
+  
+  it "should default the prior odds to the uniform set for the outcomes" do
+    v = Variable.new
+    v.prior_odds.should eql([0.5, 0.5])
+    v = Variable.new :outcomes => [:a, :b, :c]
+    v.prior_odds.should eql([1/3.0, 1/3.0, 1/3.0])
+  end
+  
+  # =================
+  # = Equality (==) =
+  # =================
+  it "should be equal by name" do
+    v1 = Variable.new(:name => :name)
+    v2 = Variable.new(:name => :name)
+    v1.should ==(v2)
+  end
+
+  # =========
+  # = Infer =
+  # =========
+  context "when infering" do
+    it "should be able to infer from a variable" do
+      @v1 = Variable.new
+      Variable.infer(@v1).should eql(@v1)
+    end
+    
+    it "should be able to infer from a hash" do
+      @hash = {:name => :name, :prior_odds => [0.4, 0.6]}
+      @v1 = Variable.new(@hash)
+      Variable.infer(@hash).should ==(@v1)
+    end
+    
+    it "should be able to infer from a symbol" do
+      @symbol = :name
+      @v1 = Variable.new(:name => @symbol)
+      Variable.infer(@symbol).should ==(@v1)
+    end
+
+    it "should be able to infer from a string" do
+      @string = 'name'
+      @v1 = Variable.new(:name => @string)
+      Variable.infer(@string).should ==(@v1)
+    end
+
+  end
+  
+  # ======
+  # = ID =
+  # ======
+  context "when ensuring a unique id" do
+    before do
+      @v = Variable.new
+    end
+    
+    it "should have an id, a UUID" do
+      uuid_re = /^\w{8}\-\w{4}\-\w{4}\-\w{4}\-\w{12}$/
+      @v.id.should match(uuid_re)
+    end
+  end
+
+end