musa-dsl 0.26.6 → 0.26.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 33fe7c69b6b470b2563a5bb631744c7d39c7adb83c21fa612d630b212e63d99b
-  data.tar.gz: 18bd3611f80fcb47af81c4afc377f827bb18aa60702b491eb8e2d5edb4f70c16
+  metadata.gz: a1598e463290a813acd81f7d4c2a380c2b4f904c266505efb1c0c76295a2e891
+  data.tar.gz: 7b6c53ec4109d923f6aab5a1c250672b87a0c1bcc275c0e3359e769b01dd9371
 SHA512:
-  metadata.gz: 35c3e1131b02666ee0f7db1dc596946a9b472738499b50139aea90fa1ecd468ff900378ce862fe6e9b31958dd94fbd8e1209cb23894a800ec8a1c888acb1cdd0
-  data.tar.gz: 6b2c952e9388f77ceb296b008ed572420f0621a0d05ebb617cc7254d18b4b5e3cbd9c81dee87b22deecf864d953a99f1cf4353e40b0ce3fb072a67ef93baada1
+  metadata.gz: 8178a6d752685d3ae592c1e80374b85cba4f59ffdcc556d358d1f0c9a2787812421a74c6c247b890b80e05bf221ce3b490a60d2201361041419b0ca4e42f93cc
+  data.tar.gz: bfd208048b17a2e4f5374eedda0bd5dd5b2d6eb7268a867c63523477da6170f2a7a340d2dca8ab719467c58efd9662fed221118301d3d321c8176cb9785f380b

data/.github/workflows/gem-test-and-push.yml

@@ -11,7 +11,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        ruby-version: ['2.7']
+        ruby-version: ['2.7.8']
 
     steps:
     - uses: actions/checkout@v2
@@ -32,31 +32,17 @@ jobs:
       packages: write
 
     steps:
-    - uses: actions/checkout@v2
-    - name: Set up Ruby 2.7
-      uses: actions/setup-ruby@v1
+    - uses: actions/checkout@v3
+    - name: Set up Ruby 2.7.8
+      uses: ruby/setup-ruby@v1
       with:
-        ruby-version: 2.7.x
-
-#    - name: Publish to GPR
-#      run: |
-#        mkdir -p $HOME/.gem
-#        touch $HOME/.gem/credentials
-#        chmod 0600 $HOME/.gem/credentials
-#        printf -- "---\n:github: ${GEM_HOST_API_KEY}\n" > $HOME/.gem/credentials
-#        gem build *.gemspec
-#        gem push --KEY github --host https://rubygems.pkg.github.com/${OWNER} *.gem
-#      env:
-#        GEM_HOST_API_KEY: "Bearer ${{secrets.GITHUB_TOKEN}}"
-#        OWNER: ${{ github.repository_owner }}
+        ruby-version: 2.7.8
 
     - name: Publish to RubyGems
       run: |
         mkdir -p $HOME/.gem
         touch $HOME/.gem/credentials
         chmod 0600 $HOME/.gem/credentials
-        printf -- "---\n:rubygems_api_key: ${GEM_HOST_API_KEY}\n" > $HOME/.gem/credentials
+        printf -- "---\n:rubygems_api_key: ${{secrets.GEM_HOST_API_KEY}}\n" > $HOME/.gem/credentials
         gem build *.gemspec
         gem push *.gem
-      env:
-        GEM_HOST_API_KEY: "${{secrets.RUBYGEMS_AUTH_TOKEN}}"

data/Gemfile

@@ -1,3 +1,6 @@
 source 'https://rubygems.org'
 
 gemspec
+gem 'rubocop', group: 'development'
+gem 'rubocop', group: 'development'
+gem 'rubocop', group: 'development'

data/lib/musa-dsl/core-ext/smart-proc-binder.rb

@@ -29,36 +29,36 @@ module Musa
           @block.parameters
         end
 
-        def call(*value_parameters, **key_parameters)
-          _call value_parameters, key_parameters
+        def call(*value_parameters, **key_parameters, &block)
+          _call value_parameters, key_parameters, block
         end
 
-        def _call(value_parameters, key_parameters = {})
+        def _call(value_parameters, key_parameters = {}, block = nil)
           if @on_rescue
             begin
-              __call value_parameters, key_parameters
+              __call value_parameters, key_parameters, block
             rescue StandardError, ScriptError => e
               @on_rescue.call e
             end
           else
-            __call value_parameters, key_parameters
+            __call value_parameters, key_parameters, block
           end
         end
 
-        private def __call(value_parameters, key_parameters = {})
+        private def __call(value_parameters, key_parameters = {}, block = nil)
           effective_value_parameters, effective_key_parameters = apply(*value_parameters, **key_parameters)
 
           if effective_key_parameters.empty?
             if effective_value_parameters.empty?
-              @block.call
+              @block.call(&block)
             else
-              @block.call *effective_value_parameters
+              @block.call(*effective_value_parameters, &block)
             end
           else
             if effective_value_parameters.empty?
-              @block.call **effective_key_parameters
+              @block.call(**effective_key_parameters, &block)
             else
-              @block.call *effective_value_parameters, **effective_key_parameters
+              @block.call(*effective_value_parameters, **effective_key_parameters, &block)
             end
           end
         end

data/lib/musa-dsl/datasets/e.rb

@@ -45,7 +45,7 @@ module Musa::Datasets
 
     NaturalKeys = (NaturalKeys +
                    [:duration, # duration of the process (note reproduction, dynamics evolution, etc)
-                    :note_duration, # duration of the note (a staccato note is effectvely shorter than elapsed duration until next note)
+                    :note_duration, # duration of the note (a staccato note is effectively shorter than elapsed duration until next note)
                     :forward_duration # duration to wait until next event (if 0 means the next event should be executed at the same time than this one)
                    ]).freeze
 

data/lib/musa-dsl/datasets/gdvd.rb

@@ -109,7 +109,7 @@ module Musa::Datasets
       r
     end
 
-    def normalize_to_scale(scale, grade, sharps)
+    private def normalize_to_scale(scale, grade, sharps)
       note = scale[grade].sharp(sharps)
       background = note.background_note
 

data/lib/musa-dsl/music/scales.rb

@@ -284,7 +284,7 @@ module Musa
         freeze
       end
 
-      def_delegators :@kind, :a_tuning
+      def_delegators :@kind, :tuning
 
       attr_reader :kind, :root_pitch
 

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

@@ -119,7 +119,9 @@ module Musa
             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,6 +44,7 @@ module Musa::Sequencer
 
         case operation[:current_operation]
         when :none
+          # do nothing
         when :block
           # duplicating parameters as direct object value (operation[:current_parameter])
           # and key_passed parameters (**operation[:current_parameter])
@@ -55,7 +56,8 @@ module Musa::Sequencer
         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
@@ -102,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
 
@@ -156,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

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.rb

@@ -1,5 +1,5 @@
 module Musa
-  VERSION = '0.26.6.wip'.freeze
+  VERSION = '0.26.8'.freeze
 end
 
 require_relative 'musa-dsl/core-ext'

data/musa-dsl.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
   s.name        = 'musa-dsl'
-  s.version     = '0.26.6'
-  s.date        = '2022-02-26'
+  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.6
+  version: 0.26.8
 platform: ruby
 authors:
 - Javier Sánchez Yeste
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-02-26 00:00:00.000000000 Z
+date: 2023-05-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: logger
@@ -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: []