rubyonacid 0.1.0

data/examples/test3.rb

@@ -0,0 +1,108 @@
+require 'rubygems'
+require 'wx'
+require 'rubyonacid/factories/meta'
+require 'rubyonacid/factories/constant'
+require 'rubyonacid/factories/flash'
+require 'rubyonacid/factories/increment'
+require 'rubyonacid/factories/loop'
+require 'rubyonacid/factories/modulo'
+require 'rubyonacid/factories/random'
+require 'rubyonacid/factories/repeat'
+require 'rubyonacid/factories/sine'
+require 'rubyonacid/factories/skip'
+
+
+
+class MyApp < Wx::App
+
+  WIDTH = 320
+  HEIGHT = 320
+
+  def on_init
+    
+    random_factory = RubyOnAcid::RandomFactory.new
+    
+    (1..1000).each do |file_number|
+      
+      file_name = sprintf("%05d_random.png", file_number)
+      
+      #The MetaFactory assigns factories to requested value types.
+      @f = RubyOnAcid::MetaFactory.new
+      @f.factory_pool << RubyOnAcid::LoopFactory.new(random_factory.within(:increment, -0.1, 0.1))
+      @f.factory_pool << RubyOnAcid::LoopFactory.new(random_factory.within(:increment, -0.1, 0.1))
+      @f.factory_pool << RubyOnAcid::LoopFactory.new(random_factory.within(:increment, -0.1, 0.1))
+      @f.factory_pool << RubyOnAcid::LoopFactory.new(random_factory.within(:increment, -0.1, 0.1))
+      @f.factory_pool << RubyOnAcid::ConstantFactory.new(random_factory.within(:constant, 0.0, 1.0))
+      @f.factory_pool << RubyOnAcid::FlashFactory.new(random_factory.within(:interval, 2, 100))
+      @f.factory_pool << RubyOnAcid::SineFactory.new(random_factory.within(:increment, -0.1, 0.1))
+      @f.factory_pool << RubyOnAcid::SineFactory.new(random_factory.within(:increment, -0.1, 0.1))
+      @f.factory_pool << RubyOnAcid::SineFactory.new(random_factory.within(:increment, -0.1, 0.1))
+      @f.factory_pool << RubyOnAcid::SineFactory.new(random_factory.within(:increment, -0.1, 0.1))
+      @f.factory_pool << RubyOnAcid::RepeatFactory.new(
+        RubyOnAcid::LoopFactory.new(random_factory.within(:increment, -0.1, 0.1)),
+        random_factory.within(:interval, 2, 100)
+      )
+      @f.factory_pool << RubyOnAcid::RepeatFactory.new(
+        RubyOnAcid::RandomFactory.new,
+        random_factory.within(:interval, 2, 1000)
+      )
+      @f.factory_pool << RubyOnAcid::RepeatFactory.new(
+        RubyOnAcid::SineFactory.new(random_factory.within(:increment, -0.1, 0.1)),
+        random_factory.within(:interval, 2, 100)
+      )
+      @f.factory_pool << RubyOnAcid::ModuloFactory.new(RubyOnAcid::LoopFactory.new(0.00001))
+    
+      frame = Wx::Frame.new(nil, :size => [WIDTH, HEIGHT])
+ 
+      bitmap = Wx::Bitmap.new(WIDTH, HEIGHT)
+      bitmap.draw do |surface|
+        # surface.pen = black_pen
+        surface.brush = Wx::BLACK_BRUSH
+        surface.draw_rectangle(0, 0, WIDTH, HEIGHT)
+      end
+      random_factory.within(:iterations, 10, 10000).to_i.times do
+        bitmap.draw {|surface| render(surface)}
+      end
+      bitmap.draw do |surface|
+        surface.text_foreground = Wx::Colour.new(255, 255, 255, 255)
+        y = 0
+        @f.to_yaml.split("\n").each do |line|
+          surface.draw_text(line, 0, y)
+          y += 10
+        end
+      end
+      
+      File.open(file_name + ".yml", "w") do |file|
+        YAML.dump(@f, file)
+      end
+      
+      bitmap.save_file(file_name, Wx::BITMAP_TYPE_PNG)
+      
+    end
+    
+    exit
+ 
+  end
+ 
+  def render(surface)
+     surface.pen = Wx::Pen.new(
+         Wx::Colour.new(
+           @f.within(:red, 0, 255).to_i,
+           @f.within(:green, 0, 255).to_i,
+           @f.within(:blue, 0, 255).to_i,
+           @f.within(:alpha, 50, 255).to_i
+         ),
+         @f.within(:width, 1, 5).to_i
+     )
+     surface.draw_line(
+        @f.within(:x, 0, WIDTH).to_i,
+        @f.within(:y, 0, HEIGHT).to_i,
+        @f.within(:x2, 0, WIDTH).to_i,
+        @f.within(:y2, 0, HEIGHT).to_i
+     )
+  end
+
+end
+
+app = MyApp.new
+app.main_loop

