midi-message 0.4.4 → 0.4.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e474d330bc417e19471d1dbd4c931748445db639
-  data.tar.gz: 8516f6b1ee25c485bfbb7265d2e4e5620f7800ed
+  metadata.gz: 33e3e855ef83585302fda5a2b7f332254b089c9f
+  data.tar.gz: d130122274fa395bd8939da501ac735c75f9b1ee
 SHA512:
-  metadata.gz: 28b952c964be9603b65def9802d72fdf7a6c9d5b8641b537601b4b91be8c5889a7aec75cc3d396cecb25d98f62dfcbf1544d657f4a24efa61d012778bb96d46e
-  data.tar.gz: 61d515a21f72a2d7fd340d82067fe5401bb1ad142e940b94c6fa9e1fc9114b8bc43e0331558243812cf8334135f2676fa06a962217cb44a1927af911d7a55cde
+  metadata.gz: 78bd93128dae08a2f2367028f9e6fd38442919777d17b7445b8a8a16e8310f39f291a904a5ebd394bac90245abdb681c28d580e20badf7ef44274219d5959a55
+  data.tar.gz: b96b8747c8582d448a991f37f9fe34f7b9f66af4644892bd449267e083eefb9ceb8a1b302d7d74ff4af1870bc64b868614736dd8691e887399fd918bfef8b21a

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright 2011-2014 Ari Russo
+Copyright 2011-2015 Ari Russo
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.

data/README.md

