musa-dsl 0.14.32 → 0.21.5

data/lib/musa-dsl/core-ext/array-apply-get.rb

@@ -1,18 +0,0 @@
-# TODO hacer que *_nice permitar recibir atributos para indicar cómo se quieren procesar los parámetros (haciendo *, **, o sin hacer nada)
-
-class Array
-	def apply method_name, source
-	
-		source = [source] unless source.is_a? Array
-		
-		self.each_with_index do |o, i|
-			o.send method_name, source[i % source.length]
-		end
-	end
-
-	def get method_name
-		self.collect { |o| o.send method_name }
-	end
-end
-
-

data/lib/musa-dsl/core-ext/array-to-neumas.rb

@@ -1,28 +0,0 @@
-require 'musa-dsl/series'
-require 'musa-dsl/neumalang'
-
-class Array
-  def to_neumas
-    if length > 1
-      MERGE(*collect { |e| convert_to_neumas(e) })
-    else
-      convert_to_neumas(first)
-    end
-  end
-
-  alias_method :neumas, :to_neumas
-  alias_method :n, :to_neumas
-
-  private
-
-  def convert_to_neumas(e)
-    case e
-    when Musa::Neumalang::Neumas then e
-    when Musa::Neumalang::Neuma::Parallel then _SE([e], extends: Musa::Neumalang::Neumas)
-    when String then e.to_neumas
-    else
-      raise ArgumentError, "Don't know how to convert to neumas #{e}"
-    end
-  end
-end
-

data/lib/musa-dsl/core-ext/as-context-run.rb

@@ -1,44 +0,0 @@
-# TODO: hacer que *_nice permitar recibir atributos para indicar cómo se quieren procesar los parámetros (haciendo *, **, o sin hacer nada)
-
-class Object
-  def as_context_run(procedure, *list_or_key_args, **key_args)
-    _as_context_run procedure, list_or_key_args, key_args
-  end
-
-  def _as_context_run(procedure, list_or_key_args = nil, key_args = nil)
-    if !list_or_key_args.nil? && list_or_key_args.is_a?(Hash)
-      key_args = list_or_key_args
-      list_or_key_args = nil
-    end
-
-    if procedure.lambda?
-      if !list_or_key_args.nil? && !list_or_key_args.empty?
-        if !key_args.nil? && !key_args.empty?
-          procedure.call *list_or_key_args, **key_args
-        else
-          procedure.call *list_or_key_args
-        end
-      else
-        if !key_args.nil? && !key_args.empty?
-          procedure.call **key_args
-        else
-          procedure.call
-        end
-      end
-    else
-      if !list_or_key_args.nil? && !list_or_key_args.empty?
-        if !key_args.nil? && !key_args.empty?
-          instance_exec *list_or_key_args, **key_args, &procedure
-        else
-          instance_exec *list_or_key_args, &procedure
-        end
-      else
-        if !key_args.nil? && !key_args.empty?
-          instance_exec **key_args, &procedure
-        else
-          instance_eval &procedure
-        end
-      end
-    end
-  end
-end

data/lib/musa-dsl/core-ext/duplicate.rb