data/features/rubyonacid.feature

@@ -0,0 +1,9 @@
+Feature: something something
+  In order to something something
+  A user something something
+  something something something
+
+  Scenario: something something
+    Given inspiration
+    When I create a sweet new gem
+    Then everyone should see how awesome I am

data/features/support/env.rb

@@ -0,0 +1,4 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../../lib')
+require 'rubyonacid'
+
+require 'spec/expectations'

data/lib/rubyonacid/factories/constant.rb

@@ -0,0 +1,25 @@
+require 'rubyonacid/factory'
+
+module RubyOnAcid
+
+class ConstantFactory < Factory
+  
+  attr_accessor :value
+  def value=(value)
+    raise "assigned #{value} to value, must be between -1 and 1" if value < -1 or value > 1
+    @value = value
+  end
+  
+  def initialize(value = 0.5)
+    super
+    @value = value
+  end
+  
+  #Increment counter for key, looping it around to opposite side if it exits boundary.
+  def get_unit(key)
+    @value
+  end
+
+end
+
+end

data/lib/rubyonacid/factories/flash.rb

@@ -0,0 +1,32 @@
+require 'rubyonacid/factory'
+
+module RubyOnAcid
+
+class FlashFactory < Factory
+  
+  attr_accessor :interval
+  
+  def initialize(interval = 3)
+    super
+    @counters = {}
+    @values = {}
+    @interval = interval
+  end
+  
+  #If key is over threshold, flip to other value and reset counter.
+  def get_unit(key)
+    @counters[key] ||= 0
+    @values[key] ||= 1.0
+    if @counters[key] >= @interval
+      @values[key] = (@values[key] == 1.0 ? 0.0 : 1.0)
+      @counters[key] = 0
+    end
+    #Increment counter.
+    @counters[key] += 1
+    #Return value.
+    @values[key]
+  end
+
+end
+
+end

data/lib/rubyonacid/factories/increment.rb

@@ -0,0 +1,32 @@
+require 'rubyonacid/factory'
+
+module RubyOnAcid
+
+class IncrementFactory < Factory
+  
+  attr_accessor :interval
+  def interval=(value)
+    @interval = value
+    @start_value = (@interval < 0.0 ? 1.0 : 0.0) 
+    @counters.each_key{|k| @counters[k] = @start_value}
+  end
+  
+  def initialize(interval = 0.001)
+    super
+    @start_value = 0.0
+    @counters = {}
+    @interval = interval
+  end
+  
+  #Increment counter for key and get its sine, then scale it between 0 and 1.
+  def get_unit(key)
+    @counters[key] ||= @start_value
+    @counters[key] += @interval
+    @counters[key] = 1.0 if @counters[key] > 1.0
+    @counters[key] = 0.0 if @counters[key] < 0.0
+    @counters[key]
+  end
+
+end
+
+end

data/lib/rubyonacid/factories/loop.rb

@@ -0,0 +1,30 @@
+require 'rubyonacid/factory'
+
+module RubyOnAcid
+
+class LoopFactory < Factory
+  
+  attr_accessor :interval
+  def interval=(value)
+    raise "assigned #{value} to interval, must be between -1 and 1" if value < -1 or value > 1
+    @interval = value
+  end
+  
+  def initialize(interval = 0.01)
+    super
+    @counters = {}
+    @interval = interval
+  end
+  
+  #Increment counter for key, looping it around to opposite side if it exits boundary.
+  def get_unit(key)
+    @counters[key] ||= 0
+    @counters[key] += @interval
+    @counters[key] = @counters[key] - 1.0 if @counters[key] > 1
+    @counters[key] = @counters[key] + 1.0 if @counters[key] < 0
+    @counters[key]
+  end
+
+end
+
+end

