fathom 0.3.7 → 0.5.0

data/lib/fathom/contexts/network_traversal.rb

@@ -0,0 +1,4 @@
+module Fathom
+  class NetworkTraversal
+  end
+end

data/lib/fathom/data/adjacency_matrix.rb

@@ -0,0 +1,27 @@
+module Fathom
+  class AdjacencyMatrix
+    
+    include Enumerable
+    
+    def initialize(default=0)
+      @default = default
+      @store = Hash.new(default)
+    end
+  
+    def [](parent, child)
+      @store[[parent, child]]
+    end
+  
+    def []=(parent, child, value)
+      if value == @default
+        @store.delete([parent, child]) # preserves a little memory
+      else
+        @store[[parent, child]] = value
+      end
+    end
+    
+    def each
+      @store.each {|k, v| yield(k,v)}
+    end
+  end
+end

data/lib/fathom/data/definition.rb

@@ -0,0 +1,22 @@
+module Fathom
+  class Definition
+    
+    # ============
+    # = Behavior =
+    # ============
+    extend Plugins
+    plugin AttributeSystem
+    
+    # ==============
+    # = Attributes =
+    # ==============
+    attribute :for
+    attribute :given
+    attribute :table
+    
+    def initialize(attrs={})
+      @attributes = attrs
+    end
+    
+  end # Definition
+end # Fathom

data/lib/fathom/data/edge.rb

@@ -0,0 +1,58 @@
+module Fathom
+  class Edge
+    
+    # =============
+    # Class Methods
+    # =============
+    class << self
+      def infer(obj, optional_child=nil)
+        return new(:parent => Variable.infer(obj), :child => Variable.infer(optional_child)) if optional_child
+        
+        case obj
+        when Edge
+          obj
+        when Array
+          new(:parent => Variable.infer(obj[0]), :child => Variable.infer(obj[1]))
+        when Hash
+          new(obj)
+        end
+      end
+    end
+    
+    # ============
+    # = Behavior =
+    # ============
+    extend Plugins
+    plugin AttributeSystem
+    
+    # ==============
+    # = Attributes =
+    # ==============
+    attribute :is_directed, true
+    attribute :parent
+    attribute :child
+    
+    def initialize(attributes={})
+      attributes[:parent] = Variable.infer(attributes[:parent])
+      attributes[:child] = Variable.infer(attributes[:child])
+      @attributes = attributes
+    end
+    
+    # ============================================================
+    # = Override setters on parent and child to ensure Variables =
+    # ============================================================
+    def parent=(obj)
+      send(self.class.attributes_proxy)[:parent] = Variable.infer(obj)
+    end
+    
+    def child=(obj)
+      send(self.class.attributes_proxy)[:child] = Variable.infer(obj)
+    end
+
+    def eql(other)
+      return false unless other.is_a?(Edge)
+      self.parent == other.parent and self.child == other.child
+    end
+    alias :== :eql
+  end
+end

data/lib/fathom/data/network.rb

@@ -0,0 +1,35 @@
+module Fathom
+  class Network
+    
+    # ============
+    # = Behavior =
+    # ============
+    extend Plugins
+    include Enumerable
+    plugin AttributeSystem
+    
+    # ==============
+    # = Attributes =
+    # ==============
+    attribute :name
+    attribute :variables, []
+    attribute :properties, []
+    attribute :edges, []
+    attribute :definitions, []
+    
+    def initialize(attrs={})
+      @attributes = attrs
+    end
+    
+    # ====================
+    # = Instance Methods =
+    # ====================
+    def each(&block)
+      variables.each do |variable|
+        yield variable
+      end
+    end
+    alias :each_variable :each
+    
+  end
+end

data/lib/fathom/data/outcome.rb

@@ -0,0 +1,30 @@
+module Fathom
+  class Outcome
+    
+    # =================
+    # = Class Methods =
+    # =================
+    class << self
+      def infer(obj)
+        new(:value => obj)
+      end
+    end
+    
+    # ============
+    # = Behavior =
+    # ============
+    extend Plugins
+    plugin AttributeSystem
+    
+    # ==============
+    # = Attributes =
+    # ==============
+    attribute :value
+    
+    def initialize(attrs={})
+      @attributes = attrs
+    end
+    
+  end # Outcome
+end # Fathom
+    

data/lib/fathom/data/property.rb

