musa-dsl 0.14.31 → 0.21.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b0d0e02c2e0316db71806cd4a1370c6f7488d074c7f0c56f9debefa68e041d14
-  data.tar.gz: 4d6e5c5f7dcd225ed5cb4f2f01129fa12a15be16253f5bfcb8cedf07c1bb6296
+  metadata.gz: dae00405142514f16df2be12de1eb9327893f3996ad3c86ec76fc315db521e7d
+  data.tar.gz: f3ebf69b72452ab83ec33ab873221ee1f0d59954e2c67277c2386fc174278a7c
 SHA512:
-  metadata.gz: d7872920c8d0b01d28ea8359a7bccb84937820dcb1ce4cb98a158c351ac46f9e5a802d5986b6e7b584f3c527dd9be65e2df75d31dc5fa7394296dc2123ed4b5d
-  data.tar.gz: a2dae59c40f1e713593a691e93ba989ee3aed3fe176b7da81e01aec579db83afc1c91d082c2915150249ab55a124c5f45f15fc99f506cc1cbdc3fb6a5d237d83
+  metadata.gz: 006f3143b93237b86600bde3b7229f14cae909a50603af4c0d1f33050835c582988325f8b2db63b74d20826d1682f09d51960e32d977f47ce86d69b4d25cd53b
+  data.tar.gz: 7c07575e0bcf7a2b5f9e6361d8ae2b64193b8bba31bec3badfbf02f8c83f8a3595bc84df42aa6c8976c947528c82752f9869ed7c19240c9d0d536cb435b4da86

data/.gitignore

@@ -3,8 +3,10 @@
 .bundle
 .rspec
 .idea
+.ruby-gemset
+.ruby-version
 Gemfile.lock
 bin
 *.mindnode
-
+test.musicxml
 

data/Gemfile

@@ -2,7 +2,6 @@ source 'https://rubygems.org'
 
 group :neuma do
   gem 'citrus', '~> 3.0.0'
-
 end
 
 group :transport do

data/README.md

@@ -2,7 +2,11 @@
 
 Work in progress.
 
