alda-rb 0.2.1 → 0.3.1

data/lib/alda-rb/event.rb

@@ -40,7 +40,7 @@ class Alda::Event
 	end
 	
 	##
-	# Delete itself from its #parent.
+	# Delete itself (or its topmost container if it has) from its #parent.
 	# If it is not at its #parent's end, raises Alda::OrderError.
 	#
 	# Here is a list of cases where the method is invoked:
@@ -60,11 +60,40 @@ class Alda::Event
 	# pushed to its #parent.
 	# However, the cases above requires the event be contained
 	# in another object.
-	def detach_from_parent
-		if @parent && self != (got = @parent.events.pop)
-			raise Alda::OrderError.new self, got
+	#
+	# The parameter +except+ specifies an Array of classes.
+	# If #parent is an instance of any of the classes in +except+,
+	# the method does nothing.
+	def detach_from_parent except = []
+		event = self
+		event = event.container while event.container
+		if @parent && except.none? { @parent.is_a? _1 } && event != (got = @parent.events.pop)
+			raise Alda::OrderError.new event, got
 		end
 	end
+	
+	##
+	# :call-seq:
+	#   is_event_of?(klass) -> true or false
+	#
+	# Whether it is an event of the given class (+klass+).
+	# By default, this is the same as +is_a?(klass)+.
+	# It is overridden in Alda::EventContainer.
+	def is_event_of? klass
+		is_a? klass
+	end
+	
+	##
+	# :call-seq:
+	#   event == other -> true or false
+	#
+	# Whether it is equal to +other+.
+	# To be overriden.
+	#
+	# Note that #parent and #container should not be taken into account when comparing two events.
+	def == other
+		super
+	end
 end
 
 ##
@@ -83,6 +112,8 @@ class Alda::EventContainer < Alda::Event
 	#     p((e/g).event.class) # => Alda::Chord
 	#     p((a b).event.class) # => Alda::Sequence
 	#  end
+	#
+	# When setting this attribute, #on_containing is invoked.
 	attr_accessor :event
 	
 	##
@@ -114,9 +145,11 @@ class Alda::EventContainer < Alda::Event
 	#
 	# +parent+ is the Alda::EventList object containing the event.
 	def initialize event, parent
+		super()
 		@event = event
-		@parent = parent
 		@labels = []
+		@count = 1
+		self.parent = parent
 		on_containing
 	end
 	
@@ -124,13 +157,31 @@ class Alda::EventContainer < Alda::Event
 	# :call-seq:
 	#   container / other -> container
 	#
-	# Makes #event an Alda::Chord object.
+	# If at first #event is not an Alda::Part,
+	# makes #event an Alda::Chord object.
 	#
 	#   Alda::Score.new { piano_; c/-e/g }.play
 	#   # (plays the chord Cm)
 	#
-	# If the contained event is an Alda::Part object,
+	# This usage assumes that +other+ is an Alda::EventContainer and will extract the contained event
+	# out from +other+.
+	# This will lose some information about +other+, such as #count and #labels,
+	# and potentially lead to confusing results.
+	#
+	# Because the #labels information about +other+ is lost,
+	# the label on +d+ disappears in the following example:
+	#
+	#   Alda::Score.new { c/(d%1) }.to_s # => "c/d"
+	#
+	# The following example shows that the two ways of writing a chord with a label are equivalent:
+	# adding the label and then using slash, or using slash and then adding the label.
+	# This is because #labels and #count are retained while the #event is updated when #/ is called.
+	#
+	#   Alda::Score.new { p c%1/d == c/d%1 }.to_s # (prints "true") => "c/d'1 c/d'1"
+	#
+	# If at first #event is an Alda::Part object,
 	# makes #event a new Alda::Part object.
+	# The meaning is to play the two parts simultaneously.
 	#
 	#   Alda::Score.new { violin_/viola_/cello_; e; f; g}.play
 	#   # (plays notes E, F, G with three instruments simultaneously)
@@ -145,12 +196,15 @@ class Alda::EventContainer < Alda::Event
 		self
 	end
 	
+	##
+	# :call-seq:
+	#   to_alda_code() -> String
+	#
+	# Overrides Alda::Event#to_alda_code.
 	def to_alda_code
 		result = @event.to_alda_code
