alda-rb 0.1.2 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b1a40fb3e4fa0d3ae035cbaf901b0fa209676743cd36b31168b9e04af9bf6aaf
-  data.tar.gz: df7faaf786abc7e90260864d5abaa275c3702f81b7ad9b114b287ca940d07dee
+  metadata.gz: fa068d3caf9d89e4c0bfb90b2bc0800f5fe2824cbd9d3674be7a4853a55e5b25
+  data.tar.gz: ec0c8aa26fd9f789d2bbcaef2502890a21223036779e29704eb8c30ebf08b27f
 SHA512:
-  metadata.gz: 7378bb4040c96cf509ea800412000f5f1d676a5e2d3e62016906c928c9991fc6f2fd0358989e5ea0d0e8526767fcbc8d8942ccbb9f7742fe2106f7ab44d0596f
-  data.tar.gz: bfb477c6af6d034c3b4b05ddf8a5e73fd2887584eae8b959487c72dddcd7deda77617e2c6b3392b2cc71574ac81a05df9825cd686a7de9f3eb79e6d8731ddb09
+  metadata.gz: 98860e1ec9598d9935bb59371d8621be062dcab44f524ada4ae1a1a5460f4c85bd440429b38bbdc74032fc19f18cfc0787f575f60593f1e1abceedc5d2ad06c1
+  data.tar.gz: 83a071c40c8e82a5d57a609c668d5f5886d02be45b1656f2a89946208eb590af940e292b550cefbcf4ed930000c1a46b518ec2a204d7f0bca8cb07293911727c

data/Gemfile

@@ -1,7 +1,7 @@
 source "https://rubygems.org"
 
-# Specify your gem's dependencies in alda-rb-rb.gemspec
 gemspec
 
 gem "rake", "~> 12.0"
 gem "minitest", "~> 5.0"
+gem "colorize"

data/alda-rb.gemspec

@@ -6,19 +6,19 @@ Gem::Specification.new do |spec|
   spec.name          = "alda-rb"
   spec.version       = Alda::VERSION
   spec.authors       = ["Ulysses Zhan"]
-  spec.email         = ["2938747508@qq.com"]
+  spec.email         = ["UlyssesZhan@gmail.com"]
 
   spec.summary       = %q{A Ruby library for live-coding music with Alda.}
   # spec.description   = %q{TODO: Write a longer description or delete this line.}
   spec.homepage      = "https://github.com/UlyssesZh/alda-rb"
   spec.license       = "MIT"
-  spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.7.0")
 
   # spec.metadata["allowed_push_host"] = "TODO: Set to 'http://mygemserver.com'"
 
   spec.metadata["homepage_uri"] = spec.homepage
   spec.metadata["source_code_uri"] = spec.homepage
-  # spec.metadata["changelog_uri"] = "TODO: Put your gem's CHANGELOG.md URL here."
+  spec.metadata["changelog_uri"] = "https://github.com/UlyssesZh/alda-rb/releases"
 
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.

data/examples/alternate_endings.rb

@@ -9,18 +9,18 @@ Alda::Score.new do
 	vibraphone_ 'vibes-1'
 	panning 10
 	s do
-		a; b8; +o; d; -o; b; g; b; +o; c
-		e4; -o; a; +o; c; -o; g
-		s{ g; +o; g8; f; e; c; -o; a4 }%1..2
-		s{ b8; +o; d; g2_4 }%3
+		a b8 o! d o? b g b o! c
+		e4 o? a o! c o? g
+		(g o! g8 f e c o? a4) % (1..2)
+		(b8 o! d g2_4) % 3
 	end * 3
 	
 	vibraphone_ 'vibes-2'
 	panning 90
 	s do
-		a; +o; e; -o; a; r
-		b; r; b; r
-		s{ g; r; +o; g; -o; g }%1..2
-		s{ +o; d; r; a; g }%3
+		a o! e o? a r
+		b r b r
+		(g r o! g o? g) % (1..2)
+		(o! d r a g) % 3
 	end * 3
 end.play

data/examples/bwv846_prelude.rb

@@ -10,16 +10,18 @@ require 'alda-rb'
 # sheet music:
 # http://www.freesheetpianomusic.com/bach/content/Well-Tempered%20Clavier_Book_1/Prelude%20and%20Fugue%20No.1%20C%20major%20BWV%20846.pdf
 
-include Alda
-
-Score.new do
-	def Note.absolute event_list, pitch, duration
+class Alda::Sequence
+	def absolute pitch, duration
 		/(?<letter>[a-g][-+_]*)(?<octave>\d*)/ =~ pitch
-		octave = @last_octave ||= '4' if octave.empty?
-		event_list.events.push new "o#{@last_octave = octave} #{letter}", duration
+		octave = @@last_octave ||= '4' if octave.empty?
+		result = Alda::Note.new "o#{@@last_octave = octave} #{letter}", duration
+		@events.push result
+		result
 	end
-	
-	piano_; tempo 60
+end
+
+Alda::Score.new do
+	piano_ tempo 60
 	%w[
 		c e g c5 e
 		c4 d a d5 f
@@ -55,9 +57,9 @@ Score.new do
 		c2 c3 g b- e4
 	].each_slice 5 do |n1, n2, *notes|
 		s do
-			v1; Note.absolute self, n1, '2'
-			v2; r16; Note.absolute self, n2, '4..'
-			v3; r8; s{ notes.each { Note.absolute self, _1, '16' } }*2
+			v1 absolute n1, '2'
+			v2 r16 absolute n2, '4..'
+			v3 r8 s{ notes.each { absolute _1, '16' } }*2
 		end * 2
 	end
 	alda_code <<~ENDING

data/examples/clapping_music.rb

@@ -12,14 +12,13 @@ require 'alda-rb'
 
 Alda::Score.new do
 	pattern = %i[clap clap clap rest clap clap rest clap rest clap clap rest]
-	pattern.define_singleton_method(:round_shift) { push shift }
 	Alda::Sequence.class_exec do
 		define_method(:clap) { +d }; define_method(:rest) { r }
 		define_method(:play) { pattern.each { __send__ _1 } }
 	end
 	
 	tempo! 172
-	midi_percussion_; o2; set_note_length 8
-	v1; s{ play }*(12*13)
-	v2; 13.times { s{ play; pattern.round_shift }*12 }
+	midi_percussion_ o2 set_note_length 8
+	v1; s{ play }*12*13
+	v2; 13.times { s{ play; pattern.rotate! }*12 }
 end.play

data/examples/dot_accessor.rb

@@ -4,5 +4,5 @@ require 'alda-rb'
 
 Alda::Score.new do
 	violin_/viola_/cello_('strings'); g1_1_1
-	strings_.cello_; -o; c1_1_1
+	strings_.cello_ o? c1_1_1
 end.play

data/examples/entropy.rb

@@ -13,8 +13,8 @@ Alda::Score.new do
 		if rand < REST_RATE
 			pause ms.()
 			octave rand OCTAVE_UPPER
-			note pitch("abcdefg"[rand 7].to_sym,
-			           %i[sharp flat natural][rand 3]), ms.()
+			note pitch('abcdefg'[rand 7].to_sym,
+			           %i[sharp flat natural].sample), ms.()
 		end
 	end
 	

data/examples/hanon.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'alda-rb'
+
+SYMBOLS = %i[c d e f g a b]
+class Solfege
+	attr_accessor :i, :octave
+	def initialize i, octave
+		@i = i
+		@octave = octave
+		update
+	end
+	def update
+		old_octave = @octave
+		@octave, @i = @i.divmod SYMBOLS.size
+		@octave += old_octave
+	end
+	def letter
+		SYMBOLS[@i]
+	end
+end
+
+class Alda::Sequence
+	def play_solfege solfege
+		v1; octave solfege.octave; note pitch solfege.letter
+		v2; octave solfege.octave-1; note pitch solfege.letter
+	end
+	def play_hanon ary, octave, delta
+		solfeges = ary.map { Solfege.new _1, octave }
+		14.times do
+			solfeges.each do |solfege|
+				play_solfege solfege
+				solfege.i += delta
+				solfege.update
+			end
+		end
+	end
+end
+
+Alda::Score.new do
+	piano_; set_note_length 16
+	def play_hanon ary1, ary2
+		s do
+			play_hanon ary1, 3, 1
+			play_hanon ary2, 5, -1
+		end * 2
+	end
+	play_hanon [0, 2, 3, 4, 5, 4, 3, 2], [4, 2, 1, 0, -1, 0, 1, 2]
+	play_hanon [0, 2, 5, 4, 3, 4, 3, 2], [4, 1, -1, 0, 1, 0, 1, 2]
+	v1; o3; c2; v2; o2; c2
+end.play

data/examples/hello_world.rb

@@ -3,6 +3,5 @@
 require 'alda-rb'
 
 Alda::Score.new do
-	piano_
-	c; d; e; f; g2; g4; f; e; d; c2
+	piano_ c d e f g2 g4 f e d c2
 end.play

data/examples/key_signature.rb

@@ -7,11 +7,11 @@ Alda::Score.new do
 	quant 200
 	
 	key_signature 'f+ c+ g+'
-	a8; b; +o; c; d; e; f; g; a; -o
-	a; b; +o; ~c; d; e; ~f; ~g; a; -o
+	a8 b o! c d e f g a o?
+	a b o! c_ d e f_ g_ a o?
 	
 	key_signature [:g, :minor]
-	g; a; b; +o; +c; d; e; +f; g; -o
+	g a b o! c! d e f! g o?
 	
 	key_signature e: [:flat], b: [:flat]
 	g1_1/b/d

data/examples/midi_note_numbers.rb

@@ -5,5 +5,5 @@ require 'alda-rb'
 Alda::Score.new do
 	midi_calliope_lead_
 	set_note_length 8
-	(10...100).step(10) { |n| note midi_note n }
+	(10...100).step(10) { note midi_note _1 }
 end.play

data/examples/modes2.rb

@@ -7,6 +7,6 @@ Alda::Score.new do
 	piano_
 	%i[ionian dorian phrygian lydian mixolydian aeolian locrian].each do |mode|
 		key_sig [:c, mode]
-		o4; c4; d8; e; f; g; a; b; +o; c1
+		o4 c4 d8 e f g a b o! c1
 	end
 end.play