-A programming language DSL based on Ruby for musical composition. 
+A programming language DSL based on Ruby for sonic and musical composition. 
 Emphasizes the creation of complex temporal structures independently of the audio rendering engine.
 
 Some works can be listened on [yeste.studio](https://soundcloud.com/yeste-studio) Soundcloud.
+
+---
+
+Coded on [Jetbrains RubyMine IDE](https://www.jetbrains.com/?from=Musa-DSL). Thanks a lot for your support letting me use an Open Source project free license! 

data/lib/musa-dsl.rb

@@ -1,17 +1,60 @@
-require 'musa-dsl/core-ext'
+module Musa
+  VERSION = '0.21.1'
+end
 
-require 'musa-dsl/series'
-require 'musa-dsl/neuma'
-require 'musa-dsl/datasets'
+require_relative 'musa-dsl/core-ext'
 
-require 'musa-dsl/neumalang'
+require_relative 'musa-dsl/series'
+require_relative 'musa-dsl/datasets'
+require_relative 'musa-dsl/matrix'
 
-require 'musa-dsl/transport'
-require 'musa-dsl/sequencer'
-require 'musa-dsl/repl'
+require_relative 'musa-dsl/neumalang'
+require_relative 'musa-dsl/neumas'
 
-require 'musa-dsl/midi'
+require_relative 'musa-dsl/logger'
 
-require 'musa-dsl/music'
+require_relative 'musa-dsl/transport'
+require_relative 'musa-dsl/sequencer'
+require_relative 'musa-dsl/repl'
 
-require 'musa-dsl/generative'
+require_relative 'musa-dsl/midi'
+require_relative 'musa-dsl/musicxml'
+
+require_relative 'musa-dsl/transcription'
+
+require_relative 'musa-dsl/music'
+
+require_relative 'musa-dsl/generative'
+
+module Musa::All
+  include Musa::Logger
+
+  include Musa::Clock
+  include Musa::Transport
+  include Musa::Sequencer
+
+  include Musa::Scales
+  include Musa::Chords
+  include Musa::Datasets
+
+  include Musa::Neumalang
+  include Musa::Neumas
+  include Musa::Matrix
+
+  include Musa::Series
+
+  include Musa::Darwin
+  include Musa::Markov
+  include Musa::Backboner
+  include Musa::Variatio
+
+  include Musa::MIDIRecorder
+  include Musa::MIDIVoices
+
+  include Musa::MusicXML
+
+  include Musa::Transcription
+  include Musa::Transcriptors
+
+  include Musa::REPL
+end

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

@@ -1,13 +1,7 @@
-require 'musa-dsl/core-ext/array-apply-get'
-require 'musa-dsl/core-ext/array-explode-ranges'
-require 'musa-dsl/core-ext/array-to-serie'
-require 'musa-dsl/core-ext/string-to-neumas'
-require 'musa-dsl/core-ext/array-to-neumas'
-require 'musa-dsl/core-ext/arrayfy'
-require 'musa-dsl/core-ext/duplicate'
-require 'musa-dsl/core-ext/key-parameters-procedure-binder'
-require 'musa-dsl/core-ext/as-context-run'
-require 'musa-dsl/core-ext/inspect-nice'
-require 'musa-dsl/core-ext/send-nice'
-require 'musa-dsl/core-ext/proc-nice'
-require 'musa-dsl/core-ext/dynamic-proxy'
+require_relative 'core-ext/array-explode-ranges'
+require_relative 'core-ext/arrayfy'
+require_relative 'core-ext/deep-copy'
+require_relative 'core-ext/smart-proc-binder'
+require_relative 'core-ext/inspect-nice'
+require_relative 'core-ext/dynamic-proxy'
+require_relative 'core-ext/with'

data/lib/musa-dsl/core-ext/array-explode-ranges.rb

@@ -1,29 +1,21 @@
-class Array
-  def arrayfy
-    self
-  end
-
-  def repeat_to_size(new_size)
-    pos = -1
-    new_size -= 1
-
-    new_array = clone
-    new_array << self[(pos += 1) % size] while (pos + size) < new_size
+module Musa
+  module Extension
+    module ExplodeRanges
+      refine Array do
+        def explode_ranges
+          array = []
 
-    new_array
-  end
-
-  def explode_ranges
-    array = []
+          each do |element|
+            if element.is_a? Range
+              element.to_a.each { |element| array << element }
+            else
+              array << element
+            end
+          end
 
-    each do |element|
-      if element.is_a? Range
-        element.to_a.each { |element| array << element }
-      else
-        array << element
+          array
+        end
       end
     end
-
-    array
   end
 end

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

@@ -1,15 +1,33 @@
-class Object
-  def arrayfy
-    if nil?
-      []
-    else
-      [self]
-    end
-  end
-end
+require_relative 'deep-copy'
 
-class Array
-  def arrayfy
-    self
+module Musa
+  module Extension
+    module Arrayfy
+      refine Object do
+        def arrayfy(size: nil)
+          if size
+            size.times.collect { self }
+          else
+            if nil?
+              []
+            else
+              [self]
+            end
+          end
+        end
+      end
+
+      refine Array do
+        def arrayfy(size: nil)
+          if size
+            DeepCopy::DeepCopy.copy_singleton_class_modules(
+                self,
+                (self * (size / self.size + ((size % self.size).zero? ? 0 : 1) )).take(size))
+          else
+            self.clone
+          end
+        end
+      end
+    end
   end
 end

data/lib/musa-dsl/core-ext/attribute-builder.rb

@@ -0,0 +1,194 @@
+module Musa
+  module Extension
+    module AttributeBuilder
+      # add_thing id, parameter
+      # things id1: parameter1, id2: parameter2 -> { id1: Thing(id1, parameter1), id2: Thing(id2, parameter2) }
+      # things -> { id1: Thing(id1, parameter1), id2: Thing(id2, parameter2) }
+      #
+      def attr_tuple_adder_to_hash(name, klass, plural: nil, variable: nil)
+
+        plural ||= name.to_s + 's'
+        variable ||= ('@' + plural.to_s).to_sym
+
+        adder_method = "add_#{name}".to_sym
+
+        define_method adder_method do |id, parameter|
+          klass.new(id, parameter).tap do |object|
+            instance_variable_get(variable)[id] = object
+          end
+        end
+
+        define_method plural do |**parameters|
+          parameters&.each_pair do |id, value|
+            send adder_method, id, value
+          end
+          instance_variable_get variable
+        end
+      end
+
+      # add_thing id, parameter
+      # things id1: parameter1, id2: parameter2 -> [ Thing(id1, parameter1), Thing(id2, parameter2) ]
+      # things -> [ Thing(id1, parameter1), Thing(id2, parameter2) ]
+
+      def attr_tuple_adder_to_array(name, klass, plural: nil, variable: nil)
+
+        plural ||= name.to_s + 's'
+        variable ||= ('@' + plural.to_s).to_sym
+
+        adder_method = "add_#{name}".to_sym
+
+        define_method adder_method do |id, parameter, &block|
+          klass.new(id, parameter, &block).tap do |object|
+            instance_variable_get(variable) << object
+          end
+        end
+
+        define_method plural do |**parameters, &block|
+          parameters.each_pair do |id, value|
+            send adder_method, id, value, &block
+          end
+          instance_variable_get variable
+        end
+      end
+
+      # add_thing param1, param2, key1: parameter1, key2: parameter2 -> Thing(...)
+      # thing param1, param2, key1: parameter1, key2: parameter2 -> Thing(...)
+      # things -> (collection)
+
+      def attr_complex_adder_to_array(name, klass, plural: nil, variable: nil)
+
+        plural ||= name.to_s + 's'
+        variable ||= ('@' + plural.to_s).to_sym
+
+        adder_method = "add_#{name}".to_sym
+
+        define_method adder_method do |*parameters, **key_parameters, &block|
+          klass.new(*parameters, **key_parameters, &block).tap do |object|
+            instance_variable_get(variable) << object
+          end
+        end
+
+        if plural == name
+          define_method plural do |*parameters, **key_parameters, &block|
+            if parameters.empty? && key_parameters.empty? && block.nil?
+              instance_variable_get variable
+            else
+              send adder_method, *parameters, **key_parameters, &block
+            end
+          end
+        else
+          alias_method name, adder_method
+
+          define_method plural do
+            instance_variable_get variable
+          end
+        end
+      end
+
+
+      # add_thing param1, param2, key1: parameter1, key2: parameter2 -> Thing(...)
+      # thing param1, param2, key1: parameter1, key2: parameter2 -> Thing(...)
+      # things -> (collection)
+
+      def attr_complex_adder_to_custom(name, plural: nil, variable: nil, &constructor_and_adder)
+
+        plural ||= name.to_s + 's'
+
+        adder_method = "add_#{name}".to_sym
+
+        define_method adder_method do |*parameters, **key_parameters, &block|
+          instance_exec(*parameters, **key_parameters, &constructor_and_adder).tap do |object|
+            object.with &block if block
+          end
+        end
+
+        if plural == name && variable
+          define_method plural do |*parameters, **key_parameters, &block|
+            if parameters.empty? && key_parameters.empty? && block.nil?
+              instance_variable_get variable
+            else
+              send adder_method, *parameters, **key_parameters, &block
+            end
+          end
+        else
+          alias_method name, adder_method
+
+          if variable
+            define_method plural do
+              instance_variable_get variable
+            end
+          end
+        end
+      end
+
+      # thing value -> crea Thing(value)
+      # thing -> Thing(value)
+
+      def attr_simple_builder(name, klass = nil, variable: nil)
+        variable ||= ('@' + name.to_s).to_sym
+
+        define_method name do |parameter = nil, &block|
+          if parameter.nil?
+            instance_variable_get variable
+          else
+            (klass&.new(parameter, &block) || parameter).tap do |object|
+              instance_variable_set variable, object
+            end
+          end
+        end
+
+        attr_writer name
+      end
+
+      # thing id: value -> crea Thing(id, value)
+      # thing -> Thing(id, value)
+
+      def attr_tuple_builder(name, klass, variable: nil)
+        variable ||= ('@' + name.to_s).to_sym
+
+        define_method name do |**parameters, &block|
+          raise ArgumentError, "Method #{name} can only create instances with one id: value arguments pattern" unless parameters.size == 1
+
+          if parameters.empty?
+            instance_variable_get variable
+          else
+            parameter = parameters.first
+            klass.new(*parameter, &block).tap do |object|
+              instance_variable_set variable, object
+            end
+          end
+        end
+
+        attr_writer name
+      end
+
+      # thing value1, value2, key1: value3, key2: value4 -> crea Thing(value1, value2, key1: value3, key2: value3)
+      # thing -> Thing(value1, value2, key1: value3, key2: value4)
+      # y también...
+      # thing value1, value2, key1: value3, key2: value4 -> crea Thing(first_parameter, value1, value2, key1: value3, key2: value3)
+      # thing -> Thing(first_parameter, value1, value2, key1: value3, key2: value4)
+
+      def attr_complex_builder(name, klass, variable: nil, first_parameter: nil)
+        variable ||= ('@' + name.to_s).to_sym
+
+        define_method name do |*parameters, **key_parameters, &block|
+          if parameters.empty? && key_parameters.empty? && block.nil?
+            instance_variable_get variable
+          else
+            if first_parameter
+              klass.new(first_parameter, *parameters, **key_parameters, &block).tap do |object|
+                instance_variable_set variable, object
+              end
+            else
+              klass.new(*parameters, **key_parameters, &block).tap do |object|
+                instance_variable_set variable, object
+              end
+            end
+          end
+        end
+
+        attr_writer name
+      end
+    end
+  end
+end

data/lib/musa-dsl/core-ext/deep-copy.rb

@@ -0,0 +1,185 @@
+# Based on https://github.com/adamluzsi/duplicate.rb/blob/master/lib/duplicate.rb
+# Modifications by Javier Sánchez Yeste
+
+module Musa
+  module Extension
+    module DeepCopy
+      module DeepCopy
+        extend self
+
+        def deep_copy(object, method: :dup, freeze: true)
+          raise ArgumentError, "deep_copy method can only be :dup or :clone" unless method == :dup || method == :clone
+          register = {}
+
+          _deep_copy(register, object, method, freeze)
+        end
+
+        def copy_singleton_class_modules(source, target)
+          source.singleton_class.included_modules.each do |m|
+            target.extend m unless target.is_a?(m)
+          end
+
+          target
+        end
+
+        protected
+
+        def registered(object, register)
+          register[object.__id__]
+        end
+
+        def register(register, object, duplicate)
+          register[object.__id__] = duplicate
+          duplicate
+        end
+
+        def _deep_copy(register, object, method, freeze)
+          return registered(object, register) if registered(object, register)
+          return register(register, object, object) unless identifiable?(object)
+
+          case object
+
+          when Array
+            deep_copy_array(register, object, method, freeze)
+
+          when Hash
+            deep_copy_hash(register, object, method, freeze)
+
+          when Range
+            deep_copy_range(register, object, method, freeze)
+
+          when Struct
+            deep_copy_struct(register, object, method, freeze)
+
+          when Proc
+            deep_copy_proc(register, object, method, freeze)
+
+          when NilClass, Symbol, Numeric, TrueClass, FalseClass, Method
+            register(register, object, object)
+
+          else
+            deep_copy_object(register, object, method, freeze)
+
+          end
+        end
+
+        def identifiable?(object)
+          object.class && object.respond_to?(:is_a?)
+        rescue NoMethodError
+          false
+        end
+
+        def deep_copy_array(register, object, method, freeze)
+          deep_copy_object(register, object, method, freeze) do |_, copy|
+            copy.map! { |e| _deep_copy(register, e, method, freeze) }
+          end
+        end
+
+        def deep_copy_hash(register, object, method, freeze)
+          deep_copy_object(register, object, method, freeze) do |object, copy|
+            object.reduce(copy) { |hash, (k, v)| hash.merge!(_deep_copy(register, k, method, freeze) => _deep_copy(register, v, method, freeze)) }
+          end
+        end
+
+        def deep_copy_range(register, range, method, freeze)
+          copy = range.class.new(_deep_copy(register, range.first, method, freeze), _deep_copy(register, range.last, method, freeze))
+          copy.freeze if range.frozen?
+
+          register(register, range, copy)
+        rescue StandardError
+          register(register, range, range.send(method))
+        end
+
+        def deep_copy_struct(register, struct, method, freeze)
+          duplication = register(register, struct, struct.send(method))
+
+          struct.each_pair do |attr, value|
+            duplication.__send__("#{attr}=", _deep_copy(register, value, method, freeze))
+          end
+
+          duplication
+        end
+
+        def deep_copy_object(register, object, method, freeze)
+          if method == :clone && object.frozen?
+            copy = try_deep_copy(object, :clone, false)
+          else
+            copy = try_deep_copy(object, method, freeze)
+          end
+
+          register(register, object, copy)
+          deep_copy_instance_variables(register, object, register(register, object, copy), method, freeze)
+
+          yield object, copy if block_given?
+
+          copy.freeze if method == :clone && object.frozen? && freeze
+
+          copy
+        end
+
+        def deep_copy_proc(register, object, method, freeze)
+          register(register, object, object.dup)
+        end
+
+        def deep_copy_instance_variables(register, object, duplication, method, freeze)
+          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, _deep_copy(register, value, method, freeze))
+          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_deep_copy(object, method, freeze)
+          if method == :dup
+            object.dup
+          else
+            object.clone(freeze: freeze)
+          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
+
+      refine Object do
+        def dup(deep: false)
+          if deep
+            Musa::Extension::DeepCopy::DeepCopy.deep_copy(self, method: :dup)
+          else
+            super()
+          end
+        end
+
+        def clone(freeze: true, deep: false)
+          if deep
+            Musa::Extension::DeepCopy::DeepCopy.deep_copy(self, method: :clone, freeze: freeze)
+          else
+            super(freeze: freeze)
+          end
+        end
+      end
+    end
+  end
+end
+