nodus 0.3.1

data/lib/nodus/version.rb

@@ -0,0 +1,6 @@
+module Nodus
+  module Version
+    VFILE   = File.join(File.dirname(__FILE__),'..','VERSION')
+    VERSION = File.exist?(VFILE) ? File.read(VFILE).strip : `git -C '#{File.dirname(__FILE__)}' describe --tags`.strip
+  end
+end

data/lib/proplist.rb

@@ -0,0 +1,142 @@
+
+# TODO: REFACTOR, CLEANUP, and SIMPLIFY!
+
+# Properties of properties (such as required, default, type, etc.)
+#
+# TODO: change this into a mixin module? Make it more like a simple add-on to openstruct? (and put in its own file)
+
+class PropSet
+  class_attr_inheritable :inverses, {}
+  class_attr_inheritable :defaults, {} # Don't confuse this with the property's default- it's the property's property's default (e.g., `required` defaults to false, or `default` defaults to nil)
+
+  class << self
+    protected def inverse(kvpairs) inverses.merge!(kvpairs) end # TODO: verify that keys aren't values and that there are no duplicate values
+    protected def default(kvpairs) defaults.merge!(kvpairs) end
+  end
+
+  def initialize(*opts)
+    @data = {}
+    merge_opts(*opts)
+  end
+
+  def inspect() "#<#{self.class.name} #{@data.inspect}>" end
+  def to_hash() @data end
+
+  def merge_opts(*opts)
+    opts = [opts].flatten.reduce({}){|h,o| Hash === o ? h.merge(o) : h.merge({o.to_sym => true})}
+    opts.each do |k, v|
+      k_str = k.to_s
+      k_sym = k.to_sym
+      if k_str.starts_with?('no_')
+        if v = true
+          k_to_remove = k_str[3..-1].to_sym
+          @data.delete(k_to_remove)
+          @data.delete(inverses[k_to_remove])
+        else
+          error ArgumentError, "Parameter aspects that start with 'no_' are for unsetting that aspect of the property. For example, `no_default: true`- Always expecting 'true' as the value."
+        end
+      else
+        if inverses[k_sym]
+          error ArgumentError, "Expected true or false value for #{k_sym} aspect of property #{@name}" unless v == !!v
+          v = !v
+          k_sym = inverses[k_sym]
+        end
+        @data[k_sym] = v
+      end
+    end
+  end
+
+  def method_missing(m, *a, &b)
+    # TODO: check @data for key before checking it for respond_to to solve future problems like this :default hack
+    return @data.send(m, *a, &b) if @data.respond_to?(m) && ![:default,:default=].include?(m.to_sym)
+    case m.to_s
+    when /^(.+)=$/      then merge_opts($1 => (a.size == 1 ? a[0] : a))
+    when /^has_(.+)\?$/ then @data.has_key?($1.to_sym) || @data.has_key?(inverses[$1.to_sym])
+    when /^(.+)\?$/     then !!val_for($1)
+    else                     val_for(m)
+    end
+  end
+
+  def val_for(key)
+    key = key.to_sym
+    rev = inverses.has_key?(key)
+    key = inverses[key] if rev
+    val = nil
+    if @data.has_key?(key) || defaults.has_key?(key)
+      val = @data.has_key?(key) ? @data[key] : defaults[key]
+      val = !val if rev
+    end
+    val
+  end
+
+  # When the property is given a value specify (via overriding this method) anything special that needs to happen to the
+  # PropSet instance.
+  def realize(val) self.value = val end
+  def realized?()  self.has_value?  end
+  def realized
+    return self.value   if self.has_value?
+    return self.default if self.has_default?
+    nil
+  end
+
+  def dup() Marshal.load(Marshal.dump(self)) end
+end
+
+class PropList
+  def initialize(propclass=PropSet)
+    @propclass = propclass
+    @data      = {}
+  end
+
+  # TODO: have the node say "parameter[]" when it wants a singular results with possibly a warning or even exception
+  # when more than one matches, vs "parameters[]" which always gives an array, even if only one or zero matches...
+
+  def [](kvs)
+    kvs = {name: kvs} unless Hash === kvs
+
+    res = @data.values
+    kvs.each{|k,v| res = res.select{|prop| prop.send(k) == v}}
+
+    case res.size
+    when 0 then nil
+    when 1 then res[0]
+    else res end
+  end
+
+  def dup() Marshal.load(Marshal.dump(self)) end
+
+  def realize(name, value) add(name).tap{|pset| pset.realize(value)} end
+  alias_method :[]=, :realize
+
+  # TODO: add-override separate from add-unique - the first used in inheritance, for example when currying parameters,
+  # and the latter used when composing many together that might normally have name conflicts.
+
+  def add_name_opts(name_and_opts) name = name_and_opts.shift; add(name, name_and_opts) end
+  alias_method :<<, :add_name_opts
+
+  def add(name, *opts)
+    name = name.to_sym
+    if     @data[name] && opts.present? then @data[name].merge_opts(opts)
+    elsif !@data[name]                  then @data[name] = @propclass.new(opts, name: name) end
+    @data[name]
+  end
+
+  def respond_to?(m, inc_all=false)
+    @data.has_key?(m.to_sym) || @data.respond_to?(m, inc_all) || !!m[/has_.+\?/]
+  end
+
+  def method_missing(m, *a, &b)
+    return @data[m.to_sym]                 if @data.has_key?(m.to_sym)
+    return @data.send(m, *a, &b)           if @data.respond_to?(m)
+    return @data.has_key?(m[4..-2].to_sym) if m[/has_.+\?/]
+    super
+  end
+
+  # TODO: method_missing revolves around `by_xxxx` - gives a hash indexed by the stated propset-value
+  #       if no `by_` then it is assumed to be the index into ANY of the propset-values that has a symbol or string as
+  #       the value. If the by_xxxx were chainable, it could be a method_missing equivalent of the [] search method...
+  #       (probably not important)
+
+  def include?(k) super(k.to_sym) end
+  alias_method :includes?, :include?
+end

