media_player 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b823e5a0ea79b9cd97a918873cee8a6acfb0d127
+  data.tar.gz: f780d09c5fa8069164f9162caa9b28d907f18bab
+SHA512:
+  metadata.gz: ce976d3e1ea6fdc21a54285996c138e80ac1d0fe0f0f3c9affbcec27bb453b4eda92f794815a41cf5b3fe5a4e04488de759cc30ba1cfaff0f346f932c5adaf1d
+  data.tar.gz: 57da31743fed05e8530aae44a25a82d32f58582141680ab7eeaa4f678bd65214850553847b19098c27476a60dc4537fef5972266909f8aa2242ebe4b5c227ce5

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.DS_Store
+

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format documentation

data/.ruby-version

@@ -0,0 +1 @@
+jruby-1.7.13

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+  - jruby-head
+script: bundle exec rspec spec
+

data/Gemfile

@@ -0,0 +1,11 @@
+source 'https://rubygems.org'
+
+group :development, :test do
+  gem 'pry'
+end
+
+group :test do
+  gem 'rspec'
+end
+# Specify your gem's dependencies in media_player.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 oozzal
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,40 @@
+# MediaPlayer (Beta)
+
+All in one command Line Media Player.
+
+## Installation
+
+Dependencies: `jruby`, [sox]( http://sox.sourceforge.net/ )
+
+Add this line to your application's Gemfile:
+
+    gem 'media_player'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install media_player
+
+## Usage
+  * Make sure you're using `jruby`.
+  * Start the player: `player`
+  * Add media: `add <filename>`
+  * Play media: `play`
+  * Currently supported instructions: `add shuffle play stop pause next prev exit`
+
+## TODO
+  * Tab complete instructions
+  * Add more function
+
+## Contributing
+
+Feel free to contribute.
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,8 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new
+
+task :default => :spec
+task :test => :spec

data/bin/player

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/process_manager'
+require_relative '../lib/playlist'
+require_relative '../lib/player'
+require_relative '../lib/input_manager'
+
+pm = MediaPlayer::ProcessManager.new
+pl = MediaPlayer::PlayList.new
+p = MediaPlayer::Player.new(process_manager: pm, playlist: pl)
+
+MediaPlayer::InputManager.new(player: p).start
+

data/lib/input_manager.rb

@@ -0,0 +1,58 @@
+require 'forwardable'
+
+module MediaPlayer
+  class InputManager
+    extend Forwardable
+    # Shortcuts? maybe
+    # SHORTCUTS = %w(a sh pl st pa n pr e)
+    # SHORTCUT_MAPPINGS = {
+    #   'a' => 'add',
+    #   'sh' => 'shuffle',
+    #   'pl' => 'play',
+    #   'st' => 'stop',
+    #   'pa' => 'pause',
+    #   'n' => 'next',
+    #   'pr' => 'prev',
+    #   'e' => 'exit'
+    # }
+    INSTRUCTIONS = %w(add shuffle play stop pause next prev exit)
+    attr_reader :player
+    def_delegators :@player, :shuffle, :play, :stop, :pause, :next
+    def_delegator :@player, :previous, :prev
+
+    def initialize(args={})
+      @player = args.fetch(:player)
+    end
+
+    def process(instruction)
+      if INSTRUCTIONS.include? instruction.split(' ').first
+        begin
+          if instruction.match(/add/)
+            path = (instruction.split(' ') - ['add']).join(' ')
+            type = File.ftype(path)
+            if type == 'directory'
+              Dir.glob("#{path}/*.mp3") { |file| @player.add_media(file) }
+            elsif type == 'file'
+              @player.add_media(path)
+            end
+          else
+            send instruction
+          end
+        rescue => e
+          return e.message
+        end
+      else
+        return 'Invalid Instruction'
+      end
+    end
+
+    # TODO: The only thing not covered by test
+    def start
+      while (input = gets.chomp) != 'exit'
+        p process(input)
+      end
+      p process('stop')
+    end
+  end
+end
+

data/lib/media_player.rb

@@ -0,0 +1,9 @@
+require_relative './input_manager'
+require_relative './player'
+require_relative './playlist'
+require_relative './process_manager'
+
+module MediaPlayer
+  extend self
+end
+

data/lib/media_player/version.rb

@@ -0,0 +1,4 @@
+module MediaPlayer
+  VERSION = '0.1.0'
+end
+

data/lib/player.rb

@@ -0,0 +1,66 @@
+require_relative './media_player/version'
+require 'forwardable'
+
+module MediaPlayer
+  class Player
+    extend Forwardable
+    attr_reader :process_manager, :playlist, :is_playing, :paused
+    def_delegator :@process_manager, :current_process_id
+    def_delegators :@playlist, :media, :current_media, :next_media, :previous_media, :shuffle
+
+    def initialize(args = {})
+      @process_manager = args.fetch(:process_manager)
+      @playlist = args.fetch(:playlist)
+      @is_playing = false
+      @paused = false
+    end
+
+    def add_media(media_file)
+      @playlist.add(media_file)
+    end
+
+    def play
+      return if @is_playing
+      if @paused
+        @paused = false
+        @process_manager.resume
+      else
+        @is_playing = true
+        @process_manager.execute(current_media)
+      end
+      observe
+    end
+
+    def stop
+      @is_playing = false
+      @process_manager.stop
+    end
+
+    def pause
+      @is_playing = false
+      @paused = true
+      @process_manager.pause
+    end
+
+    def next
+      @process_manager.stop
+      @process_manager.execute(next_media)
+    end
+
+    def previous
+      @process_manager.stop
+      @process_manager.execute(previous_media)
+    end
+
+    def observe
+      Thread.new do
+        while @is_playing
+          self.next unless @process_manager.is_current_process_alive?
+          sleep 2
+        end
+      end
+    end
+
+  end
+end
+

data/lib/playlist.rb

@@ -0,0 +1,48 @@
+module MediaPlayer
+  class PlayList
+    attr_reader :media, :current_index
+
+    def initialize(media = [])
+      @media = media
+      @current_index = 0
+    end
+
+    def filter_input(raw_input)
+      # weird :-O
+      raw_input = raw_input.gsub("'", "\\\\'")
+      raw_input = raw_input.gsub('"', '\"')
+      raw_input = raw_input.gsub('&', '\\\&')
+      regex = /[()\s]/
+      raw_input.gsub regex do |match|
+        match.gsub("#{match}", "\\#{match}")
+      end
+    end
+
+    def add(raw_media_file)
+      media_file = filter_input(raw_media_file)
+      @media.push(media_file)
+    end
+
+    def current_media
+      @media[@current_index]
+    end
+
+    def next_media
+      @current_index += 1
+      @current_index = 0 if @media.size == @current_index
+      current_media
+    end
+
+    def previous_media
+      @current_index -= 1
+      @current_index = @media.size - 1 if @current_index < 0
+      current_media
+    end
+
+    def shuffle
+      old_current_media = current_media
+      @media.shuffle!
+      @current_index = @media.index(old_current_media)
+    end
+  end
+end

data/lib/process_manager.rb

@@ -0,0 +1,42 @@
+module MediaPlayer
+  # execute, stop, pause, resume
+  class ProcessManager
+    attr_accessor :current_process_id
+
+    def build_process(media_file)
+      Process.spawn("play #{media_file}")
+    end
+
+    def execute(media_file)
+      @current_process_id = build_process(media_file)
+    end
+
+    def pause
+      Process.kill(:STOP, @current_process_id)
+    end
+
+    def resume
+      Process.kill(:CONT, @current_process_id)
+    end
+
+    def stop
+      begin
+        Process.kill(:INT, @current_process_id)
+        Process.waitpid(@current_process_id)
+      rescue
+      end
+    end
+
+    def is_current_process_alive?
+      begin
+        Process.getpgid(@current_process_id)
+        true
+      rescue Errno::ESRCH
+        false
+      rescue
+        false
+      end
+    end
+  end
+end
+

data/media_player.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'media_player/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "media_player"
+  spec.version       = MediaPlayer::VERSION
+  spec.authors       = ["oozzal"]
+  spec.email         = ["theoozzal@gmail.com"]
+  spec.description   = %q{Command line media player.}
+  spec.summary       = %q{Plays media files right from the command line giving some basic media controls.}
+  spec.homepage      = "http://github.com/oozzal/media_player"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = ['player']
+  #spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+end
+

data/spec/lib/input_manager_spec.rb

@@ -0,0 +1,87 @@
+require_relative '../spec_helper'
+
+describe 'An instance of InputManager', MediaPlayer::InputManager do
+  let(:player) { double('player') }
+  subject { MediaPlayer::InputManager.new player: player }
+
+  it 'has instructions and options' do
+    expect(subject.class::INSTRUCTIONS).not_to be_nil
+  end
+
+  it { expect(subject.player).not_to be_nil }
+
+  describe '#process' do
+    context 'when instruction is invalid' do
+      it {
+        return_value = subject.process('hawa jpt')
+        expect(subject.process 'jpt').to eql 'Invalid Instruction'
+      }
+    end
+
+    context 'when instruction is valid' do
+      context 'when add' do
+        context 'when adding directory' do
+          it {
+            dir = '/Users/uzzaldevkota/Music/Selected Music'
+            expect(File).to receive(:ftype).and_return 'directory'
+            search = "#{dir}/*.mp3"
+            expect(Dir).to receive(:glob).with search
+            subject.process("add #{dir}")
+          }
+        end
+        context 'when adding file' do
+          it {
+            file = '/Users/uzzaldevkota/Music/John Lennon imagine.mp3'
+            expect(File).to receive(:ftype).and_return 'file'
+            expect(subject.player).to receive(:add_media).with file
+            subject.process("add #{file}")
+          }
+        end
+      end
+
+      context 'when shuffle' do
+        it {
+          expect(subject.player).to receive(:shuffle).with no_args
+          subject.process('shuffle')
+        }
+      end
+
+      context 'when play' do
+        it {
+          expect(subject.player).to receive(:play).with no_args
+          subject.process('play')
+        }
+      end
+
+      context 'when stop' do
+        it {
+          expect(player).to receive(:stop).with no_args
+          subject.process('stop')
+        }
+      end
+
+      context 'when pause' do
+        it {
+          expect(player).to receive(:pause).with no_args
+          subject.process('pause')
+        }
+      end
+
+      context 'when next' do
+        it {
+          expect(player).to receive(:next).with no_args
+          subject.process('next')
+        }
+      end
+
+      context 'when prev' do
+        it {
+          expect(player).to receive(:previous).with no_args
+          subject.process('prev')
+        }
+      end
+    end
+  end
+
+end
+

data/spec/lib/media_player/version_spec.rb

@@ -0,0 +1,8 @@
+require_relative '../../spec_helper'
+
+describe MediaPlayer do
+  it 'has a version' do
+    expect(MediaPlayer::VERSION).not_to be_nil
+  end
+end
+

data/spec/lib/player_spec.rb

@@ -0,0 +1,104 @@
+require_relative '../spec_helper'
+
+describe 'An Instance of Player', MediaPlayer::Player do
+  let(:sample_media) { 'imagine.mp3' }
+  let(:media) { [] }
+  let(:process_manager) { double('process_manager') }
+  let(:playlist) {
+    double(
+      'playlist',
+      media: media,
+      current_media: nil, next_media: nil,
+      previous_media: nil, shuffle: nil
+    )
+  }
+
+  # Beware, error in testing observe method
+  # before { MediaPlayer::Player.any_instance.stub(:observe) }
+  subject {
+    MediaPlayer::Player.new(
+      process_manager: process_manager,
+      playlist: playlist
+    )
+  }
+
+  it { expect(subject.is_playing).to eql false }
+  it { expect(subject.paused).to eql false }
+
+  # Delegated methods
+  it 'responds to delegated methods' do
+    expect(subject).to respond_to(:current_process_id)
+    expect(subject).to respond_to(:media)
+    expect(subject).to respond_to(:current_media)
+    expect(subject).to respond_to(:next_media)
+    expect(subject).to respond_to(:previous_media)
+    expect(subject).to respond_to(:shuffle)
+  end
+
+  it { expect(subject.media).to eql [] }
+
+  describe '#add_media' do
+    it 'pushes media to the playlist' do
+      expect(subject.playlist).to receive(:add).with sample_media
+      subject.add_media sample_media
+    end
+  end
+
+  context 'when initialized with some media' do
+    before { allow(subject.playlist).to receive(:current_media).and_return sample_media }
+    let(:media) { ['a.mp3', 'b.wav'] }
+    it { expect(subject.playlist).not_to eql nil }
+
+    describe '#play' do
+      context 'when player is not playing any media' do
+        it 'plays the media in the playlist' do
+          expect(subject.process_manager).to receive(:execute).with sample_media
+          expect(subject).to receive(:observe).with no_args
+          subject.play
+        end
+
+        context 'when player has paused some media' do
+          before { subject.instance_variable_set('@paused', true) }
+          it 'resumes the paused media' do
+            expect(subject.process_manager).to receive(:resume).with no_args
+            subject.play
+          end
+        end
+      end
+    end
+
+    describe '#stop' do
+      it 'stops the current media' do
+        expect(subject.process_manager).to receive(:stop).with no_args
+        subject.stop
+        expect(subject.is_playing).to eql false
+      end
+    end
+
+    describe '#pause' do
+      it 'pauses the currently playing media from the playlist' do
+        expect(subject.process_manager).to receive(:pause).with no_args
+        subject.pause
+      end
+    end
+
+    describe '#next' do
+      it 'plays the next media from the playlist' do
+        expect(subject.playlist).to receive(:next_media).and_return sample_media
+        expect(subject.process_manager).to receive(:stop).with no_args
+        expect(subject.process_manager).to receive(:execute).with sample_media
+        subject.next
+      end
+    end
+
+    describe '#previous' do
+      it 'plays the previous media in the playlist' do
+        expect(subject.playlist).to receive(:previous_media).and_return sample_media
+        expect(subject.process_manager).to receive(:stop).with no_args
+        expect(subject.process_manager).to receive(:execute).with sample_media
+        subject.previous
+      end
+    end
+  end
+end
+

data/spec/lib/playlist_spec.rb

@@ -0,0 +1,72 @@
+require_relative '../spec_helper'
+
+describe 'An Instance of Playlist', MediaPlayer::PlayList do
+  subject { MediaPlayer::PlayList.new(['a.mp3', 'b.wav', 'c.mp3', 'd.wav']) }
+  context 'when initialized' do
+    it { expect(subject.media).not_to be_empty }
+    it { expect(subject.current_index).not_to be_nil }
+  end
+
+  context '#add' do
+    let(:sample_media) { 'imagine.mp3' }
+    before { subject.add(sample_media) }
+
+    it { expect(subject.media.include?(sample_media)).to eql true }
+
+    context 'when illegal characters occur in the path to media' do
+      let(:malicious_media) { '(02) - John Mayer Assassin.mp3' }
+      let(:malicious_media2) { "Free' Falling.mp3" }
+      let(:malicious_media3) { 'Free" Falling.mp3' }
+      let(:malicious_media4) { 'Pink & Nate Reus.mp3' }
+
+      it 'escapes them' do
+        subject.add(malicious_media)
+        expect(subject.media.last).to eql '\(02\)\ -\ John\ Mayer\ Assassin.mp3'
+        subject.add(malicious_media2)
+        expect(subject.media.last).to eql "Free\\'\\ Falling.mp3"
+        subject.add(malicious_media3)
+        expect(subject.media.last).to eql 'Free\"\\ Falling.mp3'
+        subject.add(malicious_media4)
+        expect(subject.media.last).to eql 'Pink\ \&\ Nate\ Reus.mp3'
+      end
+    end
+  end
+
+  context '#shuffle' do
+    it 're-adjusts the current_index to the current_media' do
+      current_media = subject.current_media
+      subject.shuffle
+      expect(subject.current_media).to eql current_media
+    end
+
+    it {
+      expect(subject.media).to receive(:shuffle!).with no_args
+      subject.shuffle
+    }
+  end
+
+  context '#current_media' do
+    it { expect(subject.current_media).to eql 'a.mp3' }
+  end
+
+  context '#next_media' do
+    it { expect(subject.next_media).to eql 'b.wav' }
+
+    context 'when end of playlist is reached' do
+      before { subject.instance_variable_set('@current_index', subject.media.size - 1) }
+      # TODO: shuffle automatically on next loop?
+      it { expect(subject.next_media).to eql 'a.mp3' }
+    end
+  end
+
+  context '#previous_media' do
+    before { subject.instance_variable_set('@current_index', 1) }
+    it { expect(subject.previous_media).to eql 'a.mp3' }
+
+    context 'when beginning of playlist is reached' do
+      before { subject.instance_variable_set('@current_index', 0) }
+      it { expect(subject.previous_media).to eql 'd.wav' }
+    end
+  end
+end
+

data/spec/lib/process_manager_spec.rb

@@ -0,0 +1,44 @@
+require_relative '../spec_helper'
+
+describe 'An Instance of ProcessManager', MediaPlayer::ProcessManager do
+  let(:sample_media) { 'imagine.mp3' }
+  let(:sample_pid) { 123 }
+  let(:play_command) { "play #{sample_media}" }
+  subject { MediaPlayer::ProcessManager.new }
+  it { expect(subject.current_process_id).to be_nil }
+
+  context '#execute' do
+    before { allow(Process).to receive(:spawn).and_return(sample_pid) }
+    it 'plays the given media' do
+      expect(Process).to receive(:spawn).with(play_command)
+      subject.execute(sample_media)
+      expect(subject.current_process_id).to eql sample_pid
+    end
+  end
+
+  context 'when manipulating current process' do
+    before { subject.current_process_id = sample_pid }
+    context '#pause' do
+      it 'pauses the given media' do
+        expect(Process).to receive(:kill).with(:STOP, sample_pid)
+        subject.pause
+      end
+    end
+
+    context '#resume' do
+      it 'resumes the paused media' do
+        expect(Process).to receive(:kill).with(:CONT, sample_pid)
+        subject.resume
+      end
+    end
+
+    context '#stop' do
+      it 'stops the current media' do
+        expect(Process).to receive(:kill).with(:INT, sample_pid)
+        expect(Process).to receive(:waitpid).with(sample_pid)
+        subject.stop
+      end
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+Dir['../../lib/**/*.rb'].each {|f| require f }
+require File.expand_path('../../lib/media_player.rb', __FILE__)
+require 'pry'
+

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification
+name: media_player
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- oozzal
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2014-10-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: rake
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  prerelease: false
+  type: :development
+description: Command line media player.
+email:
+- theoozzal@gmail.com
+executables:
+- player
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .ruby-version
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/player
+- lib/.DS_Store
+- lib/input_manager.rb
+- lib/media_player.rb
+- lib/media_player/version.rb
+- lib/player.rb
+- lib/playlist.rb
+- lib/process_manager.rb
+- media_player.gemspec
+- spec/.DS_Store
+- spec/lib/input_manager_spec.rb
+- spec/lib/media_player/version_spec.rb
+- spec/lib/player_spec.rb
+- spec/lib/playlist_spec.rb
+- spec/lib/process_manager_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/oozzal/media_player
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project:
+rubygems_version: 2.1.9
+signing_key:
+specification_version: 4
+summary: Plays media files right from the command line giving some basic media controls.
+test_files:
+- spec/.DS_Store
+- spec/lib/input_manager_spec.rb
+- spec/lib/media_player/version_spec.rb
+- spec/lib/player_spec.rb
+- spec/lib/playlist_spec.rb
+- spec/lib/process_manager_spec.rb
+- spec/spec_helper.rb
+has_rdoc: