nodus 0.3.1

data/test/core/test_proplist.rb

@@ -0,0 +1,153 @@
+require_relative '../helper.rb'
+
+describe PropSet do
+  subject       {    PropSet.new(required: false, type: Fixnum,  desc:   'does stuff', visible: true) }
+
+  class PropSetSub < PropSet
+    default weirdy:   'yes'
+    inverse visible:  :hidden
+    inverse required: :optional
+  end
+
+  let(:subclass){ PropSetSub.new(required: false, type: Numeric, visible: true) }
+
+  it 'initialization properties become methods' do
+    subject.required.must_be_false
+    subject.type.must_equal Fixnum
+    subject.desc.must_equal 'does stuff'
+    subject.visible.must_be_true
+  end
+
+  it 'allows adhoc additions to initialized properties' do
+    subject.type          = ArgumentError
+    subject.type.must_equal ArgumentError
+    subject.desc.must_equal 'does stuff'
+  end
+
+  it 'allows queries to see if things are specified' do
+    subject.has_required?.must_be_true
+    subject.has_desc?.must_be_true
+    subject.has_default?.must_be_false
+    subject.default = 1234
+    subject.default.must_equal 1234
+  end
+
+  it 'correctly emits values for reversed attributes' do
+    subclass.visible.must_be_true
+    subclass.hidden.must_be_false
+    subclass.required.must_be_false
+    subclass.optional.must_be_true
+
+    subclass.required = true
+    subclass.optional.must_be_false
+  end
+
+  it 'correctly emits values for bool attribute methods' do
+    subclass.visible?.must_be_true
+    subclass.required?.must_be_false
+    subclass.optional?.must_be_true
+    subclass.type?.must_be_true
+  end
+
+  it 'allows removal of attributes completely' do
+    subclass.has_required?.must_be_true
+    subclass.no_required = true
+    subclass.has_required?.must_be_false
+    subclass.required.must_be_nil
+    subclass.optional.must_be_nil
+  end
+
+  it 'does not confuse absent with nil-valued' do
+    subclass.has_sometimes_nil?.must_be_false
+    subclass.sometimes_nil.must_be_nil
+    subclass.sometimes_nil = nil
+    subclass.has_sometimes_nil?.must_be_true
+    subclass.sometimes_nil.must_be_nil
+  end
+
+  it 'honors default values (and with reverses)' do
+    subclass.has_weirdy?.must_be_false
+    subclass.weirdy.must_equal 'yes'
+
+    subclass.weirdy = 'yes'
+    subclass.has_weirdy?.must_be_true
+    subclass.weirdy.must_equal 'yes'
+
+    subclass.no_weirdy = true
+    subclass.has_weirdy?.must_be_false
+    subclass.weirdy.must_equal 'yes'
+    subclass.weirdy?.must_be_true
+  end
+
+  # TODO: check defaults on both keys of inverse pairs
+  # TODO: test `realize` and overridden versions
+end
+
+describe PropList do
+  class MyPropSet < PropSet
+    default blah:     20
+    default visible:  true
+    default required: false
+    inverse required: :optional
+    inverse visible:  :hidden
+    def realize(val)
+      self.value   = val
+      self.no_blah = true
+    end
+  end
+
+  subject { PropList.new(MyPropSet) }
+
+  it 'sees default correctly' do
+    b = MyPropSet.new({required: true, default: 900}, {name: :some_property})
+    b.required.must_be_true
+    b.default.must_equal 900
+  end
+
+  it 'can be populated an element at a time' do
+    subject.add 'some_property', required: true, default: 900
+    subject.add :another, :optional, :hidden
+    subject.some_property.optional?.must_be_false
+    subject[:some_property].default.must_equal 900
+    subject.another.optional?.must_be_true
+  end
+
+  it 'can query for elements using a shorthand method' do
+    subject.add 'some_property', required: true, default: 900
+    subject.add :another, :optional, :hidden
+    subject.must_respond_to :has_another?
+    subject.has_blahblah?.must_be_false
+    subject.has_some_property?.must_be_true
+    subject.has_another?.must_be_true
+
+    subject.include?('another').must_be_true
+    subject.includes?(:some_property).must_be_true
+    subject.includes?(:blahblahblah).must_be_false
+  end
+
+  it 'can be populated using the << method' do
+    subject << [:first_property, :required, {default: 100}]
+    subject.first_property.optional?.must_be_false
+    subject.first_property.default.must_equal 100
+    subject.first_property.has_default?.must_be_true
+    subject.first_property.blah.must_equal 20
+  end
+
+  it 'can be turned into a hash' do
+    subject.add 'some_property', required: true, default: 900
+    subject.add :another, :optional, :hidden
+    subject.to_hash.must_be_kind_of Hash
+    subject.to_hash.has_key?(:some_property).must_be_true
+  end
+
+  it 'allows properties to become realized' do
+    subject.add 'prop1', :required, :visible
+    subject.add 'prop2', blah: 199, default: 100
+
+    subject.prop1.value.must_be_nil
+    subject.prop1.blah.must_equal 20
+    subject.realize(:prop1, 500)
+    subject.prop1.value.must_equal 500
+    subject.prop1.has_blah?.must_be_false
+  end
+end