-		unless @labels.empty?
-			result.concat ?', @labels.map(&:to_alda_code).join(?,)
-		end
-		result.concat ?*, @count.to_alda_code if @count
+		result.concat ?', @labels.map(&:to_alda_code).join(?,) unless @labels.empty?
+		result.concat ?*, @count.to_alda_code if @count != 1
 		result
 	end
 	
@@ -163,6 +217,7 @@ class Alda::EventContainer < Alda::Event
 	# For examples, see #%.
 	def * num
 		@count = (@count || 1) * num
+		check_in_chord
 		self
 	end
 	
@@ -177,28 +232,86 @@ class Alda::EventContainer < Alda::Event
 	def % labels
 		labels = [labels] unless labels.is_a? Array
 		@labels.replace labels.to_a
+		check_in_chord
 		self
 	end
 	
+	def event= event # :nodoc:
+		@event = event.tap { on_containing }
+	end
+	
 	##
 	# :call-seq:
-	#   event=(event) -> event
+	#   check_in_chord() -> true or false
 	#
-	# Sets #event and invokes #on_containing.
-	def event= event
-		@event = event
-		on_containing
-		@event
+	# This method is called in #%, #*, and #parent=.
+	# It checks if #parent is an Alda::Chord and warns about potential dangers.
+	# Returns true if there is no danger, and false otherwise.
+	#
+	# Because \Alda 2 does not support specifying alternative endings inside a chord
+	# (something like <tt>a'1/b</tt>)
+	# ({alda-lang/alda#383}[https://github.com/alda-lang/alda/issues/383#issuecomment-886084486]),
+	# this method will warn about this if such thing happens and we are using \Alda 2.
+	#
+	#   Alda.v2!
+	#   Alda::Score.new { x{a%1;b} }.to_s # (warns) => "a'1/b"
+	#
+	# This method will warn about repetitions inside a chord in both generations
+	# because the resultant \Alda code is not valid.
+	#
+	#   Alda::Score.new { x{a*2;b} }.to_s # (warns) => "a*2/b"
+	def check_in_chord
+		if @parent.is_a?(Alda::Event) && @parent.is_event_of?(Alda::Chord)
+			Alda::Utils.warn 'alternative endings in chord not allowed in v2' if Alda.v2? && !@labels&.empty?
+			Alda::Utils.warn 'repetitions in chord not allowed' if @count && @count != 1
+			false
+		else
+			true
+		end
+	end
+	
+	##
+	# :call-seq:
+	#  parent=(event) -> event
+	#
+	# Overrides Alda::Event#parent=.
+	# Sets the Alda::Event#parent of the container as well as that of #event.
+	def parent= event
+		@parent = event
+		check_in_chord
+		@event.parent = event
 	end
 	
 	##
 	# A callback invoked in #event= and ::new.
 	def on_containing
-		if @event
-			@event.container = self
-			@event.parent = @parent
-			@event.on_contained
-		end
+		return unless @event
+		@event.container = self
+		@event.parent = @parent
+		@event.on_contained
+	end
+	
+	##
+	# :call-seq:
+	#   is_event_of?(klass) -> true or false
+	#
+	# Overrides Alda::Event#is_event_of?.
+	# Whether it is an event of the given class (+klass+)
+	# or the contained event is.
+	def is_event_of? klass
+		super || @event.is_event_of?(klass)
+	end
+	
+	##
+	# :call-seq:
+	#   container == other -> true or false
+	#
+	# Overrides Alda::Event#==.
+	# Returns true if +other+ is an Alda::EventContainer object
+	# and #event, #count and #labels are all equal (using <tt>==</tt>).
+	def == other
+		super || other.is_a?(Alda::EventContainer) &&
+				@event == other.event && @count == other.count && @labels == other.labels
 	end
 	
 	##
@@ -221,15 +334,14 @@ class Alda::EventContainer < Alda::Event
 	#   end
 	def method_missing(...)
 		result = @event.__send__(...)
-		result = self if result == @event
-		result
+		result == @event ? self : result
 	end
 end
 
 ##
 # An inline lisp event. An Alda::EventContainer containing
 # an Alda::InlineLisp can be derived using event list
-# sugar. See Alda::EventList#method_missing.
+# sugar (see Alda::EventList#method_missing) or by using Alda::EventList#l.
 #
 # Sometimes you need help from Alda::LispIdentifier.
 #
@@ -253,6 +365,9 @@ end
 #   end
 #
 # You can operate a score by purely using inline lisp events.