data/examples/multi_poly.rb

@@ -3,12 +3,12 @@
 require 'alda-rb'
 
 Alda::Score.new do
-	piano_; set_duration 4
-	harp_;  set_duration 2; octave 3
+	piano_ set_duration 4
+	harp_  set_duration 2; octave 3
 	
 	piano_/harp_
-	t { e; f; g }; t { a; b; +o; c }
+	t{ e f g }; t{ a b o! c }
 	
 	harp_
-	t { d; e; f }; t { g; a; b }
+	t{ d e f }; t { g a b }
 end.play

data/examples/nesting.rb

@@ -6,21 +6,21 @@ Alda::Score.new do
 	piano_
 	
 	v1
-	c8; d; e; f; g2_
+	c8 d e f g2_
 	
 	v2
-	s{ c8; d }*2; e
-	f; g*3
+	(c8 d)*2; e
+	f g*3
 	t do
-		t{ c; c }
+		t{ c c }
 		s{ g/e/c; s{ d }*2 }
-		s{ c; d }*5
+		(c d)*5
 	end * 5
-	a/b/c; b; c/e
+	a/b/c; b c/e
 	
 	v3
-	a8; b; +o; c2_
+	a8 b o! c2_
 	
 	clarinet_
-	a2; e
+	a2 e
 end.play

data/examples/phase.rb

@@ -10,5 +10,5 @@ Alda::Score.new do
 		tempo tempo
 	end
 	tempos.keys.lazy.map { __send__ _1 }.inject :/
-	s{ e8; f; g }*99
+	(e8 f g)*99
 end.play

data/examples/seconds_and_milliseconds.rb

@@ -5,6 +5,6 @@ require 'alda-rb'
 Alda::Score.new do
 	accordion_
 	c500ms/e/g
-	c1s/f/a
+	x{ c1s; f; a }
 	c2s/e/g
 end.play

data/examples/variables.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'alda-rb'
+
+Alda::Score.new do
+	tempo! 160
+	
+	riffA__ f8 f g! a o! c c d c o?
+	riffB__ b8? b? o! c! d f f g f o?
+	riffC__ o! c8 c d! e g g a g o?
+	riffD do
+		f8 f g! a o! c c d o? b o!
+		c c o? b? b? a a g g
+	end
+	
+	rockinRiff do
+		riffA*4
+		riffB*2; riffA*2
+		riffC riffB riffD
+	end
+	
+	electric_guitar_distorted_ 'guitar'; o2
+	tenor_saxophone_ 'sax'; o3
+	
+	guitar_/sax_
+	rockinRiff*8
+end.play

data/lib/alda-rb.rb

@@ -1,35 +1,22 @@
+require 'readline'
+require 'set'
+require 'stringio'
+require 'irb/ruby-lex'
 require 'alda-rb/version'
+require 'colorize'
+
+{
+	Array      => -> { "[#{map(&:to_alda_code).join ' '}]" },
+	Hash       => -> { "{#{to_a.reduce(:+).map(&:to_alda_code).join ' '}}" },
+	String     => -> { dump },
+	Symbol     => -> { ?: + to_s },
+	Numeric    => -> { inspect },
+	Range      => -> { "#{first}-#{last}" },
+	TrueClass  => -> { 'true' },
+	FalseClass => -> { 'false' },
+	NilClass   => -> { 'nil' }
+}.each { |klass, block| klass.define_method :to_alda_code, &block }
 
-class Array
-	def to_alda_code
-		"[#{map(&:to_alda_code).join ' '}]"
-	end
-end
-class Hash
-	def to_alda_code
-		"{#{to_a.reduce(:+).map(&:to_alda_code).join ' '}}"
-	end
-end
-class String
-	def to_alda_code
-		inspect
-	end
-end
-class Symbol
-	def to_alda_code
-		?: + to_s
-	end
-end
-class Numeric
-	def to_alda_code
-		inspect
-	end
-end
-class Range
-	def to_alda_code
-		"#{first}-#{last}"
-	end
-end
 class Proc
 	# Runs +self+ for +n+ times.
 	def * n
@@ -41,19 +28,35 @@ class Proc
 	end
 end
 
+class StringIO
+	# Equivalent to #string.
+	def to_s
+		string
+	end
+end
+
+module Kernel
+	# Runs the alda command.
+	# Does not capture output.
+	# @example
+	#   alda 'version'
+	#   alda 'play', '-c', 'piano: a'
+	#   alda 'repl'
+	def alda *args
+		system Alda.executable, *args
+	end
+end
+
 # The module serving as a namespace.
 module Alda
 	
-	# The path to the +alda+ executable.
+	# The array of available subcommands of alda executable.
 	#
-	# The default value is <tt>"alda"</tt>,
-	# which will depend on your PATH.
-	singleton_class.attr_accessor :executable
-	@executable = 'alda'
-	
-	# The method give Alda# ability to invoke +alda+ at the command line,
-	# using +name+ as subcommand and +args+ as arguments.
-	# +opts+ are converted to command line options.
+	# Alda# is able to invoke +alda+ at the command line.
+	# The subcommand is the name of the method invoked upon Alda#.
+	#
+	# The first argument (a hash) is interpreted as the options.
+	# The keyword arguments are interpreted as the subcommand options.
 	#
 	# The return value is the string output by the command in STDOUT.
 	#