@@ -9,7 +9,7 @@ Ruby MIDI message objects
 * Flexible API to accommodate various sources and destinations of MIDI data
 * Simple approach to System Exclusive data and devices
 * [YAML dictionary of MIDI constants](https://github.com/arirusso/midi-message/blob/master/lib/midi.yml)
-	
+
 ## Install
 
 `gem install midi-message`
@@ -23,16 +23,16 @@ Or if you're using Bundler, add this to your Gemfile
 ```ruby
 require "midi-message"
 ```
-  
+
 #### Basic Messages
 
 There are a few ways to create a new MIDI message.  Here are some examples
- 
-```ruby   
+
+```ruby
 MIDIMessage::NoteOn.new(0, 64, 64)
-  
+
 MIDIMessage::NoteOn["E4"].new(0, 100)
-  
+
 MIDIMessage.with(:channel => 0, :velocity => 100) { note_on("E4") }
 ```
 
@@ -52,27 +52,27 @@ Those expressions all evaluate to the same object
 #### SysEx Messages
 
 As with any kind of message, you can begin with raw data
-  
+
 ```ruby
 MIDIMessage::SystemExclusive.new(0xF0, 0x41, 0x10, 0x42, 0x12, 0x40, 0x00, 0x7F, 0x00, 0x41, 0xF7)
 ```
-  
+
 Or in a more object oriented way
 
 ```ruby  
 synth = SystemExclusive::Node.new(0x41, :model_id => 0x42, :device_id => 0x10)
-    
+
 SystemExclusive::Command.new([0x40, 0x7F, 0x00], 0x00, :node => synth)
 ```
 
 A Node represents a device that you're sending a message to (eg. your Yamaha DX7 is a Node).  Sysex messages can either be a Command or Request
-  
+
 You can use the Node to instantiate a message
 
 ```ruby  
 synth.command([0x40, 0x7F, 0x00], 0x00)
 ```
-  
+
 One way or another, you will wind up with a pair of objects like this
 
 ```ruby
@@ -86,18 +86,18 @@ One way or another, you will wind up with a pair of objects like this
      @manufacturer_id=65,
      @model_id=66>>
 ```
-     
+
 #### Parsing
 
 The parse method will take any valid message data and return the object representation
 
 ```ruby
 MIDIMessage.parse(0x90, 0x40, 0x40)
-  
+
   #<MIDIMessage::NoteOn:0x9c1c240 ..>
-  
+
 MIDIMessage.parse(0xF0, 0x41, 0x10, 0x42, 0x12, 0x40, 0x00, 0x7F, 0x00, 0x41, 0xF7)
-  
+
   #<MIDIMessage::SystemExclusive::Command:0x9c1e57c ..>
 ```
 
@@ -115,4 +115,4 @@ Check out [nibbler](http://github.com/arirusso/nibbler) for more advanced parsin
 
 Apache 2.0, See the file LICENSE
 
-Copyright (c) 2011-2014 Ari Russo
+Copyright (c) 2011-2015 Ari Russo

data/lib/midi-message.rb

@@ -1,7 +1,7 @@
 #
 # Ruby MIDI message objects
 #
-# (c)2011-2014 Ari Russo
+# (c)2011-2015 Ari Russo
 # Apache 2.0 License
 #
 
@@ -10,7 +10,8 @@ require "forwardable"
 require "yaml"
 
 # Modules
-require "midi-message/short_message"
+require "midi-message/constant"
+require "midi-message/message"
 require "midi-message/channel_message"
 require "midi-message/note_message"
 require "midi-message/system_exclusive"
@@ -18,13 +19,12 @@ require "midi-message/system_message"
 require "midi-message/type_conversion"
 
 # Classes
-require "midi-message/constant"
 require "midi-message/context"
-require "midi-message/message"
+require "midi-message/messages"
 require "midi-message/parser"
 
 module MIDIMessage
 
-  VERSION = "0.4.4"
+  VERSION = "0.4.5"
 
 end

data/lib/midi-message/channel_message.rb

@@ -4,6 +4,7 @@ module MIDIMessage
   module ChannelMessage
 
     include MIDIMessage # this enables ..kind_of?(MIDIMessage)
+
     attr_reader :data, :name
 
     # Shortcut to RawChannelMessage.new
@@ -19,44 +20,71 @@ module MIDIMessage
     def initialize(*data)
       data = data.dup
       options = data.last.kind_of?(Hash) ? data.pop : {}
-      processed_data = options[:const].nil? ? data : data_with_const(data, options[:const])
-      initialize_channel_message(self.class.type_for_status, *processed_data)
+      add_constant_value(options[:const], data) unless options[:const].nil?
+      initialize_channel_message(self.class.type_for_status, *data)
     end
 
+    # Decorates the object with the particular properties for its type
+    # @return [Boolean]
     def initialize_properties
-      props = [
-        { :name => :status, :index => 1 },
-        { :name => :data, :index => 0 },
-        { :name => :data, :index => 1 }
-      ]
       properties = self.class.properties
-      unless properties.nil?
-        properties.each_with_index do |prop,i|
-          self.class.send(:attr_reader, prop)
-          self.class.send(:define_method, "#{prop}=") do |val|
-            send(:instance_variable_set, "@#{prop.to_s}", val)
-            send(props[i][:name])[props[i][:index]] = val
-            update
-            return self
-          end
-          instance_variable_set("@#{prop}", send(props[i][:name])[props[i][:index]])
-        end
-      end
+      add_properties(properties) unless properties.nil?
     end
 
-    protected
+    private
 
     def self.included(base)
-      base.send(:include, ShortMessage)
+      base.send(:include, ::MIDIMessage::Message)
       base.send(:extend, ClassMethods)
     end
 
-    private
+    def add_constant_value(constant, data)
+      index = Constant::Loader.get_index(self)
+      data.insert(index, constant.value)
+    end
 
-    def data_with_const(data, const)
-      key = self.class.constant_property
-      ind = self.class.properties.index(key) || 0
-      data.insert(ind, const.value)
+    # @param [Array<Symbol>] properties
+    # @return [Boolean]
+    def add_properties(properties)
+      has_properties = false
+      schema = [
+        { :name => :status, :index => 1 }, # second status nibble
+        { :name => :data, :index => 0 }, # first data byte
+        { :name => :data, :index => 1 } # second data byte
+      ]
+      properties.each_with_index do |property, i|
+        property_schema = schema[i]
+        container = send(property_schema[:name])
+        index = property_schema[:index]
+        define_getter(property, container, index)
+        define_setter(property, container, index)
+        has_properties = true
+      end
+      has_properties
+    end
+
+    # @param [Symbol, String] property
+    # @param [Hash] container
+    # @param [Fixnum] index
+    # @return [Boolean]
+    def define_getter(property, container, index)
+      self.class.send(:attr_reader, property)
+      instance_variable_set("@#{property.to_s}", container[index])
+      true
+    end
+
+    # @param [Symbol, String] property
+    # @param [Hash] container
+    # @param [Fixnum] index
+    # @return [Boolean]
+    def define_setter(property, container, index)
+      self.class.send(:define_method, "#{property.to_s}=") do |value|
+        send(:instance_variable_set, "@#{property.to_s}", value)
+        container[index] = value
+        update
+        return self
+      end
+      true
     end
 
     def initialize_channel_message(status_nibble_1, status_nibble_2, data_byte_1, data_byte_2 = 0)
@@ -64,18 +92,12 @@ module MIDIMessage
       @data = [data_byte_1]
       @data[1] = data_byte_2 if self.class.second_data_byte?
       initialize_properties
-      initialize_short_message(status_nibble_1, status_nibble_2)
+      initialize_message(status_nibble_1, status_nibble_2)
     end
 
     # For defining Channel Message class types
     module ClassMethods
 
-      # Get the status nibble for this particular message type
-      # @return [Fixnum] The status nibble
-      def type_for_status
-        Status[display_name]
-      end
-
       def properties
         const_get("DATA") if const_defined?("DATA")
       end

data/lib/midi-message/constant.rb

@@ -1,58 +1,214 @@
 module MIDIMessage
 
-  # MIDI Constants
-  class ConstantGroup
-    
-    attr_reader :key, :value
-    
-    def initialize(key, constants)
-      @key = key
-      @constants = constants.map { |k, v| Constant.new(k, v) }
-    end
-    
-    def find(name)
-      @constants.find { |const| const.key.to_s.downcase == name.to_s.downcase }       
-    end
-    alias_method :[], :find
-    
-    def find_by_value(value)
-      @constants.find { |const| const.value.to_s.downcase == value.to_s.downcase }
+  # Refer to a MIDI message by its usage
+  # eg *C4* for MIDI note *60* or *Bank Select* for MIDI control change *0*
+  module Constant
+
+    def self.find(group_name, const_name)
+      group = Group[group_name]
+      group.find(const_name)
     end
-    
-    def self.all
-      ensure_initialized
-      @groups
+
+    # MIDI Constant container
+    class Group
+
+      attr_reader :key, :value
+
+      def initialize(key, constants)
+        @key = key
+        @constants = constants.map { |k, v| Constant::Map.new(k, v) }
+      end
+
+      # Find a constant by its name
+      # @param [String, Symbol] name
+      # @return [Constant::Map]
+      def find(name)
+        @constants.find { |const| const.key.to_s.downcase == name.to_s.downcase }
+      end
+      alias_method :[], :find
+
+      # Find a constant by its value
+      # @param [Object] value
+      # @return [Constant::Map]
+      def find_by_value(value)
+        @constants.find { |const| const.value.to_s.downcase == value.to_s.downcase }
+      end
+
+      # All constant groups
+      # @return [Array<ConstantGroup>]
+      def self.all
+        ensure_initialized
+        @groups
+      end
+
+      # Find a constant group by its key
+      # @param [String, Symbol] key
+      # @return [ConstantGroup]
+      def self.[](key)
+        ensure_initialized
+        @groups.find { |g| g.key.to_s.downcase == key.to_s.downcase }
+      end
+
+      private
+
+      # Lazy initialize
+      # @return [Boolean]
+      def self.ensure_initialized
+        populate_dictionary | populate_groups
+      end
+
+      # Populate the dictionary of constants
+      # @return [Boolean]
+      def self.populate_dictionary
+        if @dict.nil?
+          @dict = YAML.load_file(File.expand_path('../../midi.yml', __FILE__))
+          true
+        end
+      end
+
+      # Populate the constant groups using the dictionary
+      # @return [Boolean]
+      def self.populate_groups
+        if @groups.nil? && !@dict.nil?
+          @groups = @dict.map { |k, v| new(k, v) }
+          true
+        end
+      end
+
     end
 
-    def self.[](key)      
-      ensure_initialized
-      @groups.find { |g| g.key.to_s.downcase == key.to_s.downcase }
+    # The mapping of a constant key to its value eg "Note On" => 0x9
+    class Map
+
+      attr_reader :key, :value
+
+      # @param [String] key
+      # @param [Object] value
+      def initialize(key, value)
+        @key = key
+        @value = value
+      end
+
     end
-    
-    private
-    
-    # lazy initialize
-    def self.ensure_initialized
-      @dict ||= YAML.load_file(File.expand_path('../../midi.yml', __FILE__))
-      @groups ||= @dict.map { |k, v| new(k, v) }
+
+    class MessageBuilder
+
+      # @param [MIDIMessage] klass The message class to build
+      # @param [String] const The constant to build the message with
+      def initialize(klass, const)
+        @klass = klass
+        @const = const
+      end
+
+      # @param [*Object] args
+      # @return [Message]
+      def new(*args)
+        args = args.dup
+        args.last.kind_of?(Hash) ? args.last[:const] = @const : args.push(:const => @const)
+        @klass.new(*args)
+      end
+
     end
 
-  end
-  
-  class Constant
-    
-    attr_reader :key, :value
-    
-    def initialize(key, value)
-      @key = key
-      @value = value      
+    # Shortcuts for dealing with message status
+    module Status
+
+      # The value of the Status constant with the name status_name
+      # @param [String] status_name The key to use to look up a constant value
+      # @return [String] The constant value that was looked up
+      def self.[](status_name)
+        const = Constant.find("Status", status_name)
+        const.value unless const.nil?
+      end
+
     end
-    
-    def self.find(group_name, const_name)
-      group = ConstantGroup[group_name]
-      group.find(const_name)      
+
+    # Loading constants from the spec file into messages
+    module Loader
+
+      extend self
+
+      # Get the index of the constant from the given message's type
+      # @param [Message] message
+      # @return [Fixnum]
+      def get_index(message)
+        key = message.class.constant_property
+        message.class.properties.index(key) || 0
+      end
+
+      # Used to populate message metadata with information gathered from midi.yml
+      # @param [Message] message
+      # @return [Hash, nil]
+      def get_info(message)
+        const_group_name = message.class.display_name
+        group_name_alias = message.class.constant_name
+        property = message.class.constant_property
+        value = message.send(property) unless property.nil?
+        value ||= message.status[1] # default property to use for constants
+        group = Constant::Group[group_name_alias] || Constant::Group[const_group_name]
+        unless group.nil?
+          unless (const = group.find_by_value(value)).nil?
+            {
+              :const => const,
+              :name => const.key,
+              :verbose_name => "#{message.class.display_name}: #{@name}"
+            }
+          end
+        end
+      end
+
+      # DSL type class methods for loading constants into messages
+      module DSL
+
+        # Find a constant value in this class's group for the passed in key
+        # @param [String] name The constant key
+        # @return [String] The constant value
+        def get_constant(name)
+          key = constant_name || display_name
+          unless key.nil?
+            group = Group[key]
+            group.find(name)
+          end
+        end
+
+        # @return [String]
+        def display_name
+          const_get("DISPLAY_NAME") if const_defined?("DISPLAY_NAME")
+        end
+
+        # @return [Hash]
+        def constant_map
+          const_get("CONSTANT") if const_defined?("CONSTANT")
+        end
+
+        # @return [String]
+        def constant_name
+          constant_map.keys.first unless constant_map.nil?
+        end
+
+        # @return [Symbol]
+        def constant_property
+          constant_map[constant_name] unless constant_map.nil?
+        end
+
+        # Get the status nibble for this particular message type
+        # @return [Fixnum] The status nibble
+        def type_for_status
+          Constant::Status[display_name]
+        end
+
+        # This returns a MessageBuilder for the class, preloaded with the selected const
+        # @param [String, Symbol] const_name The constant key to use to build the message
+        # @return [MIDIMessage::MessageBuilder] A MessageBuilder object for the passed in constant
+        def [](const_name)
+          const = get_constant(const_name.to_s)
+          MessageBuilder.new(self, const) unless const.nil?
+        end
+
+      end
+
     end
-    
+
   end
 
 end