+# The following example only works in \Alda 1 due to breaking changes in \Alda 2
+# ({alda-lang/alda#483}[https://github.com/alda-lang/alda/issues/483],
+# {alda-lang/alda#484}[https://github.com/alda-lang/alda/issues/484]).
 #
 #   Alda::Score.new do
 #     part 'piano'
@@ -288,10 +403,11 @@ end
 #
 # If you want, you can generate lisp codes using ruby.
 #
+#   Alda.generation = :v1
 #   Alda::Score.new do
 #     println reduce _into_, {}, [{dog: 'food'}, {cat: 'chow'}]
 #   end.save 'temp.clj'
-#   `clj temp.clj` # => "[[:dog food] [:cat chow]]\n"
+#   `clojure temp.clj` # => "{:dog food, :cat chow}\n"
 class Alda::InlineLisp < Alda::Event
 	
 	##
@@ -313,18 +429,37 @@ class Alda::InlineLisp < Alda::Event
 	#
 	# The underlines "_" in +head+ will be converted to hyphens "-".
 	def initialize head, *args
-		@head = head.to_s.gsub ?_, ?-
+		super()
+		@head = Alda::Utils.snake_to_slug head
 		@args = args
 	end
 	
+	##
+	# :call-seq:
+	#   to_alda_code() -> String
+	#
+	# Overrides Alda::Event#to_alda_code.
 	def to_alda_code
 		"(#{head} #{args.map(&:to_alda_code).join ' '})"
 	end
 	
+	##
+	# See Alda::Event#on_contained.
 	def on_contained
 		super
 		@args.detach_from_parent
 	end
+	
+	##
+	# :call-seq:
+	#   inline_lisp == other -> true or false
+	#
+	# Overrides Alda::Event#==.
+	# Returns true if +other+ is an Alda::InlineLisp
+	# and has the same #head and #args as +inline_lisp+ (using <tt>==</tt>).
+	def == other
+		super || other.is_a?(Alda::InlineLisp) && @head == other.head && @args == other.args
+	end
 end
 
 ##
@@ -373,6 +508,7 @@ class Alda::Note < Alda::Event
 	# slur if 2,
 	# both natural and slur if 3.
 	def initialize pitch, duration
+		super()
 		@pitch = pitch.to_s
 		@duration = duration.to_s.tr ?_, ?~
 		case @duration[-1]
@@ -431,11 +567,27 @@ class Alda::Note < Alda::Event
 		self
 	end
 	
+	##
+	# :call-seq:
+	#   to_alda_code() -> String
+	#
+	# Overrides Alda::Event#to_alda_code.
 	def to_alda_code
 		result = @pitch + @duration
 		result.concat ?*, @count.to_alda_code if @count
 		result
 	end
+	
+	##
+	# :call-seq:
+	#   note == other -> true or false
+	#
+	# Overrides Alda::Event#==.
+	# Returns true if +other+ is an Alda::Note
+	# and has the same #pitch and #duration as +note+ (using <tt>==</tt>).
+	def == other
+		super || other.is_a?(Alda::Note) && @pitch == other.pitch && @duration == other.duration
+	end
 end
 
 ##
@@ -463,12 +615,29 @@ class Alda::Rest < Alda::Event
 	#
 	# Underlines "_" in +duration+ will be converted to tildes "~".
 	def initialize duration
+		super()
 		@duration = duration.to_s.tr ?_, ?~
 	end
 	
+	##
+	# :call-seq:
+	#   to_alda_code() -> String
+	#
+	# Overrides Alda::Event#to_alda_code.
 	def to_alda_code
 		?r + @duration
 	end
+	
+	##
+	# :call-seq:
+	#   rest == other -> true or false
+	#
+	# Overrides Alda::Event#==.
+	# Returns true if +other+ is an Alda::Rest
+	# and has the same #duration as +rest+ (using <tt>==</tt>).
+	def == other
+		super || other.is_a?(Alda::Rest) && @duration == other.duration
+	end
 end
 
 ##
@@ -501,6 +670,7 @@ class Alda::Octave < Alda::Event
 	#
 	# Creates an Alda::Octave.
 	def initialize num
+		super()
 		@num = num.to_s
 		@up_or_down = 0
 	end
@@ -531,6 +701,11 @@ class Alda::Octave < Alda::Event
 		self
 	end
 	
+	##
+	# :call-seq:
+	#   to_alda_code() -> String
+	#
+	# Overrides Alda::Event#to_alda_code.
 	def to_alda_code
 		case @up_or_down <=> 0
 		when 0
