pocket_miku 0.0.2 → 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 224a1798a6222b6fdfcdd075c49fc64f7b4371cd
+  data.tar.gz: bfc29cc865f43426d18aa17c434c9b5e9386e823
+SHA512:
+  metadata.gz: 0480a64f8a7b28ae31ee6a6499ce0ba3de4a980398c90659f043a8fa0798b97808c98fe944d8066e9f79d7dcd72c17863368ddafb33944095da0d6f3851e12df
+  data.tar.gz: 17bcbffc83eaac450af442fa9beb127d9aa0ca03ca26b0407842f19d516450ec81b4ad75981c039d46cefef094521c44bb84fd38b31cd2819dc90dd3da3c625f

data/README.md

@@ -26,21 +26,97 @@ Or install it yourself as:
 
 ```ruby
 require 'pocket_miku'
-PocketMiku.new('/dev/midi2') do
-  ふぁ(75,127)
-  sleep 0.12
-  ぼ(82,127)
-  sleep 0.12
-  stop
+PocketMiku.sing '/dev/midi2' do
+  tempo 240
+  ふぁ 75; ぼ 82
 end
 ```
 
-「ふぁ」「ぼ」等はメソッドで、この音を発音します。引数は「あ(音程, 強さ)」です。全ての発音は、ポケット・ミク付属の『ユーザーズマニュアル』の裏に掲載されている『ポケット・ミク　デフォルト文字テーブル』に書いてある文字が全て使用できます。
+*ふぁ (音階)* などと書くと、その高さで「ふぁ」と発音します。ポケット・ミク付属の『ユーザーズマニュアル』の裏に掲載されている『ポケット・ミク　デフォルト文字テーブル』に書いてある文字が全て使用できます。
 なお、「ん」は「N\」のエイリアスです。ほかの「ん」を使用する時は、同備考欄の文字（ダブルクォートは不要）を指定してください。
+### 休符
+「っ」です。引数は数値一つで、「長さ」（後述）です。
+
+### ノートの追加パラメータ
+音毎に追加パラメータを設定できます。追加パラメータを利用する場合、例えば *あ 60* を *あ key:60* と書き換え、
+その後に *, 追加パラメータ名: 値* と書きます。
+
+#### 長さ
+音の長さを指定するには、 *length: [長さ]* と指定します。
+長さは、32分音符が1で、長さが倍になると倍になります。又、以下の定数も用意されています。
+
+|定数|意味|
+|:-:|:-|
+|PocketMiku::Note1|全音符|
+|PocketMiku::Note2|2分音符|
+|PocketMiku::Note4|4分音符|
+|PocketMiku::Note8|8分音符|
+|PocketMiku::Note16|16分音符|
+|PocketMiku::Note32|32分音符|
+
+以下のサンプルでは見やすさのために変数を使ってます。
+
+```ruby
+PocketMiku.sing '/dev/midi2' do
+  f8 = PocketMiku::Note8
+  f16 = PocketMiku::Note16
+
+  ま key: 79, length: f8; っ f16; る key: 79, length: f16
+end
+```
+
+#### ベロシティ
+音の強さは、 *velocity: [0..127]* のように指定します。0から127まで、数字が大きいほうが音が大きくなります。
+さっきのサンプルにベロシティを追加してみました。
+
+```ruby
+PocketMiku.sing '/dev/midi2' do
+  f8 = PocketMiku::Note8
+  f16 = PocketMiku::Note16
+
+  ま key: 79, length: f8; っ f16; る key: 79, length: f16, velocity: 80
+end
+```
+
+### 楽譜パラメータ
+
+#### デフォルト値
+*default.velocity = 100* などと書くと、これ以降の音符のデフォルト値が設定できます。
+
+|定義|意味|
+|:-|:-|
+|default.key = |音の高さ|
+|default.length|長さ|
+|default.velocity|ベロシティ|
+
+#### テンポ
+*tempo 100* などと書くと、これ以降のテンポを変更できます。曲のテンポを設定する時は最初に書いてください。
+テンポの数字は、1分間に4分音符がいくつ入るか、です。
+
+先ほどのサンプルにテンポをつけてみました
+
+```ruby
+PocketMiku.sing '/dev/midi2' do
+  tempo 80
+  f8 = PocketMiku::Note8
+  f16 = PocketMiku::Note16
+
+  ま key: 79, length: f8; っ f16; る key: 79, length: f16, velocity: 80
+  た key: 79, length: f8; っ f16; け key: 79, length: f16, velocity: 80
+  え key: 79, length: f8; っ f16; べ key: 77, length: f16, velocity: 80
+  す key: 79, length: f8; っ f16; に key: 77, length: f16, velocity: 80
+  お key: 79, length: f8; っ f16; し key: 79, length: f16, velocity: 80
+  お key: 74, length: f8; っ f16; い key: 74, length: f16, velocity: 80
+  け key: 74, length: f8 * 1.5
+  っ f16 + PocketMiku::Note4;
+end
+```
 
 ## そのうち
 