@@ -63,43 +66,72 @@ module Alda
 	#   # => "Client version: 1.4.0\nServer version: [27713] 1.4.0\n"
 	#   Alda.parse code: 'bassoon: o3 c'
 	#   # => "{\"chord-mode\":false,\"current-instruments\":...}\n"
-	#   Alda.sandwich
-	#   # => Alda::CommandLineError (Expected a command, got sandwich)
-	def self.method_missing name, *args, **opts
-		name = name.to_s.gsub ?_, ?-
-		args.concat opts.map { |key, val|
-			["--#{key.to_s.gsub ?_, ?-}", val.to_s]
-		}.flatten
-		output = IO.popen [executable, name, *args], &:read
-		raise CommandLineError.new $?, output if $?.exitstatus.nonzero?
-		output
+	COMMANDS = %i[
+		help update repl up start_server init down stop_server
+		downup restart_server list status version play stop parse
+		instruments export
+	].freeze
+	
+	COMMANDS.each do |command|
+		define_method command do |*args, **opts|
+			block = ->key, val do
+				next unless val
+				args.push "--#{key.to_s.tr ?_, ?-}"
+				args.push val.to_s unless val == true
+			end
+			# executable
+			args.unshift Alda.executable
+			args.map! &:to_s
+			# options
+			Alda.options.each &block
+			# subcommand
+			args.push command.to_s
+			# subcommand options
+			opts.each &block
+			# subprocess
+			IO.popen(args, &:read).tap do
+				raise CommandLineError.new $?, _1 if $?.exitstatus.nonzero?
+			end
+		end
 	end
 	
+	# The path to the +alda+ executable.
+	#
+	# The default value is <tt>"alda"</tt>,
+	# which will depend on your PATH.
+	singleton_class.attr_accessor :executable
+	@executable = 'alda'
+	
+	singleton_class.attr_reader :options
+	@options = {}
+	
 	# @return Whether the alda server is up.
-	def self.up?
+	def up?
 		status.include? 'up'
 	end
 	
 	# @return Whether the alda server is down.
-	def self.down?
+	def down?
 		status.include? 'down'
 	end
 	
-	# The error raised when one tries to run a non-existing subcommand
-	# of +alda+.
-	class CommandLineError < Exception
-		
-		# The <tt>Process::Status</tt> object representing the status of
-		# the process that runs +alda+ command.
-		attr_accessor :status
-		
-		# Create a CommandLineError# object.
-		# @param status The status of the process running +alda+ command.
-		# @param msg The exception message.
-		def initialize status, msg = nil
-			super msg
-			@status = status
-		end
+	module_function :up?, :down?, *COMMANDS
+	
+	# Start a REPL session.
+	def self.repl
+		REPL.new.run
+	end
+	
+	# Sets the options of alda command.
+	# Not the subcommand options.
+	def self.[] **opts
+		@options.merge! opts
+		self
+	end
+	
+	# Clears the command line options.
+	def self.clear_options
+		@options.clear
 	end
 	
 	# Including this module can make your class have the ability
@@ -111,35 +143,46 @@ module Alda
 		# most of which are EventContainer# objects.
 		attr_accessor :events
 		
+		# The set containing the available variable names.
+		attr_accessor :variables
+		
+		def on_contained
+			instance_eval &@block if @block
+		end
+		
 		# Make the object have the ability to appending its +events+
 		# conveniently.
 		#
 		# Here is a list of sugar. When the name of a method meets certain
 		# condition, the method is regarded as an event appended to +events+.
 		#
-		# 1. Starting with 2 lowercase letters and
+		# 1. Ending with 2 underlines: set variable. See SetVariable#.
+		#
+		# 2. Starting with 2 lowercase letters and
 		#    ending with underline character: instrument. See Part#.
 		#
-		# 2. Starting with 2 lowercase letters: inline lisp code.
-		#    See InlineLisp#.
+		# 3. Starting with 2 lowercase letters: inline lisp code,
+		#    set variable, or get variable.
+		#    One of the above three is chosen intelligently.
+		#    See InlineLisp#, SetVariable#, GetVariable#.
 		#
-		# 3. Starting with "t": CRAM. See Cram#.
+		# 4. Starting with "t": CRAM. See Cram#.
 		#
-		# 4. Starting with one of "a", "b", ..., "g": note. See Note#.
+		# 5. Starting with one of "a", "b", ..., "g": note. See Note#.
 		#
-		# 5. Starting with "r": rest. See Rest#.
+		# 6. Starting with "r": rest. See Rest#.
 		#
-		# 6. "x": chord. See Chord#.
+		# 7. "x": chord. See Chord#.
 		#
-		# 7. "s": sequence. See Sequence#.
+		# 8. "s": sequence. See Sequence#.
 		#
-		# 8. Starting with "o": octave. See Octave#.
+		# 9. Starting with "o": octave. See Octave#.
 		#
-		# 9. Starting with "v": voice. See Voice#.
+		# 10. Starting with "v": voice. See Voice#.
 		#