@@ -1,134 +0,0 @@
-# Based on https://github.com/adamluzsi/duplicate.rb/blob/master/lib/duplicate.rb
-# Modifications by JSY
-
-module Duplicate
-  extend self
-
-  def duplicate(object)
-    register = {}
-
-    _dup(register, object)
-  end
-
-  protected
-
-  def registered(object, register)
-    register[object.__id__]
-  end
-
-  def register_duplication(register, object, duplicate)
-    register[object.__id__] = duplicate
-    duplicate
-  end
-
-  def _dup(register, object)
-    return registered(object, register) if registered(object, register)
-    return register_duplication(register, object, object) unless identifiable?(object)
-
-    case object
-
-    when Array
-      dup_array(register, object)
-
-    when Hash
-      dup_hash(register, object)
-
-    when Range
-      dup_range(register, object)
-
-    when Struct
-      dup_struct(register, object)
-
-    when NilClass, Symbol, Numeric, TrueClass, FalseClass, Method
-      register_duplication(register, object, object)
-
-    else
-      dup_object(register, object)
-
-    end
-  end
-
-  def identifiable?(object)
-    object.class && object.respond_to?(:is_a?)
-  rescue NoMethodError
-    false
-  end
-
-  def dup_array(register, object)
-    duplication = dup_object(register, object)
-    duplication.map! { |e| _dup(register, e) }
-  end
-
-  def dup_hash(register, object)
-    duplication = dup_object(register, object)
-    object.reduce(duplication) { |hash, (k, v)| hash.merge!(_dup(register, k) => _dup(register, v)) }
-  end
-
-  def dup_range(register, range)
-    register_duplication(register, range, range.class.new(_dup(register, range.first), _dup(register, range.last)))
-  rescue StandardError
-    register_duplication(register, range, range.dup)
-  end
-
-  def dup_struct(register, struct)
-    duplication = register_duplication(register, struct, struct.dup)
-
-    struct.each_pair do |attr, value|
-      duplication.__send__("#{attr}=", _dup(register, value))
-    end
-
-    duplication
-  end
-
-  def dup_object(register, object)
-    dup_instance_variables(register, object, register_duplication(register, object, try_dup(object)))
-  end
-
-  def dup_instance_variables(register, object, duplication)
-    return duplication unless respond_to_instance_variables?(object)
-
-    object.instance_variables.each do |instance_variable|
-      value = get_instance_variable(object, instance_variable)
-
-      set_instance_variable(duplication, instance_variable, _dup(register, value))
-    end
-
-    duplication
-  end
-
-  def get_instance_variable(object, instance_variable_name)
-    object.instance_variable_get(instance_variable_name)
-  rescue NoMethodError
-    object.instance_eval(instance_variable_name.to_s)
-  end
-
-  def set_instance_variable(duplicate, instance_variable_name, value_to_set)
-    duplicate.instance_variable_set(instance_variable_name, value_to_set)
-  rescue NoMethodError
-    duplicate.instance_eval("#{instance_variable_name} = Marshal.load(#{Marshal.dump(value_to_set).inspect})")
-  end
-
-  def try_dup(object)
-    o = object.dup
-
-    o.tap do
-      object.singleton_class.included_modules.each do |m|
-        o.extend m unless o.is_a? m
-      end
-    end
-  rescue NoMethodError, TypeError
-    object
-  end
-
-  def respond_to_instance_variables?(object)
-    object.respond_to?(:instance_variables) && object.instance_variables.is_a?(Array)
-  rescue NoMethodError
-    false
-  end
-end
-
-class Object
-  def duplicate
-    Duplicate.duplicate(self)
-  end
-end

data/lib/musa-dsl/core-ext/key-parameters-procedure-binder.rb

@@ -1,85 +0,0 @@
-class KeyParametersProcedureBinder
-  attr_reader :procedure
-
-  def initialize(procedure, on_rescue: nil)
-    @procedure = procedure
-    @on_rescue = on_rescue
-
-    @parameters = {}
-    @has_rest = false
-    @value_parameters_count = 0
-
-    procedure.parameters.each do |parameter|
-      @parameters[parameter[1]] = nil if parameter[0] == :key || parameter[0] == :keyreq
-      @has_rest = true if parameter[0] == :keyrest
-
-      @value_parameters_count += 1 if parameter[0] == :req || parameter[0] == :opt
-    end
-  end
-
-  def call(*value_parameters, **key_parameters)
-    _call value_parameters, key_parameters
-  end
-
-  def _call(value_parameters, key_parameters)
-    if @on_rescue
-      begin
-        __call value_parameters, key_parameters
-      rescue StandardError, ScriptError => e
-        @on_rescue.call e
-      end
-    else
-      __call value_parameters, key_parameters
-    end
-  end
-
-  def __call(value_parameters, key_parameters)
-    effective_key_parameters = apply(key_parameters)
-
-    if effective_key_parameters.empty?
-      if value_parameters.nil? || value_parameters.empty? || @value_parameters_count == 0
-        @procedure.call
-      else
-        @procedure.call *value_parameters.first(@value_parameters_count)
-      end
-    else
-      if value_parameters.nil? || value_parameters.empty?
-        @procedure.call **effective_key_parameters
-      else
-        @procedure.call *value_parameters, **effective_key_parameters
-      end
-    end
-  end
-
-  private :__call
-
-  def key?(key)
-    @has_rest || @parameters.include?(key)
-  end
-
-  alias_method :has_key?, :key?
-
-  def apply(hsh)
-    hsh ||= {}
-
-    result = @parameters.clone
-
-    @parameters.each_key do |parameter_name|
-      result[parameter_name] = hsh[parameter_name]
-    end
-
-    if @has_rest
-      hsh.each do |key, value|
-        result[key] = value unless result.key?(key)
-      end
-    end
-
-    result
-  end
-
-  def inspect
-    "KeyParametersProcedureBinder: parameters = #{@parameters} has_rest = #{@has_rest}"
-  end
-
-  alias to_s inspect
-end

data/lib/musa-dsl/core-ext/proc-nice.rb

@@ -1,13 +0,0 @@
-class Proc
-  def _call(value_args, key_value_args)
-    if value_args && key_value_args
-      call(*value_args, **key_value_args)
-    elsif value_args
-      call(*value_args)
-    elsif key_value_args
-      call(**key_value_args)
-    else
-      call
-    end
-  end
-end

data/lib/musa-dsl/core-ext/send-nice.rb