data/lib/rubyonacid/factories/meta.rb

@@ -0,0 +1,31 @@
+require 'rubyonacid/factory'
+
+module RubyOnAcid
+
+class MetaFactory < Factory
+  
+  attr_accessor :factory_pool
+  attr_accessor :assigned_factories
+  
+  def initialize(factory_pool = [])
+    super
+    @factory_pool = factory_pool
+    @assigned_factories = {}
+  end
+  
+  def assign_factory(key, factory)
+    @assigned_factories[key] = factory
+  end
+  
+  def get_unit(key)
+    @assigned_factories[key] ||= @factory_pool[rand(@factory_pool.length)]
+    @assigned_factories[key].get_unit(key)
+  end
+  
+  def reset_assignments
+    @assigned_factories.clear
+  end
+
+end
+
+end

data/lib/rubyonacid/factories/modulo.rb

@@ -0,0 +1,25 @@
+require 'rubyonacid/factory'
+
+module RubyOnAcid
+
+#Gets values from a source factory and returns the same value the given number of times before getting a fresh value.
+class ModuloFactory < Factory
+  
+  #Factory to get values from.
+  attr_accessor :source_factory
+  
+  def initialize(source_factory = nil)
+    super
+    @source_factory = source_factory
+    @prior_values = {}
+  end
+  
+  #Returns the value of get_unit on the source factory the assigned number of times.
+  def get_unit(key)
+    @prior_values[key] ||= 0
+    @prior_values[key] = (@prior_values[key] + @source_factory.get_unit(key)) % 1
+  end
+  
+end
+
+end

data/lib/rubyonacid/factories/random.rb

@@ -0,0 +1,15 @@
+require 'rubyonacid/factory'
+
+module RubyOnAcid
+
+class RandomFactory < Factory
+
+  #Returns a random value between 0 and 1.
+  def get_unit(key)
+    rand
+  end
+
+end
+
+
+end

data/lib/rubyonacid/factories/repeat.rb

@@ -0,0 +1,35 @@
+require 'rubyonacid/factory'
+
+module RubyOnAcid
+
+#Gets values from a source factory and returns the same value the given number of times before getting a fresh value.
+class RepeatFactory < Factory
+  
+  #Factory to get values from.
+  attr_accessor :source_factory
+  #The number of times to repeat a value for a given key.
+  attr_accessor :repeat_count
+  
+  def initialize(source_factory = nil, repeat_count = 2)
+    super
+    @source_factory = source_factory
+    @repeat_count = repeat_count
+    @repeat_counts = {}
+    @values = {}
+  end
+  
+  #Returns the value of get_unit on the source factory the assigned number of times.
+  def get_unit(key)
+    @repeat_counts[key] ||= 0
+    if @repeat_counts[key] >= @repeat_count
+      @values[key] = nil 
+      @repeat_counts[key] = 0
+    end
+    @values[key] ||= @source_factory.get_unit(key)
+    @repeat_counts[key] += 1
+    @values[key]
+  end
+  
+end
+
+end

data/lib/rubyonacid/factories/rinda.rb

@@ -0,0 +1,40 @@
+require 'rinda/rinda' 
+require 'rubyonacid/factory'
+
+module RubyOnAcid
+
+class RindaFactory < Factory
+  
+  #Time in seconds to wait for a value before giving up and returning the last retrieved value for the given key.
+  #Default is 0, which will return immediately.
+  attr_accessor :timeout
+  #The URI to connect to.  Default is "druby://127.0.0.1:7632" (7632 == RNDA).
+  attr_accessor :uri
+  
+  def initialize(uri = "druby://127.0.0.1:7632", timeout = 0)
+    super
+    @uri = uri
+    @timeout = timeout
+    @prior_values = {}
+  end
+  
+  def start_service
+    DRb.start_service 
+    @space = Rinda::TupleSpaceProxy.new(DRbObject.new(nil, @uri))
+  end
+  
+  #Get key from Rinda server.
+  def get_unit(key)
+    @prior_values[key] ||= 0.0
+    begin
+      key, value = @space.take([key, Float], @timeout)
+      @prior_values[key] = value
+    rescue Rinda::RequestExpiredError => exception
+      value = @prior_values[key]
+    end
+    value
+  end
+
+end
+
+end

data/lib/rubyonacid/factories/sine.rb

