musa-dsl 0.26.5 → 0.26.8

data/lib/musa-dsl/neumalang/neumalang.citrus

@@ -15,7 +15,7 @@ grammar Musa::Neumalang::Neumalang::Parser::Grammar::Grammar
 
 	rule object_expression
 		braced_command |
-        reference_expression |
+		referenced_braced_command |
         bracketed_expression |
         use_variable |
         constant |
@@ -26,8 +26,8 @@ grammar Musa::Neumalang::Neumalang::Parser::Grammar::Grammar
         vector
 	end
 
-	rule reference_expression
-		(ampersand optional_separation expression) <Musa::Neumalang::Neumalang::Parser::ReferenceExpression>
+	rule referenced_braced_command
+		(ampersand optional_separation braced_command) <Musa::Neumalang::Neumalang::Parser::ReferencedBracedCommand>
 	end
 
 	rule variable_assign
@@ -67,7 +67,13 @@ grammar Musa::Neumalang::Neumalang::Parser::Grammar::Grammar
 	end
 
 	rule parameters
-	    (lpar parameter (comma parameter)* optional_separation rpar) <Musa::Neumalang::Neumalang::Parser::Parameters>
+	    (lpar parameter? (comma parameter)* optional_separation rpar codeblock?)
+	        <Musa::Neumalang::Neumalang::Parser::Parameters>
+	end
+
+	rule codeblock
+	    (ampersand lpar (braced_command | referenced_braced_command | use_variable) rpar)
+	        <Musa::Neumalang::Neumalang::Parser::Codeblock>
 	end
 
     rule parameter

data/lib/musa-dsl/neumalang/neumalang.rb

@@ -33,10 +33,10 @@ module Musa
           end
         end
 
-        module ReferenceExpression
+        module ReferencedBracedCommand
           def value
-            { kind: :reference,
-              reference: capture(:expression).value }.extend Musa::Neumas::Neuma
+            { kind: :command_reference,
+              command: capture(:braced_command).value }.extend Musa::Neumas::Neuma
           end
         end
 
@@ -74,10 +74,21 @@ module Musa
             {}.tap do |_|
               _[:value_parameters] = value_parameters unless value_parameters.empty?
               _[:key_parameters] = key_value_parameters unless key_value_parameters.empty?
+
+              _[:proc_parameter] = capture(:codeblock).value if capture(:codeblock)
             end
           end
         end
 
+        module Codeblock
+          def value
+            { codeblock:
+                capture(:braced_command)&.value ||
+                  capture(:referenced_braced_command)&.value ||
+                  capture(:use_variable)&.value }
+          end
+        end
+
         module Parameter
           def value
             if capture(:key_value_parameter)

data/lib/musa-dsl/repl/repl.rb

@@ -113,11 +113,15 @@ module Musa
         @client_threads.clear
       end
 
-      def puts(message)
+      def puts(*messages)
         if @connection
-          send output: @connection, content: message&.to_s
+          messages.each do |message|
+            send output: @connection, content: message&.to_s
+          end
         else
-          @logger.warn('REPL') { "trying to print a message in Atom client but the client is not connected. Ignoring message \'#{message} \'." }
+          @logger.warn('REPL') do
+            "trying to print a message in MusaLCE but the client is not connected. Ignoring message \'#{message} \'."
+          end
         end
       end
 

data/lib/musa-dsl/sequencer/base-sequencer-implementation-play-helper.rb

@@ -35,6 +35,7 @@ module Musa
       class AtModePlayEval < PlayEval
         def initialize(block_procedure_binder)
           @block_procedure_binder = block_procedure_binder
+          super()
         end
 
         def run_operation(element)
@@ -42,20 +43,22 @@ module Musa
 
           if element.is_a? Hash
             value = {
-                current_operation: :block,
-                current_block: @block_procedure_binder,
-                current_parameter: element,
-                continue_operation: :at,
-                continue_parameter: element[:at]
+              current_operation: :block,
+              current_block: @block_procedure_binder,
+              current_parameter: element,
+              continue_operation: :at,
+              continue_parameter: element[:at]
             }
           end
 
           value ||= {
-              current_operation: @block_procedure_binder,
-              current_parameter: element,
-              continue_operation: :at,
-              continue_parameter: position
+            current_operation: @block_procedure_binder,
+            current_parameter: element,
+            continue_operation: :at,
+            continue_parameter: position
           }
+
+          value
         end
       end
 
