RubyGems - alda-rb - Versions diffs - 0.1.4 → 0.2.0 - Mend

alda-rb 0.1.4 → 0.2.0

Files changed (17) hide show

@@ -0,0 +1,313 @@
+require 'set'
+##
+# Including this module can make your class have the ability
+# to have an event list.
+# See docs below to get an overview of its functions.
+module Alda::EventList
+	##
+	# The array containing the events (Alda::Event objects),
+	# most of which are Alda::EventContainer objects.
+	attr_accessor :events
+	##
+	# The set containing the available variable names.
+	attr_accessor :variables
+	def on_contained
+		super if defined? super
+		instance_eval &@block if @block
+	end
+	##
+	# :call-seq:
+	#   (some sugar) -> Alda::EventContainer
+	#
+	# Make the object have the ability to append 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. Ending with 2 underlines: set variable. See Alda::SetVariable.
+	#
+	# 2. Starting with 2 lowercase letters and
+	#    ending with underline character: instrument. See Alda::Part.
+	#
+	# 3. Starting with 2 lowercase letters: inline lisp code,
+	#    set variable, or get variable.
+	#    One of the above three is chosen intelligently.
+	#    See Alda::InlineLisp, Alda::SetVariable, Alda::GetVariable.
+	#
+	# 4. Starting with "t": CRAM. See Alda::Cram.
+	#
+	# 5. Starting with one of "a", "b", ..., "g": note. See Alda::Note.
+	#
+	# 6. Starting with "r": rest. See Alda::Rest.
+	#
+	# 7. "x": chord. See Alda::Chord.
+	#
+	# 8. "s": sequence. See Alda::Sequence.
+	#
+	# 9. Starting with "o": octave. See Alda::Octave.
+	#
+	# 10. Starting with "v": voice. See Alda::Voice.
+	#
+	# 11. Starting with "__" (2 underlines): at marker. See Alda::AtMarker.
+	#
+	# 12. Starting with "_" (underline) and ending with "_" (underline):
+	#     lisp identifier. See Alda::LispIdentifier.
+	#
+	# 13. Starting with "_" (underline): marker. See Alda::Marker.
+	#
+	# All the appended events are contained in an Alda::EventContainer object,
+	# which is to be returned.
+	#
+	# These sugars forms a DSL. See ::new for examples.
+	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
+				Alda::Sequence.join event, args.first.tap(&:detach_from_parent)
+			else
+				event
+			end
+		end
+		case
+		when /\A(?<head>[a-z][a-z].*)__\z/        =~ name
+			Alda::SetVariable.new head, *args, &block
+		when /\A(?<part>[a-z][a-z].*)_\z/         =~ name
+			if args.first.is_a? String
+				Alda::Part.new [part], args.first
+			else
+				sequence_sugar.(Alda::Part.new [part])
+			end
+		when /\A[a-z][a-z].*\z/                   =~ name
+			arg = args.first
+			if block || !has_variable?(name) && args.size == 1 && arg.is_a?(Alda::Event) &&
+					!arg.is_a?(Alda::InlineLisp) && !arg.is_a?(Alda::LispIdentifier) &&
+					!(arg.is_a?(Alda::EventContainer) &&
+							(arg.event.is_a?(Alda::InlineLisp) || arg.event.is_a?(Alda::LispIdentifier)))
+				Alda::SetVariable.new name, *args, &block
+			elsif has_variable?(name) && (args.empty? || args.size == 1 && arg.is_a?(Alda::Event))
+				sequence_sugar.(Alda::GetVariable.new name)
+			else
+				Alda::InlineLisp.new name, *args
+			end
+		when /\At(?<duration>.*)\z/               =~ name
+			Alda::Cram.new duration, &block
+		when /\A(?<pitch>[a-g])(?<duration>.*)\z/ =~ name
+			sequence_sugar.(Alda::Note.new pitch, duration)
+		when /\Ar(?<duration>.*)\z/               =~ name
+			sequence_sugar.(Alda::Rest.new duration)
+		when /\Ax\z/                              =~ name
+			Alda::Chord.new &block
+		when /\As\z/                              =~ name
+			Alda::Sequence.new *args, &block
+		when /\Ao!\z/                             =~ name
+			sequence_sugar.(Alda::Octave.new('').tap { _1.up_or_down = 1})
+		when /\Ao\?\z/                            =~ name
+			sequence_sugar.(Alda::Octave.new('').tap { _1.up_or_down = -1})
+		when /\Ao(?<num>\d*)\z/                   =~ name
+			sequence_sugar.(Alda::Octave.new num)
+		when /\Av(?<num>\d+)\z/                   =~ name
+			sequence_sugar.(Alda::Voice.new num)
+		when /\A__(?<head>.+)\z/                  =~ name
+			sequence_sugar.(Alda::AtMarker.new head)
+		when /\A_(?<head>.+)_\z/                  =~ name
+			sequence_sugar.(Alda::LispIdentifier.new head)
+		when /\A_(?<head>.+)\z/                   =~ name
+			sequence_sugar.(Alda::Marker.new head)
+		else
+			super
+		end.then do |event|
+			Alda::EventContainer.new event, self
+		end.tap { @events.push _1 }
+	end
+	##
+	# :call-seq:
+	#   has_variable?(name) -> true or false
+	#
+	# Whether there is a previously declared alda variable
+	# whose name is specified by +name+.
+	#
+	# Searches variables in #parent.
+	def has_variable? name
+		@variables.include?(name) || !!@parent&.has_variable?(name)
+	end
+	##
+	# :call-seq:
+	#   import(event_list) -> nil
+	#
+	# Append the events of another Alda::EventList object here.
+	# This method covers the disadvantage of alda's being unable to
+	# import scores from other files.
+	# See https://github.com/alda-lang/alda-core/issues/8.
+	def import event_list
+		@events.concat event_list.events
+		nil
+	end
+	##
+	# :call-seq:
+	#   new(&block) -> Alda::EventList
+	#
+	# +block+ is to be passed with the Alda::EventList object as +self+.
+	#
+	# Note that +block+ is not called immediately.
+	# It is instead called in #on_contained.
+	# Specially, Alda::Score::new calls #on_contained.
+	#
+	#   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 # a sequence
+	#     d4_8                 # cannot have '~', use '_' instead
+	#     o3 b8 o4 c2          # a sequence
+	#   end
+	#   # => #<Alda::Score:0x... @events=[...]>
+	#
+	# For a list of sugars, see #method_missing.
+	def initialize &block
+		@events ||= []
+		@variables ||= Set.new
+		@block ||= block
+	end
+	##
+	# :call-seq:
+	#   to_a -> Array
+	#
+	# Same as #events.
+	def to_a
+		@events
+	end
+	##
+	# :call-seq:
+	#   events_alda_codes(delimiter=" ") -> String
+	#
+	# Join the alda codes of #events with a specified delimiter.
+	# Returns a string representing the result.
+	def events_alda_codes delimiter = ' '
+		@events.map(&:to_alda_code).join delimiter
+	end
+end
+##
+# Includes Alda::EventList and provides methods to #play, #parse, or #export.
+class Alda::Score
+	include Alda::EventList
+	##
+	# :call-seq:
+	#   play(**opts) -> String
+	#
+	# Plays the score.
+	#
+	# Returns the command line output of the +alda+ command.
+	#
+	# Run command <tt>alda help</tt> to see available options
+	# that can be specified in +opts+.
+	#
+	#   Alda::Score.new { piano_; c; d; e }.play
+	#   # => "[27713] Parsing/evaluating...\n[27713] Playing...\n"
+	#   # (and plays the sound)
+	#   Alda::Score.new { piano_; c; d; e }.play from: 1
+	#   # (plays only an E note)
+	def play **opts
+		Alda.play code: self, **opts
+	end
+	##
+	# :call-seq:
+	#   parse(**opts) -> String
+	#
+	# Parses the score.
+	#
+	# Returns the JSON string of the parse result.
+	#
+	# Run command <tt>alda help</tt> to see available options
+	# that can be specified in +opts+.
+	#
+	#   Alda::Score.new { piano_; c }.parse output: :events
+	#   # => "[{\"event-type\":...}]\n"
+	def parse **opts
+		Alda.parse code: self, **opts
+	end
+	##
+	# :call-seq:
+	#   export(**opts) -> String
+	#
+	# Exports the score.
+	#
+	# Returns the command line output of the +alda+ command.
+	#
+	# Run command <tt>alda help</tt> to see available options
+	# that can be specified in +opts+.
+	#
+	#   Alda::Score.new { piano_; c }.export output: 'temp.mid'
+	#   # (outputs a midi file called temp.mid)
+	def export **opts
+		Alda.export code: self, **opts
+	end
+	##
+	# :call-seq:
+	#   save(filename) -> nil
+	#
+	# Saves the alda codes into a file.
+	def save filename
+		File.open(filename, 'w') { _1.puts to_s }
+	end
+	##
+	# :call-seq:
+	#   load(filename) -> Alda::InlineLisp
+	#
+	# Loads alda codes from a file.
+	#
+	# Actually appends a Alda::InlineLisp event of +alda-code+ lisp call.
+	def load filename
+		event = Alda::InlineLisp.new :alda_code, File.read(filename)
+		@events.push event
+		event
+	end
+	##
+	# :call-seq:
+	#   to_s() -> String
+	#
+	# Returns a String containing the alda codes representing the score.
+	def to_s
+		events_alda_codes
+	end
+	##
+	# :call-seq:
+	#   new(&block) -> Alda::Score
+	#
+	# Creates an Alda::Score.
+	def initialize(...)
+		super
+		on_contained
+	end
+	##
+	# :call-seq:
+	#   clear() -> nil
+	#
+	# Clears all the events and variables.
+	def clear
+		@events.clear
+		@variables.clear
+		nil
+	end
+end

