xi-lang 0.1.0

data/lib/xi/pattern/transforms.rb

@@ -0,0 +1,302 @@
+module Xi
+  class Pattern
+    module Transforms
+      # Negates every number in the pattern
+      #
+      # Non-numeric values are ignored.
+      #
+      # @example
+      #   peek -[10, 20, 30].p    #=> [-10, -20, -30]
+      #   peek -[1, -2, 3].p      #=> [-1, 2, -3]
+      #
+      # @return [Pattern]
+      #
+      def -@
+        Pattern.new(self) do |y|
+          each { |v| y << (v.respond_to?(:-@) ? -v : v) }
+        end
+      end
+
+      # Concatenate +object+ pattern or perform a scalar sum with +object+
+      #
+      # If +object+ is a Pattern, concatenate the two patterns.
+      # Else, for each value from pattern, sum with +object+.
+      # Values that do not respond to #+ are ignored.
+      #
+      # @example Concatenation of patterns
+      #   peek [1, 2, 3].p + [4, 5, 6].p    #=> [1, 2, 3, 4, 5, 6]
+      #
+      # @example Scalar sum
+      #   peek [1, 2, 3].p + 60             #=> [61, 62, 63]
+      #   peek [0.25, 0.5].p + 0.125        #=> [0.375, 0.625]
+      #   peek [0, :foo, 2].p + 1           #=> [1, :foo, 3]
+      #
+      # @param object [Pattern, Numeric] pattern or numeric
+      # @return [Pattern]
+      #
+      def +(object)
+        if object.is_a?(Pattern)
+          Pattern.new(self, size: size + object.size) do |y|
+            each { |v| y << v }
+            object.each { |v| y << v }
+          end
+        else
+          Pattern.new(self) do |y|
+            each { |v| y << (v.respond_to?(:+) ? v + object : v) }
+          end
+        end
+      end
+
+      # Performs a scalar substraction with +numeric+
+      #
+      # For each value from pattern, substract with +numeric+.
+      # Values that do not respond to #- are ignored.
+      #
+      # @example
+      #   peek [1, 2, 3].p - 10       #=> [-9, -8, -7]
+      #   peek [1, :foo, 3].p - 10    #=> [-9, :foo, -7]
+      #
+      # @param numeric [Numeric]
+      # @return [Pattern]
+      #
+      def -(numeric)
+        Pattern.new(self) do |y|
+          each { |v| y << (v.respond_to?(:-) ? v - numeric : v) }
+        end
+      end
+
+      # Performs a scalar multiplication with +numeric+
+      #
+      # For each value from pattern, multiplicate with +numeric+.
+      # Values that do not respond to #* are ignored.
+      #
+      # @example
+      #   peek [1, 2, 4].p * 2      #=> [2, 4, 8]
+      #   peek [1, :foo].p * 2      #=> [2, :foo]
+      #
+      # @param numeric [Numeric]
+      # @return [Pattern]
+      #
+      def *(numeric)
+        Pattern.new(self) do |y|
+          each { |v| y << (v.respond_to?(:*) ? v * numeric : v) }
+        end
+      end
+
+      # Performs a scalar division by +numeric+
+      #
+      # For each value from pattern, divide by +numeric+.
+      # Values that do not respond to #/ are ignored.
+      #
+      # @example
+      #   peek [1, 2, 4].p / 2      #=> [(1/2), (1/1), (2/1)]
+      #   peek [0.5, :foo].p / 2    #=> [0.25, :foo]
+      #
+      # @param numeric [Numeric]
+      # @return [Pattern]
+      #
+      def /(numeric)
+        Pattern.new(self) do |y|
+          each { |v| y << (v.respond_to?(:/) ? v / numeric : v) }
+        end
+      end
+
+      # Performs a scalar modulo against +numeric+
+      #
+      # For each value from pattern, return modulo of value divided by +numeric+.
+      # Values from pattern that do not respond to #% are ignored.
+      #
+      # @example
+      #   peek (1..5).p % 2                     #=> [1, 0, 1, 0, 1]
+      #   peek [0, 1, 2, :bar, 4, 5, 6].p % 3   #=> [0, 1, 2, :bar, l, 2, 0]
+      #
+      # @param numeric [Numeric]
+      # @return [Pattern]
+      #
+      def %(numeric)
+        Pattern.new(self) do |y|
+          each { |v| y << (v.respond_to?(:%) ? v % numeric : v) }
+        end
+      end
+
+      # Raises each value to the power of +numeric+, which may be negative or
+      # fractional.
+      #
+      # Values from pattern that do not respond to #** are ignored.
+      #
+      # @example
+      #   peek (0..5).p ** 2        #=> [0, 1, 4, 9, 16, 25]
+      #   peek [1, 2, 3].p ** -2    #=> [1, (1/4), (1/9)]
+      #
+      # @param numeric [Numeric]
+      # @return [Pattern]
+      #
+      def **(numeric)
+        Pattern.new(self) do |y|
+          each { |v| y << (v.respond_to?(:**) ? v ** numeric : v) }
+        end
+      end
+      alias_method :^, :**
+
+      # Cycles pattern +repeats+ number of times, shifted by +offset+
+      #
+      # @example
+      #   peek [1, 2, 3].p.seq              #=> [1, 2, 3]
+      #   peek [1, 2, 3].p.seq(2)           #=> [1, 2, 3, 1, 2, 3]
+      #   peek [1, 2, 3].p.seq(1, 1)        #=> [2, 3, 1]
+      #   peek [1, 2, 3].p.seq(2, 2)        #=> [3, 2, 1, 3, 2, 1]
+      #   peek [1, 2].p.seq(inf, 1)         #=> [2, 1, 2, 1, 2, 1, 2, 1, 2, 1]
+      #
+      # @param repeats [Fixnum, Symbol] number or inf (defaut: 1)
+      # @param offset [Fixnum] (default: 0)
+      # @return [Pattern]
+      #
+      def seq(repeats=1, offset=0)
+        unless (repeats.is_a?(Fixnum) && repeats >= 0) || repeats == inf
+          fail ArgumentError, "repeats must be a non-negative Fixnum or inf"
+        end
+        unless offset.is_a?(Fixnum) && offset >= 0
+          fail ArgumentError, "offset must be a non-negative Fixnum"
+        end
+
+        Pattern.new(self, size: size * repeats) do |y|
+          rep = repeats
+
+          loop do
+            if rep != inf
+              rep -= 1
+              break if rep < 0
+            end
+
+            c = offset
+            offset_items = []
+
+            is_empty = true
+            each do |v|
+              is_empty = false
+              if c > 0
+                offset_items << v
+                c -= 1
+              else
+                y << v
+              end
+            end
+
+            offset_items.each { |v| y << v }
+
+            break if is_empty
+          end
+        end
+      end
+
+      # Traverses the pattern in order and then in reverse order
+      #
+      # @example
+      #   peek (0..3).p.bounce   #=> [0, 1, 2, 3, 3, 2, 1, 0]
+      #
+      # @return [Pattern]
+      #
+      def bounce
+        Pattern.new(self, size: size * 2 - 1) do |y|
+          each.with_index { |v, i| y << v if i > 0 }
+          reverse_each.with_index { |v, i| y << v if i > 0 }
+        end
+      end
+
+      # Normalizes a pattern of values that range from +min+ to +max+ to 0..1
+      #
+      # Values from pattern that do not respond to #- are ignored.
+      #
+      # @example
+      #   peek (1..5).p.normalize(0, 100)
+      #     #=> [(1/100), (1/50), (3/100), (1/25), (1/20)]
+      #   peek [0, 0x40, 0x80, 0xc0].p.normalize(0, 0x100)
+      #     #=> [(0/1), (1/4), (1/2), (3/4)]
+      #
+      # @param min [Numeric]
+      # @param max [Numeric]
+      # @return [Pattern]
+      #
+      def normalize(min, max)
+        Pattern.new(self) do |y|
+          each { |v| y << (v.respond_to?(:-) ? (v - min) / (max - min) : v) }
+        end
+      end
+
+      # Scales a pattern of normalized values (0..1) to a custom range
+      # +min+..+max+
+      #
+      # This is inverse of {#normalize}
+      # Values from pattern that do not respond to #* are ignored.
+      #
+      # @example
+      #   peek [0.01, 0.02, 0.03, 0.04, 0.05].p.denormalize(0, 100)
+      #     #=> [1.0, 2.0, 3.0, 4.0, 5.0]
+      #   peek [0, 0.25, 0.50, 0.75].p.denormalize(0, 0x100)
+      #     #=> [0, 64.0, 128.0, 192.0]
+      #
+      # @param min [Numeric]
+      # @param max [Numeric]
+      # @return [Pattern]
+      #
+      def denormalize(min, max)
+        Pattern.new(self) do |y|
+          each { |v| y << (v.respond_to?(:*) ? (max - min) * v + min : v) }
+        end
+      end
+
+      # Scale from one range of values to another range of values
+      #
+      # @example
+      #   peek [0,2,4,1,3,6].p.scale(0, 6, 0, 0x7f)
+      #
+      # @param min_from [Numeric]
+      # @param max_from [Numeric]
+      # @param min_to [Numeric]
+      # @param max_to [Numeric]
+      # @return [Pattern]
+      #
+      def scale(min_from, max_from, min_to, max_to)
+        normalize(min_from, max_from).denormalize(min_to, max_to)
+      end
+
+      # TODO Document
+      def decelerate(num)
+        Pattern.new(self) do |y|
+          each_event { |e| y << E[e.value, e.start * num, e.duration * num] }
+        end
+      end
+
+      # TODO Document
+      def accelerate(num)
+        Pattern.new(self) do |y|
+          each_event { |e| y << E[e.value, e.start / num, e.duration / num] }
+        end
+      end
+
+      # Based on +probability+, it yields original value or nil
+      # TODO Document
+      #
+      def sometimes(probability=0.5)
+        prob_pat = probability.p
+        Pattern.new(self, size: size * prob_pat.size) do |y|
+          prob_pat.each do |prob|
+            each { |v| y << (rand < prob ? v : nil) }
+          end
+        end
+      end
+
+      # Repeats each value +times+
+      # TODO Document
+      #
+      def repeat_each(times)
+        times_pat = times.p
+        Pattern.new(self, size: size * times_pat.size) do |y|
+          times_pat.each do |t|
+            each { |v| t.times { y << v } }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/xi/pattern.rb