@@ -66,6 +69,7 @@ module Musa
 
         def initialize(block_procedure_binder)
           @block_procedure_binder = block_procedure_binder
+          super()
         end
 
         def run_operation(element)
@@ -76,30 +80,30 @@ module Musa
               element = AbsD.to_AbsD(element)
 
               value = {
-                  current_operation: :block,
-                  current_block: @block_procedure_binder,
-                  current_parameter: element,
-                  continue_operation: :wait,
-                  continue_parameter: element.forward_duration
+                current_operation: :block,
+                current_block: @block_procedure_binder,
+                current_parameter: element,
+                continue_operation: :wait,
+                continue_parameter: element.forward_duration
               }
             end
 
             if element.key? :wait_event
               value = {
-                  current_operation: :block,
-                  current_block: @block_procedure_binder,
-                  current_parameter: element,
-                  continue_operation: :on,
-                  continue_parameter: element[:wait_event]
+                current_operation: :block,
+                current_block: @block_procedure_binder,
+                current_parameter: element,
+                continue_operation: :on,
+                continue_parameter: element[:wait_event]
               }
             end
           end
 
           value ||= {
-              current_operation: :block,
-              current_block: @block_procedure_binder,
-              current_parameter: element,
-              continue_operation: :now
+            current_operation: :block,
+            current_block: @block_procedure_binder,
+            current_parameter: element,
+            continue_operation: :now
           }
 
           value
@@ -115,8 +119,8 @@ module Musa
 
         @@id = 0
 
-        attr_reader :neumalang_context
-        attr_reader :block_procedure_binder
+        attr_reader :neumalang_context,
+                    :block_procedure_binder
 
         def initialize(block_procedure_binder, decoder, nl_context, parent: nil)
           @id = @@id += 1
@@ -127,6 +131,8 @@ module Musa
           @nl_context = nl_context
 
           @nl_context ||= Object.new
+
+          super()
         end
 
         def subcontext
@@ -138,17 +144,17 @@ module Musa
             AbsD.to_AbsD(element)
           else
             case element[:kind]
-            when :serie         then eval_serie element[:serie]
-            when :parallel      then eval_parallel element[:parallel]
-            when :assign_to     then eval_assign_to element[:assign_to], element[:assign_value]
-            when :use_variable  then eval_use_variable element[:use_variable]
-            when :command       then eval_command element[:command], element[:value_parameters], element[:key_parameters]
-            when :value         then eval_value element[:value]
-            when :gdvd          then eval_gdvd element[:gdvd]
-            when :p             then eval_p element[:p]
-            when :call_methods  then eval_call_methods element[:on], element[:call_methods]
-            when :reference     then eval_reference element[:reference]
-            when :event         then element
+            when :serie             then eval_serie element[:serie]
+            when :parallel          then eval_parallel element[:parallel]
+            when :assign_to         then eval_assign_to element[:assign_to], element[:assign_value]
+            when :use_variable      then eval_use_variable element[:use_variable]
+            when :command           then eval_command element[:command], element[:value_parameters], element[:key_parameters]
+            when :value             then eval_value element[:value]
+            when :gdvd              then eval_gdvd element[:gdvd]
+            when :p                 then eval_p element[:p]
+            when :call_methods      then eval_call_methods element[:on], element[:call_methods]
+            when :command_reference then eval_command_reference element[:command]
+            when :event             then element
             else
               raise ArgumentError, "eval_element: don't know how to process #{element}"
             end
@@ -197,10 +203,10 @@ module Musa
 
         def eval_command(block, value_parameters, key_parameters)
           _value_parameters = value_parameters ? value_parameters.collect { |e| subcontext.eval_element(e) } : []
-          _key_parameters = key_parameters ? key_parameters.collect { |k, e| [k, subcontext.eval_element(e)] }.to_h : {}
+          _key_parameters = key_parameters ? key_parameters.transform_values { |e| subcontext.eval_element(e) } : {}
 
-          # used instance_exec because the code on block comes from a neumalang source, so the correct execution context is the neumalang context
-          # (no other context has any sense)
+          # used instance_exec because the code on block comes from a neumalang source, so the correct
+          # execution context is the neumalang context (no other context has any sense)
           #
           @nl_context.instance_exec *_value_parameters, **_key_parameters, &block
         end
@@ -211,38 +217,43 @@ module Musa
           value = play_eval.eval_element on
 
           if value.is_a? Parallel