@@ -1,21 +0,0 @@
-class Object
-  def send_nice(method_name, *args, **key_args, &block)
-    _send_nice method_name, args, key_args, &block
-  end
-
-  def _send_nice(method_name, args, key_args, &block)
-    if args && !args.empty?
-      if key_args && !key_args.empty?
-        send method_name, *args, **key_args, &block
-      else
-        send method_name, *args, &block
-      end
-    else
-      if key_args && !key_args.empty?
-        send method_name, **key_args, &block
-      else
-        send method_name, &block
-      end
-    end
-  end
-end

data/lib/musa-dsl/core-ext/string-to-neumas.rb

@@ -1,27 +0,0 @@
-require 'musa-dsl/neumalang'
-require 'musa-dsl/generative/generative-grammar'
-
-class String
-  def to_neumas(language: nil, decode_with: nil, debug: nil)
-    Musa::Neumalang.parse(self, language: language, decode_with: decode_with, debug: debug)
-  end
-
-  def to_neumas_to_node(language: nil, decode_with: nil, debug: nil)
-    to_neumas(language: language, decode_with: decode_with, debug: debug).to_node
-  end
-
-  def |(other)
-    case other
-    when String
-      { kind: :parallel,
-        parallel: [{ kind: :serie, serie: self.to_neumas },
-                   { kind: :serie, serie: other.to_neumas }] }.extend(Musa::Neumalang::Neuma::Parallel)
-    else
-      raise ArgumentError, "Don't know how to parallelize #{other}"
-    end
-  end
-
-  alias_method :neumas, :to_neumas
-  alias_method :n, :to_neumas
-  alias_method :nn, :to_neumas_to_node
-end

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

