patch 0.4.13

data/lib/patch/report.rb

@@ -0,0 +1,132 @@
+module Patch
+
+  # Terminal/Console output explaining the hub configuration
+  class Report
+
+    # @param [Hub] hub The hub to print a report for
+    # @return [Report]
+    def self.print(hub)
+      new(hub).print
+    end
+
+    # @param [Hub] hub The hub to report about
+    def initialize(hub)
+      @hub = hub
+    end
+
+    # Print a report to standard out
+    # @return [Report] self
+    def print
+      report = self.report
+      puts
+      print_logo
+      puts
+      puts Rainbow("IPs").cyan
+      puts Rainbow("———").cyan
+      report[:ips].each { |ip| puts ip }
+      puts
+      puts Rainbow("Nodes").cyan
+      puts Rainbow("———").cyan
+      report[:nodes].each do |node|
+        puts "#{node[:id]}: #{node[:name]}"
+      end
+      puts
+      if report[:patches].count > 0
+        puts Rainbow("Patches").cyan
+        puts Rainbow("———").cyan
+        report[:patches].each_with_index do |patch, i|
+          puts "#{i+1}. #{patch[:name]}"
+          puts Rainbow("|").cyan
+          puts Rainbow("| Node Map").cyan
+          puts Rainbow("| ———").cyan
+          patch[:maps].each { |map| puts Rainbow("| ").cyan + map }
+          puts Rainbow("|").cyan
+          puts Rainbow("| Actions").cyan
+          puts Rainbow("| ———").cyan
+          chunked_actions(patch[:actions]).each do |chunk|
+            puts Rainbow("| ").cyan + chunk
+          end
+          puts Rainbow("|").cyan
+          puts
+        end
+      else
+        puts
+      end
+      unless report[:log].nil?
+        puts "Logging to #{report[:log]}"
+        puts
+      end
+      self
+    end
+
+    # Construct the report hash
+    # @return [Hash]
+    def report
+      report = {}
+      report[:ips] = @hub.ips
+      report[:nodes] = @hub.nodes.sort_by(&:id).map { |node| node_report(node) }
+      report[:patches] = @hub.patches.map { |patch| patch_report(patch) }
+      report[:log] = @hub.log.path unless @hub.log.nil?
+      report
+    end
+
+    private
+
+    # Get a patch action formatted for terminal width
+    # @param [Array<String>] actions
+    # @return [Array<String>]
+    def chunked_actions(actions)
+      max_length = columns - 10
+      chunks = []
+      actions.each do |action|
+        if chunks.last.nil? || chunks.last.length >= max_length - action.length
+          chunks << ""
+        end
+        chunk = chunks.last
+        chunk << "#{action}"
+        chunk << ", " unless action == actions.last
+      end
+      chunks
+    end
+
+    # The number of columns of the terminal
+    # @return [Fixnum]
+    def columns
+      `tput cols`.to_i rescue 80
+    end
+
+    # Output the patch logo
+    # @return [Boolean]
+    def print_logo
+      color = :blue
+      puts Rainbow("██████╗  █████╗ ████████╗ ██████╗██╗  ██╗").send(color)
+      puts Rainbow("██╔══██╗██╔══██╗╚══██╔══╝██╔════╝██║  ██║").send(color)
+      puts Rainbow("██████╔╝███████║   ██║   ██║     ███████║").send(color)
+      puts Rainbow("██╔═══╝ ██╔══██║   ██║   ██║     ██╔══██║").send(color)
+      puts Rainbow("██║     ██║  ██║   ██║   ╚██████╗██║  ██║").send(color)
+      puts Rainbow("╚═╝     ╚═╝  ╚═╝   ╚═╝    ╚═════╝╚═╝  ╚═╣").send(color)
+      puts Rainbow("═≡≡≡▓▓▓═════════════════════════════════╝").send(color)
+      true
+    end
+
+    # Construct the report about a node
+    # @return [Hash]
+    def node_report(node)
+      report = {}
+      report[:id] = node.id
+      report[:name] = node.class.name
+      report
+    end
+
+    # Construct the report about a patch
+    # @return [Hash]
+    def patch_report(patch)
+      report = {}
+      report[:name] = patch.name
+      report[:maps] = patch.maps.map { |map| "#{map.from.map(&:id)} => #{map.to.map(&:id)}" }
+      report[:actions] = patch.actions.map { |mapping| mapping[:name] }
+      report
+    end
+
+  end
+end