data/test/helper.rb

@@ -0,0 +1,107 @@
+require 'rubygems'
+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
+require 'simplecov'
+require 'ffaker'
+require 'randexp'
+require 'minitest'
+require 'minitest/reporters'
+require 'minitest/spec'
+require 'minitest/autorun'
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'nodus'
+
+Minitest::Reporters.use! Minitest::Reporters::SpecReporter.new
+
+module SimpleCov::Configuration
+  def clean_filters
+    @filters = []
+  end
+end
+
+SimpleCov.configure do
+  clean_filters
+  load_adapter 'test_frameworks'
+end
+
+ENV["COVERAGE"] && SimpleCov.start do
+  add_filter "/.rvm/"
+end
+I18n.enforce_available_locales = false
+
+include Faker
+
+
+module RandomGen
+  def rand_poisson(lmbda=10)
+    # Poisson distribution with mean & variance of lmda- via knuth's simple algorithm
+    el = Math.exp(- lmbda); k=0; p=1
+    loop do
+      k += 1; p *= rand
+      return k - 1 if p <= el
+    end
+  end
+
+  def rand_times(lmbda=10, &block)
+    k = rand_poisson(lmbda)
+    if block_given? then k.times.map(&block)
+    else k.times end
+  end
+
+  def rand_word
+    len = rand_poisson
+    return '' if len == 0
+    /\w{#{len}}/.gen
+  end
+
+  def random_path
+    '/' + rand_times{rand_word}.join('/')
+  end
+
+  def random_datetime
+    ::Faker::Time.date(series: [])[0]
+  end
+end
+
+include RandomGen
+
+class Module
+  include Minitest::Spec::DSL
+end
+
+def remove_class(klass)
+  const = klass.to_s.to_sym
+  Object.send(:remove_const, const) if Object.send(:const_defined?, const)
+end
+
+
+module MiniTest::Assertions
+  def assert_true(obj)   assert obj==true,  "expected '#{obj}' to be true"  end
+  def assert_false(obj)  assert obj==false, "expected '#{obj}' to be false" end
+  def assert_truthy(obj) assert obj,        "expected '#{obj}' to be something other than nil or false"  end
+  def assert_falsy(obj)  refute obj,        "expected '#{obj}' to be nil or false" end
+end
+Object.infect_an_assertion :assert_true,   :must_be_true,   :only_one_argument
+Object.infect_an_assertion :assert_false,  :must_be_false,  :only_one_argument
+Object.infect_an_assertion :assert_truthy, :must_be_truthy, :only_one_argument
+Object.infect_an_assertion :assert_falsy,  :must_be_falsy,  :only_one_argument
+
+
+
+#----------------------------------- NODUS SPECIFIC ---------------------------------------------------------
+
+module MiniTest::Assertions
+  def assert_kind_of_node(obj)
+    assert obj.kind_of_node?, "expected #{obj} to be a class descended from Node"
+  end
+end
+Object.infect_an_assertion :assert_kind_of_node,
+                           :must_be_a_node,
+                           :only_one_argument

metadata

@@ -0,0 +1,188 @@
+--- !ruby/object:Gem::Specification 
+name: nodus
+version: !ruby/object:Gem::Version 
+  version: 0.3.1
+platform: ruby
+authors: 
+- Joseph Wecker
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2014-07-31 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  type: :runtime
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 4.1.0
+  version_requirements: *id001
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  type: :development
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - &id003 
+      - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  version_requirements: *id002
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  name: git
+  type: :development
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    requirements: 
+    - *id003
+  version_requirements: *id004
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  name: jeweler
+  type: :development
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    requirements: 
+    - *id003
+  version_requirements: *id005
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  name: brice
+  type: :development
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    requirements: 
+    - *id003
+  version_requirements: *id006
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  name: ansi
+  type: :development
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    requirements: 
+    - *id003
+  version_requirements: *id007
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  name: rdoc
+  type: :development
+  requirement: &id008 !ruby/object:Gem::Requirement 
+    requirements: 
+    - *id003
+  version_requirements: *id008
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  name: ffaker
+  type: :development
+  requirement: &id009 !ruby/object:Gem::Requirement 
+    requirements: 
+    - *id003
+  version_requirements: *id009
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  name: randexp
+  type: :development
+  requirement: &id010 !ruby/object:Gem::Requirement 
+    requirements: 
+    - *id003
+  version_requirements: *id010
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  name: minitest
+  type: :development
+  requirement: &id011 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "5.3"
+  version_requirements: *id011
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  name: minitest-reporters
+  type: :development
+  requirement: &id012 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.0.1
+  version_requirements: *id012
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  name: simplecov
+  type: :development
+  requirement: &id013 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 0.7.1
+  version_requirements: *id013
+  prerelease: false
+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.
+email: joseph.wecker@exsig.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE.txt
+- README.md
+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
+homepage: http://github.com/exsig/nodus
+licenses: 
+- MIT
+metadata: {}
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - *id003
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - *id003
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Something between a Kahn Process Network and Algorithmic Skeleton for parallel pipelining and signal processing
+test_files: []
+