-            value.collect do |_value|
-              call_methods.each do |methd|
-                value_parameters = methd[:value_parameters] ? methd[:value_parameters].collect { |e| play_eval.subcontext.eval_element(e) } : []
-                key_parameters = methd[:key_parameters] ? methd[:key_parameters].collect { |k, e| [k, play_eval.subcontext.eval_element(e)] }.to_h : {}
-
-                _value = _value.send methd[:method], *value_parameters, **key_parameters
-              end
-
-              _value
-            end.extend Parallel
+            value.collect { |_value| eval_methods(play_eval, _value, call_methods) }.extend Parallel
           else
-            call_methods.each do |methd|
-              value_parameters = methd[:value_parameters] ? methd[:value_parameters].collect { |e| play_eval.subcontext.eval_element(e) } : []
-              key_parameters = methd[:key_parameters] ? methd[:key_parameters].collect { |k, e| [k, play_eval.subcontext.eval_element(e)] }.to_h : {}
+            eval_methods(play_eval, value, call_methods)
+          end
+        end
 
-              value = value.send methd[:method], *value_parameters, **key_parameters
-            end
+        def eval_methods(play_eval, value, methods)
+          methods.each do |methd|
+            value_parameters = methd[:value_parameters]&.collect { |e| play_eval.subcontext.eval_element(e) } || []
+            key_parameters = methd[:key_parameters]&.transform_values { |e| play_eval.subcontext.eval_element(e) } || {}
+            proc_parameter = eval_proc_parameter(methd[:proc_parameter][:codeblock]) if methd[:proc_parameter]
 
-            value
+            value = value.send methd[:method], *value_parameters, **key_parameters, &proc_parameter
           end
+
+          value
+        end
+
+        def eval_command_reference(element)
+          element[:command]
         end
 
-        def eval_reference(element)
-          if element.is_a?(Hash) && element.key?(:kind)
+        def eval_proc_parameter(element)
+          case element
+          when Proc
+            element
+          when nil
+            nil
+          else
             case element[:kind]
+            when :use_variable
+              eval_proc_parameter(eval_use_variable(element[:use_variable]))
+            when :command_reference
+              eval_proc_parameter(element[:command])
             when :command
               element[:command]
-            else
-              raise ArgumentError, "eval_reference(&): don't know how to process element #{element}"
             end
-          else
-            raise ArgumentError, "eval_reference(&): don't know how to process element #{element}"
           end
         end
 
@@ -264,7 +275,7 @@ module Musa
 
           when Parallel
             { current_operation: :parallel_play,
-              current_parameter: element.instance.tap { |e| e.each(&:restart) } }
+              current_parameter: element.tap { |e| e.each(&:restart) } }
 
           when Array
             { current_operation: :no_eval_play,
@@ -322,18 +333,15 @@ module Musa
               run_operation eval_use_variable(element[:use_variable])
 
             when :event
-              value_parameters = element[:value_parameters] ?
-                                     element[:value_parameters].collect { |e| subcontext.eval_element(e) } :
-                                     []
-
-              key_parameters = element[:key_parameters] ?
-                                   element[:key_parameters].collect { |k, e| [k, subcontext.eval_element(e)] }.to_h :
-                                   {}
+              value_parameters = element[:value_parameters]&.collect { |e| subcontext.eval_element(e) } || []
+              key_parameters = element[:key_parameters]&.transform_values { |e| subcontext.eval_element(e) } || {}
+              proc_parameter = eval_proc_parameter(element[:proc_parameter][:codeblock]) if element[:proc_parameter]
 
               { current_operation: :event,
                 current_event: element[:event],
                 current_value_parameters: value_parameters,
                 current_key_parameters: key_parameters,
+                current_proc_parameter: proc_parameter,
                 continue_operation: :now }
 
             when :command
@@ -343,7 +351,7 @@ module Musa
               run_operation eval_call_methods(element[:on], element[:call_methods])
 
             when :reference
-              run_operation eval_reference(element[:reference])
+              run_operation eval_command_reference(element[:reference])
 
             else
               raise ArgumentError, "run_operation: don't know how to process #{element}"

data/lib/musa-dsl/sequencer/base-sequencer-implementation-play.rb

@@ -44,13 +44,20 @@ module Musa::Sequencer
 
         case operation[:current_operation]
         when :none
+          # do nothing
         when :block
-          __play_eval.block_procedure_binder.call operation[:current_parameter], control: control
+          # duplicating parameters as direct object value (operation[:current_parameter])
+          # and key_passed parameters (**operation[:current_parameter])
+          #
+          __play_eval.block_procedure_binder.call operation[:current_parameter],
+                                                  **operation[:current_parameter],
+                                                  control: control
 
         when :event
           control._launch operation[:current_event],
                           operation[:current_value_parameters],
-                          operation[:current_key_parameters]
+                          operation[:current_key_parameters],
+                          operation[:current_proc_parameter]
 
         when :play
           control2 = PlayControl.new control
@@ -97,7 +104,7 @@ module Musa::Sequencer
 
           control2.on :sync do
             counter -= 1
-            _play serie, control, __play_eval: __play_eval, **mode_args if counter == 0
+            _play serie, control, __play_eval: __play_eval, **mode_args if counter.zero?
           end
         end
 
@@ -151,18 +158,18 @@ module Musa::Sequencer
       def store_continuation(sequencer:, serie:, neumalang_context:, mode:, decoder:, play_eval:, mode_args:)
         @continuation_sequencer = sequencer
         @continuation_parameters = {
-            serie: serie,
-            control: self,
-            neumalang_context: neumalang_context,
-            mode: mode,
-            decoder: decoder,
-            play_eval: play_eval,
-            mode_args: mode_args }
+          serie: serie,
+          control: self,
+          neumalang_context: neumalang_context,
+          mode: mode,
+          decoder: decoder,
+          play_eval: play_eval,
+          mode_args: mode_args }
       end
 
       def continue
         super
