lossfully 0.0.0

data/lib/lossfully/input_rules.rb

@@ -0,0 +1,176 @@
+#--
+# Copyright (C) 2011 Don March
+#
+# This file is part of Lossfully.
+#
+# Lossfully is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#  
+# Lossfully is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see
+# <http://www.gnu.org/licenses/>.
+#++
+
+module Lossfully
+  LOSSLESS_TYPES = %w(wav flac wv sox).map(&:to_sym)
+
+  # The InputRules class wraps up conditions and provides a way to
+  # test if a file meets those conditions.  It also allows the
+  # conditions to be sorted so that more restrictive conditions are
+  # tried before less restrictive.  The sorting hopefully does what
+  # seems natural; it looks at first at the regexp, then the file type
+  # (as returned by soxi -t), the file extension, the bitrate
+  # threshold, and finally if a block is given.  For example, the
+  # following encode rules are shown in the order that they would be
+  # tested against every file (even though the rules would be checked
+  # in this order even if the below encode statements were in a
+  # different order):
+  #
+  #   encode [:mp3, 128, /bach/] do 
+  #     ... 
+  #   end
+  #   encode [:mp3, 128, /bach/] => ...
+  #   encode [:mp3, /bach/] => ...
+  #   encode [:mp3, 128] => ...
+  #   encode :mp3 => ...
+  #   encode :lossy => ...
+  #   encode :audio => ...
+  #   encode :everything => ...
+  #
+  # It's obviously only a partial order; see the code for
+  # compare_strictness if you need to know exactly what it's doing.
+  #
+  class InputRules
+    include Comparable
+
+    def initialize array=[], &block
+      raise unless array.kind_of? Array
+      
+      @block = block 
+
+      array.each do |x|
+        @type = x if x.kind_of? Symbol
+        @max_bitrate = x if x.kind_of? Numeric
+        if x.kind_of? String 
+          @extension = (x[0..0] == '.') || x== '' ? x : '.' + x
+        end
+        @regexp = x if x.kind_of? Regexp
+      end
+      @type ||= :everything
+      @max_bitrate ||= 0
+      @extension ||= ''
+      @regexp ||= //
+    end
+
+    attr_reader :block, :extension, :regexp, :type, :max_bitrate
+
+    def test file_or_path
+      file = if file_or_path.kind_of? AudioFile
+               file_or_path
+             else
+               AudioFile.new(file_or_path)
+             end
+#      unless file.is_audio?
+#        return false unless [:everything, :nonaudio].include?(@type)
+#        return false unless file.path =~ @regexp
+#        (return block.call(file.path)) if @block
+#        return true
+#      end
+
+      if @type != :everything
+        if [:audio, :lossy, :lossless].include? @type
+          return false unless file.is_audio?
+        end
+
+        if @type == :lossy 
+          return false if LOSSLESS_TYPES.include? file.type
+        elsif @type == :lossless
+          return false unless LOSSLESS_TYPES.include? file.type
+        elsif @type == :nonaudio
+          return false if file.is_audio?
+        elsif @type != :audio
+          v = [:vorbis, :ogg]
+          return false unless (file.type == @type) || 
+            (v.include?(file.type) && v.include?(@type))
+        end
+      end
+
+      if @max_bitrate > 0 
+        return false unless file.bitrate_kbps > @max_bitrate
+      end
+
+      if @extension != ''
+        return false unless File.extname(file.path) == @extension
+      end
+
+      if @regexp != // 
+        return false unless file.path =~ @regexp
+      end
+
+      if @block
+        # return block.call(file.path)
+        # TODO: decide if this should be file or file.path
+        return block.call(file)
+      end
+
+      return true
+    end
+
+    # Order by strictness, which is the proper order to test things in
+    def <=> x
+      -1 * compare_strictness(x)
+    end
+
+    # return -1 if self is less strict, 1 if self is more strict
+    def compare_strictness x
+      return nil unless x.class == self.class
+
+      if @regexp != x.regexp
+        return -1 if @regexp == //
+        return 1 if x.regexp == //
+        return nil
+      end
+
+      if @type != x.type
+        return -1 if @type == :everything
+        return 1 if x.type == :everything
+        return -1 if @type == :audio
+        return 1 if x.type == :audio
+        # these don't have to be comparable since they're mutual exclusive
+        return -1 if @type == :nonaudio
+        return 1 if x.type == :nonaudio
+        return -1 if @type == :lossless
+        return 1 if x.type == :lossless
+        return -1 if @type == :lossy
+        return 1 if x.type == :lossy
+        return -1 * (@type.to_s <=> x.type.to_s)
+      end
+
+      if @extension != x.extension
+        return -1 if @extension == '' 
+        return 1 if x.extension == '' 
+        return -1 * (@extension <=> x.extension)
+      end
+
+      b = @max_bitrate <=> x.max_bitrate
+      return b unless b == 0
+      
+      if @block || x.block
+        return nil if @block && x.block
+        return -1 if ! @block
+        return 1 if ! x.block
+      end
+
+      return 0
+    end
+  end
+
+end
+