@@ -1,221 +0,0 @@
-module Musa::Datasets::GDV
-
-  # Process: appogiatura (neuma)neuma
-  class AppogiaturaDecorator < TwoNeumasDecorator
-    def process(gdv, base_duration:, tick_duration:)
-      if gdv_appogiatura = gdv[:appogiatura]
-        gdv.delete :appogiatura
-
-        # TODO process with Decorators the gdv_appogiatura
-        # TODO implement also posterior appogiatura neuma(neuma)
-        # TODO implement also multiple appogiatura with several notes (neuma neuma)neuma or neuma(neuma neuma)
-
-        gdv[:duration] = gdv[:duration] - gdv_appogiatura[:duration]
-
-        [ gdv_appogiatura, gdv ]
-      else
-        gdv
-      end
-    end
-  end
-
-  # Process: .mor
-  class MordentDecorator < Decorator
-    def initialize(duration_factor: nil)
-      @duration_factor = duration_factor || 1/4r
-    end
-
-    def process(gdv, base_duration:, tick_duration:)
-      mor = gdv.delete :mor
-
-      if mor
-        direction = :up
-
-        check(mor) do |mor|
-          case mor
-          when true, :up
-            direction = :up
-          when :down, :low
-            direction = :down
-          end
-        end
-
-        short_duration = [base_duration * @duration_factor, tick_duration].max
-
-        gdvs = []
-
-        gdvs << gdv.clone.tap { |gdv| gdv[:duration] = short_duration }
-
-        case direction
-        when :up
-          gdvs << gdv.clone.tap { |gdv| gdv[:grade] += 1; gdv[:duration] = short_duration }
-        when :down
-          gdvs << gdv.clone.tap { |gdv| gdv[:grade] -= 1; gdv[:duration] = short_duration }
-        end
-
-        gdvs << gdv.clone.tap { |gdv| gdv[:duration] -= 2 * short_duration }
-
-        gdvs
-      else
-        gdv
-      end
-    end
-  end
-
-  # Process: .turn
-  class TurnDecorator < Decorator
-    def process(gdv, base_duration:, tick_duration:)
-      turn = gdv.delete :turn
-
-      if turn
-        start = :up
-
-        check(turn) do |turn|
-          case turn
-          when :true, :up
-            start = :up
-          when :down, :low
-            start = :down
-          end
-        end
-
-        duration = gdv[:duration] / 4r
-
-        gdvs = []
-
-        case start
-        when :up
-          gdvs << gdv.clone.tap { |gdv| gdv[:grade] += 1; gdv[:duration] = duration }
-          gdvs << gdv.clone.tap { |gdv| gdv[:grade] += 0; gdv[:duration] = duration }
-          gdvs << gdv.clone.tap { |gdv| gdv[:grade] += -1; gdv[:duration] = duration }
-          gdvs << gdv.clone.tap { |gdv| gdv[:grade] += 0; gdv[:duration] = duration }
-        when :down
-          gdvs << gdv.clone.tap { |gdv| gdv[:grade] += -1; gdv[:duration] = duration }
-          gdvs << gdv.clone.tap { |gdv| gdv[:grade] += 0; gdv[:duration] = duration }
-          gdvs << gdv.clone.tap { |gdv| gdv[:grade] += 1; gdv[:duration] = duration }
-          gdvs << gdv.clone.tap { |gdv| gdv[:grade] += 0; gdv[:duration] = duration }
-        end
-
-        gdvs
-      else
-        gdv
-      end
-    end
-  end
-
-  # Process: .tr
-  class TrillDecorator < Decorator
-    def initialize(duration_factor: nil)
-      @duration_factor = duration_factor || 1/4r
-    end
-
-    def process(gdv, base_duration:, tick_duration:)
-      if gdv[:tr]
-        tr = gdv.delete :tr
-
-        note_duration = base_duration * @duration_factor
-
-        check(tr) do |tr|
-          case tr
-          when Numeric # duration factor
-            note_duration *= base_duration * tr.to_r
-          end
-        end
-
-        used_duration = 0r
-        last = nil
-
-        gdvs = []
-
-        check(tr) do |tr|
-          case tr
-          when :low # start with lower note
-            gdvs << gdv.clone.tap { |gdv| gdv[:grade] += (last = -1); gdv[:duration] = note_duration }
-            gdvs << gdv.clone.tap { |gdv| gdv[:grade] += (last = 0); gdv[:duration] = note_duration }
-            used_duration += 2 * note_duration
-
-          when :low2 # start with upper note but go to lower note once
-            gdvs << gdv.clone.tap { |gdv| gdv[:grade] += (last = 1); gdv[:duration] = note_duration }
-            gdvs << gdv.clone.tap { |gdv| gdv[:grade] += (last = 0); gdv[:duration] = note_duration }
-            gdvs << gdv.clone.tap { |gdv| gdv[:grade] += (last = -1); gdv[:duration] = note_duration }
-            gdvs << gdv.clone.tap { |gdv| gdv[:grade] += (last = 0); gdv[:duration] = note_duration }
-            used_duration += 4 * note_duration
-
-          when :same # start with the same note
-            gdvs << gdv.clone.tap { |gdv| gdv[:grade] += (last = 0); gdv[:duration] = note_duration }
-            used_duration += note_duration
-          end
-        end
-
-        2.times do
-          if used_duration + 2 * note_duration <= gdv[:duration]
-            gdvs << gdv.clone.tap { |gdv| gdv[:grade] += (last = 1); gdv[:duration] = note_duration }
-            gdvs << gdv.clone.tap { |gdv| gdv[:grade] += (last = 0); gdv[:duration] = note_duration }
-
-            used_duration += 2 * note_duration
-          end
-        end
-
-        while used_duration + 2 * note_duration * 2/3r <= gdv[:duration]
-          gdvs << gdv.clone.tap { |gdv| gdv[:grade] += (last = 1); gdv[:duration] = note_duration * 2/3r }
-          gdvs << gdv.clone.tap { |gdv| gdv[:grade] += (last = 0); gdv[:duration] = note_duration * 2/3r }
-
-          used_duration += 2 * note_duration * 2/3r
-        end
-
-        duration_diff = gdv[:duration] - used_duration
-        if duration_diff >= note_duration
-          gdvs << gdv.clone.tap { |gdv| gdv[:grade] += (last = 1); gdv[:duration] = duration_diff / 2 }
-          gdvs << gdv.clone.tap { |gdv| gdv[:grade] += (last = 0); gdv[:duration] = duration_diff / 2 }
-
-        elsif duration_diff > 0
-          gdvs[-1][:duration] += duration_diff / 2
-          gdvs[-2][:duration] += duration_diff / 2
-        end
-
-        gdvs
-      else
-        gdv
-      end
-    end
-  end
-
-  # Process: .st .st(1) .st(2) .st(3): staccato level 1 2 3
-  class StaccatoDecorator < Decorator
-    def initialize(min_duration_factor: nil)
-      @min_duration_factor = min_duration_factor || 1/8r
-    end
-
-    def process(gdv, base_duration:, tick_duration:)
-      st = gdv.delete :st
-
-      if st
-        calculated = 0
-
-        check(st) do |st|
-        case st
-          when true
-            calculated = gdv[:duration] / 2r
-          when Numeric
-            calculated = gdv[:duration] / 2**st if st >= 1
-          end
-        end
-
-        gdv[:effective_duration] = [calculated, base_duration * @min_duration_factor].max
-      end
-
-      gdv
-    end
-  end
-
-  # Process: .base .b
-  class BaseDecorator < Decorator
-    def process(gdv, base_duration:, tick_duration:)
-      base = gdv.delete :base
-      base ||= gdv.delete :b
-
-      base ? { duration: 0 }.extend(Musa::Datasets::GDV) : gdv
-    end
-  end
-
-end