-- 音の同期をsleepとかじゃなくてもっといい感じにしたい
+- 音の同期処理本当にどうしよう
+- ピッチベンド実装したい
+- 発音中に音のパラメータを操作したい(だんだん高く、だんだん弱く等)
 
 ## Contributing
 

data/lib/pocket_miku.rb

@@ -1,141 +1,23 @@
 # -*- coding: utf-8 -*-
 require "pocket_miku/version"
-require "pocket_miku/chartable"
+require "pocket_miku/literal"
 require "pocket_miku/exception"
+require "pocket_miku/packet_factory"
+require "pocket_miku/base"
+require "pocket_miku/chartable"
+require "pocket_miku/note"
+require "pocket_miku/score"
+require "pocket_miku/device"
 require 'stringio'
+require 'rational'
 
-class PocketMiku
-
-  attr_reader :sound, :key, :velocity
-
-  # ==== Args
-  # [device]
-  #   - String :: MIDIデバイスファイル名
-  #   - IO,StringIO :: 出力するIOオブジェクト
-  # ==== Exception
-  # PocketMiku::ArgumentError
-  #   ファイル device が見つからず、ストリームとしても利用できない場合
-  def initialize(device)
-    @key = 60
-    @velocity = 100
-    @io = case device
-          when IO,StringIO
-            device
-          when String
-            open(device, 'w')
-          else
-            raise PocketMiku::ArgumentError, "device should give IO or String. but give `#{device.class}'"
-          end
-    if block_given?
-      begin
-        self.instance_eval(&Proc.new)
-      ensure
-        @io.close
-      end
-    end
-  end
+module PocketMiku
+  extend self
 
-  # ポケットミクに直接MIDIパケットを送る
+  # ポケットミクに歌わせるためのショートカットメソッド
   # ==== Args
-  # [packet]
-  #   - Array :: バイト値配列をpack("C*")して送る
-  #   - Integer :: 対応するキャラクタを送る
-  # ==== Exception
-  # PocketMiku::InvalidByteError
-  #   packetの中に、1byte(0..255)に収まらない数値がある場合
-  # ==== Return
-  # self
-  def send(packet)
-    @io << pack(packet)
-    @io.flush
+  # [device] String|IO デバイスファイルの場所
+  def sing(device)
+    PocketMiku::Device.new(device, &Proc.new)
   end
