nodus 0.3.1

data/lib/flexhash.rb

@@ -0,0 +1,175 @@
+# Like a combination of HashWithIndifferentAccess, OpenStruct, plus it takes an integer and tries looking it up
+# positionally. (bleh, like php's but a little more buggy. I know I know- but it's for a very specific purpose).
+#
+# Mostly cribbed from rubinius's ostruct: https://github.com/rubysl/rubysl-ostruct/blob/2.0/lib/rubysl/ostruct/ostruct.rb
+# with just the [] access function changed and method_missing changed so it delegates unfound things to the underlying
+# table.
+
+class FlexHash
+
+  def self.[](*arr_const)
+    self.new(arr_const.flatten)
+  end
+
+  def initialize(constructor=nil)
+    @table = {}
+    if constructor.respond_to?(:each_pair)
+      constructor.each_pair{|k,v| self[k.to_sym] = v }
+    elsif constructor.respond_to?(:each_slice)
+      constructor.each_slice(2){|k,v| self[k.to_sym] = v }
+    elsif constructor != nil
+      raise ArgumentError, "cannot initialize flexhash with #{constructor}", caller(3)
+    end
+  end
+
+  def initialize_copy(orig)
+    super
+    @table = @table.dup
+    @table.each_key { |key| new_flexhash_member(key) }
+  end
+
+  def to_h
+    @table.dup
+  end
+
+  def each_pair
+    return to_enum __method__ unless block_given?
+    @table.each_pair { |p| yield p }
+  end
+
+  def marshal_dump
+    @table
+  end
+
+  def marshal_load(x)
+    @table = x
+    @table.each_key{|key| new_flexhash_member(key)}
+  end
+
+  def modifiable
+    begin
+      @modifiable = true
+    rescue
+      raise TypeError, "can't modify frozen #{self.class}", caller(3)
+    end
+    @table
+  end
+  protected :modifiable
+
+  def new_flexhash_member(name)
+    name = name.to_sym
+    unless respond_to?(name)
+      define_singleton_method(name) { @table[name] }
+      define_singleton_method("#{name}=") { |x| modifiable[name] = x }
+    end
+    name
+  end
+  protected :new_flexhash_member
+
+  def method_missing(mid, *args, &block)
+    mname = mid.id2name
+    len = args.length
+    if mname.chomp!('=')
+      if len != 1
+        raise ArgumentError, "wrong number of arguments (#{len} for 1)", caller(1)
+      end
+      modifiable[new_flexhash_member(mname)] = args[0]
+    elsif len == 0
+      res = @table[mid] || @table.send(mid, *args, &block)
+      res = FlexHash.new(res) if res.instance_of? Hash
+      res
+    else
+      res = @table.send(mid, *args, &block)
+      res = FlexHash.new(res) if res.instance_of? Hash
+      res
+    end
+  end
+
+  def [](name)
+    if Integer === name
+      @table[name] || @table[@table.keys[name]]
+    else
+      res = @table[name] || @table[name.try(:to_sym)]
+      return res if res
+      res = @table.select{|k,v| name === k}
+      return res.values[0] if res.size == 1
+      res
+    end
+  end
+
+  def []=(name, value)
+    modifiable[new_flexhash_member(name)] = value
+  end
+
+  def <<(kv)
+    name, value = kv
+    self[name] = value
+  end
+
+  def delete_field(name)
+    sym = name.to_sym
+    singleton_class.__send__(:remove_method, sym, "#{name}=")
+    @table.delete sym
+  end
+
+  InspectKey = :__inspect_key__ # :nodoc:
+
+  def inspect
+    str = "#<#{self.class}"
+
+    ids = (Thread.current[InspectKey] ||= [])
+    if ids.include?(object_id)
+      return str << ' ...>'
+    end
+
+    ids << object_id
+    begin
+      first = true
+      for k,v in @table
+        str << "," unless first
+        first = false
+        str << " #{k}=#{v.inspect}"
+      end
+      return str << '>'
+    ensure
+      ids.pop
+    end
+  end
+  alias :to_s :inspect
+
+  attr_reader :table # :nodoc:
+  protected :table
+
+  def ==(other)
+    return false unless other.kind_of?(OpenStruct)
+    @table == other.table
+  end
+
+  def eql?(other)
+    return false unless other.kind_of?(OpenStruct)
+    @table.eql?(other.table)
+  end
+
+  def hash
+    @table.hash
+  end
+end
+
+# Kind of like FlexHash, but assumes the elements of the array have a :name method, and allows duplicates
+class FlexArray < Array
+  def [](k)
+    return super if Fixnum === k
+    res = self.find_all{|element| k === element.name || k.to_s === element.name.to_s}
+    return nil if res.blank?
+    res = res[0] if res.size == 1
+    res
+  end
+
+  def method_missing(mid, *args, &block)
+    mname = mid.id2name
+    len = args.length
+    res = self[mid]
+    return res unless res.blank?
+    super
+  end
+end