@@ -0,0 +1,24 @@
+require 'rubyonacid/factory'
+
+module RubyOnAcid
+
+class SineFactory < Factory
+  
+  attr_accessor :interval
+  
+  def initialize(interval = 0.1)
+    super
+    @counters = {}
+    @interval = interval
+  end
+  
+  #Increment counter for key and get its sine, then scale it between 0 and 1.
+  def get_unit(key)
+    @counters[key] ||= 0
+    @counters[key] += @interval
+    (Math.sin(@counters[key]) + 1) / 2
+  end
+  
+end
+
+end

data/lib/rubyonacid/factories/skip.rb

@@ -0,0 +1,23 @@
+require 'rubyonacid/factory'
+
+module RubyOnAcid
+
+class SkipFactory < Factory
+  
+  #The percentage odds that the factory will return 0 instead of 1.
+  attr_accessor :odds
+  
+  def initialize(odds = 0.1)
+    super
+    @odds = odds
+  end
+  
+  #If a random number between 0 and 1 is less than the assigned odds value, will return 0 (a "skip").
+  #Otherwise returns 1.
+  def get_unit(key)
+    rand < @odds ? 0.0 : 1.0
+  end
+
+end
+
+end

data/lib/rubyonacid/factory.rb

@@ -0,0 +1,29 @@
+module RubyOnAcid
+
+class Factory
+
+  def initialize(*args)
+    @minimums = {}
+    @maximums = {}
+  end
+
+  #Calls get_unit with key to get value between 0.0 and 1.0, then converts that value to be between given minimum and maximum.
+  def within(key, minimum, maximum)
+    get_unit(key) * (maximum - minimum) + minimum
+  end
+  
+  #Calls get_unit with key to get value between 0.0 and 1.0, then converts that value to be between given minimum and maximum.
+  def get(key, options = {})
+    @minimums[key] = (options[:min] || @minimums[key] || 0.0)
+    @maximums[key] = (options[:max] || @maximums[key] || @minimums[key] > 1.0 ? @minimums[key] + 1.0 : 1.0)
+    get_unit(key) * (@maximums[key] - @minimums[key]) + @minimums[key]
+  end
+  
+  #Returns true if get_unit(key) returns greater than 0.5.
+  def boolean(key)
+    get_unit(key) >= 0.5
+  end
+  
+end
+
+end

data/spec/generators/constant_spec.rb

@@ -0,0 +1,24 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+require "shared_factory_specs"
+require 'rubyonacid/factories/constant'
+
+include RubyOnAcid
+
+describe ConstantFactory do
+  
+  MARGIN = 0.01
+  
+  before :each do
+    @it = ConstantFactory.new
+  end
+  
+  it_should_behave_like "a factory"
+  
+
+  it "always returns the same value" do
+    @it.value = 0.1
+    @it.get_unit(:x).should == 0.1
+    @it.get_unit(:x).should == 0.1
+  end
+  
+end

data/spec/generators/flash_spec.rb

@@ -0,0 +1,49 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+require "shared_factory_specs"
+require 'rubyonacid/factories/flash'
+
+include RubyOnAcid
+
+describe FlashFactory do
+  
+  before :each do
+    @it = FlashFactory.new
+  end
+  
+  it_should_behave_like "a factory"
+  
+  it "returns 1.0 three times, then 0.0 three times, then loops" do
+    @it.get_unit(:x).should == 1.0
+    @it.get_unit(:x).should == 1.0
+    @it.get_unit(:x).should == 1.0
+    @it.get_unit(:x).should == 0.0
+    @it.get_unit(:x).should == 0.0
+    @it.get_unit(:x).should == 0.0
+    @it.get_unit(:x).should == 1.0
+    @it.get_unit(:x).should == 1.0
+    @it.get_unit(:x).should == 1.0
+    @it.get_unit(:x).should == 0.0
+    @it.get_unit(:x).should == 0.0
+    @it.get_unit(:x).should == 0.0
+  end
+  
+  it "can take a different interval" do
+    @it.interval = 2
+    @it.get_unit(:x).should == 1.0
+    @it.get_unit(:x).should == 1.0
+    @it.get_unit(:x).should == 0.0
+    @it.get_unit(:x).should == 0.0
+    @it.get_unit(:x).should == 1.0
+  end
+  
+  it "handles multiple keys" do
+    @it.interval = 2
+    @it.get_unit(:x).should == 1.0
+    @it.get_unit(:y).should == 1.0
+    @it.get_unit(:x).should == 1.0
+    @it.get_unit(:y).should == 1.0
+    @it.get_unit(:x).should == 0.0
+    @it.get_unit(:y).should == 0.0
+  end
+  
+end