-        @continuation_sequencer.continuation_play(@continuation_parameters) if @continuation_sequencer
+        @continuation_sequencer&.continuation_play(@continuation_parameters)
       end
 
       def after(bars = nil, &block)

data/lib/musa-dsl/sequencer/base-sequencer-implementation.rb

@@ -18,13 +18,13 @@ module Musa::Sequencer
             @event_handlers.push command[:parent_control]
 
             @tick_mutex.synchronize do
-              command[:block].call *command[:value_parameters], **command[:key_parameters] if command[:block]
+              command[:block]&.call *command[:value_parameters], **command[:key_parameters]
             end
 
             @event_handlers.pop
           else
             @tick_mutex.synchronize do
-              command[:block].call *command[:value_parameters], **command[:key_parameters] if command[:block]
+              command[:block]&.call *command[:value_parameters], **command[:key_parameters]
             end
           end
         end
@@ -72,7 +72,7 @@ module Musa::Sequencer
       key_parameters[:control] = control if block_key_parameters_binder.key?(:control)
 
       if at_position == @position
-        @on_debug_at.each { |c| c.call } if @logger.sev_threshold >= ::Logger::Severity::DEBUG
+        @on_debug_at.each(&:call) if @logger.sev_threshold >= ::Logger::Severity::DEBUG
 
         begin
           locked = @tick_mutex.try_lock
@@ -169,24 +169,24 @@ module Musa::Sequencer
         @handlers[event][name] = { block: Musa::Extension::SmartProcBinder::SmartProcBinder.new(block), only_once: only_once }
       end
 
-      def launch(event, *value_parameters, **key_parameters)
-        _launch event, value_parameters, key_parameters
+      def launch(event, *value_parameters, **key_parameters, &proc_parameter)
+        _launch event, value_parameters, key_parameters, proc_parameter
       end
 
-      def _launch(event, value_parameters = nil, key_parameters = nil)
+      def _launch(event, value_parameters = nil, key_parameters = nil, proc_parameter = nil)
         value_parameters ||= []
         key_parameters ||= {}
         processed = false
 
         if @handlers.key? event
           @handlers[event].each do |name, handler|
-            handler[:block].call *value_parameters, **key_parameters
+            handler[:block].call *value_parameters, **key_parameters, &proc_parameter
             @handlers[event].delete name if handler[:only_once]
             processed = true
           end
         end
 
-        @parent._launch event, value_parameters, key_parameters if @parent && !processed
+        @parent._launch event, value_parameters, key_parameters, proc_parameter if @parent && !processed
       end
 
       def inspect

data/lib/musa-dsl/sequencer/sequencer-dsl.rb

@@ -2,8 +2,6 @@ require 'forwardable'
 
 require_relative '../core-ext/with'
 
-module TEMP; end
-
 module Musa
   module Sequencer
     class Sequencer
@@ -41,7 +39,7 @@ module Musa
                                          do_error_log: do_error_log,
                                          log_position_format: log_position_format
 
-        # dsl_context_class ||= DSLContext
+        dsl_context_class ||= DSLContext
 
         @dsl = dsl_context_class.new @sequencer, keep_block_context: keep_block_context
 