-		# 10. Starting with "__" (2 underlines): at marker. See AtMarker#.
+		# 11. Starting with "__" (2 underlines): at marker. See AtMarker#.
 		#
-		# 11. Starting with "_" (underline): marker. See Marker#.
+		# 12. Starting with "_" (underline): marker. See Marker#.
 		#
 		# Notes cannot have dots.
 		# To tie multiple durations, +_+ is used instead of +~+.
@@ -151,29 +194,59 @@ module Alda
 		# @see #initialize.
 		# @return an EventContainer# object.
 		def method_missing name, *args, &block
+			if @parent&.respond_to? name, true
+				return @parent.__send__ name, *args, &block
+			end
+			sequence_sugar = ->event do
+				if args.size == 1
+					joined = args.first
+					unless (got = @events.pop) == (expected = joined)
+						raise OrderError.new expected, got
+					end
+					Sequence.join event, joined
+				else
+					event
+				end
+			end
 			case
-			when /^(?<part>[a-z][a-z].*)_$/         =~ name
-				Part.new [part], args.first
-			when /^[a-z][a-z].*$/                   =~ name
-				InlineLisp.new name, *args
-			when /^t(?<duration>.*)$/               =~ name
+			when /\A(?<head>[a-z][a-z].*)__\z/        =~ name
+				SetVariable.new head, *args, &block
+			when /\A(?<part>[a-z][a-z].*)_\z/         =~ name
+				if args.first.is_a? String
+					Part.new [part], args.first
+				else
+					sequence_sugar.(Part.new [part])
+				end
+			when /\A[a-z][a-z].*\z/                   =~ name
+				if block
+					SetVariable.new name, *args, &block
+				elsif has_variable?(name) && (args.empty? || args.size == 1 && args.first.is_a?(Event))
+					sequence_sugar.(GetVariable.new name)
+				else
+					InlineLisp.new name, *args
+				end
+			when /\At(?<duration>.*)\z/               =~ name
 				Cram.new duration, &block
-			when /^(?<pitch>[a-g])(?<duration>.*)$/ =~ name
-				Note.new pitch, duration
-			when /^r(?<duration>.*)$/               =~ name
-				Rest.new duration
-			when /^x$/                              =~ name
+			when /\A(?<pitch>[a-g])(?<duration>.*)\z/ =~ name
+				sequence_sugar.(Note.new pitch, duration)
+			when /\Ar(?<duration>.*)\z/               =~ name
+				sequence_sugar.(Rest.new duration)
+			when /\Ax\z/                              =~ name
 				Chord.new &block
-			when /^s$/                              =~ name
+			when /\As\z/                              =~ name
 				Sequence.new *args, &block
-			when /^o(?<num>\d*)$/                   =~ name
-				Octave.new num
-			when /^v(?<num>\d+)$/                   =~ name
-				Voice.new num
-			when /^__(?<head>.+)$/                  =~ name
-				AtMarker.new head
-			when /^_(?<head>.+)$/                   =~ name
-				Marker.new head
+			when /\Ao!\z/                             =~ name
+				sequence_sugar.(Octave.new('').tap { _1.up_or_down = 1})
+			when /\Ao\?\z/                            =~ name
+				sequence_sugar.(Octave.new('').tap { _1.up_or_down = -1})
+			when /\Ao(?<num>\d*)\z/                   =~ name
+				sequence_sugar.(Octave.new num)
+			when /\Av(?<num>\d+)\z/                   =~ name
+				sequence_sugar.(Voice.new num)
+			when /\A__(?<head>.+)\z/                  =~ name
+				sequence_sugar.(AtMarker.new head)
+			when /\A_(?<head>.+)\z/                   =~ name
+				sequence_sugar.(Marker.new head)
 			else
 				super
 			end.then do |event|
@@ -181,6 +254,10 @@ module Alda
 			end.tap &@events.method(:push)
 		end
 		
+		def has_variable? name
+			@variables.include?(name) || !!@parent&.has_variable?(name)
+		end
+		
 		# Append the events of another EventList# object here.
 		# This method covers the disadvantage of alda's being unable to
 		# import scores from other files.
@@ -192,18 +269,19 @@ module Alda
 		# @param block to be passed with the EventList# object as +self+.
 		# @example
 		#   Alda::Score.new do
-		#     tempo! 108   # inline lisp
-		#     piano_       # piano part
-		#     o4           # octave 4
-		#     c8; d; e; f  # notes
-		#     g4; g; a; f; g; e; f; d; e; c
-		#     d4_8         # cannot have '~', use '_' instead
-		#     o3 b8 o4 c2
+		#     tempo! 108           # inline lisp
+		#     piano_               # piano part
+		#     o4                   # octave 4
+		#     c8; d; e; f          # notes
+		#     g4 g a f g e f d e c # a sequence
+		#     d4_8                 # cannot have '~', use '_' instead
+		#     o3 b8 o4 c2          # a sequence
 		#   end
 		#   # => #<Alda::Score:0x... @events=[...]>
 		def initialize &block
 			@events ||= []
-			instance_eval &block if block
+			@variables ||= Set.new
+			@block ||= block
 		end
 		
 		# Same as #events
@@ -231,7 +309,6 @@ module Alda
 		#   Alda::Score.new { piano_; c; d; e }.play from: 1
 		#   # (plays only an E note)
 		def play **opts