@@ -0,0 +1,150 @@
+require 'forwardable'
+require 'xi/event'
+require 'xi/pattern/transforms'
+require 'xi/pattern/generators'
+
+module Xi
+  class Pattern
+    include Enumerable
+    include Transforms
+    include Generators
+    extend  Forwardable
+
+    attr_reader :source, :event_duration, :metadata, :total_duration
+
+    alias_method :dur, :event_duration
+
+    def_delegators :@source, :size
+
+    def initialize(enum=nil, size: nil, **metadata)
+      size ||= enum.size if enum.respond_to?(:size)
+
+      @source = if block_given?
+        Enumerator.new(size) { |y| yield y }
+      elsif enum
+        enum
+      else
+        fail ArgumentError, 'must provide source or block'
+      end
+
+      @is_infinite = @source.size.nil? || @source.size == Float::INFINITY
+
+      @event_duration = metadata.delete(:dur) || metadata.delete(:event_duration)
+      @event_duration ||= enum.event_duration if enum.respond_to?(:event_duration)
+      @event_duration ||= 1
+
+      @metadata = enum.respond_to?(:metadata) ? enum.metadata : {}
+      @metadata.merge!(metadata)
+
+      if @is_infinite
+        @total_duration = @event_duration
+      else
+        last_ev = each_event.take(@source.size).last
+        @total_duration = last_ev ? last_ev.start + last_ev.duration : 0
+      end
+    end
+
+    def self.[](*args, **metadata)
+      new(args, **metadata)
+    end
+
+    def infinite?
+      @is_infinite
+    end
+
+    def finite?
+      !infinite?
+    end
+
+    def ==(o)
+      self.class == o.class &&
+        source == o.source &&
+        event_duration == o.event_duration &&
+        metadata == o.metadata
+    end
+
+    def p(dur=nil, **metadata)
+      Pattern.new(@source, dur: dur || @event_duration,
+                  **@metadata.merge(metadata))
+    end
+
+    def each_event
+      return enum_for(__method__) unless block_given?
+
+      dur = @event_duration
+      pos = 0
+
+      @source.each do |value|
+        if value.is_a?(Pattern)
+          value.each do |v|
+            yield Event.new(v, pos, dur)
+            pos += dur
+          end
+        elsif value.is_a?(Event)
+          yield value
+          pos += value.duration
+        else
+          yield Event.new(value, pos, dur)
+          pos += dur
+        end
+      end
+    end
+
+    def each
+      return enum_for(__method__) unless block_given?
+      each_event { |e| yield e.value }
+    end
+
+    def inspect
+      ss = if @source.respond_to?(:join)
+             @source.map(&:inspect).join(', ')
+           elsif @source.is_a?(Enumerator)
+             "?enum"
+           else
+             @source.inspect
+           end
+
+      ms = @metadata.reject { |_, v| v.nil? }
+      ms.merge!(dur: dur) if dur != 1
+      ms = ms.map { |k, v| "#{k}: #{v.inspect}" }.join(', ')
+
+      "P[#{ss}#{", #{ms}" unless ms.empty?}]"
+    end
+    alias_method :to_s, :inspect
+
+    def map_events
+      return enum_for(__method__) unless block_given?
+      Pattern.new(dur: dur, **metadata) { |y| each_event { |e| y << yield(e) } }
+    end
+    alias_method :collect_events, :map_events
+
+    def select_events
+      return enum_for(__method__) unless block_given?
+      Pattern.new { |y| each_event { |e| y << e if yield(e) } }
+    end
+    alias_method :find_all_events, :select_events
+
+    def reject_events
+      return enum_for(__method__) unless block_given?
+      Pattern.new { |y| each_event { |e| y << e unless yield(e) } }
+    end
+
+    def to_events
+      each_event.to_a
+    end
+
+    def peek(limit=10)
+      values = take(limit + 1)
+      puts "There are more than #{limit} values..." if values.size > limit
+      values.take(limit)
+    end
+
+    def peek_events(limit=10)
+      events = each_event.take(limit + 1)
+      puts "There are more than #{limit} events..." if events.size > limit
+      events.take(limit)
+    end
+  end
+end
+
+P = Xi::Pattern