data/lib/musa-dsl/series/main-serie-operations.rb

@@ -148,7 +148,12 @@ module Musa
           self.source = serie
           self.with_sources = with_series || []
           self.on_restart = on_restart
-          self.proc = block if block
+
+          if block
+            self.proc = block
+          elsif !with_series
+            proc { |_| _ }
+          end
 
           @isolate_values = isolate_values
 
@@ -278,7 +283,8 @@ module Musa
           init
         end
 
-        private def _restart
+        private :_restart
+        def _restart
           @source.restart
           if @sources.is_a? Array
             @sources.each(&:restart)
@@ -287,7 +293,8 @@ module Musa
           end
         end
 
-        private def _next_value
+        private :_next_value
+        def _next_value
           value = nil
 
           index_or_key = @source.next_value

data/lib/musa-dsl/transport/input-midi-clock.rb

@@ -21,10 +21,12 @@ module Musa
           @logger.debug! if do_log
         end
 
+        @time_table = []
         @midi_parser = MIDIParser.new
       end
 
       attr_reader :input
+      attr_reader :time_table
 
       def input=(input_midi_port)
         @input = input_midi_port
@@ -121,6 +123,7 @@ module Musa
         case m.name
         when 'Start'
           process_start
+          @time_table.clear
 
         when 'Stop'
           @logger.debug('InputMidiClock') { 'processing Stop...' }
@@ -135,7 +138,15 @@ module Musa
           @logger.debug('InputMidiClock') { 'processing Continue... done' }
 
         when 'Clock'
-          yield if block_given? && @started
+          if block_given? && @started
+            start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond)
+            yield
+            finish_time = Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond)
+
+            duration = finish_time - start_time
+            @time_table[duration] ||= 0
+            @time_table[duration] += 1
+          end
 
         when 'Song Position Pointer'
           new_position_in_midi_beats = m.data[0] & 0x7F | ((m.data[1] & 0x7F) << 7)

data/lib/musa-dsl.rb

@@ -1,5 +1,5 @@
 module Musa
-  VERSION = '0.26.5'.freeze
+  VERSION = '0.26.8'.freeze
 end
 
 require_relative 'musa-dsl/core-ext'
@@ -54,7 +54,7 @@ module Musa::All
 
   include Musa::Darwin
   include Musa::Markov
-  include Musa::Backboner
+  include Musa::Rules
   include Musa::Variatio
 
   include Musa::MIDIRecorder

data/musa-dsl.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
   s.name        = 'musa-dsl'
-  s.version     = '0.26.5'
-  s.date        = '2022-02-25'
+  s.version     = '0.26.8'
+  s.date        = '2023-05-30'
   s.summary     = 'A simple Ruby DSL for making complex music'
   s.description = 'Musa-DSL: A Ruby framework and DSL for algorithmic sound and musical thinking and composition'
   s.authors     = ['Javier Sánchez Yeste']
@@ -12,7 +12,7 @@ Gem::Specification.new do |s|
 
   s.required_ruby_version = '~> 2.7'
 
-  # TODO
+  # TODO para sistema de paquetes de MusaDSL
   #s.metadata    = {
     # "source_code_uri" => "https://",
     # "homepage_uri" => "",

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: musa-dsl
 version: !ruby/object:Gem::Version
-  version: 0.26.5
+  version: 0.26.8
 platform: ruby
 authors:
 - Javier Sánchez Yeste
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-02-25 00:00:00.000000000 Z
+date: 2023-05-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: logger
@@ -161,10 +161,10 @@ files:
 - lib/musa-dsl/datasets/score/to-mxml/to-mxml.rb
 - lib/musa-dsl/datasets/v.rb
 - lib/musa-dsl/generative.rb
-- lib/musa-dsl/generative/backboner.rb
 - lib/musa-dsl/generative/darwin.rb
 - lib/musa-dsl/generative/generative-grammar.rb
 - lib/musa-dsl/generative/markov.rb
+- lib/musa-dsl/generative/rules.rb
 - lib/musa-dsl/generative/variatio.rb
 - lib/musa-dsl/logger.rb
 - lib/musa-dsl/logger/logger.rb
@@ -255,7 +255,7 @@ homepage: https://github.com/javier-sy/musa-dsl
 licenses:
 - LGPL-3.0
 metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -271,7 +271,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.1.6
-signing_key:
+signing_key: 
 specification_version: 4
 summary: A simple Ruby DSL for making complex music
 test_files: []