@@ -541,6 +716,17 @@ class Alda::Octave < Alda::Event
 			?< * -@up_or_down
 		end
 	end
+	
+	##
+	# :call-seq:
+	#   octave == other -> true or false
+	#
+	# Overrides Alda::Event#==.
+	# Returns true if +other+ is an Alda::Octave
+	# and has the same #num and #up_or_down as +octave+ (using <tt>==</tt>).
+	def == other
+		super || other.is_a?(Alda::Octave) && @num == other.num && @up_or_down == other.up_or_down
+	end
 end
 
 ##
@@ -574,12 +760,39 @@ class Alda::Chord < Alda::Event
 	#   Alda::Score.new { piano_; x { c; -e; g } }.play
 	#   # (plays chord Cm)
 	def initialize *events, &block
+		events.each { _1.parent = self if _1.is_a? Alda::Event }
 		@events = events
 		super &block
 	end
 	
+	##
+	# :call-seq:
+	#   to_alda_code() -> String
+	#
+	# Overrides Alda::Event#to_alda_code.
+	#
+	# Behaves differently for \Alda 1 and \Alda 2:
+	# because \Alda 2 does not allow octave changes as part of a chord
+	# (something like <tt>a/>/c</tt>, and we have to write <tt>a>/c</tt> or <tt>a/>c</tt> instead)
+	# ({alda-lang/alda#383}[https://github.com/alda-lang/alda/issues/383]),
+	# the code generated by this method will omit the slash before an octave change.
+	#
+	#   Alda.generation = :v1
+	#   Alda::Score.new { a/o!/c; a/o5/c }.to_s # => "a/>/c a/o5/c"
+	#   Alda.generation = :v2
+	#   Alda::Score.new { a/o!/c; a/o5/c }.to_s # => "a>/c a o5/c"
 	def to_alda_code
-		events_alda_codes ?/
+		return events_alda_codes ?/ if Alda.v1?
+		@events.each_with_index.with_object '' do |(event, i), result|
+			if i == 0
+				# concat nothing
+			elsif event.is_event_of? Alda::Octave
+				result.concat ' ' unless event.num.empty?
+			else
+				result.concat '/'
+			end
+			result.concat event.to_alda_code
+		end
 	end
 end
 
@@ -631,10 +844,16 @@ class Alda::Part < Alda::Event
 	#
 	# Creates an Alda::Part.
 	def initialize names, arg = nil
-		@names = names.map { |name| name.to_s.tr ?_, ?- }
+		super()
+		@names = names.map { Alda::Utils.snake_to_slug _1 }
 		@arg = arg
 	end
 	
+	##
+	# :call-seq:
+	#   to_alda_code() -> String
+	#
+	# Overrides Alda::Event#to_alda_code.
 	def to_alda_code
 		result = @names.join ?/
 		result.concat " \"#{@arg}\"" if @arg
@@ -657,17 +876,26 @@ class Alda::Part < Alda::Event
 		str[-1] = ''
 		@names.last.concat ?., str
 		if args.size == 1
-			unless @container
-				@container = Alda::EventContainer.new nil, @parent
-				@parent.events.delete self
-				@parent.push @container
-			end
-			@container.event = Alda::Sequence.join self, args.first.tap(&:detach_from_parent)
-			@container
+			arg = args.first.tap &:detach_from_parent
+			detach_from_parent
+			container = Alda::EventContainer.new Alda::Sequence.join(self, arg), @parent
+			@parent.events.push container
+			container
 		else
 			@container || self
 		end
 	end
+	
+	##
+	# :call-seq:
+	#   part == other -> true or false
+	#
+	# Overrides Alda::Event#==.
+	# Returns true if +other+ is an Alda::Part
+	# and has the same #names and #arg as +part+ (using <tt>==</tt>).
+	def == other
+		super || other.is_a?(Alda::Part) && @names == other.names && @arg == other.arg
+	end
 end
 
 ##
@@ -690,12 +918,29 @@ class Alda::Voice < Alda::Event
 	#
 	# Creates an Alda::Voice.
 	def initialize num
+		super()
 		@num = num
 	end
 	
+	##
+	# :call-seq:
+	#   to_alda_code() -> String
+	#
+	# Overrides Alda::Event#to_alda_code.
 	def to_alda_code
 		?V + num + ?:
 	end