data/lib/patch/thread.rb

@@ -0,0 +1,19 @@
+module Patch
+
+  module Thread
+
+    def self.new(&block)
+      thread = ::Thread.new do
+        begin
+          yield
+        rescue Exception => exception
+          ::Thread.main.raise(exception)
+        end
+      end
+      thread.abort_on_exception = true
+      thread
+    end
+
+  end
+
+end

data/lib/patch.rb

@@ -0,0 +1,42 @@
+# Patch
+# Controller message patching
+#
+# Ari Russo
+# (c)2014-2015
+# Licensed under Apache 2.0
+#
+
+# Libs
+require "forwardable"
+require "json"
+require "socket"
+require "yaml"
+
+require "em-websocket"
+require "midi-eye"
+require "osc-ruby"
+require "osc-ruby/em_server"
+require "rainbow"
+require "scale"
+
+# Modules
+require "patch/config"
+require "patch/io"
+require "patch/node"
+require "patch/thread"
+
+# Classes
+require "patch/hub"
+require "patch/log"
+require "patch/message"
+require "patch/patch"
+require "patch/report"
+
+# Patches
+require "patch/em_patch"
+
+module Patch
+
+  VERSION = "0.4.13"
+
+end

data/test/config/nodes.yml

@@ -0,0 +1,16 @@
+:nodes:
+  - :id: 1
+    :type: websocket
+    :host: localhost
+    :port: 9006
+  - :id: 2
+    :type: midi
+    :direction: input
+    :name: Apple Inc. IAC Driver
+  - :id: 3
+    :type: osc
+    :server:
+      :port: 8000
+    :client:
+      :host: 192.168.1.118
+      :port: 9000

data/test/config/patches.yml

@@ -0,0 +1,41 @@
+:patches:
+  :test_patch:
+    :node_map:
+      [2, 3]: 1
+    :actions:
+    - :name: Zoom
+      :key: zoom
+      :default:
+        :scale: !ruby/range 0.1..5.0
+      :midi:
+        :channel: 0
+        :index: 0
+      :osc:
+        :address: /1/rotaryA
+        :scale: !ruby/range 0..1.0
+
+    - :name: Contrast
+      :key: contrast
+      :default:
+        :scale: !ruby/range 0..5.0
+      :osc:
+        :address: /1/rotaryD
+        :scale: !ruby/range 0..1.0
+
+    - :name: Saturation
+      :key: saturation
+      :default:
+        :scale: !ruby/range 0..2.0
+      :osc:
+        :address: /faderM
+        :scale: 
+          :osc: !ruby/range 0..1.0
+
+    - :name: Z Depth
+      :key: zDepth
+      :default:
+        :scale: !ruby/range 0..1000
+      :osc:
+        :address: /1/faderA
+        :scale: 
+          :osc: !ruby/range 0..1.0

data/test/config_test.rb