data/lib/nodus.rb

@@ -0,0 +1,77 @@
+require 'active_support/all'
+require 'extensions'
+require 'flexhash'
+require 'mathn'
+
+module Nodus
+  SRCDIR  = File.dirname(__FILE__)
+  @_error_msg_map = {}
+
+  def self.def_exception(sym, msg, superclass=RuntimeError)
+    klass = Class.new(superclass)
+    Nodus.const_set(sym, klass)
+    @_error_msg_map[klass] = msg
+  end
+
+  def self._error_msg(klass) @_error_msg_map[klass] end
+
+  def self.const_missing(cname)
+    m = "nodus/#{cname.to_s.underscore}"
+    require m
+    klass = const_get(cname)
+    return klass if klass
+    super
+  end
+end
+
+def error(klass, *args)
+  msg = Nodus._error_msg(klass)
+  msg ||= args.shift
+  raise klass, sprintf(*([msg] + args))
+end
+
+class Object
+  def try_dup()
+    self.dup
+  rescue
+    self
+  end
+end
+
+class Class
+  def save_as(klass_name)
+    Object.const_set(klass_name, self)
+  end
+
+  # Set class instance variable attributes, and see that the values get inherited by subclasses. Attribute readers are
+  # also set up for object instances that copy it from the class.
+  #
+  # The values are `dup`ed if possible and simply handed over otherwise (when inheriting and instantiating).
+  #
+  # Note that this seems to behave very differently than active-support's `class_attribute` method- which seems to use
+  # actual class-variables with all the problems they end up having. (of course I could have just been using
+  # active-support's wrong).
+  #
+  # The only safety that keeps these from affecting class instance variables where they shouldn't is the naming
+  # convention. Anything more clever than that and my ruby metaprogramming skills weren't up to snuff.
+  #
+  # Also, as you can surmise, it won't work if a class uses the `inherited` hook and fails to call super.
+  #
+  def class_attr_inheritable(attr_name, init_as=nil)
+    self.class_eval("def self.#{attr_name};@__cai__#{attr_name} end")
+    self.class_eval("def self.#{attr_name}=(v);@__cai__#{attr_name}=v end")
+    self.send("#{attr_name}=", init_as) unless init_as.nil?
+    self.class_eval("def #{attr_name};@#{attr_name} ||= self.class.#{attr_name}.try_dup end")
+  end
+
+  def inherited(subclass)
+    instance_variables.each do |v|
+      next unless v.to_s.starts_with?('@__cai__')
+      new_val = self.instance_variable_get(v).try_dup
+      subclass.instance_variable_set(v, new_val)
+    end
+  end
+end
+
+require 'proplist'
+require 'nodus/nodes'

data/lib/nodus/nodes.rb

