livecode 0.0.8 → 0.1.0

data/.gitignore

@@ -19,3 +19,4 @@ rdoc
 pkg
 
 ## PROJECT::SPECIFIC
+testing/*

data/README.rdoc

@@ -1,6 +1,12 @@
 = Livecode: Ruby toolkit for TextMate/OSX
 
-More to come.
+<em>Live coding (sometimes known as 'interactive programming', 'on-the-fly programming', 'just in time programming') is the name given to the process of writing software in realtime as part of a performance. Historically, similar techniques were used to produce early computer art, but recently it has been explored as a more rigorous alternative to laptop DJs who, live coders often feel, lack the charisma and pizzazz of musicians performing live.</em>
+
+<em>Generally, this practice stages a more general approach: one of interactive programming, of writing (parts of) programs while they run. Traditionally most computer music programs have tended toward the old write/compile/run model which evolved when computers were much less powerful. This approach has locked out code-level innovation by people whose programming skills are more modest. Some programs have gradually integrated real-time controllers and gesturing (for example, MIDI-driven software synthesis and parameter control). Until recently, however, the musician/composer rarely had the capability of real-time modification of program code itself."</em> - http://en.wikipedia.org/wiki/Livecoding#Live_coding
+
+Livecode is a toolkit for livecoding with Ruby using TextMate on OSX. At the core, it's a server/client setup that'll let you run and modify code in realtime. 
+
+The server and TextMate bundle is functional, I'm currently working on porting over the MIDI code. Watch this space.
 
 == Installation
 

data/VERSION

@@ -1 +1 @@
-0.0.8
+0.1.0

data/lib/livecode.rb

@@ -0,0 +1,49 @@
+require 'pathname'
+
+# = The Livecode library
+#
+# To get started, require and include Livecode:
+# 
+#  require 'livecode'
+#  include Livecode
+#
+# For your main loop, have a look at Timer, Delay or the more sophisticated Clock class.
+
+module Livecode
+	LIBRARY_PATH = Pathname.new(File.join(File.dirname(__FILE__))).realpath.to_s
+	unless self.const_defined?('Loader')
+		$:.unshift LIBRARY_PATH
+	end
+end
+
+# Bootstrap loader
+(bootstrap = %w{livecode/loader livecode/extensions/main}).each{|l| require l}
+self.send(:include, Livecode::Extensions::Main)
+(bootstrap + [__FILE__]).each{|l| Livecode.loader.add_reloadable(l)}
+
+# These should all be safe to load multiple times
+%w{ 
+	clock
+	clock_recipients
+	delay
+	extensions/numeric
+	extensions/object
+	extensions/string
+	silenceable
+	timer
+}.each{|l| live_require "livecode/#{l}"}
+
+# Apply extensions
+Numeric.send(:include, Livecode::Extensions::Numeric)
+Object.send(:include, Livecode::Extensions::Object)
+String.send(:include, Livecode::Extensions::String)
+ 
+class NilClass #:nodoc:
+	def chance?; false; end; alias :c? :chance?
+end
+class FalseClass #:nodoc:
+	def chance?; false; end; alias :c? :chance?
+end
+class TrueClass #:nodoc:
+	def chance?; true; end; alias :c? :chance?
+end

data/lib/livecode/clock.rb

@@ -0,0 +1,192 @@
+module Livecode
+	
+	# = Clock
+	#
+	# Clock is quite literally the beating pulse of Livecode,
+	# providing you with a way to sync up blocks of code.
+	#
+	# == Creating a clock
+	#
+	# Clock.new takes two options; :tempo and :resolution.
+	# Tempo should be self-explanatory, and is measured in beats
+	# per minute (BPM). The default is 120 BPM.
+	# Resolution is the number of ticks per beat. The default 
+	# is 4, which is the equivalent of 16th notes.
+	#
+	#  clock = Clock.new(:tempo => 120, :resolution => 4)
+	#
+	# == Control
+	#
+	#  clock.start    # Starts the clock
+	#  clock.stop     # Stops the clock, resets the tick
+	#  clock.pause    # Pauses the clock, does not reset the tick
+	#  clock.restart  # Restarts the clock
+	#  clock.running? # Check if the clock is running
+	#
+	# If you lose track of your variables, you can use 
+	# <tt>Clock.stop_all</tt> to stop all clocks.
+	#
+	# == Ticks
+	#
+	# The clock is based on ticks, which is simply an incrementing counter.
+	# <tt>clock.tick</tt> will return the current tick, while 
+	# <tt>clock.tick_length</tt> will return the length of one tick expressed
+	# in seconds.
+	#
+	# The modulo operator is quite handy for turning ticks into rythmical 
+	# structures:
+	#
+	#  bassdrum.play if clock.tick % 4 == 0 # Plays the bass drum on every beat
+	#  snare.play if clock.tick % 8 == 4 # ..and the snare on every other beat
+	#
+	# == Recipients
+	#
+	# A recipient is a callback that will be triggered on every tick. Each 
+	# recipient must have a unique name, and there's a few ways to attach them.
+	# The following examples all do the same:
+	#
+	#  clock.recipients.add(:hihat, proc{|clock| hihat.play})
+	#  clock.recipients[:hihat] = proc{|clock| hihat.play})
+	#  clock.recipients.hihat = proc{|clock| hihat.play}
+	#  clock.recipients.hihat{|clock| hihat.play}
+	#  clock[:hihat] = proc{|clock| hihat.play}
+	#  clock.hihat = proc{|clock| hihat.play}
+	#  clock.hihat{|clock| hihat.play}
+	#
+	# To remove a recipient, simply unset it:
+	#
+	#  clock.hihat = false
+	#
+	# Furthermore, recipients can be muted, temporarily disabling them:
+	#
+	#  clock.mute(:bassdrum, :snare)  # Mutes the bass drum and snare
+	#  clock.solo(:synth, :bass)      # Solos the synth and bass
+	#  clock.enable_all               # Re-enables all recipients
+	#
+	# Remember: The callbacks are executed sequentially. If your callback takes
+	# more than a split second, you should wrap the code in it's own thread to
+	# allow for parallel processing.
+	#
+	# Clock will also try to compensate for the run time of your code in 
+	# order to stay in sync.
+	
+	class Clock
+		class << self
+			# Register a new clock.
+			def register(clock)
+				clocks << clock
+			end
+			
+			# Return all registered clocks.
+			def clocks
+				@@clocks ||= []
+			end
+			
+			# Stop all clocks.
+			def stop_all
+				clocks.each{|clock| clock.stop}
+			end
+		end
+
+		attr_accessor :tempo, :resolution
+		attr_reader   :tick
+		
+		def initialize(options={})
+			@tempo      = options[:tempo]      || 120
+			@resolution = options[:resolution] || 4
+			@tick       = -1
+			@thread     = nil
+			@running    = false
+			@recipients = ClockRecipients.new
+			Clock.register(self)
+		end
+		
+		public
+
+			# Clock recipients
+			def recipients; @recipients; end
+			alias :r :recipients
+
+			# Length of a single tick (in seconds).
+			def tick_length
+				tl = (1/(@tempo.to_f/60))/@resolution
+				tl = 0.00000001 if tl <= 0
+				tl
+			end
+			alias :tl :tick_length
+		
+			# Start the clock. Restarts if the clock is already running.
+			def start
+				@running = true
+				stop_thread
+				start_thread
+				self
+			end
+			alias :play :start
+			
+			# Stop the clock.
+			def stop
+				stop_thread
+				@tick = -1
+				@running = false
+				self
+			end
+			
+			# Pause the clock.
+			def pause
+				@running = false
+				self
+			end
+			
+			# Restart the clock.
+			def restart
+				@tick = -1
+				start
+			end
+			
+			# Returns true if the clock is running.
+			def running?
+				@running ? true : false
+			end
+			
+			# Run next tick.
+			def tick!
+				@tick += 1
+				recipients.each do |r|; unless r.silenced?
+					if r.kind_of?(Proc)
+						r.call(self)
+					elsif r.respond_to?(:tick)
+						r.tick(self)
+					end
+				end; end
+			end
+			
+			def method_missing(method_name, *args, &block)
+				self.recipients.send(method_name, *args, &block)
+			end
+
+		protected
+		
+			# Stop the clock thread.
+			def stop_thread
+				if @thread
+					@thread.exit
+					@thread = nil
+				end
+			end
+			
+			# Start the clock thread.
+			def start_thread
+				clock = self
+				@thread ||= Thread.new do
+					next_time = Time.now
+					while @running
+						clock.tick!
+						next_time += tick_length
+						sleep_time = next_time - Time.now
+						sleep(sleep_time) if sleep_time > 0
+					end
+				end
+			end
+	end
+end

data/lib/livecode/clock_recipients.rb

@@ -0,0 +1,81 @@
+module Livecode
+
+	# Recipients hash for the clock, see Clock for documentation.
+
+	class ClockRecipients
+		include Enumerable
+
+		def initialize
+			@collection = {}
+		end
+		
+		def each
+			@collection.each{|key,r| yield r}
+		end
+		
+		def each_with_index
+			@collection.each{|key,r| yield key, r}
+		end
+		
+		def keys
+			@collection.map{|k,o| k}
+		end
+		
+		def has_key?(key)
+			(@collection.keys.map{|k| k}.include?(key.to_sym)) ? true : false
+		end
+		
+		def set(key, obj=nil, &block)
+			obj = block if block_given?
+			if obj
+				@collection[key.to_sym] = Silenceable.apply( obj )
+			elsif has_key?(key)
+				@collection.delete(key.to_sym)
+			end
+		end
+		alias :add :set
+		alias :attach :set
+		alias :[]= :set
+		
+		def get(key)
+			return nil unless self.has_key?(key)
+			@collection[key.to_sym]
+		end
+		alias :[] :get
+		
+		def method_missing(method_sym, *args, &block)
+			method_name = method_sym.to_s
+			if method_name =~ /=$/
+				self.set(method_name.gsub(/=$/, ''), *args)
+			elsif block_given?
+				self.set(method_name, *args, &block)
+			else
+				return nil unless self.has_key?(method_name)
+				self.get(method_name)
+			end
+		end
+		
+		def silence(*keys)
+			keys.each{|k| self[k].silenced = true}
+		end
+		alias :mute :silence
+		
+		def silence_all
+			each_with_index{|k,o| self[k].silenced = true}
+		end
+		alias :mute_all :silence_all
+		
+		def solo(*keys)
+			silence_all
+			keys.each{|k| self[k].silenced = false}
+		end
+		alias :play :solo
+		
+		def enable_all
+			each_with_index{|k,o| self[k].silenced = false}
+		end
+		alias :play_all :enable_all
+		alias :unsolo   :enable_all
+		
+	end
+end

data/lib/livecode/delay.rb

@@ -0,0 +1,31 @@
+module Livecode
+
+	# = Delay
+	#
+	# Delay lets you schedule a block for later.
+	#
+	#  Delay.new(1000){puts "One second later"}
+	#  later = proc{puts "I am a proc"}
+	#  Delay.new(500, later)
+
+	class Delay
+		attr_accessor :time, :proc
+
+		# Time is specified in milliseconds
+		def initialize(time, proc=nil, &block)
+			@time = time || 1
+			if proc
+				@proc = proc
+			elsif block_given?
+				@proc = block
+			end
+			Silenceable.apply(@proc) if @proc
+			if @proc && !@proc.silenced?
+				@thread = Thread.new do
+					sleep @time.to_f / 1000
+					@proc.call
+				end
+			end
+		end
+	end
+end

data/lib/livecode/extensions/main.rb

@@ -0,0 +1,13 @@
+module Livecode
+	module Extensions
+		module Main
+			def live_require(file)
+				Livecode.loader.load_file(file)
+			end
+ 
+			def reload!
+				Livecode.loader.reload!
+			end
+		end
+	end
+end

data/lib/livecode/extensions/numeric.rb

@@ -0,0 +1,12 @@
+module Livecode
+	module Extensions
+		module Numeric
+ 
+			def chance?
+				(rand() < self) ? true : false
+			end
+			alias :c? :chance?
+ 
+		end
+	end
+end

data/lib/livecode/extensions/object.rb

@@ -0,0 +1,10 @@
+module Livecode
+	module Extensions
+		module Object
+			def help
+				puts "No help for #{self.class.to_s}"; nil
+			end
+			alias :doc :help
+		end
+	end
+end

data/lib/livecode/extensions/string.rb

@@ -0,0 +1,10 @@
+module Livecode
+	module Extensions
+		module String
+ 
+			def chance?; true; end
+			alias :c? :chance?
+ 
+		end
+	end
+end

data/lib/livecode/loader.rb

@@ -0,0 +1,47 @@
+module Livecode
+ 
+	# Handles (re)loading of library files, which is mostly useful for development.
+	
+	class Loader
+		attr_accessor :reloadable_files
+ 
+		def initialize
+			@reloadable_files = []
+			@reloading = false
+		end
+ 
+		def add_reloadable(file)
+			file = parse_path(file)
+			@reloadable_files << file unless @reloadable_files.include?(file)
+		end
+ 
+		def load_file(file, force=false)
+			file = parse_path(file)
+			return false if @reloading && !force && @reloadable_files.include?(file)
+			add_reloadable file
+			load("#{file}.rb")
+		end
+ 
+		def reload!
+			puts "Reloading: #{@reloadable_files.inspect}"
+			@reloading = true
+			old_v = $-v; $-v = nil # Temporarily disable warnings
+			results = @reloadable_files.map{ |f| load_file( f, true ) }
+			$-v = old_v # Re-enable eventual warnings
+			@reloading = false
+			return results
+		end
+ 
+		def parse_path(path)
+			path.gsub(/\.rb$/, '').gsub(/^\.\//, '')
+		end
+	end
+ 
+	class << self
+		attr_accessor :loader
+		def loader
+			@loader ||= Loader.new
+			@loader
+		end
+	end
+end

data/lib/livecode/silenceable.rb

@@ -0,0 +1,19 @@
+module Livecode
+
+	# Silenceable lets you mute procs and blocks when used by Timer and Clock.
+	module Silenceable
+		class << self
+			def apply(obj)
+				unless obj.respond_to?(:silenced?)
+					class << obj
+						include Silenceable
+					end
+				end
+				return obj
+			end
+		end
+		attr_accessor :silenced
+		@silenced = false
+		def silenced?; @silenced ? true : false; end
+	end
+end

data/lib/livecode/timer.rb

@@ -0,0 +1,68 @@
+module Livecode
+
+	# = Timer
+	#
+	# Timer lets you loop a block at a certain interval.
+	#
+	#  timer = Timer.new(100) {puts "I'm executed every 100ms!"}
+	#  timer.stop       # Stops the execution
+	#  timer.start      # Starts the timer again
+	#  timer.time = 200 # Reschedules the timer
+    #
+	# Proc objects are also supported:
+	#
+	#  timer_proc = proc{puts "I'm a proc"}
+	#  timer2 = Timer.new(100, timer_proc)
+	#
+	# Timer will try to compensate for the run time of your code in order to stay in sync.
+
+	class Timer
+		attr_accessor :time, :proc
+
+		def initialize(time, proc=nil, &block)
+			@time = time || 1
+			if proc
+				@proc = proc
+			elsif block_given?
+				@proc = block
+			end
+			@tread = nil
+			start
+		end
+		
+		# Call the block
+		def call
+			Silenceable.apply(@proc) if @proc
+			if @proc && !@proc.silenced?
+				@proc.call
+			end
+		end
+		
+		# Start the timer
+		def start
+			stop
+			timer = self
+			@thread = Thread.new do
+				next_time = Time.now
+				while true
+					timer.call
+					next_time += (timer.time.to_f / 1000)
+					sleep_time = next_time - Time.now
+					sleep(sleep_time) if sleep_time > 0
+				end
+			end
+		end
+		alias :run :start
+
+		# Stop the timer.
+		def stop
+			if @thread
+				@thread.exit
+				@thread = nil
+			end
+		end
+		alias :clear :stop
+		alias :end :stop
+	end
+	
+end

data/lib/livecode_server/scope.rb

@@ -7,6 +7,10 @@ module LivecodeServer
 			@__scope_binding ||= Proc.new {}
 		end
 
+		def include(mod)
+			self.class.send(:include, mod)
+		end
+
 		def puts(string)
 			@__server.output string
 		end

data/livecode.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{livecode}
-  s.version = "0.0.8"
+  s.version = "0.1.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Inge J\303\270rgensen"]
-  s.date = %q{2009-10-23}
+  s.date = %q{2009-10-24}
   s.default_executable = %q{livecode}
   s.description = %q{A toolkit for livecoding using Ruby and TextMate on OSX}
   s.email = %q{inge@elektronaut.no}
@@ -34,6 +34,16 @@ Gem::Specification.new do |s|
      "extras/textmate/Ruby Livecode.tmbundle/Syntaxes/Ruby Livecode.tmLanguage",
      "extras/textmate/Ruby Livecode.tmbundle/info.plist",
      "lib/livecode.rb",
+     "lib/livecode/clock.rb",
+     "lib/livecode/clock_recipients.rb",
+     "lib/livecode/delay.rb",
+     "lib/livecode/extensions/main.rb",
+     "lib/livecode/extensions/numeric.rb",
+     "lib/livecode/extensions/object.rb",
+     "lib/livecode/extensions/string.rb",
+     "lib/livecode/loader.rb",
+     "lib/livecode/silenceable.rb",
+     "lib/livecode/timer.rb",
      "lib/livecode_server.rb",
      "lib/livecode_server/client.rb",
      "lib/livecode_server/command.rb",

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: livecode
 version: !ruby/object:Gem::Version 
-  version: 0.0.8
+  version: 0.1.0
 platform: ruby
 authors: 
 - "Inge J\xC3\xB8rgensen"
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-23 00:00:00 +02:00
+date: 2009-10-24 00:00:00 +02:00
 default_executable: livecode
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -47,6 +47,16 @@ files:
 - extras/textmate/Ruby Livecode.tmbundle/Syntaxes/Ruby Livecode.tmLanguage
 - extras/textmate/Ruby Livecode.tmbundle/info.plist
 - lib/livecode.rb
+- lib/livecode/clock.rb
+- lib/livecode/clock_recipients.rb
+- lib/livecode/delay.rb
+- lib/livecode/extensions/main.rb
+- lib/livecode/extensions/numeric.rb
+- lib/livecode/extensions/object.rb
+- lib/livecode/extensions/string.rb
+- lib/livecode/loader.rb
+- lib/livecode/silenceable.rb
+- lib/livecode/timer.rb
 - lib/livecode_server.rb
 - lib/livecode_server/client.rb
 - lib/livecode_server/command.rb