@@ -0,0 +1,216 @@
+require "helper"
+
+class Patch::SpecTest < Minitest::Test
+
+  context "Spec" do
+
+    setup do
+      load_test_data
+    end
+
+    context ".to_hub" do
+
+      setup do
+        @hub = Patch::Config.to_hub(@nodes_path, :patches => @patches_path)
+      end
+
+      should "have nodes" do
+        refute_nil @hub.nodes
+      end
+
+      should "have patches" do
+        refute_nil @hub.patches
+      end
+
+    end
+
+    context ".to_nodes" do
+
+      context "from files" do
+
+        setup do
+          @nodes = Patch::Config.to_nodes(@nodes_file)
+        end
+
+        should "populate" do
+          refute_nil @nodes
+          assert @nodes.kind_of?(Patch::Node::Container)
+          refute_empty @nodes
+        end
+
+      end
+
+      context "from strings" do
+
+        setup do
+          @nodes = Patch::Config.to_nodes(@nodes_path)
+        end
+
+        should "populate" do
+          refute_nil @nodes
+          assert @nodes.kind_of?(Patch::Node::Container)
+          refute_empty @nodes
+        end
+
+      end
+
+      context "from hashes" do
+
+        setup do
+          @nodes_hash = {
+            :nodes => [{
+              :type => "websocket",
+              :id => 1,
+              :host => "localhost",
+              :port =>9006
+            }]
+          }
+          @nodes = Patch::Config.to_nodes(@nodes_hash)
+        end
+
+        should "populate" do
+          refute_nil @nodes
+          assert @nodes.kind_of?(Patch::Node::Container)
+          refute_empty @nodes
+          assert_equal @nodes_hash[:nodes].count, @nodes.count
+        end
+
+      end
+
+      context ".to_node_maps" do
+
+        setup do
+          @hash = YAML.load(File.new(@patches_path))
+          @nodes = Patch::Config.to_nodes(@nodes_file)
+          @map_config = @hash[:patches][:test_patch][:node_map]
+        end
+
+        should "instantiate maps" do
+          @maps = Patch::Config.to_node_maps(@nodes, @map_config)
+          refute_nil @maps
+          refute_empty @maps
+          assert_equal @map_config.size, @maps.size
+          assert @maps.first.kind_of?(Patch::Node::Map)
+        end
+
+      end
+
+      context ".to_patches" do
+
+        setup do
+          @nodes = Patch::Config.to_nodes(@nodes_file)
+          @patches = Patch::Config.to_patches(@nodes, @patches_file)
+        end
+
+        should "create patches" do
+          refute_nil @patches
+          refute_empty @patches
+          assert @patches.first.kind_of?(Patch::Patch)
+        end
+
+      end
+
+      context ".to_patch" do
+
+        setup do
+          @nodes = Patch::Config.to_nodes(@nodes_file)
+          config = {
+            :node_map => [{ [1,2] => 3 }],
+            :action => []
+          }
+          @patch = Patch::Config.send(:to_patch, :test, @nodes, config)
+        end
+
+        should "create patch" do
+          refute_nil @patch
+          assert @patch.kind_of?(Patch::Patch)
+          refute_nil @patch.maps
+          refute_nil @patch.actions
+        end
+
+      end
+
+      context ".ensure_hash" do
+
+        setup do
+          @path = File.join(__dir__, "config/patches.yml")
+          @file = File.new(@path)
+        end
+
+        context "path" do
+
+          setup do
+            @config = Patch::Config.send(:ensure_hash, @path)
+          end
+
+          should "populate" do
+            refute_nil @config
+            refute_empty @config
+            assert_equal Hash, @config.class
+            assert_equal 1, @config.keys.count
+          end
+
+          should "deep freeze" do
+            assert @config.frozen?
+            assert @config[:patches].frozen?
+            assert @config[:patches][:test_patch].frozen?
+            assert @config[:patches][:test_patch][:node_map].frozen?
+          end
+
+        end
+
+        context "file" do
+
+          setup do
+            @config = Patch::Config.send(:ensure_hash, @file)
+          end
+
+          should "populate" do
+            refute_nil @config
+            refute_empty @config
+            assert_equal Hash, @config.class
+            assert_equal 1, @config.keys.count
+          end
+
+          should "deep freeze" do
+            assert @config.frozen?
+            assert @config[:patches].frozen?
+            assert @config[:patches][:test_patch].frozen?
+            assert @config[:patches][:test_patch][:node_map].frozen?
+          end
+
+        end
+
+        context "hash" do
+
+          setup do
+            @hash = {
+              :test => {
+                :node_map => [{ [1,2] => 3 }],
+                :action => []
+              }
+            }
+            @config = Patch::Config.send(:ensure_hash, @hash)
+          end
+
+          should "populate" do
+            refute_nil @config
+            refute_empty @config
+            assert_equal Hash, @config.class
+            assert_equal 1, @config.keys.count
+          end
+
+          should "deep freeze" do
+            assert @config.frozen?
+            assert @config[:test].frozen?
+            assert @config[:test][:node_map].frozen?
+            assert @config[:test][:action].frozen?
+          end
+
+        end
+
+      end
+
+    end
+  end
+end

