alda-rb 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dda95434d70128902d3d1ab96628c079ea8716123768d2e93b1ed429df5571b2
-  data.tar.gz: 8886cd7c861469aa980c18b56142e939c1727086c4d14e15b55fad3eb9fad1b0
+  metadata.gz: 6e35ecf8cca36fa942f004ba62c203226064ec3de09f21974ba57eb04cddd79a
+  data.tar.gz: 96f6a6540591c4a890034b234a737b68a678c199e2f88a8f73b4eadd5f824477
 SHA512:
-  metadata.gz: 4cc9a4cd860643fdd69d152d77b13dac9c9d730d119b55d2799c0ffef328ccbeb91c9e618bf706652306210bdd298d1055f3f0a88ead557cc5f550d9f644823f
-  data.tar.gz: 0c3654c453bf4d66fc6eed1bdcda53abe712ad625799d6687d64d29222c77d6bb7fc86e9190cb96d09052f7191eb43bfbcafc8dea8a0e26bf11a2a1bbb99dfee
+  metadata.gz: b8eb886e53075b0d4d154c0f2f29415eb366ce0ad1ca38aa6a0757eee136b028d952dab3e42f557d4037fcc41704b64f9467de4c89205f0cbd8d040b1d3ce70e
+  data.tar.gz: cec492d17877348e1023b5d488bd3cb2b6e874d13e13eaa1141eee5260853ff094e0daa9b412fbb7210f6a91b5fb2808bfe0831e932a84a510b1809a8df97b91

data/.github/workflows/main.yml

@@ -0,0 +1,18 @@
+name: Ruby
+
+on: [push,pull_request]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: 2.7.0
+    - name: Run the default task
+      run: |
+        gem install bundler
+        bundle install
+        bundle exec rake

data/.gitignore

@@ -8,5 +8,5 @@
 /tmp/
 
 /.idea/
-Gemfile.lock
-/html/
+.alda-nrepl-port
+*.mid

data/CHANGELOG.md