data/nodus.gemspec

@@ -0,0 +1,106 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+# stub: nodus 0.3.1 ruby lib
+
+Gem::Specification.new do |s|
+  s.name = "nodus"
+  s.version = "0.3.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.require_paths = ["lib"]
+  s.authors = ["Joseph Wecker"]
+  s.date = "2014-07-31"
+  s.description = "EXPERIMENTAL. A form of data-flow programming based loosely on Kahn Process Networks. Will allow for setting up operational components that can be pipelined together in a graph. Assumes all components (nodes) are 'online' algorithms with more or less steady-state resource utilization for continuous streams of data."
+  s.email = "joseph.wecker@exsig.com"
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.md"
+  ]
+  s.files = [
+    ".document",
+    ".ruby-gemset",
+    ".ruby-version",
+    "Gemfile",
+    "LICENSE.txt",
+    "OPERUM.md",
+    "README.md",
+    "Rakefile",
+    "VERSION",
+    "dia.rb",
+    "doc/desc.md",
+    "doc/example.node",
+    "doc/nodes.rb",
+    "doc/pipe.svg",
+    "doc/pipe.txt",
+    "doc/pipe2.dot",
+    "doc/pipe2.svg",
+    "lib/VERSION",
+    "lib/extensions.rb",
+    "lib/flexhash.rb",
+    "lib/nodus.rb",
+    "lib/nodus/nodes.rb",
+    "lib/nodus/stream.rb",
+    "lib/nodus/token.rb",
+    "lib/nodus/version.rb",
+    "lib/proplist.rb",
+    "nodus.gemspec",
+    "spec.md",
+    "test/core/test_flexhash.rb",
+    "test/core/test_generator.rb",
+    "test/core/test_node.rb",
+    "test/core/test_proplist.rb",
+    "test/helper.rb"
+  ]
+  s.homepage = "http://github.com/exsig/nodus"
+  s.licenses = ["MIT"]
+  s.rubygems_version = "2.2.2"
+  s.summary = "Something between a Kahn Process Network and Algorithmic Skeleton for parallel pipelining and signal processing"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 4
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<activesupport>, [">= 4.1.0"])
+      s.add_development_dependency(%q<bundler>, [">= 0"])
+      s.add_development_dependency(%q<git>, [">= 0"])
+      s.add_development_dependency(%q<jeweler>, [">= 0"])
+      s.add_development_dependency(%q<brice>, [">= 0"])
+      s.add_development_dependency(%q<ansi>, [">= 0"])
+      s.add_development_dependency(%q<rdoc>, [">= 0"])
+      s.add_development_dependency(%q<ffaker>, [">= 0"])
+      s.add_development_dependency(%q<randexp>, [">= 0"])
+      s.add_development_dependency(%q<minitest>, [">= 5.3"])
+      s.add_development_dependency(%q<minitest-reporters>, [">= 1.0.1"])
+      s.add_development_dependency(%q<simplecov>, ["~> 0.7.1"])
+    else
+      s.add_dependency(%q<activesupport>, [">= 4.1.0"])
+      s.add_dependency(%q<bundler>, [">= 0"])
+      s.add_dependency(%q<git>, [">= 0"])
+      s.add_dependency(%q<jeweler>, [">= 0"])
+      s.add_dependency(%q<brice>, [">= 0"])
+      s.add_dependency(%q<ansi>, [">= 0"])
+      s.add_dependency(%q<rdoc>, [">= 0"])
+      s.add_dependency(%q<ffaker>, [">= 0"])
+      s.add_dependency(%q<randexp>, [">= 0"])
+      s.add_dependency(%q<minitest>, [">= 5.3"])
+      s.add_dependency(%q<minitest-reporters>, [">= 1.0.1"])
+      s.add_dependency(%q<simplecov>, ["~> 0.7.1"])
+    end
+  else
+    s.add_dependency(%q<activesupport>, [">= 4.1.0"])
+    s.add_dependency(%q<bundler>, [">= 0"])
+    s.add_dependency(%q<git>, [">= 0"])
+    s.add_dependency(%q<jeweler>, [">= 0"])
+    s.add_dependency(%q<brice>, [">= 0"])
+    s.add_dependency(%q<ansi>, [">= 0"])
+    s.add_dependency(%q<rdoc>, [">= 0"])
+    s.add_dependency(%q<ffaker>, [">= 0"])
+    s.add_dependency(%q<randexp>, [">= 0"])
+    s.add_dependency(%q<minitest>, [">= 5.3"])
+    s.add_dependency(%q<minitest-reporters>, [">= 1.0.1"])
+    s.add_dependency(%q<simplecov>, ["~> 0.7.1"])
+  end
+end
+