@@ -0,0 +1,160 @@
+class Object
+  def kind_of_node?() false end
+end
+
+module Nodus
+  module Nodes
+    class Param < PropSet
+      default required: false,  hidden:    false
+      inverse visible: :hidden, required: :optional
+      def realize(val) self.default = val; self.hidden = true end
+      def realized?()  self.hidden? || self.optional? || self.has_default? end
+      def realized()
+        return self.default if self.has_default?
+        error RuntimeError, "Parameter #{self.name} is required but hasn't had any values set." if self.required?
+        nil
+      end
+    end
+
+    class StreamPort < PropSet
+      # `| input:  (operational<output-port[s]> | consumed  [control]) x (optional | required)`
+      # `| output: ( operational<input-port[s]> | generated [control]) x (tap      |  primary)`
+
+      inverse input:    :output
+      inverse optional: :required
+      inverse tap:      :primary
+      inverse control:  :stream
+
+      default optional: true
+      default primary:  true
+    end
+
+    # I think we'll want the following to be completely disjoint:
+    # (common methods) ⊔ (node methods) ⊔ (parameter names) ⊔ (node names) ⊔ (stream-port names)
+    # This way we can do method_missing safely to specify params, nodes, ports, or anything else depending on the context.
+    #
+    # TODO: make nodes aware of their container? in order, perhaps, for them to ask the container who they should be
+    # connected to instead of the other way around?
+    #
+    class Node
+      class_attr_inheritable :title,           nil
+      class_attr_inheritable :parameters,      PropList.new(Param)
+      class_attr_inheritable :symmetric_ports, PropList.new(StreamPort)
+      class_attr_inheritable :consumed_ports,  PropList.new(StreamPort)
+      class_attr_inheritable :generated_ports, PropList.new(StreamPort)
+
+      class_attr_inheritable :sub,             FlexArray.new  # Sub-nodes- mostly for later subclasses
+      class_attr_inheritable :channels,        FlexArray.new  # Binding pairs of inner nodes
+
+      class << self
+        def kind_of_node?()    true end
+        def param(param_name, *args)
+          arg_hash = (Hash === args.last ? args.pop : {})
+          arg_hash.merge!({name: param_name, node: self.title, node_type: self, node_name: self.name})
+          parameters << [param_name, args << arg_hash]
+        end
+
+        def compose(*args, &block)
+          Class.new(self) do |new_klass|
+            new_klass.on_compose(*args)
+            new_klass.instance_exec(new_klass, &block) if block_given?
+          end
+        end
+        alias_method :[], :compose
+
+        # Override this at will with whatever parameters you want- just remember to call super, and with the right
+        # parameters
+        def on_compose(title)
+          error ArgumentError, "First argument to compose needs to be the symbolic title, not `#{title.inspect}`" unless title.kind_of? Symbol
+          self.title = title
+        end
+
+        # TODO:
+        # undefined_parameters()  #=> tell what required parameters don't have defaults set
+        # complete?() #=> all required parameters & connections defined (well enough)
+      end
+
+
+      # --------------------------------- Instance --------------------------------------------------------
+
+      # Initialize will usually allow any parameters (/parameter overrides), and any object-level connection information
+      # required.
+      def initialize(*params)
+        # fill params with non-hash heads of args and then use any remaining hash to fill in more params
+        # runtime error if some required parameters are not set
+      end
+    end
+
+
+    class ConcurrentNode < Node
+      class << self
+        # Defined by aggregate of all parameters, input ports, and output ports (of all kinds). Probably automatically
+        # need their own naming conventions...
+
+        def on_compose(title, *sub_nodes)
+          super(title)
+          sub_nodes.each{|node| sub << node}
+        end
+
+        #def parameters
+        #  sub.map{|s| s.parameters}
+        #end
+      end
+    end
+
+
+    class Pipe < Node
+
+    end
+
+    # Given: enumerator or something that can be to_enum'ed
+    # Given: lambda or proc or block - params are gathered by reflection
+    # Given: class - assumed to be enumerable (or perhaps have a wrappable loop function?) params gathered via
+    #        reflection on initialize.
+    # see http://stackoverflow.com/questions/4982630/trouble-yielding-inside-a-block-lambda when we get to lambdas etc.
+    #
+    class Generator < Node
+      class << self
+        attr_reader :kernel
+
+        def on_compose(title, kernel=nil, &block)
+          super(title)
+          @kernel = kernel || block
+          case @kernel
+          when Enumerator then @kernel = @kernel.lazy # No parameters
+          when Class
+            init_params = @kernel.instance_method(:initialize).parameters
+            init_params.each{|kind,pname| param(pname, (kind == :req ? :required : :optional))}
+          when Node
+            # TODO: Simply verify that the kernel has no input ports and create this thin wrapper around it...
+            # Although it still might make sense to warn that this is a senseless act? (unless it becomes
+            # necessary for some sorts of renaming etc.?)
+            error NotImplementedError
+          else
+            error ArgumentError, "Generator Nodes don't support #{kernel.inspect} as a kernel"
+          end
+        end
+      end
+    end
+  end
+end
+
+# given:
+#    parent_1   :   p1, p2, p3
+#    parent_2   :       p2, p3, p4
+#    parent_3   :                  p5
+#
+#
+#    parent_1__p1 -> valid
+#    parent_1__p2 -> valid
+#    ...
+#
+#    p1, p4, p5         -> valid (maps to parent_1__p1 etc.)
+#    p2, p3             -> exception asks parent_1__... or parent_2__...?
+#    parent_1, parent_2 -> exception asks which property (p1, p2, or p3), or (p2, p3, p4)
+#    parent_3           -> valid (maps to parent_3__p5)
+#
+#    doesn't solve the problem of nodes having the same name running in a concurrent composition (for example)!
+#
+#    ability to rename params & ports as they get composed... (or as something else done while currying etc...)
+#

data/lib/nodus/stream.rb

@@ -0,0 +1,12 @@
+module Nodus
+  class Stream
+    def initialize(originator)
+      @origin = originator
+      @seq_id = 0
+    end
+
+    def make_new_token
+      Nodus::Token.new(self, @seq_id += 1)
+    end
+  end
+end

data/lib/nodus/token.rb

@@ -0,0 +1,31 @@
+
+
+
+# - [ ] modification graph
+# - [ ] timings in graph
+# - [ ] current-data per thread/context
+# - [ ] data appending
+# - [ ] data freezing/locking per thread/context
+#
+
+module Nodus
+  def self.timestamp
+    # Use a better Process.clock_gettime time instead (not supported by rubinius yet)
+    Time.now
+  end
+
+  # TODO: probably a token wrapper which designates the active data of the underlying token. This way the token can be
+  # the same token across all parallel streams, while each parallel stream will have it's own temporary view of it at
+  # each step...
+
+  class Token
+    attr_reader :seq_id, :stream, :timings
+    def initialize(stream, seq_id)
+      @stream  = stream
+      @seq_id  = seq_id
+      @timings = {generated: Nodus.timestamp}
+      @data    = {}
+
+    end
+  end
+end