+	
+	##
+	# :call-seq:
+	#   voice == other -> true or false
+	#
+	# Overrides Alda::Event#==.
+	# Returns true if +other+ is an Alda::Voice
+	# and has the same #num as +voice+ (using <tt>==</tt>).
+	def == other
+		super || other.is_a?(Alda::Voice) && @num == other.num
+	end
 end
 
 ##
@@ -731,9 +976,25 @@ class Alda::Cram < Alda::Event
 		super &block
 	end
 	
+	##
+	# :call-seq:
+	#   to_alda_code() -> String
+	#
+	# Overrides Alda::Event#to_alda_code.
 	def to_alda_code
 		"{#{events_alda_codes}}#@duration"
 	end
+	
+	##
+	# :call-seq:
+	#   cram == other -> true or false
+	#
+	# Overrides Alda::EventList#==.
+	# Returns true if the super method returns true and +other+
+	# has the same #duration as +cram+ (using <tt>==</tt>).
+	def == other
+		super && @duration == other.duration
+	end
 end
 
 ##
@@ -760,12 +1021,29 @@ class Alda::Marker < Alda::Event
 	#
 	# Underlines in +name+ is converted to hyphens.
 	def initialize name
-		@name = name.to_s.tr ?_, ?-
+		super()
+		@name = Alda::Utils.snake_to_slug name
 	end
 	
+	##
+	# :call-seq:
+	#   to_alda_code() -> String
+	#
+	# Overrides Alda::Event#to_alda_code.
 	def to_alda_code
 		?% + @name
 	end
+	
+	##
+	# :call-seq:
+	#   marker == other -> true or false
+	#
+	# Overrides Alda::Event#==.
+	# Returns true if +other+ is an Alda::Marker
+	# and has the same #name as +marker+ (using <tt>==</tt>).
+	def == other
+		super || other.is_a?(Alda::Marker) && @name == other.name
+	end
 end
 
 ##
@@ -789,12 +1067,29 @@ class Alda::AtMarker < Alda::Event
 	#
 	# Underlines "_" in +name+ is converted to hyphens "-".
 	def initialize name
-		@name = name.to_s.tr ?_, ?-
+		super()
+		@name = Alda::Utils.snake_to_slug name
 	end
 	
+	##
+	# :call-seq:
+	#   to_alda_code() -> String
+	#
+	# Overrides Alda::Event#to_alda_code.
 	def to_alda_code
 		?@ + @name
 	end
+	
+	##
+	# :call-seq:
+	#   at_marker == other -> true or false
+	#
+	# Overrides Alda::Event#==.
+	# Returns true if +other+ is an Alda::AtMarker
+	# and has the same #name as +at_marker+ (using <tt>==</tt>).
+	def == other
+		super || other.is_a?(Alda::AtMarker) && @name == other.name
+	end
 end
 
 ##
@@ -814,7 +1109,8 @@ end
 #     p((c d e f).event.class) # => Alda::Sequence
 #   end
 #
-# The effects of the two examples above are the same.
+# The effects of the two examples above are technically the same
+# although actually the generated list of events are slightly different.
 class Alda::Sequence < Alda::Event
 	include Alda::EventList
 	
@@ -829,6 +1125,8 @@ class Alda::Sequence < Alda::Event
 	#   [a].flatten # => [#<Object:...>]
 	module RefineFlatten
 		refine Array do
+			##
+			# Overrides Array#flatten.
 			def flatten
 				each_with_object [] do |element, result|
 					if element.is_a? Array
@@ -842,8 +1140,13 @@ class Alda::Sequence < Alda::Event
 	end
 	using RefineFlatten
 	
+	##
+	# :call-seq:
+	#   to_alda_code() -> String
+	#
+	# Overrides Alda::Event#to_alda_code.
 	def to_alda_code
-		@events.to_alda_code
+		"[#{events_alda_codes}]"
 	end
 	
 	##
@@ -857,7 +1160,7 @@ class Alda::Sequence < Alda::Event
 	def self.join *events
 		new do
 			@events = events.map do |event|
-				while event.is_a?(Alda::EventContainer) && !event.count && event.labels.empty?
+				while event.is_a?(Alda::EventContainer) && event.count == 1 && event.labels.empty?
 					event = event.event
 				end
 				event.is_a?(Alda::Sequence) ? event.events : event