data/lib/xi/repl.rb

@@ -0,0 +1,66 @@
+require "pry"
+require 'io/console'
+require "xi/error_log"
+
+module Xi
+  module REPL
+    extend self
+
+    CONFIG_PATH = File.expand_path("~/.config/xi")
+    HISTORY_FILE = "history"
+    INIT_SCRIPT_FILE = "init.rb"
+
+    DEFAULT_INIT_SCRIPT =
+      "# Here you can customize or define functions that will be available in\n" \
+      "# Xi, e.g. new streams or a custom clock."
+
+    def start
+      configure
+      load_init_script
+
+      Pry.start
+    end
+
+    def configure
+      prepare_config_dir
+
+      if ENV["INSIDE_EMACS"]
+        Pry.config.correct_indent = false
+        Pry.config.pager = false
+        Pry.config.prompt = [ proc { "" }, proc { "" }]
+      else
+        Pry.config.prompt = [ proc { "xi> " }, proc { "..> " }]
+      end
+
+      Pry.config.history.file = history_path
+
+      Pry.hooks.add_hook(:after_eval, "check_for_errors") do |result, pry|
+        more_errors = ErrorLog.instance.more_errors?
+        ErrorLog.instance.each do |msg|
+          puts "(╯°□°）╯︵ ɹoɹɹǝ #{msg}"
+        end
+        puts "(⌣_⌣”) There were more errors..." if more_errors
+      end
+    end
+
+    def load_init_script
+      require(init_script_path)
+    end
+
+    def prepare_config_dir
+      FileUtils.mkdir_p(CONFIG_PATH)
+
+      unless File.exists?(init_script_path)
+        File.write(init_script_path, DEFAULT_INIT_SCRIPT)
+      end
+    end
+
+    def history_path
+      File.join(CONFIG_PATH, HISTORY_FILE)
+    end
+
+    def init_script_path
+      File.join(CONFIG_PATH, INIT_SCRIPT_FILE)
+    end
+  end
+end

