patch 0.4.13

data/lib/patch/io/websocket/node.rb

@@ -0,0 +1,103 @@
+module Patch
+
+  module IO
+
+    module Websocket
+
+      class Node
+
+        attr_reader :id
+
+        # @param [Fixnum] id
+        # @param [String] host
+        # @param [Fixnum] port
+        # @param [Hash]
+        # @option properties [Log] :log
+        def initialize(id, host, port, options = {})
+          @config = {
+            :host => host,
+            :port => port
+          }
+          @id = id
+          @log = options[:log]
+        end
+
+        # Send a message over the socket
+        # @param [Patch::Patch] patch Context
+        # @param [Array<::Patch::Message>] messages A message or messages to send
+        # @return [String, nil] If a message was sent, its JSON string; otherwise nil
+        def puts(patch, messages)
+          if running?
+            unless (messages = [messages].flatten.compact).empty?
+              json = messages.to_json
+              @log.puts("Sending messages: #{json}") if @log
+              begin
+                @socket.puts(json)
+              rescue Exception => exception # failsafe
+                @log.exception(exception) if @log
+                ::Thread.main.raise(exception)
+              end
+              json
+            end
+          else
+            @log.puts("Warning: No connection") if @log
+            nil
+          end
+        end
+
+        # Disable the message listener
+        # @return [Boolean]
+        def disable(patch)
+          @socket.disable
+        end
+
+        # Listen for messages with the given patch context
+        # @param [Patch] patch
+        # @param [Proc] callback callback to fire when events are received
+        # @return [Boolean]
+        def listen(patch, &callback)
+          ensure_socket.on_message do |data|
+            handle_input(patch, data, &callback)
+          end
+          true
+        end
+
+        # Start the websocket
+        # @return [Boolean]
+        def socket
+          ensure_socket
+        end
+        alias_method :start, :socket
+
+        # Is the server active?
+        # @return [Boolean]
+        def active?
+          !@socket.nil? && @socket.active?
+        end
+        alias_method :running?, :active?
+
+        private
+
+        def ensure_socket
+          @socket ||= ::Patch::IO::Websocket::Socket.start(@config)
+        end
+
+        # Handle a received message
+        # @param [String] json_message A raw inputted JSON message
+        # @param [Proc] callback A callback to fire with the received message
+        # @return [Message]
+        def handle_input(patch, json_message, &callback)
+          message_hash = JSON.parse(json_message, :symbolize_names => true)
+          message = Message.new(message_hash)
+          @log.puts("Recieved message: #{message_hash.to_json}") if @log
+          yield(message) if block_given?
+          message
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/patch/io/websocket/socket.rb

@@ -0,0 +1,103 @@
+module Patch
+
+  module IO
+
+    module Websocket
+
+      class Socket
+
+        def self.start(config)
+          socket = new
+          socket.start(config)
+          socket
+        end
+
+        def initialize
+          @onmessage = []
+        end
+
+        def puts(data)
+          @socket.send(data)
+        end
+
+        # @return [Boolean]
+        def disable
+          @socket.onmessage = nil
+          @onmessage.clear
+          true
+        end
+
+        # @param [Proc] callback callback to fire when events are received
+        # @return [Boolean]
+        def on_message(&callback)
+          if @socket.nil?
+            @onmessage << callback
+          else
+            @socket.onmessage { |data| yield(data) }
+          end
+          true
+        end
+
+        # Start the websocket
+        # @param [Hash] config
+        # @return [Boolean]
+        def start(config, &block)
+          EM::WebSocket.run(config) do |websocket|
+            ::Thread.current.abort_on_exception = true
+            begin
+              enable(websocket)
+            rescue Exception => exception
+              ::Thread.main.raise(exception)
+            end
+          end
+          true
+        end
+
+        # Is the socket active?
+        # @return [Boolean]
+        def active?
+          !@socket.nil?
+        end
+
+        private
+
+        # If callbacks were added before the socket was active, assign them to the socket event handler
+        def configure_message_callbacks
+          @onmessage.each do |callback|
+            on_message(&callback)
+          end
+          @onmessage.clear
+        end
+
+        # Enable this node after initializing an EM::Websocket
+        # @param [EM::Websocket] websocket
+        # @return [Boolean]
+        def enable(websocket)
+          @socket = websocket
+          configure
+          true
+        end
+
+        # Configure the server actions
+        # @return [Boolean]
+        def configure
+          @socket.onopen do |handshake|
+            puts "Connection open"
+          end
+
+          @socket.onclose do
+            puts "Connection closed"
+          end
+
+          configure_message_callbacks unless @onmessage.empty?
+
+          true
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/patch/io/websocket.rb

@@ -0,0 +1,27 @@
+require "patch/io/websocket/node"
+require "patch/io/websocket/socket"
+
+module Patch
+
+  module IO
+
+    # Websocket IO
+    module Websocket
+
+      # Key that will be used by Patch to identify the module
+      KEY = :websocket
+      extend self
+      ::Patch::IO::Module.add(self)
+
+      # Construct a websocket from a node config
+      # @param [Hash] config
+      # @param [Hash] options
+      # @param [Hash]
+      # @option properties [Log] :log
+      def new_from_config(config, options = {})
+        ::Patch::IO::Websocket::Node.new(config[:id], config[:host], config[:port], options)
+      end
+
+    end
+  end
+end

