arcenciel 0.0.1

data/.gitignore

@@ -0,0 +1 @@
+Gemfile.lock

data/DEDICATION

@@ -0,0 +1 @@
+This project is dedicated to Ben Hughes.

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/README.md

@@ -0,0 +1,116 @@
+## Arcenciel: Physical Knobs for Virtual Machines
+
+![Hero](docs/images/hero.jpg)
+
+*"Touch the cloud; feel its thunder beneath your fingertips."*
+
+### Introduction
+
+Arcenciel is a declarative microframework for the [Monome](http://monome.org/) Arc OSC controller. 
+
+All sufficiently complex systems have *phases* and *transitions*.
+Discovering the boundary of each is challenging and often defies intuition.
+Trajectories can be stable, metastable, or chaotic.
+Small variations in the parameters of the system can manifest as large, unexpected effects.
+How can we thoroughly and naturally explore the space of all states?
+
+Consider this idea: Play your benchmarks like a *musical instrument*.
+
+Here's an [inspiring example](https://vimeo.com/21596928) of the Arc's potential.
+
+*Monome has discontinued all models of the Arc controller and the supply is therefore strictly limited.*
+*Each unit is a stunningly beautiful masterpiece: a rare combination of technology and aesthetic joy.*
+*If you're among the lucky few who own this extraordinary recherché, love and cherish it forever.*
+*The Arc's value handily surpasses its weight in gold.*
+
+### Dependencies
+
+Arcenciel uses the OSC protocol (UDP).
+SerialOSC interfaces each Arc with the host machine.
+
+To get started on Mac OS X, you'll need to:
+
+* Install the [FTDI virtual COM port (VCP) driver](http://www.ftdichip.com/Drivers/VCP.htm).
+* Install the [SerialOSC server](https://github.com/monome/serialosc/releases/tag/1.2).
+* Restart your computer.
+
+Test your configuration by running the bundled demonstration script:
+
+```
+$ gem install arcenciel
+$ arcenciel-demo
+[ARC] Added device (m0000171; UDP 19930).
+[ARC] Assigning control 'Arc' to device...
+[ARC] Illuminated encoder 'First' (0). Press any key.
+[ARC] Illuminated encoder 'Second' (1). Press any key.
+[ARC] Assigned control 'Arc'.
+```
+
+### Usage
+
+The Arc reacts to tactile interactions with its rotary encoders:
+
+* Angular motion
+* Threshold pressure
+
+From events generated by the device, Arcenciel emulates *logical knobs*.
+Each knob has a distinct configuration: a name, a value type, a range, and a precision (degrees per sweep).
+When the value of a knob changes, the provided callback is invoked.
+
+Arcenciel discovers all connected devices and assigns each to a logical controller (defining one or more knobs).
+When a device is assigned to a controller, for each of its knobs, Arcenciel illuminates the rotary encoder's ring and requests that you to confirm the assignment.
+
+Knobs are defined using these attributes:
+
+* Name
+* Initial value
+* Minimum and maximum value (individually or as a range)
+* Sweep (degrees of rotation for the entire range)
+* Value type (integer or float)
+
+### Example
+
+Here's a sample that targets a single Arc (two-encoder version).
+
+* Emulate two knobs: "Query rate" and "Rows scanned."
+* Use a distinct range and sweep for each knob, with integer values.
+* Invoke a distinct callback for each knob.
+
+Implementation:
+
+```
+require 'arcenciel'
+
+Arcenciel.run! do
+  knob do
+    name "Query rate"
+
+    min 0
+    max 100
+    type :integer
+    sweep 1440
+
+    on_value do |rate|
+      puts "A: #{name}: #{rate}"
+    end
+  end
+
+  knob do
+    name "Rows scanned"
+
+    min 0
+    max 10000
+    type :integer
+    sweep 360
+
+    on_value do |rows|
+      puts "B: #{name}: #{rows}"
+    end
+  end
+end
+```
+
+### Special Thanks
+
+* The Monome minimalists, for a solid concept and outstanding craftsmanship.
+* The generous dudes who sold me their Arcs, without which this project would not be possible.

data/arcenciel.gemspec

@@ -0,0 +1,22 @@
+# encoding: utf-8
+$:.push File.expand_path("../lib", __FILE__)
+
+require 'arcenciel/version'
+
+Gem::Specification.new do |s|
+  s.name         = 'arcenciel'
+  s.version      = Arcenciel::VERSION
+  s.platform     = Gem::Platform::RUBY
+  s.authors      = ['Nelson Gauthier']
+  s.email        = ['nelson.gauthier@gmail.com']
+  s.homepage     = 'https://github.com/nelgau/arcenciel'
+  s.summary      = "Declarative Monome Arc microframework"
+  s.description  = "Physical knobs for virtual machines"
+
+  s.files        = `git ls-files`.split("\n")
+  s.executables  = ['arcenciel-demo']
+  s.require_path = 'lib'
+
+  s.add_runtime_dependency 'osc-ruby', '~> 1.1.1'
+  s.add_runtime_dependency 'colored', '>= 1.2.0'
+end

data/bin/arcenciel-demo

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+require 'arcenciel'
+
+Arcenciel.run! do
+  knob do
+    name 'First'
+  end
+
+  knob do
+    name 'Second'
+  end
+end

data/lib/arcenciel.rb

@@ -0,0 +1,30 @@
+require 'osc-ruby'
+
+require 'arcenciel/utility'
+require 'arcenciel/manager'
+require 'arcenciel/surfaces'
+
+module Arcenciel
+
+  # Lists all controllers.
+  def self.controllers
+    @controllers ||= []
+  end
+
+  # Add a new controllers.
+  def self.add(&blk)
+    controllers << Surfaces::Controller.from_dsl(&blk)
+  end
+
+  # Run the main event loop.
+  def self.run!(&blk)
+    add(&blk) if block_given?
+    Manager.run!(controllers)
+  end
+
+  # Set the controller lifecycle logger.
+  def self.logger=(logger)
+    Logging.logger = logger
+  end
+
+end

data/lib/arcenciel/manager.rb

@@ -0,0 +1,187 @@
+require 'thread'
+
+require 'arcenciel/manager/device'
+require 'arcenciel/manager/hub'
+
+module Arcenciel
+  class Manager
+    include Logging
+
+    attr_reader :controllers
+    attr_reader :devices
+
+    def self.run!(controllers)
+      new(controllers).run!
+    end
+
+    def initialize(controllers)
+      @controllers = controllers
+
+      @hub = Hub.new
+      @mutex = Mutex.new
+      @shutdown = false
+
+      @id_map = {}
+      @port_map = {}
+    end
+
+    def run!
+      trap_signals
+
+      add_listeners
+      list_devices
+      begin_notify
+
+      start_hub
+      run_loop
+    ensure
+      clear_devices
+    end
+
+    def shutdown!
+      @shutdown = true
+    end
+
+    def shutdown?
+      !!@shutdown
+    end
+
+    private
+
+    def trap_signals
+      Signal.trap('INT')  { shutdown! }
+      Signal.trap('TERM') { shutdown! }
+    end
+
+    def run_loop
+      until shutdown?
+        assign_devices
+        sleep 0.1
+      end
+    end
+
+    def devices
+      @id_map.values
+    end
+
+    def assign_devices
+      devices.each do |device|
+        next if device.attached?
+        begin
+          if controller = controllers.first(&:assigned?)
+            controller.assign!(device)
+          end
+        rescue Device::InvalidDeviceError
+          controller.unassign!
+        end
+      end
+    end
+
+    def clear_devices
+      devices.each do |device|
+        begin
+          device.ring_clear_all
+        rescue
+        end
+      end
+    end
+
+    def start_hub
+      @hub.run!
+    end
+
+    def add_listeners
+      listen('/serialosc/add',    :process_add)
+      listen('/serialosc/remove', :process_remove)
+      listen('/serialosc/device', :process_device)
+      listen('/arc/enc/delta',    :process_delta)
+      listen('/arc/enc/key',      :process_key)
+    end
+
+    def listen(path, name)
+      @hub.listen(path, &method(name))
+    end
+
+    def list_devices
+      @hub.send('/serialosc/list')
+    end
+
+    def begin_notify
+      @hub.send('/serialosc/notify')
+    end
+
+    def add_device(device)
+      return if @id_map.include?(device.id)
+
+      @id_map[device.id] = device
+      @port_map[device.port] = device
+      device.start!(@hub.server_port)
+    end
+
+    def remove_device(id)
+      if device = @id_map.delete(id)
+        @port_map.delete(device.port)
+        device.stop!
+      end
+    end
+
+    def dispatch_delta(port, index, delta)
+      if device = @port_map[port]
+        device.on_delta(index, delta)
+      end
+    end
+
+    def dispatch_key(port, index, state)
+      if device = @port_map[port]
+        device.on_key(index, state)
+      end
+    end
+
+    def process_add(msg)
+      list_devices
+      begin_notify
+    end
+
+    def process_remove(msg)
+      id = msg.to_a[0]
+
+      @mutex.synchronize do
+        remove_device(id)
+        begin_notify
+      end
+    end
+
+    def process_device(msg)
+      id, type, port = msg.to_a
+      device = Device.new(id, type, port)
+
+      if device.arc?
+        @mutex.synchronize do
+          add_device(device)
+        end
+      end
+    end
+
+    def process_delta(msg)
+      port = msg.ip_port
+      args = msg.to_a
+      index = args[0].to_i
+      delta = args[1].to_i
+
+      @mutex.synchronize do
+        dispatch_delta(port, index, delta)
+      end
+    end
+
+    def process_key(msg)
+      port = msg.ip_port
+      args = msg.to_a
+      index = args[0].to_i
+      state = args[1].to_i
+
+      @mutex.synchronize do
+        dispatch_key(port, index, state)
+      end
+    end
+  end
+end

data/lib/arcenciel/manager/device.rb

@@ -0,0 +1,120 @@
+module Arcenciel
+  class Device
+    class InvalidDeviceError < StandardError; end
+
+    include Logging
+
+    attr_reader :id
+    attr_reader :type
+    attr_reader :port
+    attr_reader :size
+
+    attr_reader :controller
+
+    def initialize(id, type, port)
+      @id = id
+      @type = type
+      @port = port
+      @is_arc, @size = parse_type(type)
+
+      @valid = false
+      @controller = nil
+
+      @client = OSC::Client.new('localhost', port)
+    end
+
+    def arc?
+      !!@is_arc
+    end
+
+    def attached?
+      !!@controller
+    end
+
+    def valid?
+      !!@valid
+    end
+
+    def validate!
+      raise InvalidDeviceError unless valid?
+    end
+
+    def start!(server_port)
+      set_destination(server_port)
+      @valid = true
+      ring_clear_all
+
+      log_info "Added device (#{id}; UDP #{port})."
+    end
+
+    def stop!
+      unassign_controller!
+      @valid = false
+
+      log_warn "Removed device (#{id}; UDP #{port})."
+    end
+
+    def attach!(controller)
+      validate!
+      @controller = controller
+    end
+
+    def ring_clear_all
+      validate!
+      (0...size).each do |i|
+        ring_clear(i)
+      end
+    end
+
+    def ring_clear(index)
+      validate!
+      ring_all(index, 0)
+    end
+
+    def ring_set(index, x, level)
+      validate!
+      @client.send(OSC::Message.new('/arc/ring/set', index, x, level))
+    end
+
+    def ring_all(index, level)
+      validate!
+      @client.send(OSC::Message.new('/arc/ring/all', index, level))
+    end
+
+    def ring_map(index, array)
+      validate!
+      @client.send(OSC::Message.new('/arc/ring/map', index, *array))
+    end
+
+    def ring_range(index, x1, x2, level)
+      validate!
+      @client.send(OSC::Message.new('/arc/ring/range', index, x1, x2, level))
+    end
+
+    def on_delta(index, delta)
+      @controller && @controller.on_delta(index, delta)
+    end
+
+    def on_key(index, state)
+      @controller && @controller.on_key(index, state)
+    end
+
+    private
+
+    def set_destination(port)
+      @client.send(OSC::Message.new('/sys/prefix', 'arc'))
+      @client.send(OSC::Message.new('/sys/host', 'localhost'))
+      @client.send(OSC::Message.new('/sys/port', port))
+    end
+
+    def unassign_controller!
+      @controller && @controller.unassign!
+      @controller = nil
+    end
+
+    def parse_type(type)
+      m = type.match(/monome arc (\d+)/)
+      m ? [true , m[1].to_i] : [false, nil]
+    end
+  end
+end

data/lib/arcenciel/manager/hub.rb

@@ -0,0 +1,33 @@
+require 'thread'
+
+module Arcenciel
+  class Hub
+    attr_reader :serial_port
+    attr_reader :server_port
+
+    attr_reader :client
+    attr_reader :server
+
+    def initialize
+      @serial_port = 12002
+      @server_port = 10210
+
+      @client = OSC::Client.new('localhost', serial_port)
+      @server = OSC::Server.new(server_port)
+    end
+
+    def run!
+      Thread.start do
+        server.run
+      end
+    end
+
+    def send(command)
+      client.send(OSC::Message.new(command, 'localhost', server_port))
+    end
+
+    def listen(path, &blk)
+      server.add_method(path, &blk)
+    end
+  end
+end

data/lib/arcenciel/surfaces.rb

@@ -0,0 +1,109 @@
+require 'arcenciel/surfaces/controller'
+require 'arcenciel/surfaces/knob'
+
+module Arcenciel
+  module Surfaces
+
+    class Controller
+
+      class DSL < DSLBase
+
+        # Set the name of this logical controller.
+        def name(name)
+          opts[:name] = name
+        end
+
+        # Add a new logical knob (encoder) to the controller.
+        def knob(&blk)
+          opts[:knobs] ||= []
+          opts[:knobs] << Knob.from_dsl(&blk)
+        end
+
+      end
+
+    end
+
+    class Knob
+
+      class DSL < DSLBase
+
+        # Set the name of this logical knob (encoder).
+        def name(name)
+          opts[:name] = name
+        end
+
+        # Set the initial value of the knob.
+        # Default - Minimum value
+        def initial(value)
+          opts[:initial] = value
+        end
+
+        # Set the range of values for the knob.
+        def range(range)
+          opts[:min] = range.begin
+          opts[:max] = range.end
+        end
+
+        # Set the minimum value of the knob.
+        # Default - 0
+        def min(value)
+          opts[:min] = value
+        end
+
+        # Set the maximum value of the knob.
+        # Default - 100
+        def max(value)
+          opts[:max] = value
+        end
+
+        # Set the type of value (:integer or :float).
+        # Default - :float
+        def type(type)
+          opts[:type] = type
+        end
+
+        # Set the precision of the knob (degrees per sweep).
+        # Default - 360 (one rotation per sweep)
+        def sweep(degrees)
+          opts[:sweep] = degrees
+        end
+
+        # Set the callback invoked when the value changes.
+        def on_value(&blk)
+          opts[:on_value] = blk
+        end
+
+        # Set the callback invoked when the knob is depressed.
+        def on_push(&blk)
+          opts[:on_push] = blk
+        end
+
+        # Set the callback invoked when the knob is released.
+        def on_release(&blk)
+          opts[:on_release] = blk
+        end
+
+      end
+
+      class Context
+
+        def initialize(knob)
+          @knob = knob
+        end
+
+        # Returns the name of this logical knob (encoder).
+        def name
+          @knob.name
+        end
+
+        # Returns the value of this knob.
+        def value
+          @knob.typed_value
+        end
+
+      end
+
+    end
+
+  end
+end

data/lib/arcenciel/surfaces/controller.rb

@@ -0,0 +1,68 @@
+module Arcenciel
+  module Surfaces
+    class Controller
+      include Logging
+
+      attr_reader :name
+      attr_reader :knobs
+
+      attr_reader :device
+
+      def self.from_dsl(&blk)
+        new(DSL.eval(&blk))
+      end
+
+      def initialize(options)
+        @name = options[:name] || default_name
+        @knobs = options[:knobs] || []
+
+        @device = nil
+      end
+
+      def assigned?
+        !!@device
+      end
+
+      def assign!(device)
+        log_info "Assigning controller '#{name}' to device..."
+
+        @device = device
+        knobs.each_with_index do |k, i|
+          k.assign!(device, i)
+          k.confirm!
+        end
+
+        device.attach!(self)
+        device.validate!
+
+        knobs.each do |k|
+          k.first_update!
+        end
+
+        log_info "Assigned controller '#{name}'."
+      end
+
+      def unassign!
+        @device = nil
+        knobs.each(&:unassign!)
+        log_warn "Controller '#{name}' is unassigned."
+      end
+
+      def on_delta(index, delta)
+        return unless index < knobs.size
+        knobs[index].on_delta(delta)
+      end
+
+      def on_key(index, state)
+        return unless index < knobs.size
+        knobs[index].on_key(state)
+      end
+
+      private
+
+      def default_name
+        'Arc'
+      end
+    end
+  end
+end

data/lib/arcenciel/surfaces/knob.rb

@@ -0,0 +1,211 @@
+require 'io/console'
+
+module Arcenciel
+  module Surfaces
+    class Knob
+      include Logging
+
+      DEFAULT_OPTIONS = {
+        min:      0,
+        max:      100,
+        sweep:    360,
+        type:     :float
+      }
+
+      attr_reader :name
+      attr_reader :min
+      attr_reader :max
+      attr_reader :type
+      attr_reader :sweep
+
+      attr_reader :on_value
+      attr_reader :on_push
+      attr_reader :on_release
+
+      attr_reader :value
+      attr_reader :counter
+      attr_reader :precision
+      attr_reader :depressed
+
+      attr_reader :context
+      attr_reader :device
+      attr_reader :index
+
+      def self.from_dsl(&blk)
+        new(DSL.eval(&blk))
+      end
+
+      def initialize(options)
+        options = DEFAULT_OPTIONS.merge(options)
+
+        @name       = options[:name]
+        @min        = options[:min]
+        @max        = options[:max]
+        @type       = options[:type]
+        @sweep      = options[:sweep]
+        @value      = options[:initial]
+
+        @on_value   = options[:on_value]
+        @on_push    = options[:on_push]
+        @on_release = options[:on_release]
+
+        @name       ||= default_name
+        @value      ||= @min
+
+        @precision  = precision_for_sweep(sweep)
+        @counter    = counter_for_value(@value)
+        @depressed  = false
+
+        @context = Context.new(self)
+        @device = nil
+        @index = nil
+
+        clamp_counter
+        update_value
+        trigger_value
+      end
+
+      def typed_value
+        integer_type? ?
+          value.to_i :
+          value.to_f
+      end
+
+      def assigned?
+        !!@device
+      end
+
+      def assign!(device, index)
+        @device = device
+        @index = index
+      end
+
+      def unassign!
+        @device = nil
+        @index = nil
+      end
+
+      def confirm!
+        start_chaser
+
+        log_info "Illuminated knob '#{name}' (#{index}). Press any key."
+        wait_for_key
+
+        stop_chaser
+        ring_clear
+      end
+
+      def first_update!
+        update_ring
+      end
+
+      def on_delta(delta)
+        @counter += delta
+        clamp_counter
+
+        update_value
+        update_ring
+        trigger_value
+      end
+
+      def on_key(state)
+        case state
+        when 0
+          @depressed = false
+          trigger_release
+        when 1
+          @depressed = true
+          trigger_push
+        end
+      end
+
+      private
+
+      def default_name
+        'Unnamed'
+      end
+
+      def integer_type?
+        type == :integer
+      end
+
+      def fraction_for_counter(x)
+        x / precision.to_f
+      end
+
+      def value_for_counter(x)
+        f = fraction_for_counter(x)
+        (max - min) * f + min
+      end
+
+      def precision_for_sweep(x)
+        (256 / 360.0 * x).to_i
+      end
+
+      def counter_for_value(x)
+        ((x - min) / (max - min).to_f * precision.to_f).to_i
+      end
+
+      def clamp_counter
+        @counter = 0 if @counter < 0
+        @counter = precision if @counter > precision
+      end
+
+      def update_value
+        @value = value_for_counter(counter)
+      end
+
+      def update_ring
+        f = fraction_for_counter(counter)
+        ring_fraction(f)
+      end
+
+      def trigger_value
+        on_value &&
+          context.instance_exec(typed_value, &on_value)
+      end
+
+      def trigger_push
+        on_push &&
+          context.instance_exec(&on_push)
+      end
+
+      def trigger_release
+        on_release &&
+          context.instance_exec(&on_release)
+      end
+
+      def ring_clear
+        device.ring_clear(index)
+      end
+
+      def ring_fraction(x)
+        units = 64 * x
+        count = units.to_i
+        subpixel = units - units.to_i
+        final_level = (15 * subpixel).to_i
+
+        levels = []
+        (0...count).each { levels << 15 }
+        levels << final_level if levels.size < 64
+        (levels.size...64).each { levels << 0 }
+
+        device.ring_map(index, levels)
+      end
+
+      def start_chaser
+        @chaser = Chaser.new(device, index)
+        @chaser.start!
+      end
+
+      def stop_chaser
+        @chaser.stop!
+        @chaser = nil
+      end
+
+      def wait_for_key
+        $stdin.noecho(&:gets)
+      end
+    end
+  end
+end

data/lib/arcenciel/utility.rb

@@ -0,0 +1,3 @@
+require 'arcenciel/utility/logging'
+require 'arcenciel/utility/dsl_base'
+require 'arcenciel/utility/chaser'

data/lib/arcenciel/utility/chaser.rb

@@ -0,0 +1,93 @@
+require 'thread'
+
+module Arcenciel
+  class Chaser
+    MAX_LEVEL = 13
+
+    SEQUENCE = (1..5).to_a.reverse.map do |i|
+      (MAX_LEVEL * 1.0 / (i * i)).to_i
+    end
+
+    attr_reader :device
+    attr_reader :index
+
+    def self.position
+      @position ||= 0
+    end
+
+    def self.advance
+      @position ||= 0
+      @position += 1
+      @position %= 64
+    end
+
+    def initialize(device, index)
+      @device = device
+      @index = index
+
+      @running = false
+      @thread = nil
+    end
+
+    def running?
+      !!@running
+    end
+
+    def start!
+      return if running?
+      @running = true
+      ring_clear
+      run_async
+    end
+
+    def stop!
+      return if !running?
+      @running = false
+      join_async
+      ring_clear
+    end
+
+    private
+
+    def run_async
+      @thread = Thread.start do
+        run_loop
+      end
+    end
+
+    def join_async
+      @thread.join
+      @thread = nil
+    end
+
+    def run_loop
+      while running?
+        advance
+        update
+        sleep 0.02
+      end
+    end
+
+    def advance
+      self.class.advance
+    end
+
+    def update
+      pos = self.class.position
+      (0...4).each do |e|
+        SEQUENCE.each_with_index do |level, i|
+          x = (pos + 16 * e + i) % 64
+          ring_set(x, level)
+        end
+      end
+    end
+
+    def ring_clear
+      device.ring_clear(index)
+    end
+
+    def ring_set(x, level)
+      device.ring_set(index, x, level)
+    end
+  end
+end

data/lib/arcenciel/utility/dsl_base.rb

@@ -0,0 +1,15 @@
+module Arcenciel
+  class DSLBase
+    attr_reader :opts
+
+    def self.eval(&blk)
+      dsl = new
+      dsl.instance_eval(&blk)
+      dsl.opts
+    end
+
+    def initialize
+      @opts = {}
+    end
+  end
+end

data/lib/arcenciel/utility/logging.rb

@@ -0,0 +1,58 @@
+require 'logger'
+require 'colored'
+
+module Arcenciel
+  module Logging
+
+    class << self
+      attr_writer :logger
+
+      def logger
+        @logger ||= DEFAULT_LOGGER
+      end
+    end
+
+    def logger
+      Logging.logger
+    end
+
+    def log_info(msg)
+      logger.info(msg)
+    end
+
+    def log_warn(msg)
+      logger.warn(msg)
+    end
+
+    def log_error(msg)
+      logger.error(msg)
+    end
+
+    class DefaultFormater
+      SEVERITY_CONFIG = {
+        'INFO'  => ['ARC', :blue],
+        'WARN'  => ['WARN', :red],
+        'ERROR' => ['ERROR', :red],
+        'FATAL' => ['FATAL', :red],
+        'DEBUG' => ['DEBUG', :blue]
+      }
+
+      def call(severity, time, progname, msg)
+        tag, color = SEVERITY_CONFIG[severity]
+        colored_tag = Colored.colorize(tag, foreground: color)
+
+        string = ''
+        string += "[#{progname}] " if progname
+        string += "[#{colored_tag}] "
+        string += msg
+        string += "\n"
+
+        string
+      end
+    end
+
+    DEFAULT_LOGGER = Logger.new($stdout).tap do |l|
+      l.formatter = DefaultFormater.new
+    end
+  end
+end

data/lib/arcenciel/version.rb

@@ -0,0 +1,3 @@
+module Arcenciel
+  VERSION = '0.0.1'
+end

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification
+name: arcenciel
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Nelson Gauthier
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-03-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: osc-ruby
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.1
+- !ruby/object:Gem::Dependency
+  name: colored
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+description: Physical knobs for virtual machines
+email:
+- nelson.gauthier@gmail.com
+executables:
+- arcenciel-demo
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- DEDICATION
+- Gemfile
+- README.md
+- arcenciel.gemspec
+- bin/arcenciel-demo
+- docs/images/hero.jpg
+- lib/arcenciel.rb
+- lib/arcenciel/manager.rb
+- lib/arcenciel/manager/device.rb
+- lib/arcenciel/manager/hub.rb
+- lib/arcenciel/surfaces.rb
+- lib/arcenciel/surfaces/controller.rb
+- lib/arcenciel/surfaces/knob.rb
+- lib/arcenciel/utility.rb
+- lib/arcenciel/utility/chaser.rb
+- lib/arcenciel/utility/dsl_base.rb
+- lib/arcenciel/utility/logging.rb
+- lib/arcenciel/version.rb
+homepage: https://github.com/nelgau/arcenciel
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Declarative Monome Arc microframework
+test_files: []
+has_rdoc: