fathom 0.3.7 → 0.5.0

data/features/support/env.rb

@@ -0,0 +1,13 @@
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../../lib')
+require 'fathom'
+
+require 'rspec/expectations'

data/lib/ext/array.rb

@@ -1,5 +1,9 @@
 class Array
-  def rand
-    self[Kernel.rand(self.length)]
+  def invert(&block)
+    h = {}
+    self.each_with_index do |x, i|
+      h[x] = block ? yield(x, i) : i
+    end
+    h
   end
 end

data/lib/ext/string.rb

@@ -1,8 +1,39 @@
-# From ActiveSupport
-class String
+module Inflector
+  extend self
+
+  def camelize(lower_case_and_underscored_word, first_letter_in_uppercase = true)
+    if first_letter_in_uppercase
+      lower_case_and_underscored_word.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+    else
+      lower_case_and_underscored_word.to_s[0].chr.downcase + camelize(lower_case_and_underscored_word)[1..-1]
+    end
+  end
+
+  def underscore(camel_cased_word)
+    word = camel_cased_word.to_s.dup
+    word.gsub!(/::/, '/')
+    word.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+    word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+    word.tr!("-", "_")
+    word.downcase!
+    word
+  end
+
+  def dasherize(underscored_word)
+    underscored_word.gsub(/_/, '-')
+  end
+
+  def demodulize(class_name_in_module)
+    class_name_in_module.to_s.gsub(/^.*::/, '')
+  end
+
+  def foreign_key(class_name, separate_class_name_and_id_with_underscore = true)
+    underscore(demodulize(class_name)) + (separate_class_name_and_id_with_underscore ? "_id" : "id")
+  end
+
   if Module.method(:const_get).arity == 1
-    def constantize
-      names = self.split('::')
+    def constantize(camel_cased_word)
+      names = camel_cased_word.split('::')
       names.shift if names.empty? || names.first.empty?
 
       constant = Object
@@ -12,8 +43,8 @@ class String
       constant
     end
   else
-    def constantize #:nodoc:
-      names = self.split('::')
+    def constantize(camel_cased_word) #:nodoc:
+      names = camel_cased_word.split('::')
       names.shift if names.empty? || names.first.empty?
 
       constant = Object
@@ -23,5 +54,53 @@ class String
       constant
     end
   end