data/lib/lossfully/thread_pool.rb

@@ -0,0 +1,162 @@
+#--
+# Copyright (C) 2011 Don March
+#
+# This file is part of Lossfully.
+#
+# Lossfully is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#  
+# Lossfully is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see
+# <http://www.gnu.org/licenses/>.
+#++
+
+require 'thread'
+require 'timeout'
+
+module Lossfully
+
+# There's (at least) two ways to do this: 1) the Ruby Recipes way,
+# which is to make a thread for every incoming task, but put it to
+# sleep until there's room in the pool for another task, or 2) have a
+# pool of threads that eat tasks from a queue.  This implements (2),
+# mainly because it seemed more fun to me.  But also because it
+# doesn't require the explicit use of Mutexes at all; it uses them,
+# for the sake of sending signals with ConditionVaribles, but if those
+# signals aren't received there would be a delay of at most 1 second.
+#
+# Another useful thing about this implementation is for the case when
+# every task you anticipate adding to the ThreadPool of the same
+# general form.  Then then ThreadPool can be initialized with a block
+# and you can just add objects to the task queue.
+#
+  class ThreadPool
+
+    DEFAULT_BLOCK = lambda {|block, &blk| block = blk if block_given? ; block.call}
+
+    def initialize(max_size = 1, block=nil, &blk)
+      @running = true
+      @joining = false
+      
+      @mutex = Mutex.new
+      @cv = ConditionVariable.new
+      @max_size = max_size
+      block = blk if block_given?
+      @block = block.nil? ? DEFAULT_BLOCK : block
+      @queue = Queue.new
+      @workers = []
+      @master = master_thread
+      @completed = 0
+      @total = 0
+    end
+
+    def process (block_or_item=nil, &blk)
+      block_or_item = blk if block_given?
+      if block_or_item.respond_to?(:call) 
+        @queue << block_or_item
+      else
+        @queue << lambda { @block.call(block_or_item) }
+      end
+#      @mutex.synchronize { @total +=1 }
+      @total += 1
+      signal_master
+    end
+
+    def current
+      @total - @queue.size
+    end
+
+    attr_reader :max_size, :mutex, :completed, :total
+    alias :enq :process
+    alias :dispatch :process
+    
+    def max_size=(size)
+      @max_size = size
+      signal_master
+    end
+
+    def << block_or_item
+      process block_or_item
+    end
+
+    def join
+      @running = false
+      @joining = true
+      signal_master
+      # A weird bug happens on this next line if you don't test
+      # @master.alive?, but only sometimes.  I don't care enough to
+      # figure it out right now.
+      @master.join if @master.alive?
+    end
+
+    def size
+      @workers.size
+    end
+
+    def queue_size
+      @queue.size
+    end
+
+    def stop
+      @queue.clear
+      join
+    end
+
+    def kill
+      @queue.clear
+      @workers.each(&:kill)
+      join
+    end
+
+    private
+
+    def signal_master
+      @mutex.synchronize { @cv.signal }
+    end
+
+    def master_thread
+      Thread.new do
+        while @running || ! @queue.empty?
+
+          @workers ||= []
+          @workers.delete_if { |w| ! w.alive? }    
+
+          while @workers.size < @max_size && @queue.size > 0 
+            @workers << Thread.new do 
+              begin
+                if task = @queue.pop(true) rescue nil
+                  task.call
+                  @mutex.synchronize { @completed +=1 }
+                end 
+              ensure
+                signal_master
+              end
+            end
+          end
+
+          @mutex.synchronize do
+            # @cv.wait(@mutex, 1) # can't do this in 1.8.7
+            begin
+              Timeout::timeout(2) { @cv.wait(@mutex) }
+            rescue Timeout::Error
+            end
+          end
+          # This needs to come after the critical section above,
+          # otherwise the main thread will have to wait for the timeout
+          # before continuing when the ThreadPool is joined.  The rescue
+          # below handles exceptions that might have happened in the
+          # threads, which will stop the main thread now that they're
+          # being joined.
+          @workers.each(&:join) if @joining rescue nil
+        end
+      end
+    end
+  end
+end