data/spec/generators/increment_spec.rb

@@ -0,0 +1,43 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+require "shared_factory_specs"
+require 'rubyonacid/factories/increment'
+
+include RubyOnAcid
+
+describe IncrementFactory do
+  
+  MARGIN = 0.01
+  
+  before :each do
+    @it = IncrementFactory.new
+  end
+  
+  it_should_behave_like "a factory"
+  
+  it "Stops at 1 if increment is positive" do
+    @it.interval = 0.3
+    @it.get_unit(:x).should be_close(0.3, MARGIN)
+    @it.get_unit(:x).should be_close(0.6, MARGIN)
+    @it.get_unit(:x).should be_close(0.9, MARGIN)
+    @it.get_unit(:x).should be_close(1.0, MARGIN)
+    @it.get_unit(:x).should be_close(1.0, MARGIN)
+  end
+  
+  it "Stops at 0 if increment is negative" do
+    @it.interval = -0.3
+    @it.get_unit(:x).should be_close(0.7, MARGIN)
+    @it.get_unit(:x).should be_close(0.4, MARGIN)
+    @it.get_unit(:x).should be_close(0.1, MARGIN)
+    @it.get_unit(:x).should be_close(0.0, MARGIN)
+    @it.get_unit(:x).should be_close(0.0, MARGIN)
+  end
+  
+  it "handles multiple keys" do
+    @it.interval = 0.3
+    @it.get_unit(:x).should be_close(0.3, MARGIN)
+    @it.get_unit(:y).should be_close(0.3, MARGIN)
+    @it.get_unit(:x).should be_close(0.6, MARGIN)
+    @it.get_unit(:y).should be_close(0.6, MARGIN)
+  end
+  
+end

data/spec/generators/loop_spec.rb

@@ -0,0 +1,43 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+require "shared_factory_specs"
+require 'rubyonacid/factories/loop'
+
+include RubyOnAcid
+
+describe LoopFactory do
+  
+  MARGIN = 0.01
+  
+  before :each do
+    @it = LoopFactory.new
+  end
+  
+  it_should_behave_like "a factory"
+  
+  it "Loops to 0 if increment is positive" do
+    @it.interval = 0.3
+    @it.get_unit(:x).should be_close(0.3, MARGIN)
+    @it.get_unit(:x).should be_close(0.6, MARGIN)
+    @it.get_unit(:x).should be_close(0.9, MARGIN)
+    @it.get_unit(:x).should be_close(0.2, MARGIN)
+    @it.get_unit(:x).should be_close(0.5, MARGIN)
+  end
+  
+  it "Loops to 1 if increment is negative" do
+    @it.interval = -0.3
+    @it.get_unit(:x).should be_close(0.7, MARGIN)
+    @it.get_unit(:x).should be_close(0.4, MARGIN)
+    @it.get_unit(:x).should be_close(0.1, MARGIN)
+    @it.get_unit(:x).should be_close(0.8, MARGIN)
+    @it.get_unit(:x).should be_close(0.5, MARGIN)
+  end
+  
+  it "handles multiple keys" do
+    @it.interval = 0.3
+    @it.get_unit(:x).should be_close(0.3, MARGIN)
+    @it.get_unit(:y).should be_close(0.3, MARGIN)
+    @it.get_unit(:x).should be_close(0.6, MARGIN)
+    @it.get_unit(:y).should be_close(0.6, MARGIN)
+  end
+  
+end

data/spec/generators/meta_spec.rb

@@ -0,0 +1,20 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+require 'rubyonacid/factories/meta'
+
+include RubyOnAcid
+
+describe MetaFactory do
+  
+  before :each do
+    @it = MetaFactory.new
+  end
+  
+  it "takes a list of factories, then randomly and permanently assigns a factory to each requested key" do
+    @it.factory_pool << mock('FactoryZero', :get_unit => 0.0)
+    @it.factory_pool << mock('FactoryOne', :get_unit => 1.0)
+    ('a'..'z').each do |key|
+      @it.get_unit(key.to_sym).should == @it.get_unit(key.to_sym)
+    end
+  end
+  
+end