xi-lang 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 65bceb35fd0dbad39331e9c89bea0a83254fe075
-  data.tar.gz: a20c3dd41afe001b698aab57d8cd3577e66d6dcb
+  metadata.gz: 38043c0ad025b398a49d63e1c93681992c0b184a
+  data.tar.gz: fbc0e32315abf8272f388bbe59917236633a0d09
 SHA512:
-  metadata.gz: e92c7bf49fa2bba86bf0eb153d7c0d1fd363a21060d52faf3a472655ffce291c8e57563edc303ae1ef65c591dc6b6db746d2f64592e469e927ba56a35ce6cd31
-  data.tar.gz: 3ab57ef7a85d4cac9a9e260aba0b030972b80105e320036feefc3ef3a418b22aec361180685cdda28ef92ab72ee39639ca7786595c030000b96f76d4b04c5be5
+  metadata.gz: 10f089d5ecb56a89e70091b2845654fdbdf7beb9c7b3fc23366038ae078769065166b3b89fd08de19fca0ec99612bce60853f16554aacb2d269036e895df4a29
+  data.tar.gz: e4fa8eef3158cbf1d14d8f9b8d4241dfe83de117a1ef6730c947992baf555a9c110f425e9d7828eaafdf9201cf71f52d9c2cd2737100e85c198397ce22048a68

data/README.md

@@ -1,4 +1,4 @@
-# Xi
+# Xi  [![Build Status](https://travis-ci.org/xi-livecode/xi.svg?branch=master)](https://travis-ci.org/xi-livecode/xi)
 
 Xi (pronounced /ˈzaɪ/) is a musical pattern language inspired in Tidal and
 SuperCollider for building higher-level musical constructs easily.  It is

data/lib/xi/clock.rb

@@ -8,11 +8,15 @@ module Xi
     DEFAULT_CPS  = 1.0
     INTERVAL_SEC = 10 / 1000.0
 
+    attr_reader :init_ts, :latency
+
     def initialize(cps: DEFAULT_CPS)
       @mutex = Mutex.new
       @cps = cps
       @playing = true
       @streams = [].to_set
+      @init_ts = Time.now.to_f
+      @latency = 0.0
       @play_thread = Thread.new { thread_routine }
     end
 
@@ -29,7 +33,11 @@ module Xi
     end
 
     def cps=(new_cps)
-      @mutex.synchronize { @cps = new_cps }
+      @mutex.synchronize { @cps = new_cps.to_f }
+    end
+
+    def latency=(new_latency)
+      @latency = new_latency.to_f
     end
 
     def playing?
@@ -40,10 +48,6 @@ module Xi
       !playing?
     end
 
-    def now
-      Time.now.to_f * cps
-    end
-
     def play
       @mutex.synchronize { @playing = true }
       self
@@ -60,12 +64,9 @@ module Xi
       @mutex.synchronize { 1.0 / @cps }
     end
 
-    def at(cycle_pos)
-      Time.at(cycle_pos * seconds_per_cycle)
-    end
-
     def inspect
-      "#<#{self.class.name}:#{"0x%014x" % object_id} cps=#{cps.inspect} #{playing? ? :playing : :stopped}>"
+      "#<#{self.class.name}:#{"0x%014x" % object_id} " \
+        "cps=#{cps.inspect} #{playing? ? :playing : :stopped}>"
     end
 
     private
@@ -78,9 +79,10 @@ module Xi
     end
 
     def do_tick
-      cycles = Time.now.to_f * cps
       return unless playing?
-      @streams.each { |s| s.notify(cycles) }
+      now = Time.now.to_f - @init_ts + @latency
+      cps = self.cps
+      @streams.each { |s| s.notify(now, cps) }
     rescue => err
       error(err)
     end

data/lib/xi/core_ext/string.rb