data/lib/lossfully.rb

@@ -0,0 +1,79 @@
+#--
+# Copyright (C) 2011 Don March
+#
+# This file is part of Lossfully.
+#
+# Lossfully is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#  
+# Lossfully is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see
+# <http://www.gnu.org/licenses/>.
+#++
+
+module Lossfully
+
+  # :stopdoc:
+  LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
+  PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
+  # :startdoc:
+  VERSION = ::File.read(PATH + 'version.txt').strip
+
+  # Returns the library path for the module. If any arguments are given,
+  # they will be joined to the end of the libray path using
+  # <tt>File.join</tt>.
+  #
+  def self.libpath( *args )
+    rv =  args.empty? ? LIBPATH : ::File.join(LIBPATH, args.flatten)
+    if block_given?
+      begin
+        $LOAD_PATH.unshift LIBPATH
+        rv = yield
+      ensure
+        $LOAD_PATH.shift
+      end
+    end
+    return rv
+  end
+
+  # Returns the lpath for the module. If any arguments are given,
+  # they will be joined to the end of the path using
+  # <tt>File.join</tt>.
+  #
+  def self.path( *args )
+    rv = args.empty? ? PATH : ::File.join(PATH, args.flatten)
+    if block_given?
+      begin
+        $LOAD_PATH.unshift PATH
+        rv = yield
+      ensure
+        $LOAD_PATH.shift
+      end
+    end
+    return rv
+  end
+
+  # Utility method used to require all files ending in .rb that lie in the
+  # directory below this file that has the same name as the filename passed
+  # in. Optionally, a specific _directory_ name can be passed in such that
+  # the _filename_ does not have to be equivalent to the directory.
+  #
+  def self.require_all_libs_relative_to( fname, dir = nil )
+    dir ||= ::File.basename(fname, '.*')
+    search_me = ::File.expand_path(
+        ::File.join(::File.dirname(fname), dir, '**', '*.rb'))
+
+    Dir.glob(search_me).sort.each {|rb| require rb}
+  end
+
+end
+
+Lossfully.require_all_libs_relative_to(__FILE__)
+

data/test/test_audio_file.rb

@@ -0,0 +1,47 @@
+require 'test/unit'
+
+$:.unshift File.dirname(__FILE__) + '/../lib'
+require 'lossfully'
+
+module TestLossfully
+  class TestAudioFile < Test::Unit::TestCase
+  
+    def test_encoding
+      assert_raise RuntimeError do Lossfully::AudioFile.encoding('test/data/this_file_does_not_exist') end
+      assert ! Lossfully::AudioFile.is_audio?('test/data/text.txt')
+      assert Lossfully::AudioFile.encoding('test/data/so_sad.ogg')
+    end
+    
+    def test_bitrate
+      assert_equal '114k', Lossfully::AudioFile.bitrate('test/data/so_sad.ogg')      
+    end
+
+    def test_bitrate_kbps
+      assert_equal 114, Lossfully::AudioFile.bitrate_kbps('test/data/so_sad.ogg')
+      assert_equal 2820, Lossfully::AudioFile.bitrate_kbps('test/data/so_sad.sox')
+    end
+
+    def test_duration
+      f = Lossfully::AudioFile.new('test/data/so_sad.ogg')      
+      assert_equal 6.047959, f.duration
+    end
+
+    def test_class_encode
+      input  = 'test/data/so_sad.flac'
+      output = 'test/data/so_sad.wav'
+      FileUtils.rm output if File.exist? output
+      Lossfully::AudioFile.encode input, output
+      assert_equal :wav, Lossfully::AudioFile.type(output)
+    end
+
+    def test_encode
+      input = 'test/data/so_sad.flac'
+      f = Lossfully::AudioFile.new input
+      output = 'test/data/so_sad.wav'
+      FileUtils.rm output if File.exist? output
+      f.encode output
+      assert_equal :wav, Lossfully::AudioFile.type(output)
+    end
+
+  end
+end

data/test/test_input_rules.rb

@@ -0,0 +1,125 @@
+require 'test/unit'
+
+$:.unshift File.dirname(__FILE__) + '/../lib'
+require 'lossfully'
+
+module TestLossfully
+  class TestInputRules < Test::Unit::TestCase
+  
+    def test_test
+      r1 = Lossfully::InputRules.new [:flac]
+      r2 = Lossfully::InputRules.new [:everything]
+      r2 = Lossfully::InputRules.new [:nonaudio]
+      f1 = 'test/data/text.txt'
+      assert !(r1.test f1)
+      assert r2.test f1
+
+      r1 = Lossfully::InputRules.new [:flac]
+      r2 = Lossfully::InputRules.new [:ogg]
+      r3 = Lossfully::InputRules.new [:everything]
+      r4 = Lossfully::InputRules.new [:lossy]
+      r5 = Lossfully::InputRules.new [:lossless]
+      r6 = Lossfully::InputRules.new [:audio]
+      r7 = Lossfully::InputRules.new [:nonaudio]
+      f1 = 'test/data/so_sad.flac'
+      f2 = 'test/data/so_sad.ogg'
+      assert r1.test f1
+      assert r2.test f2
+      assert r3.test f1
+      assert r3.test f2
+      assert r4.test f2
+      assert r5.test f1
+      assert r6.test f1
+      assert r6.test f2
+      assert ! (r4.test f1)
+      assert ! (r5.test f2)
+
+      r1 = Lossfully::InputRules.new [100]
+      r2 = Lossfully::InputRules.new [128]
+      f1 = 'test/data/so_sad.ogg'
+      assert r1.test f1
+      assert !(r2.test f1)      
+
+      r1 = Lossfully::InputRules.new ['.ogg']
+      r2 = Lossfully::InputRules.new ['.flac']
+      f1 = 'test/data/so_sad.ogg'
+      f2 = 'test/data/so_sad.flac'
+      assert r1.test f1
+      assert r2.test f2
+      assert !(r1.test f2)
+      assert !(r2.test f1)
+
+      r1 = Lossfully::InputRules.new [/sad/]
+      r2 = Lossfully::InputRules.new [/happy/]
+      f1 = Lossfully::AudioFile.new 'test/data/so_sad.ogg'
+      assert r1.test f1
+      assert !(r2.test f1)
+
+      r1 = Lossfully::InputRules.new do |f|
+        [:mp3] if File.dirname(f.path) == 'test/data' 
+      end
+      f1 = Lossfully::AudioFile.new 'test/data/so_sad.ogg'
+      assert r1.test f1
+      
+      r1 = Lossfully::InputRules.new [:ogg, 100] do |f|
+        [:mp3] if File.dirname(f.path) == 'test/data' 
+      end
+      assert r1.test f1
+
+      r1 = Lossfully::InputRules.new [:ogg, 128] do |f|
+        [:mp3] if File.dirname(f.path) == 'test/data' 
+      end
+      assert !(r1.test f1)
+    end
+
+    def test_comparison
+      r1 = Lossfully::InputRules.new [:mp3, /mp3/]
+      r2 = Lossfully::InputRules.new [:mp3, /mp3/]
+      r3 = Lossfully::InputRules.new [:mp3]
+      r4 = Lossfully::InputRules.new { false }
+      a = [r1]
+      assert a.include? r2
+      assert !(a.include? r3)
+      assert !(a.include? r4)
+
+      r1 = Lossfully::InputRules.new { false }
+      r2 = Lossfully::InputRules.new 
+      r3 = Lossfully::InputRules.new [:mp3, /regexp/, 192]
+      r4 = Lossfully::InputRules.new [:mp3, /regexp/, 192] do false end
+      assert r1 < r2
+      assert r3 < r1
+      assert r4 < r3
+
+      r1 = Lossfully::InputRules.new [:everything]
+      r2 = Lossfully::InputRules.new [:lossy]
+      r3 = Lossfully::InputRules.new [:lossless]
+      r4 = Lossfully::InputRules.new [:audio]
+      r5 = Lossfully::InputRules.new [:nonaudio]
+      assert r2 < r1
+      assert r3 < r1
+      assert r4 < r1
+      assert r5 < r1
+      assert r2 < r4
+      assert r3 < r4
+
+      r1 = Lossfully::InputRules.new ['']
+      r2 = Lossfully::InputRules.new ['ogg']
+      assert r2 < r1
+
+      r1 = Lossfully::InputRules.new [192]
+      r2 = Lossfully::InputRules.new [128]
+      assert r1 < r2
+
+      r1 = Lossfully::InputRules.new [//]
+      r2 = Lossfully::InputRules.new [/a/]
+      r3 = Lossfully::InputRules.new [/b/]
+      assert r2 < r1
+      assert_not_equal r2, r3
+
+      r1 = Lossfully::InputRules.new [:ogg, 192]
+      r2 = Lossfully::InputRules.new [:ogg, /a/]
+      assert r2 < r1
+    end
+
+  end
+end

data/test/test_thread_pool.rb

@@ -0,0 +1,77 @@
+require 'test/unit'
+
+$:.unshift File.dirname(__FILE__) + '/../lib'
+require 'lossfully'
+
+module TestLossfully
+  class TestThreadPool < Test::Unit::TestCase
+
+    def test_everything
+      a = [] 
+      tp = Lossfully::ThreadPool.new(2)
+      tp.max_size = 3
+      assert_equal 3, tp.max_size
+      tp.process { a << 1}
+      tp.process { a << 2 }
+      tp.process { a << 3 }
+      tp.join
+      assert a.include? 1
+      assert a.include? 2
+      assert a.include? 3
+    end
+
+    def test_everything_with_auto_blocks
+      a = []
+      tp = Lossfully::ThreadPool.new(2) do |x|
+        a << x
+      end
+      tp << 1
+      tp << 2
+      tp << 3
+      tp.join
+      assert a.include? 1
+      assert a.include? 2
+      assert a.include? 3
+    end
+
+    def test_stop
+      tp = Lossfully::ThreadPool.new(2) 
+      r1 = false
+      r2 = false
+      r3 = false
+
+      tp.process { sleep 0.3; r1 = true}
+      tp.process { sleep 0.3; r2 = true}
+      tp.process { sleep 0.3; r3 = true}
+      2.times { Thread.pass } and sleep 0.1
+      assert_equal 1, tp.queue_size 
+      assert_equal 2, tp.size
+      tp.stop
+      sleep 0.4
+
+      assert r1, 'first task finished'
+      assert r2, 'second task finished'
+      assert ! r3, 'third task did not finish'
+    end
+
+    def test_kill
+      tp = Lossfully::ThreadPool.new(2) 
+      r1 = false
+      r2 = false
+      r3 = false
+
+      tp.process { sleep 0.3; r1 = true}
+      tp.process { sleep 0.3; r2 = true}
+      tp.process { sleep 0.3; r3 = true}
+      2.times { Thread.pass } and sleep 0.1
+
+      tp.kill
+      sleep 0.4
+
+      assert ! r1, 'first task did not finished'
+      assert ! r2, 'second task did not finished'
+      assert ! r3, 'third task did not finish'
+    end
+
+  end
+end

data/version.txt

@@ -0,0 +1 @@
+0.0.0