@@ -0,0 +1,31 @@
+module Fathom
+  class Property
+    
+    # =================
+    # = Class Methods =
+    # =================
+    class << self
+      def infer(obj)
+        new(:value => obj)
+      end
+    end
+    
+    # ============
+    # = Behavior =
+    # ============
+    extend Plugins
+    plugin AttributeSystem
+    
+    # ==============
+    # = Attributes =
+    # ==============
+    attribute :value
+    
+    def initialize(attrs={})
+      @attributes = attrs
+    end
+    
+  end # Property
+end # Fathom
+    
+    

data/lib/fathom/data/variable.rb

@@ -0,0 +1,59 @@
+module Fathom
+  class Variable
+    
+    # =================
+    # = Class Methods =
+    # =================
+    class << self
+      def infer(obj)
+        case obj
+        when Variable
+          obj
+        when Hash
+          new(obj)
+        when Symbol, String
+          new(:name => obj)
+        end
+      end
+    end
+    
+    # ============
+    # = Behavior =
+    # ============
+    extend Plugins
+    plugin AttributeSystem
+    
+    # ==============
+    # = Attributes =
+    # ==============
+    attribute :id
+    attribute :name
+    attribute :properties
+    attribute :outcomes, [true, false]
+    attribute :prior_odds
+    
+    def initialize(attrs={})
+      attrs[:id] ||= UUID.generate
+      @attributes = attrs
+      self.prior_odds ||= uniform_set.dup
+    end
+    
+    def underscored_name
+      name.to_s.gsub(/\W/, "_").underscore
+    end
+    
+    def eql(other)
+      return false unless other.is_a?(Variable)
+      self.name == other.name
+    end
+    alias :== :eql
+    
+    protected
+      def uniform_set
+        size = self.outcomes.size
+        Array.new(size, 1/size.to_f)
+      end
+    
+  end # class Data
+  
+end

data/lib/fathom/roles/general_graph_tools.rb

@@ -0,0 +1,87 @@
+module Fathom
+  module GeneralGraphTools
+    
+    def adjacency_matrix
+      @adjacency_matrix ||= AdjacencyMatrix.new
+    end
+    
+    def add_edge(parent, child)
+      self.variables |= [parent, child]
+      self.adjacency_matrix[parent, child] = 1
+    end
+    
+    def remove_edge(parent, child)
+      return false unless self.variables.include?(parent) and self.variables.include?(child)
+      self.adjacency_matrix[parent, child] = 0
+    end
+    
+    def at(parent, child)
+      self.adjacency_matrix[parent, child]
+    end
+    alias :[] :at
+    
+    def edge?(parent, child)
+      return false unless ([parent, child] - self.variables).empty?
+      self.adjacency_matrix[parent, child] == 1
+    end
+    
+    # Implemented as an out-degree
+    def degree(node)
+      found = self.adjacency_matrix.select do |(parent, child), value|
+        parent == node
+      end
+      found.size
+    end
+    
+    def each_vertex
+      self.variables.each {|v| yield v}
+    end
+    
+    def each_edge
+      self.adjacency_matrix.each {|(parent, child), value| yield parent, child}
+    end
+    
+    # Find whether the graph is connected, based on notes here:
+    # http://www.ics.uci.edu/~eppstein/161/960201.html
+    # This assumes that all variables in the network have been added 
+    # to the adjacency matrix.
+    def connected?
+      x = self.variables[0] # Arbitrary first node
+      reachable_vertices = [x]
+      vertices_to_explore = [x]
+
+      while !vertices_to_explore.empty?
+        y = vertices_to_explore.shift
+        self.each_edge do |parent, child|
+          unless reachable_vertices.include?(child)
+            vertices_to_explore << child
+            reachable_vertices << child
+          end
+        end
+      end
+      
+      reachable_vertices.size < self.variables.size ? false : true
+      
+    end
+
+    def euler_circuit?
+      return false if !connected?
+      self.each_vertex do |v|
+        return false if degree(v) % 2 != 0
+      end
+      true
+    end
+    
+    def euler_path?
+      return false if !connected?
+      odd=0
+      self.each_vertex do |v|
+        if degree(v) % 2 == 1
+          odd += 1
+        end
+      end
+      odd <= 2
+    end
+    
+  end
+end

data/lib/fathom/roles/network_builder.rb