@@ -0,0 +1,271 @@
+# CHANGELOG
+
+## v0.3.0 (2023-05-29)
+
+### Changes for \Alda 2
+
+Added API for support \Alda 2 while still being able to support \Alda 1:
+
+- Added Alda::COMMANDS_FOR_VERSIONS and Alda::GENERATIONS.
+- Added Alda::generation, which can be `:v1` or `:v2`.
+Specifically, one of the values in the array Alda::GENERATIONS.
+- Added Alda::v1?, Alda::v2?, Alda::v1!, Alda::v2! (See Alda::GENERATIONS).
+- Added Alda::deduce_generation.
+- Added Alda::GenerationError.
+- In Alda::Chord#to_alda_code, considering an undocumented breaking change about chords,
+the behavior is slightly different for \Alda 1 and \Alda 2.
+- Added Thread#inside_alda_list.
+- Added Alda::REPL#message and Alda::REPL#raw_message.
+
+APIs that are modified to support \Alda 2:
+
+- (BREAKING CHANGE!) Changed Alda::COMMANDS from an array of symbols into a hash.
+  The keys are the names of the commands,
+  and the values are arrays of generations where the command is available.
+- Because \Alda 2 does not have the notion of down and up, if we are in v2,
+  Alda::down? will always return false and Alda::up? will always return true.
+- Array#to_alda_code and Hash#to_alda_code behaves differently for \Alda 1 and \Alda 2 regarding
+[a breaking change](https://github.com/alda-lang/alda/blob/master/doc/alda-2-migration-guide.md#attribute-syntax-has-changed-in-some-cases).
+
+Documents that modified for notice about \Alda 2:
+
+- Alda::[], Alda::up?, Alda::down?, Alda::COMMANDS.
+- Alda::EventList#method_missing.
+- Alda::InlineLisp.
+- Array#to_alda_code, Hash#to_alda_code.
+- Alda::REPL.
+- Alda::CommandLineError#port.
+
+Examples that are modified to work in \Alda 2:
+
+- clapping_music,
+- dot_accessor,
+- marriage_d_amour.
+
+### New things
+
+New features:
+
+- Added warnings about structures that probably trigger errors in \Alda.
+See Alda::EventContainer#check_in_chord, Alda::EventList#method_missing.
+- Now you can specify a parameter in Alda::Event#detach_from_parent to exclude some
+classes of parents that will be detached from.
+- (Potentially BREAKING) Alda::Event#detach_from_parent now tries to detach the topmost container
+instead of the event itself from the parent.
+- Added a commandline program called `alda-irb`. See Alda::REPL.
+- Traceback of exception will also be printed now if an Interrupt is caught in \REPL.
+- <kbd>Ctrl</kbd>+<kbd>C</kbd> can now be used to discard the current input in \REPL.
+- Now, Alda::REPL takes better care of indents.
+- Added no-color mode and no-preview mode for \REPL.
+- Now Alda::REPL::TempScore#score and Alda::REPL::TempScore#map output in blue color.
+
+New APIs:
+
+- Added Alda::Raw.
+- Added Alda::Utils::warn, Alda::Utils::win_platform?,
+Alda::Utils::snake_to_slug, Alda::Utils::slug_to_snake.
+- Added Alda::Event#is_event_of?. It is overridden in Alda::EventContainer#is_event_of?.
+- Added Alda::Event#== and Alda::EventList#==. It is overridden in many subclasses.
+- Added Alda::EventContainer#check_in_chord.
+- Added Alda::EventList#l.
+- Added Alda::EventList#raw.
+- Added Alda::REPL#color, Alda::REPL#preview.
+- Added Alda::REPL#setup_repl, Alda::REPL#readline.
+- Added Alda::REPL::TempScore#new_score, Alda::REPL::TempScore#score_text,
+Alda::REPL::TempScore#score_data, Alda::REPL::TempScore#score_events.
+- Added Alda::pipe.
+- Added Alda::processes.
+- Added Alda::NREPLServerError.
+- Added Alda::GenerationError::assert_generation.
+
+Slightly improved docs:
+
+- Alda::EventContainer#event.
+- The overriding +to_alda_code+'s and +on_contained+'s.
+- Alda::Sequence, Alda::Sequence::RefineFlatten#flatten.
+- The patches to Ruby's core classes.
+- Alda::repl.
+- Kernel.
+- Alda::EventList::new.
+- Alda::OrderError::new.
+- Alda::InlineLisp.
+- Alda::OrderError#expected.
+
+Much better docs:
+
+- Alda::EventContainer#/.
+- Alda::EventList#on_contained.
+- Alda::REPL::TempScore.
+
+New examples:
+
+- dynamics,
+- track-volume,
+- variables-2.
+
+### BREAKING changes
+
+Removed APIs:
+
+- Removed Alda::SetVariable#original_events.
+- Removed Alda::repl. Now calling `Alda.repl` will trigger commandline `alda repl`.
+For the old REPL function, use `Alda::REPL.new.run` instead.
+- Removed Alda::REPL::TempScore#history.
+
+Modified APIs or features:
+
+- Now Alda::REPL#play_score does not call Alda::REPL#try_command.
+- Alda::Score#load now use Alda::Raw instead of an Alda::InlineLisp to load a file.
+
+### Fixed bugs
+
+- Fixed: sometimes Alda::Event#parent returns wrong result
+because it is not updated in some cases.
+- Fixed (potentially BREAKING): Hash#to_alda_code returns `[[k1 v1] [k2 v2]]`.
+Now, it returns `{k1 v1 k2 v2}`.
+- Use reline instead of readline in Alda::REPL
+because Ruby 3.3 is dropping the shipment of readline-ext.
+
+### Others
+
+- Added changelog.
+- Modified the homepage and changelog URI in gemspec.
+- Fixed the email in code of conduct.
+
+## v0.2.1 (2020-08-13)
+
+- Fixed the bug in `examples/bwv846_prelude.rb`.
+The file isn't changed when the version change
+from [v0.1.4](#v014-2020-04-23) to [v0.2.0](#v020-2020-05-08)
+but the new features in 0.2.0 made some codes in that file stop working.
+
+## v0.2.0 (2020-05-08)
+
+- Separated `alda-rb.rb` into several files.
+- REPL now supports `map`, `score`, and `new`.
+- Added a lot of docs. Can be seen [here](https://ulysseszh.github.io/doc/alda-rb).
+- Added Alda::Event#detach_from_parent.
+- Fixed the bug that dot accessor of Alda::Part does not return the container (or the part itself).
+- Added Alda::LispIdentifier.
+- Fixed Alda::EventList#import now returns `nil`.
+- Added some unit tests.
+- Fixed the bug that creating an Alda::GetVariable occasionally crashes.
+- Fixed bug that inline lisp is mistakenly interpreted as set-variable.
+
+## v0.1.4 (2020-04-23)
+
+- The Ruby requirements become `">= 2.7"`, so update your Ruby.
+- Added a colorful REPL! Run Alda::repl and see.
+```
+$ ruby -ralda-rb -e "Alda.repl"
+> puts status
+[27713] Server up (2/2 workers available, backend port: 33245)
+> piano_ c d e f
+[piano: c d e f]
+> 5.times do
+> c
+> end
+c c c c c
+> puts history
+[piano: c d e f]
+c c c c c
+> play
+> save 'temp.alda'
+> puts `cat temp.alda`
+[piano: c d e f]
+c c c c c
+> system 'rm temp.alda'
+> exit
+```
+- More than 2 events written together will become an Alda::Sequence object
+(contained by an Alda::EventContainer).
+Events that can use such sugar includes:
+part (supports dot accessor), note, rest, octave, voice, marker, at-marker.
+```ruby
+Alda::Score.new { p((c d e).event.class) } # => Alda::Sequence
+```
+- Added: `o!` means octave up, `o?` means octave down. This is to be compatible with the sugar above.
+- Similarly added: `!` at the end of a note means sharp, and `?` for flat, `_` for natural. It conflicts with slur, so `__` means slur, and `___` means slur and natural.
+```ruby
+Alda::Score.new { piano_ c o? b? o! c o? b? }.to_s
+# => "[piano: c < b- > c < b-]"
+```
+- Added attr accessor Alda::Event#container.
+- Fixed the bug occurring when one uses a dot accessor wrongly.
+- Added Alda::Sequence::join to join several events into a flatten sequence.
+- Fixed the bug in `examples/alternate_endings.rb`.
+- Some of the examples are rewritten using the new sugar feature.
+- Assign an alda variable by using a method ending with 2 underlines, or pass a block for it. The following three are equivalent:
+```ruby
+Alda::Score.new { var__ c d e; piano_ var }
+```
+```ruby
+Alda::Score.new { var { c d e }; piano_ var }
+```
+```ruby
+Alda::Score.new { var__ { c d e }; piano_ var }
+```
+This one is slightly different but has the same effect:
+```ruby
+Alda::Score.new { var__ c, d, e; piano_ var }
+```
+The name of a variable can be same as that of a lisp function if there is no ambiguity.
+- The message of Alda::CommandLineError is optimized.
+- Added Alda::OrderError, which is used instead of RuntimeError, representing a disorder of events.
+```ruby
+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
+```
+- The block passed to an Alda::EventList object is now called in Alda::Event#on_contained, so `@parent`, `@container` etc can be gotten inside.
+- Alda::EventList can access methods in `@parent`.
+- Canceled Alda::method_missing. Use meta-programming to define methods instead. You can now use `include Alda` to import such commands.
+```ruby
+include Alda
+version # => "Client version: 1.4.1\nServer version: [27713] 1.4.1\n"
+```
+- Added Kernel#alda. It runs `alda` at command line and does not capture the output.
+```ruby
+alda 'version'
+```
+- Use Alda::[] to specify command options (not subcommand options):
+```ruby
+Alda[quiet: true].play code: 'piano: c d e f' # => ""
+```
+The options specified will be remembered. Invoke `Alda::clear_options` to forget them.
+- Added Alda::CommandLineError#port.
+```ruby
+begin
+  Alda[port: 1108].play code: 'y'
+rescue CommandLineError => e
+  e.port # => 1108
+end
+```
+- Added Alda::Score#save and Alda::Score#load to save and load \Alda files.
+```ruby
+Alda::Score.new { c d e }.save 'temp.alda'
+File.read 'temp.alda' #  => "[c d e]\n"
+```
+
+## v0.1.2 (2020-04-16)
+
+- Added examples
+- Fixed bug when writing `key_sig b: [:flat]`
+- Added sequence sugar(s) and alternative repetition sugar (`%`) (see examples/alternate_endings.rb)
+- Write options naturally for alda command line (`Alda.play code: 'piano: c'`)
+- Can pass scores to alda command line (`Alda.play code: Alda::Score.new`)
+- Added Alda::Score#parse, Alda::Score#export, and Alda::Score#to_s
+- Fixed bug when writing `+o/c`
+- Added support for dot accessor (see example/dot_accessor.rb)
+- Fixed some mistakes in docs and README
+
+## v0.1.0 (2020-04-15)
+
+The original version.

data/CODE_OF_CONDUCT.md

@@ -55,7 +55,7 @@ further defined and clarified by project maintainers.
 ## Enforcement
 
 Instances of abusive, harassing, or otherwise unacceptable behavior may be
-reported by contacting the project team at 2938747508@qq.com. All
+reported by contacting the project team at UlyssesZhan@gmail.com. All
 complaints will be reviewed and investigated and will result in a response that
 is deemed necessary and appropriate to the circumstances. The project team is
 obligated to maintain confidentiality with regard to the reporter of an incident.

data/Gemfile

@@ -5,6 +5,7 @@ gemspec
 gem "rake", "~> 12.0"
 gem "minitest", "~> 5.0"
 gem "colorize"
+gem "bencode"
 group :develop do
 	gem 'rubocop'
 	gem 'rdoc'

data/Gemfile.lock

@@ -0,0 +1,54 @@
+PATH
+  remote: .
+  specs:
+    alda-rb (0.3.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.4.2)
+    bencode (0.8.2)
+    colorize (0.8.1)
+    json (2.6.3)
+    minitest (5.18.0)
+    parallel (1.23.0)
+    parser (3.2.2.1)
+      ast (~> 2.4.1)
+    psych (5.1.0)
+      stringio
+    rainbow (3.1.1)
+    rake (12.3.3)
+    rdoc (6.5.0)
+      psych (>= 4.0.0)
+    regexp_parser (2.8.0)
+    rexml (3.2.5)
+    rubocop (1.51.0)
+      json (~> 2.3)
+      parallel (~> 1.10)
+      parser (>= 3.2.0.0)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml (>= 3.2.5, < 4.0)
+      rubocop-ast (>= 1.28.0, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 2.4.0, < 3.0)
+    rubocop-ast (1.28.1)
+      parser (>= 3.2.1.0)
+    ruby-progressbar (1.13.0)
+    stringio (3.0.6)
+    unicode-display_width (2.4.2)
+
+PLATFORMS
+  x86_64-linux
+
+DEPENDENCIES
+  alda-rb!
+  bencode
+  colorize
+  minitest (~> 5.0)
+  rake (~> 12.0)
+  rdoc
+  rubocop
+
+BUNDLED WITH
+   2.4.1

data/README.md

@@ -21,7 +21,7 @@ Or install it yourself as:
 
 ## Usage
 
-[Install Alda](https://github.com/alda-lang/alda#Installation),
+[Install Alda](https://alda.io/install),
 and try the following Ruby codes yourself:
 
 ```ruby
@@ -56,21 +56,70 @@ Alda::Score.new do
 end.play
 ```
 
+There is also an interactive mode.
+You can run it by running `alda-irb` in your command line if you installed the gem.
+Run `bundle exec alda-irb` instead if you installed it using the bundler.
+
+```plain
+$ alda-irb
+> p processes.last
+{:id=>"dus", :port=>34317, :state=>nil, :expiry=>nil, :type=>:repl_server}
+> piano_; c d e f
+piano: [c d e f]
+> 5.times do
+.   c
+>   end
+c c c c c
+> score_text
+piano: [c d e f]
+c c c c c
+> play
+Playing...
+> save 'temp.alda'
+> puts `cat temp.alda`
+piano: [c d e f]
+c c c c c
+> system 'rm temp.alda'
+> exit
+```
+
+You can also use it to programmatically communicate with the nREPL server:
+
+```ruby
+repl = Alda::REPL.new
+repl.message :eval_and_play, code: 'piano: c d e f' # => nil
+repl.message :eval_and_play, code: 'g a b > c' # => nil
+repl.message :score_text # => "piano: [c d e f]\ng a b > c\n"
+repl.message :eval_and_play, code: 'this will cause an error' # (raises Alda::NREPLServerError)
+```
+
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+After checking out the repo, run `bin/setup` to install dependencies.
+Then, run `rake test` to run the tests.
+You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+To install this gem onto your local machine, run `bundle exec rake install`.
+To release a new version, update the version number in `version.rb`,
+and then run `bundle exec rake release`,
+which will create a git tag for the version,
+push git commits and tags,
+and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/UlyssesZh/alda-rb. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/UlyssesZh/alda-rb/blob/master/CODE_OF_CONDUCT.md).
-
+Bug reports and pull requests are welcome on GitHub at https://github.com/UlyssesZh/alda-rb.
+This project is intended to be a safe, welcoming space for collaboration,
+and contributors are expected to adhere to the
+[code of conduct](https://github.com/UlyssesZh/alda-rb/blob/master/CODE_OF_CONDUCT.md).
 
 ## License
 
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+The gem is available as open source under the terms of the
+[MIT License](https://opensource.org/licenses/MIT).
 
 ## Code of Conduct
 
-Everyone interacting in the alda-rb project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/UlyssesZh/alda-rb/blob/master/CODE_OF_CONDUCT.md).
+Everyone interacting in the alda-rb project's codebases, issue trackers,
+chat rooms and mailing lists is expected to follow the
+[code of conduct](https://github.com/UlyssesZh/alda-rb/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -4,8 +4,8 @@ require 'rdoc/task'
 
 RDoc::Task.new do |t|
 	t.main = 'README.md'
-	t.rdoc_files.include 'README.md', 'CODE_OF_CONDUCT.md',
-	                     'LICENSE.txt', 'lib/**/*.rb'
+	t.rdoc_dir = 'doc'
+	t.rdoc_files.include 'README.md', 'CODE_OF_CONDUCT.md', 'CHANGELOG.md', 'LICENSE.txt', 'lib/**/*.rb'
 	t.options << '--tab-width'
 	t.options << '2'
 end

data/alda-rb.gemspec

@@ -10,15 +10,15 @@ Gem::Specification.new do |spec|
 
   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.homepage      = "https://ulysseszh.github.io/doc/alda-rb"
   spec.license       = "MIT"
   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"] = "https://github.com/UlyssesZh/alda-rb/releases"
+  spec.metadata["source_code_uri"] = "https://github.com/UlyssesZh/alda-rb"
+  spec.metadata["changelog_uri"] = "https://ulysseszh.github.io/doc/alda-rb/CHANGELOG_md.html"
 
   # 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/bwv846_prelude.rb

@@ -15,13 +15,13 @@ class Alda::Sequence
 		/(?<letter>[a-g][-+_]*)(?<octave>\d*)/ =~ pitch
 		octave = @@last_octave ||= '4' if octave.empty?
 		result = Alda::Note.new "o#{@@last_octave = octave} #{letter}", duration
-        @events.push result
+		@events.push result.tap { _1.parent = self }
 		result
 	end
 end
 
 Alda::Score.new do
-	piano_ tempo 60
+	piano_; tempo 60
 	%w[
 		c e g c5 e
 		c4 d a d5 f
@@ -62,7 +62,7 @@ Alda::Score.new do
 			v3 r8 s{ notes.each { absolute _1, '16' } }*2
 		end * 2
 	end
-	alda_code <<~ENDING
+	raw <<~ENDING
 		V1:
 			o2 c1 | c1 | c1~1s
 		V2:

data/examples/clapping_music.rb

@@ -18,7 +18,7 @@ Alda::Score.new do
 	end
 	
 	tempo! 172
-	midi_percussion_ o2 set_note_length 8
+	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/dynamics.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'alda-rb'
+
+Alda::Score.new do
+	piano_
+	c8
+	pppppp; d
+	ppppp;  e
+	pppp;   f
+	ppp;    g
+	l :pp;  a
+	l :p;   b
+	mp;     o! c
+	mf;     o? b
+	l :f;   a
+	ff;     g
+	fff;    f
+	ffff;   e
+	fffff;  d
+	ffffff; c4
+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].sample), ms.()
+			note pitch(['abcdefg'[rand 7].to_sym,
+			           %i[sharp flat natural].sample]), ms.()
 		end
 	end
 	

data/examples/hanon.rb

@@ -22,8 +22,8 @@ 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
+		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 }