@@ -894,10 +1197,6 @@ class Alda::SetVariable < Alda::Event
 	# The name of the variable.
 	attr_accessor :name
 	
-	##
-	# The events passed to it using arguments instead of a block.
-	attr_reader :original_events
-	
 	##
 	# :call-seq:
 	#   new(name, *events, &block) -> Alda::SetVariable
@@ -905,21 +1204,38 @@ class Alda::SetVariable < Alda::Event
 	# Creates an Alda::SetVariable.
 	def initialize name, *events, &block
 		@name = name.to_sym
-		@original_events = events
-		@events = events.clone
+		@events = events
 		super &block
 	end
 	
 	##
+	# :call-seq:
+	#   to_alda_code() -> String
+	#
 	# Specially, the returned value ends with a newline "\\n".
+	# Overrides Alda::Event#to_alda_code.
 	def to_alda_code
 		"#@name = #{events_alda_codes}\n"
 	end
 	
+	##
+	# See Alda::Event#on_contained.
 	def on_contained
 		super
 		@parent.variables.add @name
-		@original_events.detach_from_parent
+		@events.detach_from_parent [self.class]
+		@events.each { _1.parent = self if _1.is_a? Alda::Event }
+	end
+	
+	##
+	# :call-seq:
+	#   set_variable == other -> true or false
+	#
+	# Overrides Alda::EventList#==.
+	# Returns true if the super method returns true and +other+
+	# has the same #name as +set_variable+ (using <tt>==</tt>).
+	def == other
+		super && @name == other.name
 	end
 end
 
@@ -942,12 +1258,29 @@ class Alda::GetVariable < Alda::Event
 	#
 	# Creates an Alda::GetVariable.
 	def initialize name
+		super()
 		@name = name
 	end
 	
+	##
+	# :call-seq:
+	#   to_alda_code() -> String
+	#
+	# Overrides Alda::Event#to_alda_code.
 	def to_alda_code
 		@name.to_s
 	end
+	
+	##
+	# :call-seq:
+	#   get_variable == other -> true or false
+	#
+	# Overrides Alda::Event#==.
+	# Returns true if +other+ is an Alda::GetVariable
+	# and has the same #name as +get_variable+ (using <tt>==</tt>).
+	def == other
+		super || other.is_a?(Alda::GetVariable) && @name == other.name
+	end
 end
 
 ##
@@ -974,10 +1307,69 @@ class Alda::LispIdentifier < Alda::Event
 	#
 	# Underlines "_" in +name+ is converted to hyphens "-".
 	def initialize name
-		@name = name.tr ?_, ?-
+		super()
+		@name = Alda::Utils.snake_to_slug name
 	end
 	
+	##
+	# :call-seq:
+	#   to_alda_code() -> String
+	#
+	# Overrides Alda::Event#to_alda_code.
 	def to_alda_code
 		@name
 	end
+	
+	##
+	# :call-seq:
+	#   lisp_identifier == other -> true or false
+	#
+	# Overrides Alda::Event#==.
+	# Returns true if +other+ is an Alda::LispIdentifier
+	# and has the same #name as +lisp_identifier+ (using <tt>==</tt>).
+	def == other
+		super || other.is_a?(Alda::LispIdentifier) && @name == other.name
+	end
+end
+
+##
+# A special event that contains raw \Alda codes.
+# This is a walkaround for the absence of <tt>alda-code</tt> function in \Alda 2
+# ({alda-lang/alda#379}[https://github.com/alda-lang/alda/issues/379]).
+# You can use Alda::EventList#raw to add an Alda::Raw event to the event list.
+class Alda::Raw < Alda::Event
+	
+	##
+	# The raw \Alda codes.
+	attr_accessor :contents
+	
+	##
+	# :call-seq:
+	#   new(code) -> Alda::Raw
+	#
+	# Creates an Alda::Raw.
+	def initialize contents
+		super()
+		@contents = contents
+	end
+	
+	##
+	# :call-seq:
+	#   to_alda_code() -> String
+	#
+	# Overrides Alda::Event#to_alda_code.
+	def to_alda_code
+		@contents
+	end
+	
+	##
+	# :call-seq:
+	#   raw == other -> true or false
+	#
+	# Overrides Alda::Event#==.
+	# Returns true if +other+ is an Alda::Raw
+	# and has the same #contents as +raw+ (using <tt>==</tt>).
+	def == other
+		super || other.is_a?(Alda::Raw) && @contents == other.contents
+	end
 end