data/spec.md

@@ -0,0 +1,60 @@
+
+
+* name (original)
+* desc (description name in context of a group, or name by which it is thereafter registered as)
+* parameterization
+* number of input streams
+* number of output streams
+
+
+
+    Node[node<n,n>]            => node<n,n>     # (ident)
+    Node[desc, node<n,n>]      => node<n,n>     # duplicate, but with a new name
+    Node[desc, object]         => node<0,1>     # makes generator node out of enumerator (each)
+    Node[desc, name]           => node<n,n>     # aliases a node
+
+    Node[desc, lambda_or_proc] => node<0..1,1>  # arity on lambda simply unpacks array with arity check
+    Node[desc]{ ... }          => node<0..1,1>  # arity on block works just like enumerators etc.
+    
+    Sink[desc]{ ... }          => node<1,0>     # block must have arity of 1 or more- first arg is always state. must pass updated state as result of the block run
+                                                # OR just allow some specialized @state object (initialized somehow?)
+
+
+
+
+## Generator Nodes with single stream output
+
+
+    # Implied
+    def registered_name(*params)
+      Nodus.lookup(registered_name, *params)
+    end
+
+    registered_name(*params).as(contextual_name)  # .as method simply appends to the name-chain (where the last member gets used by default) and returns the resulting node
+
+    # ?? necessary anymore?
+    nodelib(registered_name)
+    nodelib(registered_name, *parameters)
+    nodelib(registered_name, as: contextual_name, *parameters)
+
+
+
+    node(name){...}                        # warn on conflict with registered-name? implicit looping?
+    node(name, initial_state){|state| ...} # ditto
+
+
+
+- name of registered node for lookup
+- name for current context (already good default for anything looked-up, very important for lambdas etc.)
+- initial-state/parameters
+- kernel (as proc, block, lambda, class, or object- not very relevant for registered node lookups)
+
+
+
+register node (?? necessary?)
+  * `node.register_as(:name)` or `node.register_as([:chain,:of,:names])`
+  * looks in `LIB_NODUS_NODE_PATHS` paths for modules/classes and maps to names
+
+look-up & parameterize registered node:
+
+look-up, parameterize, and rename registered node:

data/test/core/test_flexhash.rb

@@ -0,0 +1,87 @@
+require_relative '../helper.rb'
+require 'ostruct'
+
+describe FlexHash do
+  it 'can be initialized like a hash' do
+    h = FlexHash.new(name: 'hello', blah: 'there!')
+    h.must_be_instance_of FlexHash
+    h.size.must_equal 2
+  end
+
+  it 'can be be initialized with an array' do
+    h = FlexHash.new([:one, 1, :two, 2])
+    h.must_be_instance_of FlexHash
+    h.size.must_equal 2
+  end
+
+  it 'can be initialized with an array shorthand' do
+    h = FlexHash[:one, 1, :two, 2]
+    h.must_be_instance_of FlexHash
+    h.size.must_equal 2
+  end
+
+  it 'can be initialized with a non-flat array shorthand' do
+    h = FlexHash[[:one, 1], [:two, 2]]
+    h.must_be_instance_of FlexHash
+    h.size.must_equal 2
+  end
+
+  subject { FlexHash.new(a: 100, b: 101, c: 102, d: 103) }
+
+  it 'can be accessed with methods' do
+    subject.a.must_equal 100
+    subject.d.must_equal 103
+  end
+
+  it 'can be accessed with symbols' do
+    subject[:a].must_equal 100
+    subject[:b].must_equal 101
+  end
+
+  it 'can be accessed with strings' do
+    subject['a'].must_equal 100
+    subject['c'].must_equal 102
+  end
+
+  it 'accumulates more methods' do
+    subject[:hmmmmm] = 500
+    subject[:a].must_equal 100
+    subject[:hmmmmm].must_equal 500
+    subject.hmmmmm.must_equal 500
+  end
+
+  it 'allows modifying of original values' do
+    subject[:a] = 200
+    subject[:a].must_equal 200
+    subject[:d].must_equal 103
+    subject.a.must_equal 200
+  end
+
+  it 'allows position-based access of values' do
+    subject[0].must_equal 100
+    subject[3].must_equal 103
+    subject[4].must_equal nil
+  end
+
+  it 'acts more like a hash than OpenStruct tends to' do
+    subject.shift.must_equal [:a, 100]
+  end
+
+end
+
+describe FlexArray do
+  it 'seems to work' do
+    a = FlexArray.new
+    a << OpenStruct.new(name: 'howdy')
+    a[1] = OpenStruct.new(name: :duty)
+    a << OpenStruct.new(name: 123)
+
+    a[0].name.must_equal       'howdy'
+    a['howdy'].name.must_equal 'howdy'
+    a.howdy.name.must_equal    'howdy'
+    a[/d/].map{|os| os.name.to_s}.sort.must_equal ['duty', 'howdy']
+    a[2].must_be_kind_of OpenStruct
+  end
+
+  # TODO: test for real
+end

data/test/core/test_generator.rb