data/lib/xi/stream.rb

@@ -0,0 +1,203 @@
+require 'set'
+
+module Xi
+  class Stream
+    WINDOW_SEC = 0.05
+
+    attr_reader :clock, :source, :source_patterns, :state, :event_duration, :gate
+
+    def initialize(clock)
+      @mutex = Mutex.new
+      @playing = false
+      @state = {}
+      @new_sound_object_id = 0
+      @changed_params = [].to_set
+
+      self.clock = clock
+    end
+
+    def set(event_duration: nil, gate: nil, **source)
+      @mutex.synchronize do
+        @source = source
+        @gate = gate if gate
+        @event_duration = event_duration if event_duration
+        update_internal_structures
+      end
+      play
+      self
+    end
+    alias_method :<<, :set
+
+    def event_duration=(new_value)
+      @mutex.synchronize do
+        @event_duration = new_value
+        update_internal_structures
+      end
+    end
+
+    def gate=(new_value)
+      @mutex.synchronize do
+        @gate = new_value
+        update_internal_structures
+      end
+    end
+
+    def clock=(new_clock)
+      @clock.unsubscribe(self) if @clock
+      new_clock.subscribe(self) if playing?
+      @clock = new_clock
+    end
+
+    def playing?
+      @mutex.synchronize { @playing }
+    end
+
+    def stopped?
+      !playing?
+    end
+
+    def play
+      @mutex.synchronize do
+        @playing = true
+        @clock.subscribe(self)
+      end
+      self
+    end
+    alias_method :start, :play
+
+    def stop
+      @mutex.synchronize do
+        @playing = false
+        @state.clear
+        @clock.unsubscribe(self)
+      end
+      self
+    end
+    alias_method :pause, :play
+
+    def inspect
+      "#<#{self.class.name}:#{"0x%014x" % object_id} clock=#{@clock.inspect} #{playing? ? :playing : :stopped}>"
+    rescue => err
+      logger.error(err)
+    end
+
+    def notify(now)
+      return unless playing? && @source
+
+      @mutex.synchronize do
+        @changed_params.clear
+
+        forward_enums(now) if @must_forward
+
+        gate_on, gate_off = play_enums(now)
+
+        do_gate_off_change(gate_off) unless gate_off.empty?
+        do_state_change if state_changed?
+        do_gate_on_change(gate_on) unless gate_on.empty?
+      end
+    end
+
+    private
+
+    def changed_state
+      @state.select { |k, _| @changed_params.include?(k) }
+    end
+
+    def forward_enums(now)
+      @enums.each do |p, (enum, total_dur)|
+        cur_pos = now % total_dur
+        next_ev = enum.peek
+
+        while distance = (cur_pos - next_ev.start) % total_dur do
+          enum.next
+
+          break if distance <= next_ev.duration
+          next_ev = enum.peek
+        end
+      end
+      @must_forward = false
+    end
+
+    def play_enums(now)
+      gate_off = []
+      gate_on = []
+
+      @enums.each do |p, (enum, total_dur)|
+        cur_pos = now % total_dur
+        next_ev = enum.peek
+
+        # Check if there are any currently playing sound objects that
+        # must be gated off
+        @playing_sound_objects.dup.each do |end_pos, so_ids|
+          if (cur_pos - end_pos) % total_dur <= WINDOW_SEC
+            gate_off = so_ids
+            @playing_sound_objects.delete(end_pos)
+          end
+        end
+
+        # Do we need to play next event now? If not, skip this parameter
+        if (cur_pos - next_ev.start) % total_dur <= WINDOW_SEC
+          # Update state based on pattern value
+          update_state(p, next_ev.value)
+
+          # If this parameter is a gate, mark it as gate on as
+          # a new sound object
+          if p == @gate
+            new_so_ids = Array(next_ev.value).size.times.map do
+              so_id = @new_sound_object_id
+              @new_sound_object_id += 1
+              so_id
+            end
+            gate_on = new_so_ids
+            @playing_sound_objects[next_ev.end] = new_so_ids
+          end
+
+          # Because we already processed event, advance enumerator
+          enum.next
+        end
+      end
+
+      [gate_on, gate_off]
+    end
+
+    def update_internal_structures
+      @playing_sound_objects ||= {}
+      @must_forward = true
+      @enums = @source.map { |k, v|
+        pat = v.p(@event_duration)
+        [k, [infinite_enum(pat), pat.total_duration]]
+      }.to_h
+    end
+
+    def do_gate_on_change(ss)
+      logger.info "Gate on change: #{ss}"
+    end
+
+    def do_gate_off_change(ss)
+      logger.info "Gate off change: #{ss}"
+    end
+
+    def do_state_change
+      logger.info "State change: #{@state.select { |k, v| @changed_params.include?(k) }.to_h}"
+    end
+
+    def update_state(p, v)
+      logger.debug "Update state of :#{p}: #{v}"
+      @changed_params << p if v != @state[p]
+      @state[p] = v
+    end
+
+    def state_changed?
+      !@changed_params.empty?
+    end
+
+    def infinite_enum(p)
+      Enumerator.new { |y| loop { p.each_event { |e| y << e } } }
+    end
+
+    def logger
+      # FIXME this should be configurable
+      @logger ||= Logger.new("/tmp/xi.log")
+    end
+  end
+end