-
-  # ポケットミクに発音させる情報をセットする
-  # ==== Args
-  # [key] Integer 音程
-  # [velocity] Integer 音の強さ
-  # [sound] Integer|Symbol 文字テーブルの文字コード(Integer)か文字(Symbol)
-  # ==== Return
-  # self
-  def set(options)
-    @key = byte_check(options[:key], "invalid key `%d'".freeze) if options[:key]
-    @velocity = byte_check(options[:velocity], "invalid velocity `%d'".freeze) if options[:velocity]
-    self.sound = options[:sound] if options[:sound]
-    self
-  end
-
-  # ポケットミクに発音させる文字テーブル情報をセットする
-  # ==== Args
-  # [new] Integer|Symbol セットする文字テーブルの文字コード(Integer)か文字(Symbol)
-  # ==== Exceptions
-  # PocketMiku::CharMappingError
-  #   newが文字テーブルに存在しない場合
-  # PocketMiku::InvalidByteError
-  #   newが1byte(0..255)に収まらない数値である場合
-  # ==== Return
-  # 新しい sound の値。Symbolをセットしても必ず数値になる。
-  def sound=(new)
-    case new
-    when Fixnum
-      @sound = byte_check(new, "invalid sound `%d'".freeze)
-    when -> _ {CharTable.include? _}
-      @sound = CharTable[new]
-    else
-      raise CharMappingError, "unknown sound `#{new}'"
-    end
-  end
-
-  # 設定されている情報でサウンドを再生開始する
-  # ==== Exception
-  # PocketMiku::InvalidByteError
-  #   packetの中に、1byte(0..255)に収まらない数値がある場合
-  def play
-    send([0xF0, 0x43, 0x79, 0x09, 0x11, 0x0A, 0, @sound, 0xF7])
-    send([0x90, @key, @velocity])
-  end
-  alias +@ play
-
-  # 設定されているサウンドを再生停止する
-  # ==== Exception
-  # PocketMiku::InvalidByteError
-  #   packetの中に、1byte(0..255)に収まらない数値がある場合
-  def stop
-    send([0x80, @key, 0])
-  end
-  alias -@ stop
-
-  alias sing instance_eval
-
-  def method_missing(method, *args)
-    case method
-    when -> _ {CharTable.include? _}
-      set(key: args[0], velocity: args[1], sound: CharTable[method]).play
-    else
-      super
-    end
-  end
-
-  def close
-    stop
-    @io.close
-  end
-
-  def closed?
-    @io.closed?
-  end
-
-  private
-
-  def pack(bytes)
-    bytes = [bytes] if bytes.is_a? Integer
-    bytes.each(&method(:byte_check))
-    bytes.pack "C*".freeze
-  end
-
-  def byte_check(byte, error_message="byte should 0...255 but give `%d'".freeze)
-    raise InvalidByteError, "`#{byte}' is not integer." unless byte.is_a? Integer
-    raise InvalidByteError, error_message % byte unless (0..0xFF).include?(byte)
-    byte
-  end
-
 end

data/lib/pocket_miku/base.rb

@@ -0,0 +1,2 @@
+class PocketMiku::Base
+end

