musa-dsl 0.23.11 → 0.23.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: abb4a2e7ffcd4376fd2d54f73172d611fe65da0cf6406365c7341b65e0706d30
-  data.tar.gz: 84214e98aa34a365a370e7597e0a64bafb800eafd59e17a6fdd8ac840bd915de
+  metadata.gz: 83e058435542d40d1947cb484686b8b78b67c39e0a00f88d60d3b1c534620401
+  data.tar.gz: eef1c767f85c7ad1c174986eee492f7588d6c6c32e57b3fa13f8dcb7e8a8db23
 SHA512:
-  metadata.gz: 26936f34fc5038249db6df38ee405af52ff67ff7328d47a0f1f030768c33f61f828004b3d5581adc4857e2fbca60aba628e3c2cf14b21b48e3f455b52f587efd
-  data.tar.gz: 107fbc88359e3fe58b996d3156ae09b381580807bf6e0fe51fe281a37eb1b476eeeb483eacc63cb28e7c215ebd713d30dc432304d54b3b9155ef6fc304b6a33a
+  metadata.gz: ce2bbb09377ad73191994790009429f469a7c46edaa47bdf5dd7cbc04b4541cfeef36006bc9b68c0f5baf2598e9c52acf339dd3b166702cef102e96209cb5013
+  data.tar.gz: 0c787f3da1d3beddbf09dcf20493c0cb0ed97868a49ea26432307093df222ec69ef9128cf2ce9d58a0211ccd2ec3a4ea59446fb14026b00f90dd41691c4cbf3a

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

@@ -4,10 +4,10 @@ require_relative 'pdv'
 
 require_relative 'helper'
 
-using Musa::Extension::InspectNice
-
 module Musa::Datasets
   module GDV
+    using Musa::Extension::InspectNice
+
     include AbsD
 
     include Helper

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

@@ -3,7 +3,6 @@ require_relative 'gdv'
 
 require_relative 'helper'
 
-using Musa::Extension::InspectNice
 
 module Musa::Datasets
   module GDVd
@@ -12,6 +11,8 @@ module Musa::Datasets
 
     include Helper
 