@@ -0,0 +1,27 @@
+require_relative '../helper.rb'
+include Nodus::Nodes
+
+class GenClass; def each() loop{yield(rand)} end end
+
+class GenClassWithRange
+  def initialize(range)
+    @range = range
+  end
+  def each() loop{yield(rand(@range))} end
+end
+
+describe Nodus::Nodes::Generator do
+  it 'can be created from a class with an "each" method' do
+    g = Generator[:mygen, GenClass]
+    g.must_be_a_node
+    g.title.must_equal  :mygen
+    g.kernel.must_equal GenClass
+  end
+
+  it 'infers parameters from the class initialization' do
+    g = Generator[:mygen, GenClassWithRange]
+    g.must_be_a_node
+    g.parameters.keys.include?(:range).must_be_true
+    g.parameters.range.required?.must_be_true
+  end
+end

data/test/core/test_node.rb

@@ -0,0 +1,103 @@
+require_relative '../helper.rb'
+include Nodus::Nodes
+
+describe Nodus::Nodes::Node do
+  subject do
+    Node.compose(:subject) do
+      param :p1, :required
+      param :p2,  default: 10
+      param :p3, :optional, default: 100
+    end
+  end
+
+  it 'is a node, with correct title' do
+    subject.must_be_a_node
+    subject.new.must_be_kind_of Node
+    subject.title.must_equal :subject
+  end
+
+  it 'has the correct parameters' do
+    subject.parameters.keys.sort.must_equal [:p1, :p2, :p3]
+    subject.parameters.p3.default.must_equal 100
+  end
+
+  it 'ensures that there is a title' do
+    ->{Node.compose()}.must_raise ArgumentError
+    ->{Node[]}.must_raise         ArgumentError
+  end
+
+  it 'children having children having children' do
+    ssubject = subject.compose(:ssubject)
+    ssubject.must_be_a_node
+    ssubject.parameters.keys.sort.must_equal [:p1, :p2, :p3]
+    ssubject.parameters.p3.default.must_equal 100
+
+    sssubject = ssubject.compose(:sssubject){ param :p4 }
+    sssubject.must_be_a_node
+    sssubject.parameters.keys.sort.must_equal [:p1, :p2, :p3, :p4]
+    sssubject.parameters.p3.default.must_equal 100
+  end
+
+  it 'can be done using a more natural class syntax' do
+    class MySuperNode < Node.compose :my_super_node
+      param :p2, :hidden
+    end
+    MySuperNode.must_be_a_node
+    MySuperNode.parameters.p2.hidden?.must_be_true
+    remove_class(:MySuperNode)
+
+    class MyOtherNode < subject[:my_other_node]
+      param :pzz
+    end
+    MyOtherNode.must_be_a_node
+    MyOtherNode.parameters.pzz.must_be_kind_of Param
+    remove_class(:MyOtherNode)
+
+    class MyThirdNode < Node[:the_third]; end
+    MyThirdNode.must_be_a_node
+    MyThirdNode.parameters.must_be_empty
+    MyThirdNode.title.must_equal :the_third
+
+    remove_class(:MyThirdNode)
+  end
+end
+
+describe Nodus::Nodes::ConcurrentNode do
+  let(:base_1) do
+    Node.compose(:base_1) do
+      param :p1, :required
+      param :p2,  default: 10
+      param :p3, :optional, default: 100
+    end
+  end
+  let(:base_2){ Node.compose(:base_2){ [:p4,:p5,:p6].each{|p| param p} }}
+  let(:base_3){ Node.compose(:base_3){ [:p1,:p2,:p3].each{|p| param p, default: 20} }}
+
+  it 'is a kind of node' do
+    conc = ConcurrentNode.compose(:conc, base_1, base_2)
+    conc.must_be_a_node
+    conc.new.must_be_kind_of Node
+    conc.title.must_equal :conc
+
+    conc = ConcurrentNode[:conc, base_1, base_2]
+    conc.must_be_a_node
+    conc.new.must_be_kind_of Node
+    conc.title.must_equal :conc
+  end
+
+  it 'also requires a title (for now)' do
+    ->{ConcurrentNode.compose(base_1, base_2)}.must_raise ArgumentError
+  end
+
+  it 'non-conflicting consolidated params act normal' do
+    skip
+  end
+
+  it 'non-conflicting params can also be accessed with parent specifier' do
+    skip
+  end
+
+  it 'can have its parameters curried ala basenode' do
+    skip
+  end
+end