vmsim 0.2.3

data/.autotest

@@ -0,0 +1,27 @@
+class Autotest
+  def path_to_classname(s)
+    sep = File::SEPARATOR
+    f = s.sub(/^test#{sep}/, '').sub(/\.rb$/, '').split(sep)
+    f = f.map { |path| path.split(/_|(\d+)/).map { |seg| seg.capitalize }.join }
+
+    f.join('::')
+  end
+end
+
+
+Autotest.add_hook :initialize do |autotest|
+    autotest.add_mapping(%r%^test/.*\.rb$%) do |filename, _|
+        filename
+    end
+    autotest.add_mapping(%r%^lib/(.*)\.rb$%) do |_, m|
+        ["test/#{m[1]}_test.rb"]
+    end
+    autotest.add_mapping(%r%^test/test_helper.rb$%) do
+        files_matching %r%^test/.*_test\.rb$%
+    end
+end
+
+
+Autotest.add_discovery do
+  "testunit"
+end

data/README.txt

@@ -0,0 +1 @@
+vendingmachine exercise in Ruby

data/Rakefile

@@ -0,0 +1,40 @@
+require 'rubygems'
+#Gem::manage_gems
+require 'rubygems/package_task'
+require 'rake/testtask'
+
+
+desc 'Running all unit tests'
+task :default => :test
+
+Rake::TestTask.new(:test) do |t|
+  t.test_files = FileList['test/**/*test.rb', 'test/*test.rb']
+end
+ 
+desc 'Measures test coverage'
+task :coverage do
+   rm_f "coverage"
+   rm_f "coverage.data"
+   rcov = "rcov --aggregate coverage.data"
+   system("#{rcov} --html test/*test.rb")
+end
+ 
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "vmsim"
+  gem.executables << 'vmsim'
+  gem.executables << 'vmdeploy'
+  gem.license = "MIT"
+  gem.summary = %Q{Vending machine simulator - part of the vendingmachine tdd bdd case}
+  gem.description = %Q{Vending machine; this simulator starts a vendingmachine ui which behaviour can be programmed with control code}
+  gem.email = "info@qwan.it"
+  gem.authors = ["Rob Westgeest, Marc Evers, Willem van den Ende"]
+  # Include your dependencies below. Runtime dependencies are required when using your gem,
+  # and development dependencies are only needed for development (ie running rake tasks, tests, etc)
+  #gem.add_runtime_dependency 'gtk2', '>= 1.0.3'
+  gem.add_development_dependency 'mocha', '> 0.9.8'
+end
+Jeweler::RubygemsDotOrgTasks.new
+ 

data/VERSION

@@ -0,0 +1 @@
+0.2.3

data/bin/vmdeploy

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+$: << File.join(File.dirname(__FILE__),'..','lib')
+
+require 'deploy'
+
+def usage(errormessage = "")
+  puts errormessage
+  puts "usage: "
+  puts "   vmdeploy <archive> [executable]" 
+  puts ""
+  puts "   archive   : the archive to deploy"
+  puts "   executable: the executable to execute after deployment - default : 'vmsim'" 
+  puts ""
+  exit 1
+end
+
+archive = ARGV[0]
+executable = ARGV[1] || 'vmsim' 
+usage unless archive
+usage("archive #{archive} does not exist") unless File.exists?(archive)
+
+Deploy::Deployer.new(executable).deploy ARGV[0]
+

data/bin/vmsim

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+
+$: << File.expand_path(File.join(File.dirname(__FILE__),'..','lib'))
+require 'fileutils'
+require 'hardware_adapter'
+require 'hardware'
+require 'gui'
+
+simulator = Hardware::Simulator.new
+simulator.assemble_hardware
+
+simulator_gui = Gui::SimulatorGui.new(simulator)
+simulator_gui.show
+
+simulator.on_boot do
+  simulator.drawer(0).fill(Hardware::Can.cola, 2, 0)
+  simulator.drawer(1).fill(Hardware::Can.fanta, 2, 0)
+  simulator.drawer(2).fill(Hardware::Can.sprite, 2, 0)
+  simulator.drawer(3).fill(Hardware::Can.sisi, 2, 0)
+
+  simulator.cash_register.fill(Hardware::Coin.two_euro, 3, 0)
+  simulator.cash_register.fill(Hardware::Coin.one_euro, 3, 0)
+  simulator.cash_register.fill(Hardware::Coin.fifty_cents, 3, 0)
+end
+
+FileUtils.cd(File.expand_path('~/.vendingmachine/control')) do
+  $: << 'lib'
+  load 'main.rb'
+  Control.main if defined?(Control.main)
+end
+
+simulator.boot
+
+while !simulator_gui.stopped? do
+  Gtk.main_iteration while Gtk.events_pending?
+end
+puts "vending machine going home drunk"

data/doc/actuators_and_sensors.txt

@@ -0,0 +1,32 @@
+actuators
+:cash_drop_100
+:cash_drop_200
+:cash_drop_50
+:display_show, <line>, <message>
+:drawer_drop_can_0
+:drawer_drop_can_1
+:drawer_drop_can_2
+:drawer_drop_can_3
+
+
+sensors
+:bin_entry
+:bin_fetch_all
+:button_press_0
+:button_press_1
+:button_press_2
+:button_press_3
+:cash_fill_100
+:cash_fill_200
+:cash_fill_50
+:cash_insert_100
+:cash_insert_200
+:cash_insert_50
+:drawer_drop_can_0
+:drawer_drop_can_1
+:drawer_drop_can_2
+:drawer_drop_can_3
+:drawer_fill_can_0
+:drawer_fill_can_1
+:drawer_fill_can_2
+:drawer_fill_can_3

data/doc/todo.txt

@@ -0,0 +1,25 @@
+ - vmsim start - required in ~/.vendingmachine/control/main.rb
+ - zut in gem
+ - gem voor 
+    - api voor display (show (line, message))
+        Devices.display_show(line, message)
+        Devices.on_button_pressed(0) { } 
+
+        Devices.get_display().show(line, message)
+            Actuators(:display).fire(:show, line, message)
+    - api voor buttons (list, on_pres(0))
+        VM.get_button(0).on_press { }
+            Sensors.on(
+    - api voor drawers (on_pres(0), drop(0))
+        VM.get_drawer(0).drop()
+    - api voor bin (on_entry, on_fetch_all)
+    - api voor cashregister (on_fill(100), on_insert(100), drop(100))
+
+============== DONEDONEDONE ====================
+ - vmdeploy exe
+ - vmdeploy 
+    - stopt vmsim als running
+    - 
+    - start vmsim
+
+

data/lib/adapter/actuator_collection.rb

@@ -0,0 +1,61 @@
+module Adapter
+  class NoActuatorBlockGiven < Exception 
+  end
+  class DuplicateActuatorException < Exception 
+  end
+  class NoSuchActuatorException < Exception 
+  end
+
+  class AsynchronousFirer 
+    attr_reader :block
+    protected :block
+
+    def initialize(&block)
+      @block = block
+    end
+
+    def fire(*params)
+      Thread.start { block.call(*params) }
+    end
+  end
+
+  class SynchronousFirer < AsynchronousFirer
+    def fire(*params)
+      block.call *params
+    end
+  end
+
+
+  class ActuatorCollection
+    class Null
+      def create_actuator_for(actuator_name, &block) 
+      end
+      def fire(actuator_name)
+      end
+    end
+
+    def self.null
+      Null.new
+    end
+
+    def initialize(firer_class = AsynchronousFirer)
+      @actuators = {}
+      @firer_class = firer_class
+    end
+
+    def list
+      @actuators.entries.collect {|e| e[0].to_s}.sort.collect{|e| e.to_sym}
+    end
+
+    def create_actuator_for(actuator_name, &block) 
+      raise NoActuatorBlockGiven.new("must supply a code block for an actuator - none given") unless block_given?
+      raise DuplicateActuatorException.new("actuator :#{actuator_name} already exists") if @actuators.has_key?(actuator_name)
+      @actuators[actuator_name.to_sym] = @firer_class.new(&block)
+    end
+
+    def fire(actuator_name, *params)
+      raise NoSuchActuatorException.new("actuator :#{actuator_name} does not exist") unless @actuators.has_key?(actuator_name)
+      @actuators[actuator_name.to_sym].fire(*params)
+    end
+  end
+end

data/lib/adapter/sensor_collection.rb

@@ -0,0 +1,57 @@
+module Adapter
+  class Sensor
+    def fire
+      @on_fire_block.call if @on_fire_block
+    end
+    def on_fire_do(&block)
+      @on_fire_block = block
+    end
+    def remove_fire_listener
+      @on_fire_block = nil
+    end
+  end
+  
+  class NoSuchSensorException < Exception 
+  end
+  
+  class SensorCollection
+    class Null
+      def on(sensor)
+      end
+      def create_sensor_for(event)
+      end
+      def fire(sensor)
+      end
+    end
+    
+    def initialize
+      @sensors = {}
+      @sensors.default = Sensor.new
+    end
+    
+    def self.null
+      Null.new 
+    end 
+    
+    def list
+      @sensors.entries.collect { |e| e[0].to_s }.sort.collect{ |e| e.to_sym }
+    end
+    
+    def on(sensor, &block)
+      raise NoSuchSensorException.new("sensor :#{sensor} does not exist") unless @sensors.has_key?(sensor.to_sym)
+      @sensors[sensor.to_sym].on_fire_do(&block) 
+    end
+    
+    def create_sensor_for(event)
+      @sensors[event.to_sym] = Sensor.new    
+    end
+    
+    def fire(sensor)
+      @sensors[sensor.to_sym].fire
+    end
+
+    def remove_fire_listeners
+      @sensors.collect {|name, sensor| sensor.remove_fire_listener } 
+    end
+  end
+end

data/lib/archive_builder.rb

@@ -0,0 +1,64 @@
+require 'tmpdir'
+module ArchiveBuilder
+
+  def an_archive(filename, work_dir = Dir.tmpdir, &block)
+    archive = ArchiveBuilder.new(filename, work_dir)
+    archive.in_work_dir(&block) if block_given?
+    return archive.build.file_path
+  end
+
+  require 'fileutils'
+  class ArchiveBuilder
+    include FileUtils
+    def initialize(filename, work_dir = Dir.tmpdir)
+      @filename = filename
+      @work_dir = File.join(work_dir, 'archive_builder')
+    end
+
+    def a_file(filename)
+      FileBuilder.new(filename)
+    end
+
+    def in_work_dir(&block)
+      mk_work_dir
+      cd(@work_dir) do
+        instance_eval(&block)
+      end
+    end
+
+    def build
+      cd(@work_dir) do
+        system "zip -r #{@filename} * >> /dev/null"
+      end
+      return self
+    end
+
+    def file_path
+      File.join(@work_dir, @filename)
+    end
+    private
+    def mk_work_dir
+      rm_r(@work_dir) if File.exists?(@work_dir) && @work_dir =~ /^\/tmp/
+      mkdir_p(@work_dir) unless File.exists?(@work_dir)
+    end
+  end
+
+  class FileBuilder
+    include FileUtils
+    attr_reader :filename
+    def initialize(filename)
+      @filename = filename
+    end
+
+    def with(content)
+      create_dirs
+      File.open(filename, "w+") { |f| f.puts content }
+      return self
+    end
+    def create_dirs
+      dirname = File.dirname(filename)
+      mkdir_p dirname unless File.exists?(dirname) 
+    end
+  end
+end
+

data/lib/control/main.rb

@@ -0,0 +1,21 @@
+require "vmlog"
+require 'devices'
+
+include VMLog
+
+module Control
+  def self.main
+    # here, you should load your vending machine control software
+
+    # as an example of using the actuators and sensors (see doc/actuators_and_sensors)
+    Devices.display_show(0, 'Choose')
+    Devices.display_show(1, 'Please...')
+
+    Devices.on_button_pressed(0) do
+      log "cola pressed"
+
+      Devices.display_show(0, 'Cola')
+    end
+  end
+end
+

data/lib/control.rb

@@ -0,0 +1,3 @@
+require 'control/vending_machine'
+require 'control/main'
+

data/lib/deploy/deployer.rb

@@ -0,0 +1,96 @@
+
+require 'fileutils'
+module Deploy
+  def self.deploy(file)
+    Deployer.new(file).deploy
+  end
+  class Deployer
+    include FileUtils
+    DEPLOYED_DIR = File.expand_path("~/.vendingmachine/control")
+    PIDFILE = File.expand_path("~/.vendingmachine/pid")
+
+    attr_reader :executable, :current_pid
+
+    def initialize(executable)
+      @executable = executable
+      @log = ""
+      $: << DEPLOYED_DIR unless $:.include?(DEPLOYED_DIR)
+    end
+
+    def run_log
+      @log
+    end
+
+    def deploy(file_path)
+      create_deployment_environment
+      read_current_pid
+      kill_running_process
+      install_deployed_code(file_path)
+      start_deployed_code
+    end
+
+    def kill
+      read_current_pid
+      kill_running_process
+    end
+
+    def wait_for
+      @running_thread.join if @running_thread
+      self
+    end
+
+    private
+    def start_deployed_code
+      @running_thread = Thread.start do 
+        IO.popen(executable) do |io|
+          save_current_pid io.pid
+          while !io.eof? do
+            @log << io.gets
+          end
+        end
+        clear_current_pid
+      end
+    end
+
+    def install_deployed_code(file_path)
+      rm_r Dir.glob(File.join(DEPLOYED_DIR, '*'))
+      file_path = File.expand_path(file_path)
+      cd(DEPLOYED_DIR) do
+        sh "unzip #{file_path}"
+      end
+    end
+
+    def kill_running_process
+      begin
+        p current_pid
+        Process.kill("SIGKILL", current_pid) if current_pid
+      rescue Errno::ESRCH => e
+        # thats fine
+      end
+    end
+
+    def save_current_pid(pid)
+      @current_pid = pid
+      File.open(PIDFILE, 'w+') { |f| f.write(@current_pid.to_s) }
+    end
+
+    def read_current_pid
+      @current_pid = File.read(PIDFILE).to_i if File.exists?(PIDFILE)
+    end
+
+    def clear_current_pid
+      @current_pid = nil
+      rm PIDFILE if File.exists?(PIDFILE)
+    end
+
+    def create_deployment_environment
+      mkdir_p DEPLOYED_DIR unless File.exists?(DEPLOYED_DIR)
+    end
+
+    def sh(command)
+      system "#{command} >> /dev/null"
+    end
+
+  end
+end
+

data/lib/deploy.rb

@@ -0,0 +1 @@
+require 'deploy/deployer'

data/lib/devices/devices.rb

@@ -0,0 +1,73 @@
+require 'hardware_adapter'
+module Devices
+
+  def self.method_missing(method_sym, *arguments, &block)
+    devices = Devices.new
+    devices.send(method_sym, *arguments, &block)
+  end
+
+  class Devices
+    def initialize(actuators = Adapter.actuators, sensors = Adapter.sensors)
+      @actuators = actuators
+      @sensors = sensors
+    end
+
+    # display a a message on the specified line on the display
+    # the line is a 0 based index in the available lines on the display
+    def display_show(line, message)
+      actuators.fire(:display_show, line, message)
+    end
+
+    # drops a coin in the bin where:
+    # coin is 50 100 or 200 cts
+    def cash_drop_coin(coin)
+      actuators.fire(:"cash_drop_#{coin}")
+    end
+
+    # register a handler on filling coin of a specific 
+    # kind in the cash register
+    def on_cash_filled(coin, &block) 
+      sensors.on(:"cash_fill_#{coin}", &block)
+    end
+
+    # register a handler on inserting a specifica coin 
+    # in the cash register as part of paying
+    def on_cash_inserted(coin, &block) 
+      sensors.on(:"cash_insert_#{coin}", &block)
+    end
+
+    # register a handler on getting something being dropped in the bin
+    def on_bin_entry(&block)
+      sensors.on(:bin_entry, &block)
+    end
+
+    # register a handler on sbdy getting stuff from the bin
+    def on_bin_fetch_all(&block)
+      sensors.on(:bin_fetch_all, &block)
+    end
+
+    # register a handleer on sbgy pressing a specific button 
+    # where button can be one of 0 1 2 or three
+    def on_button_pressed(button, &block)
+      sensors.on(:"button_press_#{button}", &block)
+    end
+
+    # drops a can from a specified drawer
+    def drawer_drop_can(drawer)
+      actuators.fire(:"drawer_drop_can_#{drawer}")
+    end
+
+    # register a handler on a drawer dropping a can
+    def on_drawer_dropped(drawer, &block)
+      sensors.on(:"drawer_drop_can_#{drawer}", &block)
+    end
+
+    # register a handler on a drawer being filled with a can
+    def on_drawer_filled(drawer, &block)
+      sensors.on(:"drawer_fill_can_#{drawer}", &block)
+    end
+
+    private 
+    attr_reader :actuators, :sensors
+  end
+end

data/lib/devices.rb

@@ -0,0 +1 @@
+require 'devices/devices'