-			Alda.stop
 			Alda.play code: self, **opts
 		end
 		
@@ -253,9 +330,231 @@ module Alda
 			Alda.export code: self, **opts
 		end
 		
+		# Saves the alda codes into a file.
+		def save filename
+			File.open(filename, 'w') { _1.puts to_s }
+		end
+		
+		# Loads alda codes from a file.
+		def load filename
+			event = InlineLisp.new :alda_code, File.read(filename)
+			@events.push event
+			event
+		end
+		
+		# @return Alda codes.
 		def to_s
 			events_alda_codes
 		end
+		
+		# The initialization.
+		def initialize(...)
+			super
+			on_contained
+		end
+		
+		# Clears all the events and variables.
+		def clear
+			@events.clear
+			@variables.clear
+			self
+		end
+	end
+	
+	# An encapsulation for the REPL session for alda-rb.
+	class REPL
+		
+		# The score object used in REPL.
+		# Includes Alda#, so it can refer to alda commandline.
+		class TempScore < Score
+			include Alda
+			
+			Score.instance_methods(false).each do |meth|
+				define_method meth, Score.instance_method(meth)
+			end
+			
+			def initialize session
+				super()
+				@session = session
+			end
+			
+			def to_s
+				history
+			end
+			
+			def history
+				@session.history.to_s
+			end
+			
+			def clear_history
+				@session.clear_history
+			end
+			
+			def get_binding
+				binding
+			end
+			
+			alias quit exit
+		end
+		
+		# The history.
+		attr_reader :history
+		
+		# Initialization.
+		def initialize
+			@score = TempScore.new self
+			@binding = @score.get_binding
+			@lex = RubyLex.new
+			@history = StringIO.new
+		end
+		
+		# Runs the session. Includes the start, the main loop, and the termination.
+		def run
+			start
+			while code = rb_code
+				break unless process_rb_code code
+			end
+			terminate
+		end
+		
+		# Starts the session.
+		def start
+		end
+		
+		# Reads the next Ruby codes input in the REPL session.
+		# It can intelligently continue reading if the code is not complete yet.
+		def rb_code
+			result = ''
+			begin
+				buf = Readline.readline '> '.green, true
+				return unless buf
+				result.concat buf, ?\n
+				ltype, indent, continue, block_open = @lex.check_state result
+			rescue Interrupt
+				$stdout.puts
+				retry
+			end while ltype || indent.nonzero? || continue || block_open
+			result
+		end
+		
+		# Processes the Ruby codes read.
+		# Sending it to a score and sending the result to alda.
+		# @return +true+ for continue looping, +false+ for breaking the loop.
+		def process_rb_code code
+			@score.clear
+			begin
+				@binding.eval code
+			rescue StandardError, ScriptError => e
+				$stderr.print e.full_message
+				return true
+			rescue Interrupt
+				return true
+			rescue SystemExit
+				return false
+			end
+			code = @score.events_alda_codes
+			unless code.empty?
+				$stdout.puts code.yellow
+				play_score code
+			end
+			true
+		end
+		
+		# Tries to run the block and rescue CommandLineError#.
+		def try_command # :block:
+			begin
+				yield
+			rescue CommandLineError => e
+				puts e.message.red
+			end
+		end
+		
+		# Plays the score.
+		def play_score code
+			try_command do
+				Alda.play code: code, history: @history
+				@history.puts code
+			end
+		end
+		
+		# Terminates the REPL session.
+		def terminate
+			clear_history
+		end
+		
+		# Clears the history.
+		def clear_history
+			@history = StringIO.new
+		end
+	end
+	
+	# The error is raised when one tries to
+	# run a non-existing subcommand of +alda+.
+	class CommandLineError < StandardError
+		
+		# The <tt>Process::Status</tt> object representing the status of
+		# the process that runs +alda+ command.
+		attr_reader :status
+		
+		# The port on which the problematic Alda server runs.
+		# @example
+		#   begin
+		#     Alda.play({port: 1108}, code: "y")
+		#   rescue CommandLineError => e
+		#     e.port # => 1108
+		#   end
+		attr_reader :port
+		
+		# Create a CommandLineError# object.
+		# @param status The status of the process running +alda+ command.
+		# @param msg The exception message.
+		def initialize status, msg = nil
+			if match = msg&.match(/^\[(?<port>\d+)\]\sERROR\s(?<message>.*)$/)
+				super match[:message]
+				@port = match[:port].to_i
+			else
+				super msg
+				@port = nil
+			end
+			@status = status
+		end
+	end
+	
+	# This error is raised when one tries to
+	# append events in an EventList# in a wrong order.
+	# @example
+	#   Alda::Score.new do
+	#     motif = f4 f e e d d c2
+	#     g4 f e d c2 # It commented out, error will not occur
+	#     c4 c g g a a g2 motif # (OrderError)
+	#   end
+	class OrderError < StandardError
+		
+		# The expected element gotten if it is of the correct order.
+		# @see #got
+		# @example
+		#   Alda::Score.new do
+		#     motif = f4 f e e d d c2
+		#     g4 f e d c2
+		#     p @events.size # => 2
+		#     c4 c g g a a g2 motif
+		#   rescue OrderError => e
+		#     p @events.size # => 1
+		#     p e.expected   # => #<Alda::EventContainer:...>
+		#     p e.got        # => #<Alda::EventContainer:...>
+		#   end
+		attr_reader :expected
+		
+		# The actually gotten element.
+		# For an example, see #expected.
+		# @see #expected
+		attr_reader :got
+		
+		def initialize expected, got
+			super 'events are out of order'
+			@expected = expected
+			@got = got
+		end
 	end
 	
 	# The class of elements of EventList#events.