+
+  def ordinalize(number)
+    if (11..13).include?(number.to_i % 100)
+      "#{number}th"
+    else
+      case number.to_i % 10
+        when 1; "#{number}st"
+        when 2; "#{number}nd"
+        when 3; "#{number}rd"
+        else    "#{number}th"
+      end
+    end
+  end
+end
+
+class String
+  def constantize
+    Inflector.constantize(self)
+  end
+  
+  def camelize(first_letter_in_uppercase = true)
+    Inflector.camelize(self, first_letter_in_uppercase)
+  end
+  
+  def underscore
+    Inflector.underscore(self)
+  end
+  
+  def dasherize
+    Inflector.dasherize(self)
+  end
+
+  def demodulize
+    Inflector.demodulize(self)
+  end
+  
+  def foreign_key(separate_class_name_and_id_with_underscore = true)
+    Inflector.foreign_key(self, separate_class_name_and_id_with_underscore)
+  end
+  
+  def ordinalize  
+    Inflector.ordinalize(self)
+  end
+  
+  def wrap(col=80)
+    # http://blog.macromates.com/2006/wrapping-text-with-regular-expressions/
+    gsub(/(.{1,#{col}})( +|$\n?)|(.{1,#{col}})/, "\\1\\3\n") 
+  end
   
-end
+end

data/lib/fathom.rb

@@ -1,103 +1,66 @@
 # ================
 # = Dependencies =
 # ================
+Dir.glob("#{File.dirname(__FILE__)}/ext/*.rb").each { |file| require file}
 
-# Make decoupling easier with an informed LoadPath
-$:.unshift(File.dirname(__FILE__))
-$:.unshift(File.expand_path(File.join(File.dirname(__FILE__), 'fathom')))
-
-require 'rubygems'
-
-require "gsl"
-require 'options_hash'
-
-require 'ext/open_struct'
-require 'ext/array'
-require 'ext/string'
+require 'uuid'
 
 module Fathom
-  lib = File.expand_path(File.dirname(__FILE__))
-  $LOAD_PATH.unshift(lib)
   
-  # Autoload classes and modules so that we only load as much of the library as we're using.
-  # This allows us to have a fairly large library without taking up a lot of memory unless we need it.
-  # autoload :Node, "node"
-  # autoload :BeliefNode, "node/belief_node"
-  # autoload :DataCollection, "node/data_collection"
-  # autoload :DataNode, "node/data_node"
-  # autoload :DiscreteNode, "node/discrete_node"
-  # autoload :MCNode, "node/mc_node"
-  # autoload :PlausibleRange, "node/plausible_range"
-  # autoload :Fact, "node/fact"
-  # autoload :Decision, "node/decision"
-  # autoload :CPMNode, 'node/cpm_node'
-  # 
-  # autoload :ValueDescription, "value_description"
-  # autoload :MonteCarloSet, "monte_carlo_set"
-  # autoload :KnowledgeBase, "knowledge_base"
-  # 
-  # autoload :Import, "import"
-  # autoload :ImportNode, "import/import_node"
-  # autoload :YAMLImport, 'import/yaml_import'
-  # autoload :CSVImport, 'import/csv_import'
-  # # autoload :RDFImport, 'import/rdf_import'
-  # # autoload :SQLiteImport, 'import/sqlite_import'
-  # 
-  # autoload :Simulation, 'simulation'
-  # autoload :TickMethods, 'simulation/tick_methods'
-  # autoload :TickSimulation, 'simulation/tick_simulation'
-  # 
-  # autoload :Agent, 'agent'
-  # autoload :Properties, 'agent/properties'
-  # autoload :AgentCluster, 'agent/agent_cluster'
-  # 
-  # autoload :EnforcedName, 'node/node_extensions/enforced_name'
-  # autoload :NumericMethods, 'node/node_extensions/numeric_methods'
-  
-  require 'distributions'
-  module Distributions
-    autoload :Gaussian, 'distributions/gaussian'
-    autoload :Uniform, 'distributions/uniform'
-    autoload :DiscreteGaussian, 'distributions/discrete_gaussian'
-    autoload :DiscreteUniform, 'distributions/discrete_uniform'
+  class Config
+    attr_writer :storage
+    def storage
+      @storage ||= Hash
+    end
   end
-
-  def knowledge_base
-    @knowledge_base ||= KnowledgeBase.new
+  
+  # =================
+  # = Configuration =
+  # =================
+  class << self
+    # A reset-able configuration that provides access to other services (pod storage, say)
+    def config
+      @config ||= Config.new
+    end
+  
+    # The reset on the configuration
+    def reset_config!
+      @config = Config.new
+    end
   end
-  alias :kb :knowledge_base
+  
 end
 
-# Temporary
-# include Fathom
-
-Fathom.autoload :Node, "node"
-Fathom.autoload :BeliefNode, "node/belief_node"
-Fathom.autoload :DataCollection, "node/data_collection"
-Fathom.autoload :DataNode, "node/data_node"
-Fathom.autoload :DiscreteNode, "node/discrete_node"
-Fathom.autoload :MCNode, "node/mc_node"
-Fathom.autoload :PlausibleRange, "node/plausible_range"
-Fathom.autoload :Fact, "node/fact"
-Fathom.autoload :Decision, "node/decision"
-Fathom.autoload :CPMNode, 'node/cpm_node'
-
-Fathom.autoload :ValueDescription, "value_description"
-Fathom.autoload :MonteCarloSet, "monte_carlo_set"
-Fathom.autoload :KnowledgeBase, "knowledge_base"
+def path(path)
+  File.expand_path("../fathom/#{path}", __FILE__)
+end
 
-Fathom.autoload :Import, "import"
-Fathom.autoload :ImportNode, "import/import_node"
-Fathom.autoload :YAMLImport, 'import/yaml_import'
-Fathom.autoload :CSVImport, 'import/csv_import'
+# =============
+# = Behaviors =
+# =============
+Fathom.autoload :AttributeSystem, path('behaviors/attribute_system')
+Fathom.autoload :ContextBehavior, path('behaviors/context_behavior')
+Fathom.autoload :Plugins, path('behaviors/plugins')
 
-Fathom.autoload :Simulation, 'simulation'
-Fathom.autoload :TickMethods, 'simulation/tick_methods'
-Fathom.autoload :TickSimulation, 'simulation/tick_simulation'
+# ===============
+# = Data Models =
+# ===============
+Fathom.autoload :AdjacencyMatrix, path('data/adjacency_matrix')
+Fathom.autoload :Definition, path('data/definition')
+Fathom.autoload :Edge, path('data/edge')
+Fathom.autoload :Network, path('data/network')
+Fathom.autoload :Outcome, path('data/outcome')
+Fathom.autoload :Property, path('data/property')
+Fathom.autoload :Variable, path('data/variable')
 
-Fathom.autoload :Agent, 'agent'
-Fathom.autoload :Properties, 'agent/properties'
-Fathom.autoload :AgentCluster, 'agent/agent_cluster'
+# ============
+# = Contexts =
+# ============
+Fathom.autoload :NetworkPopulation, path('contexts/network_population')
+Fathom.autoload :NetworkTraversal, path('contexts/network_traversal')
 
-Fathom.autoload :EnforcedName, 'node/node_extensions/enforced_name'
-Fathom.autoload :NumericMethods, 'node/node_extensions/numeric_methods'
+# =========
+# = Roles =
+# =========
+Fathom.autoload :NetworkBuilder, path('roles/network_builder')
+Fathom.autoload :GeneralGraphTools, path('roles/general_graph_tools')

data/lib/fathom/behaviors/attribute_system.rb

@@ -0,0 +1,91 @@
+module Fathom
+  
+  # This is a simple way to use thin Ruby classes to only store data values for attributes.
+  # In this way, we can have data models that can have various roles injected into them at
+  # runtime and perform fairly well.  We can also have other kinds of data models mixed into 
+  # Fathom, such as an ActiveRecord or DataMapper model, and we can just ignore this system
+  # altogether.
+  #
+  # It is important that it is easy to set an attributes_proxy.  Other Fathom gems 
+  # (say fm-redis, if I were to write that gem) could override the AttributeSystem default
+  # attributes to store data in a Redis data store directly.  This is what the set_attributes_proxy
+  # is designed to do here.
+  #
+  # Example Usage:
+  # require 'memcache'
+  # CACHE = MemCache.new 'localhost:11211', :namespace => 'my_project'
+  # CACHE[1] = {:name => 'special'}
+  # 
+  # class MyClass
+  #   extend Fathom::Plugins
+  #   plugin Fathom::AttributeSystem
+  #   
+  #   attribute :name
+  #   attribute :value, 1
+  #   
+  #   def initialize(attrs={})
+  #     @attributes = attrs
+  #   end
+  # end
+  # 
+  # obj = MyClass.new(CACHE[1])
+  # obj.name # => special
+  # obj.value # => 1
+  module AttributeSystem
+  
+    module ClassMethods
+      
+      # Define an attribute, or property of this class.
+      # Useful for very thin, generic Ruby classes for Data models.
+      def attribute(getter_name, default=nil)
+        
+        # Define a getter on the object
+        define_method(getter_name) do
+          
+          target = send(self.class.attributes_proxy)
+
+          return target[getter_name] unless target.respond_to?(:has_key?)
+
+          if target.has_key?(getter_name)
+            target[getter_name]
+          else
+            self.class.attribute_defaults[getter_name]
+          end
+        end
+
+        # Define a setter on the object
+        define_method("#{getter_name}=") do |value|
+          send(self.class.attributes_proxy)[getter_name] = value
+        end
+        
+        # Define a default on the object
+        attribute_defaults[getter_name] = default
+        
+      end
+      
+      # Defines where the attributes are stored for the target class.
+      def set_attributes_proxy(value)
+        @attributes_proxy = value
+      end
+      
+      def attributes_proxy
+        @attributes_proxy ||= :attributes
+      end
+      
+      def attribute_defaults
+        @attribute_defaults ||= {}
+      end
+    end
+    
+    module InstanceMethods
+
+      # Defines an attributes getter and defaults it to a Hash.
+      def attributes
+        @attributes ||= {}
+      end
+      
+    end
+    
+  end # AttributeSystem
+  
+end # Fathom

data/lib/fathom/behaviors/context_behavior.rb

@@ -0,0 +1,28 @@
+module Fathom
+  module ContextBehavior
+  
+    module ClassMethods
+      
+      def default_class(value=nil)
+        @default_class = value if value
+        @default_class
+      end
+      
+      def new(*attrs, &block)
+        target = attrs.shift
+        target ||= default_class.new if default_class
+        raise ArgumentError, "You must provide a target object to build this context." unless target
+        obj = super(*attrs, &block)
+        obj.send(:instance_variable_set, :@object, target)
+        obj
+      end
+    end
+  
+    module InstanceMethods
+      attr_reader :object
+    end
+    
+    def self.configure(base)
+    end
+  end
+end

data/lib/fathom/behaviors/plugins.rb

@@ -0,0 +1,16 @@
+module Fathom
+  module Plugins
+    def plugins
+      @plugins ||= []
+    end
+
+    def plugin(mod)
+      include mod unless mod.const_defined?(:InstanceMethods)
+      extend mod::ClassMethods if mod.const_defined?(:ClassMethods)
+      include mod::InstanceMethods if mod.const_defined?(:InstanceMethods)
+      mod.configure(self) if mod.respond_to?(:configure)
+      plugins << mod
+    end
+  end
+  
+end

data/lib/fathom/contexts/network_population.rb

@@ -0,0 +1,47 @@
+module Fathom
+  class NetworkPopulation
+    # ============
+    # = Behavior =
+    # ============
+    extend Plugins
+    plugin ContextBehavior
+    default_class Network
+    
+    # Uses YAML to populate a network.  
+    # Expects a format in the YAML that mirrors the data models we are using.
+    # 
+    # Dependencies:
+    # * yaml (standard library)
+    # * open-uri (standard library)
+    # 
+    # Roles: NetworkBuilder
+    # 
+    # Usage:
+    # @context = NetworkPopulation.new(some_network)
+    # @context.import_records_from_yaml(:filename => 'some_network.yml')
+    def import_records_from_yaml(opts={})
+      require 'yaml'
+      require 'open-uri'
+      object.extend NetworkBuilder
+      hash = extract_data_hash_from_parameters(opts)
+      object.from_hash(hash)
+    end
+    
+    protected
+    
+      # Contract: return a hash, the best one you can find, or an empty one.
+      def extract_data_hash_from_parameters(opts)
+        if opts[:filename]
+          data_from_yaml_file(opts[:filename])
+        else
+          {}
+        end
+      end
+
+      # Contract: return a hash or raise an error
+      def data_from_yaml_file(filename)
+        YAML.load_file(filename)
+      end
+    
+  end
+end