data/test/helper.rb

@@ -0,0 +1,20 @@
+$:.unshift(File.join("..", "lib"))
+
+require "minitest/autorun"
+require "mocha/test_unit"
+require "shoulda-context"
+
+require "patch"
+
+UDPSocket.any_instance.stubs(:connect)
+EventMachine.stubs(:open_datagram_socket).returns(true)
+EventMachine.stubs(:open_udp_socket).returns(true)
+EventMachine.stubs(:start_server).returns(true)
+EventMachine.stubs(:start_tcp_server).returns(true)
+
+def load_test_data
+  @nodes_path = File.join(__dir__,"/config/nodes.yml")
+  @nodes_file = File.new(@nodes_path)
+  @patches_path = File.join(__dir__,"config/patches.yml")
+  @patches_file = File.new(@patches_path)
+end

data/test/hub_test.rb

@@ -0,0 +1,49 @@
+require "helper"
+
+class Patch::HubTest < Minitest::Test
+
+  context "Hub" do
+
+    setup do
+      load_test_data
+      @hub = Patch::Config.to_hub(@nodes_path, :patches => @patches_path)
+    end
+
+    context "#ips" do
+
+      should "have ips array" do
+        refute_nil @hub.ips
+        refute_empty @hub.ips
+      end
+
+    end
+
+    context "#listen" do
+
+      should "start listeners and controller" do
+        @hub.patches.each { |patch| patch.expects(:enable).once }
+        @hub.nodes.each { |node| node.expects(:enable).once }
+        assert @hub.listen(:background => true)
+      end
+
+    end
+
+    context "#nodes" do
+
+      should "be populated" do
+        refute_nil @hub.nodes
+      end
+
+      should "have nodes" do
+        refute_empty @hub.nodes
+      end
+
+      should "be node container" do
+        assert_equal Patch::Node::Container, @hub.nodes.class
+      end
+
+    end
+
+  end
+
+end

data/test/io/midi/action_test.rb

@@ -0,0 +1,82 @@
+require "helper"
+
+class Patch::IO::MIDI::ActionTest < Minitest::Test
+
+  context "Action" do
+
+    setup do
+      @actions = [
+        {
+          :name=>"Volume",
+          :key=>"volume",
+          :default=> {
+            :scale=>0..2.0
+          },
+          :midi => {
+            :channel=>4,
+            :index=>7
+          },
+          :osc=> {
+            :address=>"/faderM",
+            :scale=> {
+              :osc=>0..1.0
+            }
+          }
+        },
+        {
+          :name=>"Z Depth",
+          :key=>"zDepth",
+          :default=>{
+            :scale=>0..1000
+          },
+          :osc=>{
+            :address=>"/1/faderA",
+            :scale=> {
+              :osc=>0..1.0
+            }
+          }
+        }
+      ]
+    end
+
+    context "#midi_actions" do
+
+      should "return only midi actions" do
+        actions = Patch::IO::MIDI::Action.midi_actions(@actions)
+        refute_nil actions
+        refute_empty actions
+        assert_equal 1, actions.size
+        assert_equal @actions[0], actions.first
+      end
+
+    end
+
+    context "#midi?" do
+
+      should "return true for actions with midi" do
+        assert Patch::IO::MIDI::Action.midi?(@actions[0])
+      end
+
+      should "return false for actions without midi" do
+        refute Patch::IO::MIDI::Action.midi?(@actions[1])
+      end
+
+    end
+
+    context "#find_by_index" do
+
+      should "return action if it has midi" do
+        action = Patch::IO::MIDI::Action.find_by_index(@actions, 7)
+        refute_nil action
+      end
+
+      should "not return action if it doesn't have midi" do
+        action = Patch::IO::MIDI::Action.find_by_index(@actions, 1)
+        assert_nil action
+      end
+
+    end
+
+  end
+
+end