@@ -266,9 +565,13 @@ module Alda
 		# object in the middle.
 		attr_accessor :parent
 		
+		# The EventContainer# object that contains it.
+		# It may be +nil+, especially probably when
+		# it itself is an EventContainer#.
+		attr_accessor :container
+		
 		# The callback invoked when it is contained in an EventContainer#.
-		# It is overridden in InlineLisp#, so be aware if you want to
-		# override InlineLisp#on_contained.
+		# It is overridden in InlineLisp# and EventList#.
 		# @example
 		#   class Alda::Note
 		#     def on_contained
@@ -302,9 +605,8 @@ module Alda
 		def initialize event, parent
 			@event = event
 			@parent = parent
-			@event.parent = @parent
 			@labels = []
-			@event.on_contained
+			on_containing
 		end
 		
 		# Make #event a Chord# object.
@@ -318,7 +620,9 @@ module Alda
 		#   Alda::Score.new { violin_/viola_/cello_; e; f; g}.play
 		#   # (plays notes E, F, G with three instruments simultaneously)
 		def / other
-			raise unless other == @parent.events.pop
+			unless (expected = other) == (got = @parent.events.pop)
+				raise OrderError.new expected, got
+			end
 			@event =
 					if @event.is_a? Part
 						Part.new @event.names + other.event.names, other.event.arg
@@ -339,13 +643,29 @@ module Alda
 		
 		# Marks repetition.
 		def * num
-			@count = num
+			@count = (@count || 1) * num
+			self
 		end
 		
 		# Marks alternative repetition.
 		def % labels
-			labels = [labels] unless labels.respond_to? :to_a
+			labels = [labels] unless labels.is_a? Array
 			@labels.replace labels.to_a
+			self
+		end
+		
+		def event= event
+			@event = event
+			on_containing
+			@event
+		end
+		
+		def on_containing
+			if @event
+				@event.container = self
+				@event.parent = @parent
+				@event.on_contained
+			end
 		end
 		
 		def method_missing name, *args
@@ -363,7 +683,7 @@ module Alda
 		
 		# The arguments passed to the lisp function.
 		# Its elements can be
-		# Array#, Hash#, Numeric#, String#, Symbol#, or InlineLisp#.
+		# Array#, Hash#, Numeric#, String#, Symbol#, or Event#.
 		attr_accessor :args
 		
 		# The underlines in +head+ will be converted to hyphens.
@@ -377,8 +697,11 @@ module Alda
 		end
 		
 		def on_contained
+			super
 			@args.reverse_each do |event|
-				raise if event.is_a?(Event) && event != @parent.events.pop
+				if event.is_a?(Event) && (expected = event) != (got = @parent.events.pop)
+					raise OrderError.new expected, got
+				end
 			end
 		end
 	end
@@ -394,9 +717,32 @@ module Alda
 		attr_accessor :duration
 		
 		# The underlines in +duration+ will be converted to +~+.
+		# Exclamation mark and question mark in +duration+
+		# will be interpreted as accidentals in #pitch.
+		#
+		# The number of underlines at the end of +duration+ means:
+		# neither natural nor slur if 0,
+		# natural if 1,
+		# slur if 2,
+		# both natural and slur if 3.
 		def initialize pitch, duration
 			@pitch = pitch.to_s
-			@duration = duration.to_s.gsub ?_, ?~
+			@duration = duration.to_s.tr ?_, ?~
+			case @duration[-1]
+			when ?! # sharp
+				@pitch.concat ?+
+				@duration[-1] = ''
+			when ?? # flat
+				@pitch.concat ?-
+				@duration[-1] = ''
+			end
+			waves = /(?<str>~+)\z/ =~ @duration ? str.size : return
+			@duration[@duration.length - waves..] = ''
+			if waves >= 2
+				waves -= 2
+				@duration.concat ?~
+			end
+			@pitch.concat ?_ * waves
 		end
 		
 		# Append a sharp sign after #pitch.
@@ -441,7 +787,7 @@ module Alda
 		
 		# Underlines in +duration+ will be converted to +~+.
 		def initialize duration
-			@duration = duration.to_s.gsub ?_, ?~
+			@duration = duration.to_s.tr ?_, ?~
 		end
 		
 		def to_alda_code
@@ -525,7 +871,7 @@ module Alda
 		attr_accessor :arg
 		
 		def initialize names, arg = nil
-			@names = names.map { |name| name.to_s.gsub ?_, ?- }
+			@names = names.map { |name| name.to_s.tr ?_, ?- }
 			@arg = arg
 		end
 		
@@ -535,16 +881,29 @@ module Alda
 			result.concat ?:
 		end
 		