@@ -0,0 +1,61 @@
+module Fathom
+  
+  # This is the role necessary for importing nodes, shaping graphs, adding edges, that sort of thing.
+  module NetworkBuilder
+    def from_hash(hash)
+      hash = serialize_hash(hash)
+      attributes.merge!(hash)
+    end
+    
+    protected
+    
+      def serialize_hash(hash)
+        hash.inject({}) do |h, (key, value)|
+
+          value = [value] if attribute_should_be_an_array(key) and not value.is_a?(Array)
+
+          if klass = serialization_class_for(key)
+            value = infer_serialized_array(value, klass)
+          end
+
+          h[key] = value
+
+          h
+        end
+      end
+      
+      def serialization_class_for(attribute)
+        serialization_map[attribute]
+      end
+      
+      def serialization_map
+        @serialization_map ||= {
+          definitions: Definition,
+          edges: Edge,
+          properties: Property,
+          variables: Variable
+        }
+      end
+      
+      def attribute_should_be_an_array(attribute)
+        array_conversion_attributes.include?(attribute)
+      end
+      
+      def array_conversion_attributes
+        @array_conversion_map ||= [:properties, :variables, :edges, :definitions]
+      end
+      
+      # Uses the Class.infer, if available.  Otherwise initializes the value passed in.
+      def infer_serialized_array(array, klass)
+        array.map do |e|
+          if  klass == e.class
+            e
+          elsif klass.respond_to?(:infer)
+            klass.infer(e)
+          else
+            klass.new(e)
+          end
+        end
+      end
+  end
+end

data/spec/fathom/behaviors/attribute_system_spec.rb

@@ -0,0 +1,141 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+include Fathom
+
+describe AttributeSystem do
+
+  context "when checking the default nature of a class that has plugged in AttributeSystem" do
+    
+    before do
+      @class = Class.new do
+        extend Plugins
+        plugin AttributeSystem
+      end
+    end
+
+    it "should have an attributes getter" do
+      obj = @class.new
+      obj.should respond_to(:attributes)
+    end
+    
+    it "should default the attributes to a Hash" do
+      obj = @class.new
+      obj.attributes.should eql({})
+    end
+  end
+  
+  context "when proxying to another object" do
+    
+    before do
+      @class = Class.new do
+        extend Plugins
+        plugin AttributeSystem
+      end
+    end
+    
+    it "should default the attributes_proxy to :attributes" do
+      @class.attributes_proxy.should eql(:attributes)
+    end
+    
+    it "should be able to set_attributes_proxy" do
+      @class.set_attributes_proxy :some_method
+      @class.attributes_proxy.should eql(:some_method)
+    end
+  end
+  
+  context "when defining an attribute" do
+    
+    before do
+      @class = Class.new do
+        extend Plugins
+        plugin AttributeSystem
+      end
+    end
+    
+    it "should have an attribute method" do
+      @class.should respond_to(:attribute)
+    end
+    
+    it "should be able to take an attribute name and have a setter and getter on that" do
+      @class.attribute(:name)
+      obj = @class.new
+      obj.name = :name
+      obj.name.should eql(:name)
+    end
+    
+    it "should be able to read from the attributes object" do
+      @class = Class.new do
+        extend Plugins
+        plugin AttributeSystem
+        attribute :name
+        def initialize
+          @attributes = {:name => :value}
+        end
+      end
+      obj = @class.new
+      obj.name.should eql(:value)
+    end
+    
+    it "should follow the proxied attributes, if it's been changed" do
+      @class = Class.new do
+        extend Plugins
+        plugin AttributeSystem
+
+        attribute :name
+        set_attributes_proxy :alternate_attributes
+        
+        def alternate_attributes
+          {:name => :value}
+        end
+      end
+      obj = @class.new
+      obj.name.should eql(:value)
+    end
+    
+    it "should be able to set an attribute with a default" do
+      @class.attribute(:name, :default)
+      obj = @class.new
+      obj.name.should eql(:default)
+    end
+    
+    it "should not use the default if the attribute has been set" do
+      @class.attribute(:name, :default)
+      obj = @class.new
+      obj.name.should eql(:default)
+      obj.name = :changed
+      obj.name.should eql(:changed)
+    end
+    
+    it "should not use the default if the underlying attribute has been set" do
+      @class = Class.new do
+        extend Plugins
+        plugin AttributeSystem
+        attribute :name, :default
+        
+        def initialize(attrs={})
+          @attributes = attrs
+        end
+      end
+      
+      obj = @class.new :name => :changed
+      obj.name.should eql(:changed)
+    end
+
+
+    it "should not use the default if the underlying attribute has been set" do
+      @class = Class.new do
+        extend Plugins
+        plugin AttributeSystem
+        attribute :name, :default
+        
+        def initialize(attrs={})
+          @attributes = attrs
+        end
+      end
+      
+      obj = @class.new :name => nil
+      obj.name.should be_nil
+    end
+  end
+  
+end