@@ -0,0 +1,50 @@
+# String Inflectors, taken from ActiveSupport 5.0 source code
+module Xi::Inflectors
+  # Converts strings to UpperCamelCase.
+  # If the +uppercase_first_letter+ parameter is set to false, then produces
+  # lowerCamelCase.
+  #
+  # Also converts '/' to '::' which is useful for converting
+  # paths to namespaces.
+  #
+  #   camelize('active_model')                # => "ActiveModel"
+  #   camelize('active_model', false)         # => "activeModel"
+  #   camelize('active_model/errors')         # => "ActiveModel::Errors"
+  #   camelize('active_model/errors', false)  # => "activeModel::Errors"
+  #
+  # As a rule of thumb you can think of +camelize+ as the inverse of
+  # #underscore, though there are cases where that does not hold:
+  #
+  #   camelize(underscore('SSLError'))        # => "SslError"
+  def camelize
+    string = self.sub(/^[a-z\d]*/) { |match| match.capitalize }
+    string.gsub!(/(?:_|(\/))([a-z\d]*)/i) { "#{$1}#{$2.capitalize}" }
+    string.gsub!('/'.freeze, '::'.freeze)
+    string
+  end
+
+  # Makes an underscored, lowercase form from the expression in the string.
+  #
+  # Changes '::' to '/' to convert namespaces to paths.
+  #
+  #   underscore('ActiveModel')         # => "active_model"
+  #   underscore('ActiveModel::Errors') # => "active_model/errors"
+  #
+  # As a rule of thumb you can think of +underscore+ as the inverse of
+  # #camelize, though there are cases where that does not hold:
+  #
+  #   camelize(underscore('SSLError'))  # => "SslError"
+  def underscore
+    return self unless self =~ /[A-Z-]|::/
+    word = self.to_s.gsub('::'.freeze, '/'.freeze)
+    word.gsub!(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2'.freeze)
+    word.gsub!(/([a-z\d])([A-Z])/, '\1_\2'.freeze)
+    word.tr!("-".freeze, "_".freeze)
+    word.downcase!
+    word
+  end
+end
+
+class String
+  include Xi::Inflectors
+end

data/lib/xi/core_ext.rb

@@ -3,3 +3,4 @@ require 'xi/core_ext/fixnum'
 require 'xi/core_ext/numeric'
 require 'xi/core_ext/object'
 require 'xi/core_ext/simple'
+require 'xi/core_ext/string'

data/lib/xi/event.rb

@@ -1,13 +1,44 @@
 module Xi
+  # An Event is an object that represents a scalar +value+ of some type, and
+  # has a +start+ position or onset, and +duration+ in time.
+  #
+  # Both +start+ and +duration+ are in terms of cycles.
+  #
+  # Usually you don't create events, they are created by a Pattern when
+  # assigned to a Stream, or by some transformation methods on Pattern, so you
+  # don't need to worry about them.  Most of the time, you will manually build
+  # Patterns from values and let the Pattern handle when values are applied in
+  # time, based on its default event duration, for example.
+  #
+  # You can instantiate an Event using {.[]}, like this
+  #
+  #   Event.new(42, 0, 2) #=> E[42,0,2]
+  #   Event[:a, 1, 1/2]   #=> E[:a,1,1/2]
+  #
+  # E is an alias of Event, so you can build them using E instead.  Note that
+  # the string representation of the object can be used to build the same event
+  # again (almost the same ignoring whitespace between constructor arguments).
+  #
+  #   E[:a, 1, 1/4]       #=> E[:a,1,1/4]
+  #
   class Event
     attr_reader :value, :start, :duration
 
+    # Creates a new Event with +value+, with both +start+ position and
+    # +duration+ in cycles 
+    #
+    # @param value [Object]
+    # @param start [Numeric] default: 0
+    # @param duration [Numeric] default: 1
+    # @return [Event]
+    #
     def initialize(value, start=0, duration=1)
       @value = value
       @start = start
       @duration = duration
     end
 
+    # @see #initialize
     def self.[](*args)
       new(*args)
     end
@@ -19,10 +50,20 @@ module Xi
         duration == o.duration
     end
 
+    # Return the end position in cycles
+    # 
+    # @return [Numeric]
+    #
     def end
       @start + @duration
     end
 
+    # Creates a Pattern that only yields this event
+    #
+    # @param dur [Numeric, #each] event duration
+    # @param metadata [Hash]
+    # @return [Pattern]
+    #
     def p(dur=nil, **metadata)
       [self].p(dur, metadata)
     end

data/lib/xi/pattern/generators.rb

@@ -51,12 +51,17 @@ module Xi
           end
         end
 
-        # Choose items from the list randomly
+        # Choose items from the +list+ randomly, +repeats+ number of times
+        #
+        # +list+ can be a *finite* enumerable or Pattern.
+        #
+        # @see Pattern::Transforms#rand
         #
         # @example
-        #   peek [1, 2, 3].p.rand             #=> [2]
-        #   peek [1, 2, 3, 4].p.rand(6)       #=> [1, 3, 2, 2, 4, 3]
+        #   peek P.rand([1, 2, 3])          #=> [2]
+        #   peek P.rand([1, 2, 3, 4], 6)    #=> [1, 3, 2, 2, 4, 3]
         #
+        # @param list [#each] list of values
         # @param repeats [Fixnum, Symbol] number or inf (default: 1)
         # @return [Pattern]
         #
@@ -70,10 +75,15 @@ module Xi
         # Choose randomly, but only allow repeating the same item after yielding
         # all items from the list.
         #
+        # +list+ can be a *finite* enumerable or Pattern.
+        #
+        # @see Pattern::Transforms#xrand
+        #
         # @example
-        #   peek [1, 2, 3, 4, 5].p.xrand    #=> [4]
-        #   peek [1, 2, 3].p.xrand(8)       #=> [1, 3, 2, 3, 1, 2, 3, 2]
+        #   peek P.xrand([1, 2, 3, 4, 5])    #=> [4]
+        #   peek P.xrand([1, 2, 3], 8)       #=> [1, 3, 2, 3, 1, 2, 3, 2]
         #
+        # @param list [#each] list of values
         # @param repeats [Fixnum, Symbol] number or inf (default: 1)
         # @return [Pattern]
         #
@@ -91,10 +101,15 @@ module Xi
         # Shuffle the list in random order, and use the same random order
         # +repeats+ times
         #
+        # +list+ can be a *finite* enumerable or Pattern.
+        #
+        # @see Pattern::Transforms#shuf
+        #
         # @example
-        #   peek [1, 2, 3, 4, 5].p.xrand    #=> [4]
-        #   peek [1, 2, 3].p.xrand(8)       #=> [1, 3, 2, 3, 1, 2, 3, 2]
+        #   peek P.shuf([1, 2, 3, 4, 5])    #=> [5, 3, 4, 1, 2]
+        #   peek P.shuf([1, 2, 3], 3)       #=> [2, 3, 1, 2, 3, 1, 2, 3, 1]
         #
+        # @param list [#each] list of values
         # @param repeats [Fixnum, Symbol] number or inf (default: 1)
         # @return [Pattern]
         #
@@ -107,7 +122,26 @@ module Xi
           end
         end
 
-        # TODO Document
+        # Generates values from a sinewave discretized to +quant+ events
+        # for the duration of +dur+ cycles.
+        #
+        # Values range from -1 to 1
+        #
+        # @see #sin1 for the same function but constrained on 0 to 1 values
+        #
+        # @example
+        #   P.sin(8).map { |i| i.round(2) }
+        #     #=> [0.0, 0.71, 1.0, 0.71, 0.0, -0.71, -1.0, -0.71]
+        #
+        # @example +quant+ determines the size, +dur+ the total duration
+        #   P.sin(8).size                 #=> 8
+        #   P.sin(22).total_duration      #=> (1/1)
+        #   P.sin(19, 2).total_duration   #=> (2/1)
+        #
+        # @param quant [Fixnum]
+        # @param dur [Fixnum] (default: 1)
+        # @return [Pattern]
+        #
         def sin(quant, dur=1)
           Pattern.new(size: quant, dur: dur / quant) do |y|
             quant.times do |i|
@@ -116,7 +150,21 @@ module Xi
           end
         end
 
-        # TODO Document
+        # Generates values from a sinewave discretized to +quant+ events
+        # for the duration of +dur+ cycles.
+        #
+        # Values range from 0 to 1
+        #
+        # @see #sin
+        #
+        # @example
+        #   P.sin1(8).map { |i| i.round(2) }
+        #     #=> [0.5, 0.85, 1.0, 0.85, 0.5, 0.15, 0.0, 0.15]
+        #
+        # @param quant [Fixnum]
+        # @param dur [Fixnum] (default: 1)
+        # @return [Pattern]
+        #
         def sin1(quant, dur=1)
           sin(quant, dur).scale(-1, 1, 0, 1)
         end

data/lib/xi/pattern/transforms.rb

@@ -291,6 +291,7 @@ module Xi
       #
       # @example
       #   peek [0,2,4,1,3,6].p.scale(0, 6, 0, 0x7f)
+      #     #=> [(0/1), (127/3), (254/3), (127/6), (127/2), (127/1)]
       #
       # @param min_from [Numeric]
       # @param max_from [Numeric]
@@ -302,14 +303,38 @@ module Xi
         normalize(min_from, max_from).denormalize(min_to, max_to)
       end
 
-      # TODO Document
+      # Slows down a pattern by stretching start and duration of events
+      # +num+ times.
+      #
+      # It is the inverse operation of #accelerate
+      #
+      # @example
+      #   peek_events %w(a b c d).p([1/4, 1/8, 1/6]).decelerate(2)
+      #     #=> [E["a",0,1/2], E["b",1/2,1/4], E["c",3/4,1/3], E["d",13/12,1/2]]
+      #
+      # @param num [Numeric]
+      # @return [Pattern]
+      # @see #accelerate
+      #
       def decelerate(num)
         Pattern.new(self) { |y|
           each_event { |e| y << E[e.value, e.start * num, e.duration * num] }
         }
       end
 
-      # TODO Document
+      # Advance a pattern by shrinking start and duration of events
+      # +num+ times.
+      #
+      # It is the inverse operation of #decelerate
+      #
+      # @example
+      #   peek_events %w(a b c d).p([1/2, 1/4]).accelerate(2)
+      #     #=> [E["a",0,1/4], E["b",1/4,1/8], E["c",3/8,1/4], E["d",5/8,1/8]]
+      #
+      # @param num [Numeric]
+      # @return [Pattern]
+      # @see #decelerate
+      #
       def accelerate(num)
         Pattern.new(self) { |y|
           each_event { |e| y << E[e.value, e.start / num, e.duration / num] }
@@ -317,12 +342,26 @@ module Xi
       end
 
       # Based on +probability+, it yields original value or nil
-      # TODO Document
+      #
+      # +probability+ can also be an enumerable or a *finite* Pattern. In this
+      # case, for each value in +probability+ it will enumerate original
+      # pattern based on that probability value.
+      #
+      # @example
+      #   peek (1..6).p.sometimes        #=> [1, nil, 3, nil, 5, 6]
+      #   peek (1..6).p.sometimes(1/4)   #=> [nil, nil, nil, 4, nil, 6]
+      #
+      # @example
+      #   peek (1..6).p.sometimes([0.5, 1]), 12
+      #     #=> [1, 2, nil, nil, 5, 6, 1, 2, 3, 4, 5, 6]
+      #
+      # @param probability [Numeric, #each] (default=0.5)
+      # @return [Pattern]
       #
       def sometimes(probability=0.5)
         prob_pat = probability.p
 
-        if times_pat.infinite?
+        if prob_pat.infinite?
           fail ArgumentError, 'times must be a finite pattern'
         end
 
@@ -334,7 +373,21 @@ module Xi
       end
 
       # Repeats each value +times+
-      # TODO Document
+      #
+      # +times+ can also be an enumerable or a *finite* Pattern.  In this case,
+      # for each value in +times+, it will yield each value of original pattern
+      # repeated a number of times based on that +times+ value.
+      #
+      # @example
+      #   peek [1, 2, 3].p.repeat_each(2)   #=> [1, 1, 2, 2, 3, 3]
+      #   peek [1, 2, 3].p.repeat_each(3)   #=> [1, 1, 1, 2, 2, 2, 3, 3, 3]
+      #
+      # @example
+      #   peek [1, 2, 3].p.repeat_each([3,2]), 15
+      #     #=> [1, 1, 1, 2, 2, 2, 3, 3, 3, 1, 1, 2, 2, 3, 3]
+      #
+      # @param times [Numeric, #each]
+      # @return [Pattern]
       #
       def repeat_each(times)
         times_pat = times.p
@@ -349,6 +402,53 @@ module Xi
           end
         end
       end
+
+      # Choose items from the list randomly, +repeats+ number of times
+      #
+      # @see Pattern::Generators::ClassMethods#rand
+      #
+      # @example
+      #   peek [1, 2, 3].p.rand             #=> [2]
+      #   peek [1, 2, 3, 4].p.rand(6)       #=> [1, 3, 2, 2, 4, 3]
+      #
+      # @param repeats [Fixnum, Symbol] number or inf (default: 1)
+      # @return [Pattern]
+      #
+      def rand(repeats=1)
+        P.rand(self, repeats)
+      end
+
+      # Choose randomly, but only allow repeating the same item after yielding
+      # all items from the list.
+      #
+      # @see Pattern::Generators::ClassMethods#xrand
+      #
+      # @example
+      #   peek [1, 2, 3, 4, 5].p.xrand    #=> [4]
+      #   peek [1, 2, 3].p.xrand(8)       #=> [1, 3, 2, 3, 1, 2, 3, 2]
+      #
+      # @param repeats [Fixnum, Symbol] number or inf (default: 1)
+      # @return [Pattern]
+      #
+      def xrand(repeats=1)
+        P.xrand(self, repeats)
+      end
+
+      # Shuffle the list in random order, and use the same random order
+      # +repeats+ times
+      #
+      # @see Pattern::Generators::ClassMethods#shuf
+      #
+      # @example
+      #   peek [1, 2, 3, 4, 5].p.xrand    #=> [4]
+      #   peek [1, 2, 3].p.xrand(8)       #=> [1, 3, 2, 3, 1, 2, 3, 2]
+      #
+      # @param repeats [Fixnum, Symbol] number or inf (default: 1)
+      # @return [Pattern]
+      #
+      def shuf(repeats=1)
+        P.shuf(self, repeats)
+      end
     end
   end
 end

data/lib/xi/pattern.rb

@@ -16,6 +16,13 @@ module Xi
 
     def_delegators :@source, :size
 
+    # Creates a new Pattern given either a +source+ or a block
+    # that yields values
+    #
+    # @param source [#each]
+    # @param size [Fixnum] number of elements (default: nil)
+    # @param dur [Hash]
+    #
     def initialize(source=nil, size: nil, **metadata)
       if source.nil? && !block_given?
         fail ArgumentError, 'must provide source or block'
@@ -29,8 +36,6 @@ module Xi
         source
       end
 
-      @is_infinite = @source.size.nil? || @source.size == Float::INFINITY
-
       @event_duration = metadata.delete(:dur) || metadata.delete(:event_duration)
       @event_duration ||= source.event_duration if source.respond_to?(:event_duration)
       @event_duration ||= 1
@@ -38,8 +43,14 @@ module Xi
       @metadata = source.respond_to?(:metadata) ? source.metadata : {}
       @metadata.merge!(metadata)
 
+      @is_infinite = @source.size.nil? || @source.size == Float::INFINITY
+
       if @is_infinite
-        @total_duration = @event_duration
+        @total_duration = if @event_duration.respond_to?(:each)
+          @event_duration.each.first
+        else
+          @event_duration
+        end
       else
         last_ev = each_event.take(@source.size).last
         @total_duration = last_ev ? last_ev.start + last_ev.duration : 0
@@ -73,12 +84,13 @@ module Xi
     def each_event
       return enum_for(__method__) unless block_given?
 
-      dur = @event_duration
+      dur_enum = each_event_duration
       pos = 0
 
       @source.each do |value|
         if value.is_a?(Pattern)
           value.each do |v|
+            dur = dur_enum.next
             yield Event.new(v, pos, dur)
             pos += dur
           end
@@ -86,6 +98,7 @@ module Xi
           yield value
           pos += value.duration
         else
+          dur = dur_enum.next
           yield Event.new(value, pos, dur)
           pos += dur
         end
@@ -97,6 +110,15 @@ module Xi
       each_event { |e| yield e.value }
     end
 
+    def each_event_duration
+      return enum_for(__method__) unless block_given?
+      if @event_duration.respond_to?(:each)
+        loop { @event_duration.each { |v| yield v } }
+      else
+        loop { yield @event_duration }
+      end
+    end
+
     def inspect
       ss = if @source.respond_to?(:join)
              @source.map(&:inspect).join(', ')

data/lib/xi/stream.rb

@@ -1,13 +1,21 @@
+require 'xi/scale'
 require 'set'
-require 'xi/music_parameters'
 
 module Xi
   class Stream
-    prepend MusicParameters
-
     attr_reader :clock, :opts, :source, :state, :event_duration, :gate
 
+    DEFAULT_PARAMS = {
+      degree: 0,
+      octave: 5,
+      root:   0,
+      scale:  Xi::Scale.major,
+      steps_per_octave: 12,
+    }
+
     def initialize(name, clock, **opts)
+      Array(opts.delete(:include)).each { |m| include_mixin(m) }
+
       @name = name.to_sym
       @opts = opts
 
@@ -24,7 +32,6 @@ module Xi
 
     def set(event_duration: nil, gate: nil, **source)
       @mutex.synchronize do
-        source[:s] ||= @name
         @source = source
         @gate = gate if gate
         @event_duration = event_duration if event_duration
@@ -90,15 +97,15 @@ module Xi
       error(err)
     end
 
-    def notify(now)
+    def notify(now, cps)
       return unless playing? && @source
 
       @mutex.synchronize do
         @changed_params.clear
 
-        forward_enums(now) if @must_forward
+        forward_enums(now, cps) if @must_forward
         gate_off = gate_off_old_sound_objects(now)
-        gate_on = play_enums(now)
+        gate_on = play_enums(now, cps)
 
         # Call hooks
         do_gate_off_change(gate_off) unless gate_off.empty?
@@ -109,22 +116,33 @@ module Xi
 
     private
 
+    def include_mixin(module_or_name)
+      mod = if module_or_name.is_a?(Module)
+        module_or_name
+      else
+        name = module_or_name.to_s
+        require "#{self.class.name.underscore}/#{name}"
+        self.class.const_get(name.camelize)
+      end
+      singleton_class.send(:include, mod)
+    end
+
     def changed_state
       @state.select { |k, _| @changed_params.include?(k) }
     end
 
-    def forward_enums(now)
+    def forward_enums(now, cps)
       @enums.each do |p, (enum, total_dur)|
         next if total_dur == 0
 
-        cur_pos = now % total_dur
-        start_pos = now - cur_pos
+        cur_pos = (now * cps) % total_dur
+        start_ts = now - (cur_pos / cps)
 
         loop do
           next_ev = enum.peek
           distance = (cur_pos - next_ev.start) % total_dur
 
-          @prev_end[p] = start_pos + next_ev.end
+          @prev_end[p] = @clock.init_ts + start_ts + (next_ev.end / cps)
           enum.next
 
           break if distance <= next_ev.duration
@@ -140,7 +158,7 @@ module Xi
       # Check if there are any currently playing sound objects that
       # must be gated off
       @playing_sound_objects.dup.each do |end_pos, h|
-        if now >= h[:at] - latency_sec
+        if now + @clock.init_ts >= h[:at] - latency_sec
           gate_off << h
           @playing_sound_objects.delete(end_pos)
         end
@@ -149,19 +167,21 @@ module Xi
       gate_off
     end
 
-    def play_enums(now)
+    def play_enums(now, cps)
       gate_on = []
 
       @enums.each do |p, (enum, total_dur)|
         next if total_dur == 0
 
-        cur_pos = now % total_dur
-        start_pos = now - cur_pos
+        cur_pos = (now * cps) % total_dur
+        start_ts = now - (cur_pos / cps)
 
         next_ev = enum.peek
 
         # Do we need to play next event now? If not, skip this parameter
-        if (@prev_end[p].nil? || now >= @prev_end[p]) && cur_pos >= next_ev.start - latency_sec
+        if (@prev_end[p].nil? || now + @clock.init_ts >= @prev_end[p]) &&
+            cur_pos >= next_ev.start - latency_sec
+
           # Update state based on pattern value
           # TODO: Pass as parameter exact time (start_ts + next_ev.start)
           update_state(p, next_ev.value)
@@ -174,27 +194,55 @@ module Xi
 
             gate_on << {
               so_ids: new_so_ids,
-              at: start_pos + next_ev.start
+              at: @clock.init_ts + start_ts + (next_ev.start / cps),
             }
 
             @playing_sound_objects[rand(100000)] = {
               so_ids: new_so_ids,
               duration: total_dur,
-              at: start_pos + next_ev.end,
+              at: @clock.init_ts + start_ts + (next_ev.end / cps),
             }
           end
 
           # Because we already processed event, advance enumerator
           next_ev = enum.next
-          @prev_end[p] = start_pos + next_ev.end
+          @prev_end[p] = @clock.init_ts + start_ts + (next_ev.end / cps)
         end
       end
 
       gate_on
     end
 
-    # @override
     def transform_state
+      @state = DEFAULT_PARAMS.merge(@state)
+
+      @state[:s] ||= @name
+
+      if !changed_param?(:note) && changed_param?(:degree, :scale, :steps_per_octave)
+        @state[:note] = reduce_to_note
+        @changed_params << :note
+      end
+
+      if !changed_param?(:midinote) && changed_param?(:note)
+        @state[:midinote] = reduce_to_midinote
+        @changed_params << :midinote
+      end
+    end
+
+    def reduce_to_midinote
+      Array(@state[:note]).compact.map { |n|
+        @state[:root].to_i + @state[:octave].to_i * @state[:steps_per_octave] + n
+      }
+    end
+
+    def reduce_to_note
+      Array(@state[:degree]).compact.map do |d|
+        d.degree_to_key(Array(@state[:scale]), @state[:steps_per_octave])
+      end
+    end
+
+    def changed_param?(*params)
+      @changed_params.any? { |p| params.include?(p) }
     end
 
     def new_sound_object_id
@@ -222,11 +270,14 @@ module Xi
         .select { |k, v| @changed_params.include?(k) }.to_h}"
     end
 
-    def update_state(p, v)
-      if v != @state[p]
-        debug "Update state of :#{p}: #{v}"
-        @changed_params << p
-        @state[p] = v
+    def update_state(param, value)
+      kv = value.is_a?(Hash) ? value : {param => value}
+      kv.each do |k, v|
+        if v != @state[k]
+          debug "Update state of :#{k}: #{v}"
+          @changed_params << k
+          @state[k] = v
+        end
       end
     end
 

data/lib/xi/tidal_clock.rb

@@ -0,0 +1,118 @@
+require "websocket"
+require "time"
+
+module Xi
+  class TidalClock < Clock
+    SYNC_INTERVAL_SEC = 100 / 1000.0
+
+    attr_reader :server, :port, :attached
+    alias_method :attached?, :attached
+
+    def initialize(server: 'localhost', port: 9160, **opts)
+      @server = server
+      @port = port
+      @attached = true
+
+      super(opts)
+
+      @ws_thread = Thread.new { ws_thread_routine }
+    end
+
+    def cps=(new_cps)
+      fail NotImplementedError, 'cps is read-only'
+    end
+
+    def dettach
+      @attached = false
+      self
+    end
+
+    def attach
+      @attached = true
+      self
+    end
+
+    private
+
+    def ws_thread_routine
+      loop do
+        do_ws_sync
+        sleep INTERVAL_SEC
+      end
+    end
+
+    def do_ws_sync
+      return unless @attached
+
+      # Try to connect to websocket server
+      connect
+      return if @socket.nil? || @socket.closed?
+
+      # Offer a handshake
+      @handshake = WebSocket::Handshake::Client.new(url: "ws://#{@server}:#{@port}")
+      @socket.puts @handshake.to_s
+
+      # Read server response
+      while line = @socket.gets
+        @handshake << line
+        break if @handshake.finished?
+      end
+
+      unless @handshake.finished?
+        debug(__method__, "Handshake didn't finished. Disconnect")
+        @socket.close
+        return
+      end
+
+      unless @handshake.valid?
+        debug(__method__, "Handshake is not valid. Disconnect")
+        @socket.close
+        return
+      end
+
+      frame = WebSocket::Frame::Incoming::Server.new(version: @handshake.version)
+
+      # Read loop
+      loop do
+        data, _ = @socket.recvfrom(4096)
+        break if data.empty?
+
+        frame << data
+        while f = frame.next
+          if (f.type == :close)
+            debug(__method__, "Close frame received. Disconnect")
+            @socket.close
+            return
+          else
+            debug(__method__, "Frame: #{f}")
+            hash = parse_frame_body(f.to_s)
+            update_clock_from_server_data(hash)
+          end
+        end
+      end
+
+    rescue => err
+      error(err)
+    end
+
+    def connect
+      @socket = TCPSocket.new(@server, @port)
+    rescue => err
+      error(err)
+      sleep 1
+    end
+
+    def parse_frame_body(body)
+      h = {}
+      ts, _, cps = body.split(',')
+      h[:ts] = Time.parse(ts)
+      h[:cps] = cps.to_f
+      h
+    end
+
+    def update_clock_from_server_data(h)
+      @init_ts = h[:ts].to_f
+      @cps = h[:cps]
+    end
+  end
+end

data/lib/xi/version.rb

@@ -1,3 +1,3 @@
 module Xi
-  VERSION = "0.1.3"
+  VERSION = "0.1.4"
 end

data/lib/xi.rb

@@ -18,27 +18,31 @@ module Xi
     @default_backend = new_name && new_name.to_sym
   end
 
+  def self.default_clock
+    @default_clock ||= Clock.new
+  end
+
+  def self.default_clock=(new_clock)
+    @default_clock = new_clock
+  end
+
   module Init
-    def peek(pattern, *args)
-      pattern.peek(*args)
+    def stop_all
+      @streams.each { |_, ss| ss.each { |_, s| s.stop } }
     end
+    alias_method :hush, :stop_all
 
-    def peek_events(pattern, *args)
-      pattern.peek_events(*args)
+    def start_all
+      @streams.each { |_, ss| ss.each { |_, s| s.start } }
     end
 
-    def clock
-      @default_clock ||= Clock.new
+    def peek(pattern, *args)
+      pattern.peek(*args)
     end
 
-    def stop_all
-      @streams.each do |backend, ss|
-        ss.each do |name, stream|
-          stream.stop
-        end
-      end
+    def peek_events(pattern, *args)
+      pattern.peek_events(*args)
     end
-    alias_method :hush, :stop_all
 
     def method_missing(method, backend=nil, **opts)
       backend ||= Xi.default_backend
@@ -51,16 +55,17 @@ module Xi
       @streams ||= {}
       @streams[backend] ||= {}
 
-      s = @streams[backend][method] ||= begin
+      stream = @streams[backend][method] ||= begin
         require "xi/#{backend}"
-        cls = Class.const_get("#{backend.to_s.capitalize}::Stream")
-        cls.new(method, self.clock, **opts)
+
+        cls = Class.const_get("#{backend.to_s.camelize}::Stream")
+        cls.new(method, Xi.default_clock, **opts)
       end
 
-      b = Pry.binding_for(self)
-      b.local_variable_set(method, s)
+      # Define (or overwrite) a local variable named +method+ with the stream
+      Pry.binding_for(self).local_variable_set(method, stream)
 
-      s
+      stream
     end
   end
 end

data/xi.gemspec

@@ -30,4 +30,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "guard-minitest"
 
   spec.add_dependency 'pry'
+  spec.add_dependency 'websocket'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: xi-lang
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - Damián Silvani
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-02-17 00:00:00.000000000 Z
+date: 2017-02-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -108,6 +108,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: websocket
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: |-
   A musical pattern language inspired in Tidal and SuperCollider
                             for building higher-level musical constructs easily.
@@ -135,16 +149,17 @@ files:
 - lib/xi/core_ext/numeric.rb
 - lib/xi/core_ext/object.rb
 - lib/xi/core_ext/simple.rb
+- lib/xi/core_ext/string.rb
 - lib/xi/error_log.rb
 - lib/xi/event.rb
 - lib/xi/logger.rb
-- lib/xi/music_parameters.rb
 - lib/xi/pattern.rb
 - lib/xi/pattern/generators.rb
 - lib/xi/pattern/transforms.rb
 - lib/xi/repl.rb
 - lib/xi/scale.rb
 - lib/xi/stream.rb
+- lib/xi/tidal_clock.rb
 - lib/xi/version.rb
 - xi.gemspec
 homepage: https://github.com/xi-livecode/xi

data/lib/xi/music_parameters.rb

@@ -1,47 +0,0 @@
-require 'xi/scale'
-
-class Xi::Stream
-  module MusicParameters
-    DEFAULT = {
-      degree: 0,
-      octave: 5,
-      root:   0,
-      scale:  Xi::Scale.major,
-      steps_per_octave: 12,
-    }
-
-    private
-
-    def transform_state
-      super
-
-      @state = DEFAULT.merge(@state)
-
-      if !changed_param?(:note) && changed_param?(:degree, :scale, :steps_per_octave)
-        @state[:note] = reduce_to_note
-        @changed_params << :note
-      end
-
-      if !changed_param?(:midinote) && changed_param?(:note)
-        @state[:midinote] = reduce_to_midinote
-        @changed_params << :midinote
-      end
-    end
-
-    def reduce_to_midinote
-      Array(@state[:note]).compact.map { |n|
-        @state[:root].to_i + @state[:octave].to_i * @state[:steps_per_octave] + n
-      }
-    end
-
-    def reduce_to_note
-      Array(@state[:degree]).compact.map do |d|
-        d.degree_to_key(Array(@state[:scale]), @state[:steps_per_octave])
-      end
-    end
-
-    def changed_param?(*params)
-      @changed_params.any? { |p| params.include?(p) }
-    end
-  end
-end