data/lib/alda-rb/patches.rb ADDED

@@ -0,0 +1,168 @@
+require 'stringio'
+##
+class Array
+	##
+	# See Alda::Event#to_alda_code.
+	def to_alda_code
+		"[#{map(&:to_alda_code).join ' '}]"
+	end
+	##
+	# See Alda::Event#detach_from_parent.
+	def detach_from_parent
+		reverse_each &:detach_from_parent
+	end
+end
+##
+class Hash
+	##
+	# See Alda::Event#to_alda_code.
+	def to_alda_code
+		"[#{map(&:to_alda_code).join ' '}]"
+	end
+	##
+	# See Alda::Event#detach_from_parent.
+	def detach_from_parent
+		each.reverse_each &:detach_from_parent
+	end
+end
+##
+class String
+	##
+	# See Alda::Event#to_alda_code.
+	def to_alda_code
+		dump
+	end
+	##
+	# See Alda::Event#detach_from_parent.
+	def detach_from_parent
+	end
+end
+##
+class Symbol
+	##
+	# See Alda::Event#to_alda_code.
+	def to_alda_code
+		?: + to_s
+	end
+	##
+	# See Alda::Event#detach_from_parent.
+	def detach_from_parent
+	end
+end
+##
+class Numeric
+	##
+	# See Alda::Event#to_alda_code.
+	def to_alda_code
+		inspect
+	end
+	##
+	# See Alda::Event#detach_from_parent.
+	def detach_from_parent
+	end
+end
+##
+class Range
+	##
+	# See Alda::Event#to_alda_code.
+	def to_alda_code
+		"#{first}-#{last}"
+	end
+	##
+	# See Alda::Event#detach_from_parent.
+	def detach_from_parent
+	end
+end
+##
+class TrueClass
+	##
+	# See Alda::Event#to_alda_code.
+	def to_alda_code
+		'true'
+	end
+	##
+	# See Alda::Event#detach_from_parent.
+	def detach_from_parent
+	end
+end
+##
+class FalseClass
+	##
+	# See Alda::Event#to_alda_code.
+	def to_alda_code
+		'false'
+	end
+	##
+	# See Alda::Event#detach_from_parent.
+	def detach_from_parent
+	end
+end
+##
+class NilClass
+	##
+	# See Alda::Event#to_alda_code.
+	def to_alda_code
+		'nil'
+	end
+	##
+	# See Alda::Event#detach_from_parent.
+	def detach_from_parent
+	end
+end
+##
+class Proc
+	##
+	# :call-seq:
+	#   proc * n -> n
+	#
+	# Runs +self+ for +n+ times.
+	def * n
+		if !lambda? || arity == 1
+			n.times &self
+		else
+			n.times { self.() }
+		end
+	end
+end
+##
+class StringIO
+	##
+	# :call-seq:
+	#   to_s() -> String
+	#
+	# Equivalent to <tt>string</tt>.
+	def to_s
+		string
+	end
+end