data/lib/patch/io.rb

@@ -0,0 +1,15 @@
+# Classes
+require "patch/io/module"
+
+# Implementations
+require "patch/io/midi"
+require "patch/io/osc"
+require "patch/io/websocket"
+
+module Patch
+
+  # Namespace for IO nodes
+  module IO
+  end
+
+end

data/lib/patch/log.rb

@@ -0,0 +1,97 @@
+module Patch
+
+  # Logging
+  class Log
+
+    # @param [IO] out
+    # @param [Hash] options
+    # @option options [Array<Symbol>] :show
+    def initialize(out, options = {})
+      @out = out
+      @start = Time.now
+      populate_level(options)
+    end
+
+    def path
+      @out.path
+    end
+
+    # The current time since startup
+    # @return [Time]
+    def time
+      Time.now - @start
+    end
+
+    # Output an info message
+    # @param [String] message
+    # @return [String]
+    def puts(message)
+      message = format(message, :type => :info)
+      @out.puts(message) if @info
+      message
+    end
+    alias_method :info, :puts
+
+    # Output an exception
+    # @param [String] exception
+    # @return [String]
+    def exception(exception)
+      if @exception
+        message = format(exception.message, :type => :exception)
+        @out.puts(message)
+      end
+      exception
+    end
+    alias_method :error, :exception
+
+    private
+
+    # Populate the level setting
+    # @param [Hash] options
+    # @return [Debug]
+    def populate_level(options = {})
+      if !options[:show].nil?
+        show = [options[:show]].flatten.compact
+        @exception = !(show & [:exception, :error]).empty?
+        @info = !(show & [:info, :message]).empty?
+      end
+      @exception = true if @exception.nil?
+      @info = true if @info.nil?
+      self
+    end
+
+    # Format a message for output
+    # @param [String] message
+    # @param [Hash] options
+    # @option options [Symbol] type
+    # @return [String]
+    def format(message, options = {})
+      {
+        :timestamp => time.seconds.round(2),
+        :caller => caller_method,
+        :message => message,
+        :type => options[:type]
+      }.to_json
+    end
+
+    # Get the caller method where a message originated
+    # @param [Fixnum] depth
+    # @return [String]
+    def caller_method(depth=1)
+      method = caller(depth+1).first
+      parse_caller(method)
+    end
+
+    # Parse the caller name
+    # @param [String] at
+    # @return [String]
+    def parse_caller(at)
+      if /^(.+?):(\d+)(?::in `(.*)')?/ =~ at
+        file   = Regexp.last_match[1]
+        file.scan(/.+\/(\w+)\.rb/)[0][0]
+      end
+    end
+
+  end
+
+end

data/lib/patch/message.rb

@@ -0,0 +1,67 @@
+module Patch 
+
+  # A generic controller message
+  class Message
+
+    attr_accessor :index, :patch_name, :value
+    attr_reader :time
+
+    # @param [Hash] properties
+    def initialize(properties = nil)
+      populate_from_properties(properties) unless properties.nil?
+      @time ||= Time.now
+    end
+
+    # Convert the message to a hash
+    # @return [Hash]
+    def to_h
+      properties = {
+        :index => @index, 
+        :patch_name => @patch_name, 
+        :timestamp => timestamp, #js format
+        :value => @value
+      }
+      properties.merge!(@other_properties) unless @other_properties.nil?
+      properties
+    end
+
+    # Convert the message to a JSON string
+    # @return [String]
+    def to_json(*args)
+      to_h.to_json(*args)
+    end
+
+    # Get the message time as a JS timestamp
+    # @return [Fixnum]
+    def timestamp
+      js_time = @time.to_f * 1000
+      js_time.to_i
+    end
+
+    private
+
+    # Populate this message from a hash of properties
+    # @param [Hash] properties
+    # @return [Hash]
+    def populate_from_properties(properties)
+      properties = properties.dup
+      @index = properties.delete(:index)
+      @patch_name = properties.delete(:patch_name)
+      @value = properties.delete(:value)
+      if !(timestamp = properties.delete(:timestamp)).nil?
+        @time = timestamp_to_time(timestamp)
+      end
+      @other_properties = properties
+    end
+
+    # Convert a JS timestamp to a Ruby time
+    # @param [String, Numeric] timestamp
+    # @return [Time]
+    def timestamp_to_time(timestamp)
+      js_time = timestamp.to_f / 1000
+      Time.at(js_time.to_i)
+    end
+
+  end
+
+end

data/lib/patch/node/container.rb

@@ -0,0 +1,69 @@
+module Patch
+
+  module Node
+
+    # A container for Patch::Node
+    class Container
+
+      include Enumerable
+      extend Forwardable
+
+      attr_reader :nodes
+      def_delegators :@nodes, :all?, :any?, :count, :empty?
+
+      # @param [Array<Object>] nodes
+      def initialize(nodes)
+        @threads = []
+        @nodes = nodes
+      end
+
+      def |(other)
+        @nodes | other.nodes
+      end
+
+      def each(&block)
+        @nodes.each(&block)
+      end
+
+      # Enable the nodes in this container
+      # @return [Boolean]
+      def enable
+        result = @nodes.map { |node| enable_node(node) }
+        result.any?
+      end
+
+      # Get the nodes of the given type
+      # @param [Symbol] :type The type of node (eg :midi)
+      # @return [Array<IO::MIDI, IO::OSC, IO::Websocket>]
+      def find_all_by_type(type)
+        if (mod = IO::Module.find_by_key(type)).nil?
+          []
+        else
+          @nodes.select { |node| node.class.name.match(/\A#{mod.name}/) }
+        end
+      end
+
+      # Find the node with the given id
+      # @param [Fixnum] id
+      # @return [IO::MIDI, IO::OSC, IO::Websocket]
+      def find_by_id(id)
+        @nodes.find { |node| node.id == id }
+      end
+
+      private
+
+      # Enable the given node
+      # @param [Patch::Node] node
+      # @return [Boolean]
+      def enable_node(node)
+        if node.respond_to?(:start) && !node.active?
+          @threads << ::Patch::Thread.new { node.start }
+        end
+        true
+      end
+
+    end
+
+  end
+
+end

data/lib/patch/node/map.rb

@@ -0,0 +1,71 @@
+module Patch
+
+  module Node
+
+    # A map of connections between nodes for a given patch
+    class Map
+
+      attr_reader :from, :to
+
+      # @param [Array<Object>, NodeContainer, Object] from
+      # @param [Array<Object>, NodeContainer, Object] to
+      def initialize(from, to)
+        @from = to_node_container(from)
+        @to = to_node_container(to)
+      end
+
+      # Disable the map for the given patch context
+      # @return [Boolean]
+      def disable(patch)
+        result = @to.map do |to_node|
+          disabled = @from.map do |from_node|
+            from_node.disable(patch)
+            true
+          end
+          disabled.any?
+        end
+        result.any?
+      end
+
+      # Enable this map for the given nodes
+      # @param [::Patch::Patch] patch The patch context to enable the map in
+      # @return [Boolean] Whether nodes were enabled
+      def enable(patch)
+        result = @to.map do |to_node|
+          enabled = @from.map do |from_node|
+            from_node.listen(patch) do |messages|
+              to_node.puts(patch, messages)
+            end
+            true
+          end
+          enabled.any?
+        end
+        result.flatten.any?
+      end
+
+      # The nodes for this map, collected
+      # @return [NodeContainer]
+      def nodes
+        @from | @to
+      end
+
+      private
+
+      # Convert the given arg to a node container
+      # @param [Object] object
+      # @return [NodeContainer]
+      def to_node_container(object)
+        if !object.kind_of?(Array) || !object.kind_of?(Node::Container)
+          object = [object].flatten.compact
+        end
+        if object.kind_of?(Array)
+          object = Node::Container.new(object)
+        end
+        object
+      end
+
+    end
+
+  end
+
+end

data/lib/patch/node.rb

@@ -0,0 +1,10 @@
+require "patch/node/container"
+require "patch/node/map"
+
+module Patch
+
+  # A network or hardware connection
+  module Node
+  end
+
+end

data/lib/patch/patch.rb

@@ -0,0 +1,59 @@
+module Patch
+
+  # A single patch consisting of a node mapping and actions
+  class Patch
+
+    attr_reader :actions, :maps, :name
+
+    # @param [Symbol, String] name
+    # @param [Array<Node::Map>, Node::Map] maps A node map or maps
+    # @param [Array<Hash>, Hash] actions An action or actions
+    def initialize(name, maps, actions)
+      @name = name
+      populate(maps, actions)
+    end
+
+    # Enable the given nodes to implement this patch
+    # @param [Node::Container] nodes
+    # @return [Boolean]
+    def enable
+      result = @maps.map { |map| map.enable(self) }
+      result.any?
+    end
+
+    private
+
+    # Populate the patch
+    # @param [Array<Hash, Node::Map>, Hash, Node::Map] maps
+    # @param [Array<Hash>, Hash] actions
+    # @return [Patch]
+    def populate(maps, actions)
+      populate_maps(maps)
+      populate_actions(actions)
+      self
+    end
+
+    # Populate the patch actions from various arg formats
+    # @param [Array<Hash>, Hash] actions
+    # @return [Array<Hash>]
+    def populate_actions(actions)
+      @actions = actions.kind_of?(Hash) ? [actions] : actions
+    end
+
+    # Populate the node maps from various arg formats
+    # @param [Array<Hash, Node::Map>, Hash, Node::Map] maps
+    # @return [Array<Node::Map>]
+    def populate_maps(maps)
+      maps = [maps] unless maps.kind_of?(Array)
+      maps = maps.map do |map|
+        if map.kind_of?(Hash)
+          Node::Map.new(map.keys.first, map.values.first)
+        else
+          map
+        end
+      end
+      @maps = maps.flatten.compact
+    end
+
+  end
+end