+		# Enables dot accessor.
 		# @example
 		#   Alda::Score.new do
 		#     violin_/viola_/cello_('strings'); g1_1_1
 		#     strings_.cello_; -o; c1_1_1
 		#   end.play
 		def method_missing name, *args
-			name = name.to_s
-			return super unless name[-1] == ?_
-			name[-1] = ''
-			@names.last.concat ?., name
+			str = name.to_s
+			return super unless str[-1] == ?_
+			str[-1] = ''
+			@names.last.concat ?., str
+			if args.size == 1
+				joined = args.first
+				unless (got = @parent.events.pop) == (expected = joined)
+					raise OrderError.new expected, got
+				end
+				unless @container
+					@container = EventContainer.new nil, @parent
+					@parent.events.delete self
+					@parent.push @container
+				end
+				@container.event = Sequence.join self, joined
+			end
 		end
 	end
 	
@@ -594,7 +953,7 @@ module Alda
 		
 		# Underlines in +name+ is converted to hyphens.
 		def initialize name
-			@name = name.to_s.gsub ?_, ?-
+			@name = name.to_s.tr ?_, ?-
 		end
 		
 		def to_alda_code
@@ -611,7 +970,7 @@ module Alda
 		
 		# Underlines in +name+ is converted to hyphens.
 		def initialize name
-			@name = name.to_s.gsub ?_, ?-
+			@name = name.to_s.tr ?_, ?-
 		end
 		
 		def to_alda_code
@@ -623,8 +982,94 @@ module Alda
 	class Sequence < Event
 		include EventList
 		
+		# Using this module can fix a bug of Array#flatten.
+		# @example
+		#   def (a = Object.new).method_missing(...)
+		#     Object.new
+		#   end
+		#   [a].flatten rescue $! # => #<TypeError:...>
+		#   using Alda::Sequence::RefineFlatten
+		#   [a].flatten # => [#<Object:...>]
+		module RefineFlatten
+			refine Array do
+				def flatten
+					each_with_object [] do |element, result|
+						if element.is_a? Array
+							result.push *element.flatten
+						else
+							result.push element
+						end
+					end
+				end
+			end
+		end
+		using RefineFlatten
+		
 		def to_alda_code
 			@events.to_alda_code
 		end
+		
+		# Creates a Sequence# object by joining +events+.
+		# The EventContainer# objects are extracted,
+		# and the Sequence# objects are flattened.
+		def self.join *events
+			new do
+				@events = events.map do |event|
+					while event.is_a?(EventContainer) && !event.count && event.labels.empty?
+						event = event.event
+					end
+					event.is_a?(Sequence) ? event.events : event
+				end.flatten
+			end
+		end
+	end
+	
+	# A set-variable event.
+	# Includes EventList#.
+	class SetVariable < Event
+		include EventList
+		
+		# The name of the variable.
+		attr_accessor :name
+		
+		# The events passed to it using arguments instead of a block.
+		attr_reader :original_events
+		
+		def initialize name, *events, &block
+			@name = name.to_sym
+			@original_events = events
+			@events = events.clone
+			super &block
+		end
+		
+		# Specially, the result ends with a newline.
+		def to_alda_code
+			"#@name = #{events_alda_codes}\n"
+		end
+		
+		def on_contained
+			super
+			@parent.variables.add @name
+			@original_events.reverse_each do |event|
+				unless (expected = event) == (got = @parent.events.pop)
+					raise OrderError.new expected, got
+				end
+			end
+		end
+	end
+	
+	# A get-variable event
+	class GetVariable < Event
+		
+		# The name of the variable
+		attr_accessor :name
+		
+		def initialize name
+			@name = name
+		end
+		
+		def to_alda_code
+			@name.to_s
+		end
 	end
 end

data/lib/alda-rb/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Alda
-	VERSION = '0.1.2'
+	VERSION = '0.1.4'
 end

metadata

@@ -1,18 +1,18 @@
 --- !ruby/object:Gem::Specification
 name: alda-rb
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.4
 platform: ruby
 authors:
 - Ulysses Zhan
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-04-16 00:00:00.000000000 Z
+date: 2020-04-24 00:00:00.000000000 Z
 dependencies: []
 description: 
 email:
-- 2938747508@qq.com
+- UlyssesZhan@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -32,6 +32,7 @@ files:
 - examples/clapping_music.rb
 - examples/dot_accessor.rb
 - examples/entropy.rb
+- examples/hanon.rb
 - examples/hello_world.rb
 - examples/key_signature.rb
 - examples/midi_note_numbers.rb
@@ -41,6 +42,7 @@ files:
 - examples/phase.rb
 - examples/seconds_and_milliseconds.rb
 - examples/showcase.rb
+- examples/variables.rb
 - lib/alda-rb.rb
 - lib/alda-rb/version.rb
 homepage: https://github.com/UlyssesZh/alda-rb
@@ -49,6 +51,7 @@ licenses:
 metadata:
   homepage_uri: https://github.com/UlyssesZh/alda-rb
   source_code_uri: https://github.com/UlyssesZh/alda-rb
+  changelog_uri: https://github.com/UlyssesZh/alda-rb/releases
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -57,7 +60,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.3.0
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="