+    using Musa::Extension::InspectNice
+
     NaturalKeys = (NaturalKeys +
                     [:abs_grade, :abs_sharps, :abs_octave,
                      :delta_grade, :delta_sharps, :delta_interval_sign, :delta_interval, :delta_octave,

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

@@ -1,6 +1,6 @@
 module Musa::Datasets
   module Helper
-    protected
+    private
 
     def positive_sign_of(x)
       x >= 0 ? '+' : ''

data/lib/musa-dsl/datasets/score/queriable.rb

@@ -1,48 +1,49 @@
-module Musa::Datasets; class Score
-  module Queriable
-    module QueryableByTimeSlot
-      def group_by_attribute(attribute)
-        group_by { |e| e[attribute] }.transform_values! { |e| e.extend(QueryableByTimeSlot) }
+module Musa::Datasets
+  class Score
+    module Queriable
+      module QueryableByTimeSlot
+        def group_by_attribute(attribute)
+          group_by { |e| e[attribute] }.transform_values! { |e| e.extend(QueryableByTimeSlot) }
+        end
+
+        def select_by_attribute(attribute, value = nil)
+          if value.nil?
+            select { |e| !e[attribute].nil? }
+          else
+            select { |e| e[attribute] == value }
+          end.extend(QueryableByTimeSlot)
+        end
+
+        def sort_by_attribute(attribute)
+          select_by_attribute(attribute).sort_by { |e| e[attribute] }.extend(QueryableByTimeSlot)
+        end
       end
 
-      def select_by_attribute(attribute, value = nil)
-        if value.nil?
-          select { |e| !e[attribute].nil? }
-        else
-          select { |e| e[attribute] == value }
-        end.extend(QueryableByTimeSlot)
+      private_constant :QueryableByTimeSlot
+
+      module QueryableByDataset
+        def group_by_attribute(attribute)
+          group_by { |e| e[:dataset][attribute] }.transform_values! { |e| e.extend(QueryableByDataset) }
+        end
+
+        def select_by_attribute(attribute, value = nil)
+          if value.nil?
+            select { |e| !e[:dataset][attribute].nil? }
+          else
+            select { |e| e[:dataset][attribute] == value }
+          end.extend(QueryableByDataset)
+        end
+
+        def subset
+          raise ArgumentError, "subset needs a block with the inclusion condition on the dataset" unless block_given?
+          select { |e| yield e[:dataset] }.extend(QueryableByDataset)
+        end
+
+        def sort_by_attribute(attribute)
+          select_by_attribute(attribute).sort_by { |e| e[:dataset][attribute] }.extend(QueryableByDataset)
+        end
       end
 
-      def sort_by_attribute(attribute)
-        select_by_attribute(attribute).sort_by { |e| e[attribute] }.extend(QueryableByTimeSlot)
-      end
-    end
-
-    private_constant :QueryableByTimeSlot
-
-    module QueryableByDataset
-      def group_by_attribute(attribute)
-        group_by { |e| e[:dataset][attribute] }.transform_values! { |e| e.extend(QueryableByDataset) }
-      end
-
-      def select_by_attribute(attribute, value = nil)
-        if value.nil?
-          select { |e| !e[:dataset][attribute].nil? }
-        else
-          select { |e| e[:dataset][attribute] == value }
-        end.extend(QueryableByDataset)
-      end
-
-      def subset
-        raise ArgumentError, "subset needs a block with the inclusion condition on the dataset" unless block_given?
-        select { |e| yield e[:dataset] }.extend(QueryableByDataset)
-      end
-
-      def sort_by_attribute(attribute)
-        select_by_attribute(attribute).sort_by { |e| e[:dataset][attribute] }.extend(QueryableByDataset)
-      end
+      private_constant :QueryableByDataset
     end
-
-    private_constant :QueryableByDataset
-  end
 end; end

data/lib/musa-dsl/datasets/score/render.rb

@@ -1,31 +1,35 @@
 require_relative '../../sequencer'
 require_relative '../../series'
 
-module Musa::Datasets; class Score
-  module Render
-    def render(on:, &block)
-      @score.keys.each do |score_at|
-        effective_wait = score_at - 1r
+module Musa
+  module Datasets
+    class Score
+      module Render
+        def render(on:, &block)
+          @score.keys.each do |score_at|
+            effective_wait = score_at - 1r
 
-        @score[score_at].each do |element|
-          case element
-          when Score
-            on.wait effective_wait do
-              element.render(on: on, &block)
-            end
+            @score[score_at].each do |element|
+              case element
+              when Score
+                on.wait effective_wait do
+                  element.render(on: on, &block)
+                end
 
-          when Abs
-            on.wait effective_wait do
-              block.call(element)
-            end
+              when Abs
+                on.wait effective_wait do
+                  block.call(element)
+                end
 
-          else
-            raise ArgumentError, "Can't sequence #{element} because it's not an Abs dataset"
+              else
+                raise ArgumentError, "Can't sequence #{element} because it's not an Abs dataset"
+              end
+            end
           end
+
+          nil
         end
       end
-
-      nil
     end
   end
-end; end
+end

data/lib/musa-dsl/datasets/score/to-mxml/to-mxml.rb

@@ -6,167 +6,165 @@ require_relative 'process-time'
 require_relative 'process-pdv'
 require_relative 'process-ps'
 
-module Musa::Datasets; class Score
-  module ToMXML
-    include Musa::MusicXML::Builder
-    include Musa::Datasets
-
-    using Musa::Extension::InspectNice
-
-    def to_mxml(beats_per_bar, ticks_per_beat,
-                bpm: nil,
-                title: nil,
-                creators: nil,
-                encoding_date: nil,
-                parts:,
-                logger: nil,
-                do_log: nil)
-
-      bpm ||= 90
-      title ||= 'Untitled'
-      creators ||= { composer: 'Unknown' }
-
-      if logger.nil?
-        logger = Musa::Logger::Logger.new
-        logger.debug! if do_log
-      end
+module Musa::Datasets 
+  class Score
+    module ToMXML
+      using Musa::Extension::InspectNice
+
+      def to_mxml(beats_per_bar, ticks_per_beat,
+                  bpm: nil,
+                  title: nil,
+                  creators: nil,
+                  encoding_date: nil,
+                  parts:,
+                  logger: nil,
+                  do_log: nil)
+
+        bpm ||= 90
+        title ||= 'Untitled'
+        creators ||= { composer: 'Unknown' }
+
+        if logger.nil?
+          logger = Musa::Logger::Logger.new
+          logger.debug! if do_log
+        end
 
-      do_log ||= nil
+        do_log ||= nil
 
-      mxml = ScorePartwise.new do |_|
-        _.work_title title
-        _.creators **creators
-        _.encoding_date encoding_date if encoding_date
+        mxml = Musa::MusicXML::Builder::ScorePartwise.new do |_|
+          _.work_title title
+          _.creators **creators
+          _.encoding_date encoding_date if encoding_date
 
-        parts.each_pair do |id, part_info|
-          _.part id,
-                 name: part_info&.[](:name),
-                 abbreviation: part_info&.[](:abbreviation) do |_|
+          parts.each_pair do |id, part_info|
+            _.part id,
+                   name: part_info&.[](:name),
+                   abbreviation: part_info&.[](:abbreviation) do |_|
 
-            _.measure do |_|
-              _.attributes do |_|
-                _.divisions ticks_per_beat
+              _.measure do |_|
+                _.attributes do |_|
+                  _.divisions ticks_per_beat
 
-                i = 0
-                (part_info&.[](:clefs) || { g: 2 }).each_pair do |clef, line|
-                  i += 1
-                  _.clef i, sign: clef.upcase, line: line
-                  _.time i, beats: beats_per_bar, beat_type: 4
+                  i = 0
+                  (part_info&.[](:clefs) || { g: 2 }).each_pair do |clef, line|
+                    i += 1
+                    _.clef i, sign: clef.upcase, line: line
+                    _.time i, beats: beats_per_bar, beat_type: 4
+                  end
                 end
-              end
 
-              _.metronome placement: 'above', beat_unit: 'quarter', per_minute: bpm
+                _.metronome placement: 'above', beat_unit: 'quarter', per_minute: bpm
+              end
             end
           end
         end
-      end
 
-      if do_log
-        logger.debug ""
-        logger.debug"score.to_mxml log:"
-        logger.debug"------------------"
-      end
+        if do_log
+          logger.debug ""
+          logger.debug"score.to_mxml log:"
+          logger.debug"------------------"
+        end
 
-      parts.each_key do |part_id|
-        fill_part mxml.parts[part_id],
-                  beats_per_bar * ticks_per_beat,
-                  (parts.size > 1 ? part_id : nil),
-                  logger, do_log
-      end
+        parts.each_key do |part_id|
+          fill_part mxml.parts[part_id],
+                    beats_per_bar * ticks_per_beat,
+                    (parts.size > 1 ? part_id : nil),
+                    logger, do_log
+        end
 
-      mxml
-    end
+        mxml
+      end
 
-    private
+      private
 
-    def fill_part(part, divisions_per_bar, instrument, logger, do_log)
-      measure = nil
-      dynamics_context = nil
+      def fill_part(part, divisions_per_bar, instrument, logger, do_log)
+        measure = nil
+        dynamics_context = nil
 
-      (1..finish || 0).each do |bar|
-        if do_log
-          logger.debug ""
-          logger.debug msg = "filling part #{part.name} (#{instrument || 'nil'}): processing bar #{bar}"
-          logger.debug "-" * msg.size
-        end
+        (1..finish || 0).each do |bar|
+          if do_log
+            logger.debug ""
+            logger.debug msg = "filling part #{part.name} (#{instrument || 'nil'}): processing bar #{bar}"
+            logger.debug "-" * msg.size
+          end
 
-        measure = part.add_measure if measure
-        measure ||= part.measures.last
+          measure = part.add_measure if measure
+          measure ||= part.measures.last
 
-        pointer = 0r
+          pointer = 0r
 
-        instrument_score = subset { |dataset| instrument.nil? || dataset[:instrument] == instrument }
+          instrument_score = subset { |dataset| instrument.nil? || dataset[:instrument] == instrument }
 
-        bar_elements = \
-        (instrument_score.changes_between(bar, bar + 1).select { |p| p[:dataset].is_a?(PS) } +
-            (pdvs = instrument_score.between(bar, bar + 1).select { |p| p[:dataset].is_a?(PDV) }))
-                                   .sort_by { |e| [ e[:time_in_interval] || e[:start_in_interval],
-                                                    e[:dataset].is_a?(PS) ? 0 : 1 ] }
+          bar_elements = \
+          (instrument_score.changes_between(bar, bar + 1).select { |p| p[:dataset].is_a?(Musa::Datasets::PS) } +
+              (pdvs = instrument_score.between(bar, bar + 1).select { |p| p[:dataset].is_a?(Musa::Datasets::PDV) }))
+                                     .sort_by { |e| [ e[:time_in_interval] || e[:start_in_interval],
+                                                      e[:dataset].is_a?(Musa::Datasets::PS) ? 0 : 1 ] }
 
-        if pdvs.empty?
-          logger.debug "\nadding full bar silence..." if do_log
+          if pdvs.empty?
+            logger.debug "\nadding full bar silence..." if do_log
 
-          process_pdv(measure, bar, divisions_per_bar,
-                      { start: bar,
-                        finish: bar + 1,
-                        dataset: { pitch: :silence, duration: 1 }.extend(PDV) },
-                      pointer,
-                      logger,
-                      do_log)
-        else
-          first = bar_elements.first
+            process_pdv(measure, bar, divisions_per_bar,
+                        { start: bar,
+                          finish: bar + 1,
+                          dataset: { pitch: :silence, duration: 1 }.extend(Musa::Datasets::PDV) },
+                        pointer,
+                        logger,
+                        do_log)
+          else
+            first = bar_elements.first
 
-          logger.debug "\nfirst element #{first.inspect}" if do_log
+            logger.debug "\nfirst element #{first.inspect}" if do_log
 
-          # TODO habrá que arreglar el cálculo de pointer cuando haya avances y retrocesos para que
-          # TODO no añada silencios incorrectos al principio o al final
+            # TODO habrá que arreglar el cálculo de pointer cuando haya avances y retrocesos para que
+            # TODO no añada silencios incorrectos al principio o al final
 
-          if (first[:time_in_interval] || first[:start_in_interval]) > bar
+            if (first[:time_in_interval] || first[:start_in_interval]) > bar
 
-            silence_duration = first[:start_in_interval] - bar
+              silence_duration = first[:start_in_interval] - bar
 
-            logger.debug "\nadding initial silence for duration #{silence_duration}..." if do_log
+              logger.debug "\nadding initial silence for duration #{silence_duration}..." if do_log
 
-            pointer = process_pdv(measure, bar, divisions_per_bar,
-                                  { start: bar,
-                                    finish: first[:start_in_interval],
-                                    dataset: { pitch: :silence, duration: silence_duration }.extend(PDV) },
-                                  pointer,
-                                  logger,
-                                  do_log)
-          end
+              pointer = process_pdv(measure, bar, divisions_per_bar,
+                                    { start: bar,
+                                      finish: first[:start_in_interval],
+                                      dataset: { pitch: :silence, duration: silence_duration }.extend(Musa::Datasets::PDV) },
+                                    pointer,
+                                    logger,
+                                    do_log)
+            end
 
-          logger.debug "\nadding PDV and PS elements..." if do_log
+            logger.debug "\nadding PDV and PS elements..." if do_log
 
-          bar_elements.each do |element|
-            case element[:dataset]
-            when PDV
-              pointer = process_pdv(measure, bar, divisions_per_bar, element, pointer, logger, do_log)
+            bar_elements.each do |element|
+              case element[:dataset]
+              when Musa::Datasets::PDV
+                pointer = process_pdv(measure, bar, divisions_per_bar, element, pointer, logger, do_log)
 
-            when PS
-              dynamics_context = process_ps(measure, element, dynamics_context, logger, do_log)
+              when Musa::Datasets::PS
+                dynamics_context = process_ps(measure, element, dynamics_context, logger, do_log)
 
-            else
-              # ignored
+              else
+                # ignored
+              end
             end
-          end
 
-          if pointer < 1r
-            silence_duration = 1r - pointer
+            if pointer < 1r
+              silence_duration = 1r - pointer
 
-            logger.debug "\nadded ending silence for duration #{silence_duration}..." if do_log
+              logger.debug "\nadded ending silence for duration #{silence_duration}..." if do_log
 
-            process_pdv(measure, bar, divisions_per_bar,
-                        { start: bar + pointer,
-                          finish: bar + 1 - Rational(1, divisions_per_bar),
-                          dataset: { pitch: :silence, duration: silence_duration }.extend(PDV) },
-                        pointer,
-                        logger,
-                        do_log)
+              process_pdv(measure, bar, divisions_per_bar,
+                          { start: bar + pointer,
+                            finish: bar + 1 - Rational(1, divisions_per_bar),
+                            dataset: { pitch: :silence, duration: silence_duration }.extend(Musa::Datasets::PDV) },
+                          pointer,
+                          logger,
+                          do_log)
 
+            end
           end
         end
       end
     end
-  end
 end; end