data/lib/pocket_miku/chartable.rb

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-class PocketMiku
+module PocketMiku
   CharTable = {
     あ: 0,
     い: 1,

data/lib/pocket_miku/device.rb

@@ -0,0 +1,99 @@
+# -*- coding: utf-8 -*-
+
+module PocketMiku
+  class Device < PocketMiku::Base
+    
+    # ==== Args
+    # [device]
+    #   - String :: MIDIデバイスファイル名
+    #   - IO,StringIO :: 出力するIOオブジェクト
+    # ==== Exception
+    # PocketMiku::ArgumentError
+    #   ファイル device が見つからず、ストリームとしても利用できない場合
+    def initialize(device)
+      @io = case device
+            when IO,StringIO
+              device
+            when String
+              open(device, 'w')
+            else
+              raise PocketMiku::ArgumentError, "device should give IO or String. but give `#{device.class}'"
+            end
+      if block_given?
+        begin
+          self.sing(&Proc.new)
+        ensure
+          @io.close
+        end
+      end
+    end
+
+    # ポケットミクに直接MIDIパケットを送る
+    # ==== Args
+    # [packet]
+    #   - Array :: バイト値配列をpack("C*")して送る
+    #   - Integer :: 対応するキャラクタを送る
+    # ==== Exception
+    # PocketMiku::InvalidByteError
+    #   packetの中に、1byte(0..255)に収まらない数値がある場合
+    # ==== Return
+    # self
+    def send(packet)
+      @io << PocketMiku::PacketFactory.pack(packet)
+      @io.flush
+    end
+
+    # score をこのデバイスで再生する
+    # ==== Array
+    # [score] PocketMiku::Score 楽譜情報
+    # ==== Exception
+    # PocketMiku::InvalidByteError
+    #   packetの中に、1byte(0..255)に収まらない数値がある場合
+    def play(score)
+      score.map{|note|[note, note.to_s.freeze]}.each do |note, packet|
+        case note
+        when RestNote
+          sleep Rational(60.to_f, score.tempo) * Rational(note.length.to_f, Note4)
+        when Note
+          @io << packet
+          @io.flush
+          sleep Rational(60.to_f, score.tempo) * Rational(note.length.to_f, Note4)
+          stop 0, note.key
+          @io.flush
+        end
+      end
+    end
+    alias +@ play
+
+    # 特定のトラックとキーのサウンドを再生停止する
+    # ==== Args
+    # [track] トラック番号
+    # [key] 音程
+    # ==== Exception
+    # PocketMiku::InvalidByteError
+    #   packetの中に、1byte(0..255)に収まらない数値がある場合
+    def stop(track, key)
+      send([0x80 + track, key, 0])
+    end
+    alias -@ stop
+
+    # ブロックをこのインスタンスのコンテキストで実行してから、ポケットミクで再生する
+    # ==== Array
+    # [score] PocketMiku::Score 楽譜情報
+    # ==== Return
+    # ブロックの評価結果
+    def sing(score=nil)
+      score = PocketMiku::Score.new(&Proc.new) if block_given?
+      play score
+    end
+
+    def close
+      #stop
+      @io.close
+    end
+
+    def closed?
+      @io.closed?
+    end
+  end
+end

data/lib/pocket_miku/exception.rb

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-class PocketMiku
+module PocketMiku
   # PocketMikuが定義する例外の基底クラス
   class Exception < ::RuntimeError; end
 

data/lib/pocket_miku/literal.rb

@@ -0,0 +1,11 @@
+module PocketMiku
+  Note32 = 1
+  Note16 = Note32*2
+  Note8 = Note16*2
+  Note4 = QuarterNote = Note8*2
+  Note2 = HalfNote = Note4*2
+  Note1 = Note2*2
+  DoubleNote = Note1*2
+  LongaNote = DoubleNote*2
+  MaximaNote = LongaNote*2
+end

data/lib/pocket_miku/note.rb

@@ -0,0 +1,123 @@
+# -*- coding: utf-8 -*-
+
+module PocketMiku
+  class Note < PocketMiku::Base
+    attr_reader :sound, :key, :velocity, :pitchbend, :length
+
+    # ==== Args
+    # [options]
+    #   - sound :: 発音する文字テーブルコード
+    #   - key :: 音程 (0-127)
+    #   - velocity :: 強さ (0-127)
+    #   - pitchvend :: ピッチベンド
+    #   - length :: 音の長さ(相対)
+    def initialize(options={})
+      self.sound = options[:sound]
+      self.key = options[:key]
+      self.velocity = options[:velocity]
+      self.pitchbend = options[:pitchbend]
+      self.length = options[:length]
+    end
+
+    def to_s
+      PocketMiku::PacketFactory.pack(to_a)
+    end
+
+    def to_a
+      [0xF0, 0x43, 0x79, 0x09, 0x11, 0x0A, 0, sound, 0xF7,
+       0x90, key, velocity]
+    end
+
+    def to_h
+      { sound: sound,
+        key: key,
+        velocity: velocity,
+        pitchbend: pitchbend,
+        length: length }
+    end
+
+    # ポケットミクに発音させる文字テーブル情報をセットする
+    # ==== Args
+    # [new] Integer|Symbol セットする文字テーブルの文字コード(Integer)か文字(Symbol)
+    # ==== Exceptions
+    # PocketMiku::CharMappingError
+    #   newが文字テーブルに存在しない場合
+    # PocketMiku::InvalidByteError
+    #   newが1byte(0..255)に収まらない数値である場合
+    # ==== Return
+    # 新しい sound の値。Symbolをセットしても必ず数値になる。
+    def sound=(new)
+      case new
+      when Fixnum
+        raise CharMappingError, "sound out of range 0..127" unless (0..127).include? new
+        @sound = new
+      when -> _ {CharTable.include? _}
+        @sound = CharTable[new]
+      else
+        raise CharMappingError, "unknown sound `#{new}'"
+      end
+    end
+
+    # ポケットミクに発音させる音程をセットする
+    # ==== Args
+    # [new] Integer 設定する音程(0-127)
+    # ==== Exceptions
+    # PocketMiku::ArgumentError
+    #   new 0-127の範囲外
+    # ==== Return
+    # new
+    def key=(new)
+      raise ArgumentError, "key out of range 0..127" unless (0..127).include? new
+      @key = new
+    end
+
+    # ポケットミクに発音させるベロシティをセットする
+    # ==== Args
+    # [new] Integer 設定するベロシティ(0-127)
+    # ==== Exceptions
+    # PocketMiku::ArgumentError
+    #   new 0-127の範囲外
+    # ==== Return
+    # new
+    def velocity=(new)
+      raise ArgumentError, "velocity out of range 0..127" unless (0..127).include? new
+      @velocity = new
+    end
+
+    # ポケットミクに発音させるピッチベンドをセットする
+    # ==== Args
+    # [new] Integer 設定するピッチベンド(-8192 - 8191)
+    # ==== Exceptions
+    # PocketMiku::ArgumentError
+    #   new -8192 - 8191の範囲外
+    # ==== Return
+    # new
+    def pitchbend=(new)
+      raise ArgumentError, "pitchbend out of range -8192..8191" unless (-8192..8191).include? new
+      @pitchbend = new
+    end
+
+    # ポケットミクにこの音を発音する長さをセットする
+    # ==== Args
+    # [new] Integer 設定する長さ(1以上)
+    # ==== Exceptions
+    # PocketMiku::ArgumentError
+    #   new -8192 - 8191の範囲外
+    # ==== Return
+    # new
+    def length=(new)
+      raise ArgumentError, "length must than 1" unless 1 <= new
+      @length = new
+    end
+  end
+
+  class RestNote < Note
+    def initialize(length)
+      super(sound:0, key:0, velocity:0, pitchbend:0, length: length)
+    end
+
+    def to_a
+      []
+    end
+  end
+end

data/lib/pocket_miku/packet_factory.rb

@@ -0,0 +1,15 @@
+module PocketMiku::PacketFactory
+  extend self
+  def pack(bytes)
+    bytes = [bytes] if bytes.is_a? Integer
+    bytes.each(&PocketMiku::PacketFactory.method(:byte_check))
+    bytes.pack "C*".freeze
+  end
+
+  def byte_check(byte, error_message="byte should 0...255 but give `%d'".freeze)
+    raise PocketMiku::InvalidByteError, "`#{byte}' is not integer." unless byte.is_a? Integer
+    raise PocketMiku::InvalidByteError, error_message % byte unless (0..0xFF).include?(byte)
+    byte
+  end
+
+end

data/lib/pocket_miku/score.rb

@@ -0,0 +1,96 @@
+# -*- coding: utf-8 -*-
+
+module PocketMiku
+  class Score < PocketMiku::Base
+    include Enumerable
+
+    attr_reader :default
+
+    def initialize
+      @default = PocketMiku::Note.new(sound: 0,
+                                      key: 60,
+                                      velocity: 100,
+                                      pitchbend: 0,
+                                      length: QuarterNote)
+      @playlist = []
+      @tempo = 120
+      if block_given?
+        record(&Proc.new)
+      end
+    end
+
+    alias record instance_eval
+
+    def to_a
+      @playlist.dup
+    end
+
+    def each
+      @playlist.each(&Proc.new)
+    end
+
+    # 再生速度を取得/設定する。テンポの値は、１分間に再生する四分音符の数
+    # ==== Args
+    # [new] 
+    #  - nil(指定なし) :: 現在のテンポを返す
+    #  - Integer :: テンポをこの値に設定
+    # ==== Return
+    # 現在のテンポ
+    def tempo(new=nil)
+      case new
+      when nil
+        @tempo
+      when Integer
+        @tempo = new
+      else
+        raise ArgumentError, "new mush nil or Integer but give `#{new.class}'"
+      end
+    end
+
+    # PocketMiku::Note を末尾に追加する
+    # ==== Args
+    # [note] PocketMiku::Note
+    # ==== Return
+    # self
+    def add(note)
+      @playlist << note
+      self
+    end
+
+    # Note を作成して、再生キューの末尾に追加する
+    # ==== Args
+    # [sound] Symbol|Integer 発音する文字テーブルの文字(Symbol)か番号(Integer)
+    # [options] 以下のいずれか
+    #   - Integer :: 音の高さ(key)
+    #   - Hash :: PocketMiku::Noteの第一引数
+    # 設定されたなかった Note のオプションは、 default の値が使われる
+    # ==== Return
+    # self
+    def generate_note(sound, options=nil)
+      add case options
+          when NilClass
+            PocketMiku::Note.new default.to_h.merge sound: sound
+          when Integer
+            PocketMiku::Note.new default.to_h.merge sound: sound, key: options
+          when Hash, -> _ {_.respond_to? :to_h}
+            PocketMiku::Note.new default.to_h.merge(options).merge sound: sound
+          else
+            raise ArgumentError, "options must nil, Integer, or Hash. but given `#{options.class}'"
+          end
+    end
+
+    def っ(length)
+      add PocketMiku::RestNote.new(length)
+    end
+
+    def method_missing(method, *args)
+      case method
+      when -> _ {CharTable.include? _}
+        generate_note method, *args
+      else
+        super
+      end
+    end
+
+  end
+end

data/lib/pocket_miku/version.rb

@@ -1,5 +1,5 @@
-class PocketMiku
-  VERSION = "0.0.2"
+module PocketMiku
+  VERSION = "0.1.0"
 end
 
 

data/spec/device_spec.rb

@@ -0,0 +1,34 @@
+# -*- coding: utf-8 -*-
+require 'spec_helper'
+
+describe PocketMiku::Device, "pocket miku" do
+  before do
+    @stream_body = String.new
+    @stream = StringIO.new(@stream_body, 'w')
+    @pocketmiku = PocketMiku::Device.new(@stream)
+  end
+
+  it "should send raw data" do
+    @pocketmiku.send [0, 128, 255]
+    expect(@stream_body.unpack('C*')).to eq([0, 128, 255])
+  end
+
+  it "should error send out of range raw data" do
+    expect { @pocketmiku.send [257] }.to raise_error(PocketMiku::InvalidByteError)
+    expect { @pocketmiku.send [-1] }.to raise_error(PocketMiku::InvalidByteError)
+  end
+
+  it "should play DSL Context" do
+    @pocketmiku.sing do
+      あ 60
+    end
+    expect(@stream_body.unpack('C*')).to eq([0xF0, 0x43, 0x79, 0x09, 0x11, 0x0A, 0, 0, 0xF7, 0x90, 60, 100, 0x80, 60, 0])
+  end
+
+  it "should raise IOError try to output after close" do
+    expect(@pocketmiku.closed?).to eq false
+    @pocketmiku.close
+    expect(@pocketmiku.closed?).to eq true
+    expect { @pocketmiku.sing { あ 60 } }.to raise_error IOError
+  end
+end

data/spec/note_spec.rb

@@ -0,0 +1,86 @@
+# -*- coding: utf-8 -*-
+require 'spec_helper'
+
+describe PocketMiku::Note, "pocket miku note" do
+  before do
+    @note = PocketMiku::Note.new(sound: 0,
+                                 key: 0,
+                                 velocity: 0,
+                                 pitchbend: 0,
+                                 length: 1)
+  end
+
+  it "should set sound parameter" do
+    expect { @note.sound=-1 }.to raise_error(PocketMiku::CharMappingError)
+    expect { @note.sound=128 }.to raise_error(PocketMiku::CharMappingError)
+    expect { @note.sound=:亜 }.to raise_error(PocketMiku::CharMappingError)
+    expect { @note.sound=Object }.to raise_error(PocketMiku::CharMappingError)
+
+    @note.sound=0
+    expect(@note.sound).to eq 0
+
+    @note.sound=127
+    expect(@note.sound).to eq 127
+
+    @note.sound=:あ
+    expect(@note.sound).to eq 0
+  end
+
+  it "should set key parameter" do
+    expect { @note.key=-1 }.to raise_error(PocketMiku::ArgumentError)
+    expect { @note.key=128 }.to raise_error(PocketMiku::ArgumentError)
+    @note.key=0
+    expect(@note.key).to eq 0
+    @note.key=127
+    expect(@note.key).to eq 127
+  end
+
+  it "should set velocity parameter" do
+    expect { @note.velocity=-1 }.to raise_error(PocketMiku::ArgumentError)
+    expect { @note.velocity=128 }.to raise_error(PocketMiku::ArgumentError)
+    @note.velocity=0
+    expect(@note.velocity).to eq 0
+    @note.velocity=127
+    expect(@note.velocity).to eq 127
+  end
+
+  it "should set pitchbend parameter" do
+    expect { @note.pitchbend=-8193 }.to raise_error(PocketMiku::ArgumentError)
+    expect { @note.pitchbend=8192 }.to raise_error(PocketMiku::ArgumentError)
+    @note.pitchbend=-8192
+    expect(@note.pitchbend).to eq(-8192)
+    @note.pitchbend=8191
+    expect(@note.pitchbend).to eq 8191
+  end
+
+  it "should set length parameter" do
+    expect { @note.length=0 }.to raise_error(PocketMiku::ArgumentError)
+    @note.length=1
+    expect(@note.length).to eq 1
+    @note.length=9999
+    expect(@note.length).to eq 9999
+  end
+
+  it "should return sound packet" do
+    note = PocketMiku::Note.new(sound: 1,
+                                key: 2,
+                                velocity: 3,
+                                pitchbend: 4,
+                                length: 5)
+    expect(note.to_a).to eq([0xF0, 0x43, 0x79, 0x09, 0x11, 0x0A, 0, 1, 0xF7,
+                             0x90, 2, 3])
+  end
+
+  it "should write out to Hash" do
+    note = PocketMiku::Note.new(sound: 1,
+                                key: 2,
+                                velocity: 3,
+                                pitchbend: 4,
+                                length: 5)
+    expect(note.to_h).to eq(sound: 1,
+                            key: 2,
+                            velocity: 3,
+                            pitchbend: 4,
+                            length: 5)
+  end
+end

data/spec/packet_factory_spec.rb

@@ -0,0 +1,25 @@
+# -*- coding: utf-8 -*-
+require 'spec_helper'
+
+describe PocketMiku::PacketFactory, "pocket miku note" do
+  it "should pack array to string" do
+    result = PocketMiku::PacketFactory.pack([32])
+    expect(result.unpack('C*')).to eq [32]
+
+    result = PocketMiku::PacketFactory.pack(32)
+    expect(result.unpack('C*')).to eq [32]
+  end
+
+  it "should raise exception too big/small bytes" do
+    expect { PocketMiku::PacketFactory.pack([-1]) }.to raise_error(PocketMiku::InvalidByteError)
+    expect { PocketMiku::PacketFactory.pack([256]) }.to raise_error(PocketMiku::InvalidByteError)
+    PocketMiku::PacketFactory.pack([0])
+    PocketMiku::PacketFactory.pack([255])
+
+    expect { PocketMiku::PacketFactory.pack(-1) }.to raise_error(PocketMiku::InvalidByteError)
+    expect { PocketMiku::PacketFactory.pack(256) }.to raise_error(PocketMiku::InvalidByteError)
+    PocketMiku::PacketFactory.pack(0)
+    PocketMiku::PacketFactory.pack(255)
+  end
+
+end

data/spec/score_spec.rb

@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+require 'spec_helper'
+
+describe PocketMiku::Score, "pocket miku score" do
+  before do
+    @score = PocketMiku::Score.new
+  end
+
+  it "should get/set default data" do
+    expect { @score.default.key = -1 }.to raise_error(PocketMiku::ArgumentError)
+    expect { @score.default.key = 128 }.to raise_error(PocketMiku::ArgumentError)
+    expect { @score.default.velocity = -1 }.to raise_error(PocketMiku::ArgumentError)
+    expect { @score.default.velocity = 128 }.to raise_error(PocketMiku::ArgumentError)
+    expect { @score.default.pitchbend = -8193 }.to raise_error(PocketMiku::ArgumentError)
+    expect { @score.default.pitchbend = 8192 }.to raise_error(PocketMiku::ArgumentError)
+    expect { @score.default.length = 0 }.to raise_error(PocketMiku::ArgumentError)
+
+    @score.default.key = 0
+    expect(@score.default.key).to eq 0
+    @score.default.key = 127
+    expect(@score.default.key).to eq 127
+    @score.default.velocity = 0
+    expect(@score.default.velocity).to eq 0
+    @score.default.velocity = 127
+    expect(@score.default.velocity).to eq 127
+    @score.default.pitchbend = -8192
+    expect(@score.default.pitchbend).to eq(-8192)
+    @score.default.pitchbend = 8191
+    expect(@score.default.pitchbend).to eq 8191
+    @score.default.length = 1
+    expect(@score.default.length).to eq 1
+  end
+
+  it "should can recording" do
+    @score.record do
+      あ 60
+    end
+  end
+
+end

metadata

@@ -1,62 +1,55 @@
 --- !ruby/object:Gem::Specification
 name: pocket_miku
 version: !ruby/object:Gem::Version
-  version: 0.0.2
-  prerelease: 
+  version: 0.1.0
 platform: ruby
 authors:
 - Toshiaki Asai
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-04 00:00:00.000000000 Z
+date: 2014-04-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.5'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.5'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: Rubyコードから「ポケットミク」を使ってミクを調教するためのライブラリです。
@@ -66,43 +59,54 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
+- ".gitignore"
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - lib/pocket_miku.rb
+- lib/pocket_miku/base.rb
 - lib/pocket_miku/chartable.rb
+- lib/pocket_miku/device.rb
 - lib/pocket_miku/exception.rb
+- lib/pocket_miku/literal.rb
+- lib/pocket_miku/note.rb
+- lib/pocket_miku/packet_factory.rb
+- lib/pocket_miku/score.rb
 - lib/pocket_miku/version.rb
 - pocket_miku.gemspec
-- spec/pocket_miku_spec.rb
+- spec/device_spec.rb
+- spec/note_spec.rb
+- spec/packet_factory_spec.rb
+- spec/score_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/toshia/pocket_miku
 licenses:
 - MIT
+metadata: {}
 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
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Play voice via PocketMiku
 test_files:
-- spec/pocket_miku_spec.rb
+- spec/device_spec.rb
+- spec/note_spec.rb
+- spec/packet_factory_spec.rb
+- spec/score_spec.rb
 - spec/spec_helper.rb

data/spec/pocket_miku_spec.rb

@@ -1,66 +0,0 @@
-# -*- coding: utf-8 -*-
-require 'spec_helper'
-
-describe PocketMiku, "pocket miku" do
-  before do
-    @stream_body = String.new
-    @stream = StringIO.new(@stream_body, 'w')
-    @pocketmiku = PocketMiku.new(@stream)
-  end
-
-  it "should send raw data" do
-    @pocketmiku.send [0, 128, 255]
-    expect(@stream_body.unpack('C*')).to eq([0, 128, 255])
-  end
-
-  it "should error send out of range raw data" do
-    expect { @pocketmiku.send [257] }.to raise_error(PocketMiku::InvalidByteError)
-    expect { @pocketmiku.send [-1] }.to raise_error(PocketMiku::InvalidByteError)
-  end
-
-  it "should error set invalid data" do
-    expect { @pocketmiku.set(key: -1) }.to raise_error(PocketMiku::InvalidByteError)
-    expect { @pocketmiku.set(key: 257) }.to raise_error(PocketMiku::InvalidByteError)
-    expect { @pocketmiku.set(velocity: -1) }.to raise_error(PocketMiku::InvalidByteError)
-    expect { @pocketmiku.set(velocity: 257) }.to raise_error(PocketMiku::InvalidByteError)
-    expect { @pocketmiku.set(sound: -1) }.to raise_error(PocketMiku::InvalidByteError)
-    expect { @pocketmiku.set(sound: 257) }.to raise_error(PocketMiku::InvalidByteError)
-    expect { @pocketmiku.set(sound: :亜) }.to raise_error(PocketMiku::CharMappingError)
-    expect { @pocketmiku.set(sound: Object) }.to raise_error(PocketMiku::CharMappingError)
-  end
-
-  it "should error set invalid sound" do
-    expect { @pocketmiku.sound = -1 }.to raise_error(PocketMiku::InvalidByteError)
-    expect { @pocketmiku.sound = 257 }.to raise_error(PocketMiku::InvalidByteError)
-    expect { @pocketmiku.sound = :亜 }.to raise_error(PocketMiku::CharMappingError)
-    expect { @pocketmiku.sound = Object }.to raise_error(PocketMiku::CharMappingError)
-  end
-
-  it "should play current data" do
-    @pocketmiku.set(key: 100, velocity: 101, sound: 102)
-    expect(@stream_body.unpack('C*')).to eq []
-    @pocketmiku.play
-    expect(@stream_body.unpack('C*')).to eq [0xF0, 0x43, 0x79, 0x09, 0x11, 0x0A, 0, 102, 0xF7, 0x90, 100, 101]
-    @stream_body.clear
-    @stream.seek 0
-    @pocketmiku.stop
-    expect(@stream_body.unpack('C*')).to eq [0x80, 100, 0]
-  end
-
-  it "should play DSL Context" do
-    @pocketmiku.sing {あ(60, 100) }
-    expect(@stream_body.unpack('C*')).to eq([0xF0, 0x43, 0x79, 0x09, 0x11, 0x0A, 0, 0, 0xF7, 0x90, 60, 100])
-  end
-
-  it "should raise InvalidByteError try to play that not yet set sound" do
-    expect { @pocketmiku.play }.to raise_error PocketMiku::InvalidByteError
-  end
-
-  it "should raise IOError try to output after close" do
-    @pocketmiku.set(key: 100, velocity: 101, sound: 102)
-    expect(@pocketmiku.closed?).to eq false
-    @pocketmiku.close
-    expect(@pocketmiku.closed?).to eq true
-    expect { @pocketmiku.play }.to raise_error IOError
-  end
-end