typingpool 0.7.0 → 0.7.1

data/lib/typingpool/app/cli/formatter.rb

@@ -0,0 +1,16 @@
+module Typingpool
+  module App
+    module CLI
+      module Formatter
+        require 'highline/import'
+        def cli_bold(text)
+          HighLine.color(text, :bold)
+        end
+
+        def cli_reverse(text)
+          HighLine.color(text, :reverse)
+        end
+      end #Formatter
+    end #CLI
+  end #App
+end #Typingpool

data/lib/typingpool/app/cli.rb

@@ -0,0 +1,64 @@
+module Typingpool
+  module App
+    module CLI
+      class << self
+        include App::FriendlyExceptions
+
+        #Optionally takes an ostensible path to a config file, as passed
+        #as a command-line option. Checks to make sure the file exists;
+        #returns nil if does not, returns a Config instance if it
+        #does. If no path is passed, the default config file is returned
+        #(as retrieved by Config.file with no args).
+        def config_from_arg(arg=nil)
+          if arg
+            path = File.expand_path(arg)
+            return unless File.exists?(path) && File.file?(path)
+            Config.file(path)
+          else
+            Config.file
+          end #if option
+        end
+
+        #Outputs a friendly explanation of the --help option for
+        #appending to script usage banners.
+        def help_arg_explanation
+          "`#{File.basename($PROGRAM_NAME)} --help` for more information."
+        end
+
+        #Converts a user arg into a Project instance, setting up or
+        #consulting a Config along the way.
+        # ==== Params
+        # [arg]    A user-supplied argument specifying either an absolute
+        #          path to a Project folder (Project#local) or the
+        #          name of a project folder within
+        #          [config]#transcripts.
+        # [config] A Config instance. If [arg] is an absolute path,
+        #          will be modified -- Config#itranscripts will be
+        #          changed to match the implied transcripts dir.
+        # ==== Errors
+        # Will abort with a friendly message on any errors.
+        # ==== Returns
+        # A Project instance.
+        def project_from_arg_and_config(arg, config)
+          path = if (File.exists?(arg) && File.directory?(arg))
+                   config.transcripts = File.dirname(arg)
+                   arg
+                 else
+                   abort "No 'transcripts' dir specified in your config file and '#{arg}' is not a valid path" unless config.transcripts
+                   path = File.join(config.transcripts, arg)
+                   abort "No such project '#{arg}' in dir '#{config.transcripts}'" unless File.exists? path
+                   abort "'#{arg}' is not a directory at '#{path}'" unless File.directory? path
+                   path
+                 end
+          project = with_friendly_exceptions('project name', File.basename(path)) do 
+            Typingpool::Project.new(File.basename(path), config)
+          end
+          abort "Not a project directory at '#{path}'" unless project.local
+          project
+        end
+
+      end #class << self
+      require 'typingpool/app/cli/formatter'
+    end #CLI
+  end #App
+end #Typingpool

data/lib/typingpool/app/friendlyexceptions.rb

@@ -0,0 +1,34 @@
+module Typingpool
+  module App
+    module FriendlyExceptions
+
+      #Massages terse exceptions from our model layer into a
+      #human-friendly message suitable for an abort message from a
+      #command-line script.
+      # ==== Params
+      # [name]   A string used to refer to the input. For example
+      #          'project title' or '--config argument'. Used in the
+      #          goodbye message.
+      # [*input] One or more values. The user input that will cause
+      #          any exceptions. Used in the goodbye message.
+      # [&block] The block to execute and monitor for
+      #          exceptions. Will be passed [*input].
+      # ==== Errors
+      # Will abort with a friendly message on any exception of the
+      # type Typingpool::Error::Argument.
+      # ==== Returns
+      # The return value of &block.
+      def with_friendly_exceptions(name, *input)
+        begin
+          yield(*input)
+        rescue Typingpool::Error::Argument => exception
+          goodbye = "Could not make sense of #{name.to_s} "
+          goodbye += input.map{|input| "'#{input}'" }.join(', ')
+          goodbye += ". #{exception.message}"
+          goodbye += '.' unless goodbye.match(/\.$/)
+          abort goodbye
+        end #begin
+      end
+    end #FriendlyExceptions
+  end #App
+end #Typingpool

data/lib/typingpool/app.rb

@@ -533,102 +533,7 @@ module Typingpool
         end #assignments.each!...
       end
     end #class << self
-    module FriendlyExceptions
-      #Massages terse exceptions from our model layer into a
-      #human-friendly message suitable for an abort message from a
-      #command-line script.
-      # ==== Params
-      # [name]   A string used to refer to the input. For example
-      #          'project title' or '--config argument'. Used in the
-      #          goodbye message.
-      # [*input] One or more values. The user input that will cause
-      #          any exceptions. Used in the goodbye message.
-      # [&block] The block to execute and monitor for
-      #          exceptions. Will be passed [*input].
-      # ==== Errors
-      # Will abort with a friendly message on any exception of the
-      # type Typingpool::Error::Argument.
-      # ==== Returns
-      # The return value of &block.
-      def with_friendly_exceptions(name, *input)
-        begin
-          yield(*input)
-        rescue Typingpool::Error::Argument => exception
-          goodbye = "Could not make sense of #{name.to_s} "
-          goodbye += input.map{|input| "'#{input}'" }.join(', ')
-          goodbye += ". #{exception.message}"
-          goodbye += '.' unless goodbye.match(/\.$/)
-          abort goodbye
-        end #begin
-      end
-    end #FriendlyExceptions
-    module CLI
-      class << self
-        include App::FriendlyExceptions
-        #Optionally takes an ostensible path to a config file, as passed
-        #as a command-line option. Checks to make sure the file exists;
-        #returns nil if does not, returns a Config instance if it
-        #does. If no path is passed, the default config file is returned
-        #(as retrieved by Config.file with no args).
-        def config_from_arg(arg=nil)
-          if arg
-            path = File.expand_path(arg)
-            return unless File.exists?(path) && File.file?(path)
-            Config.file(path)
-          else
-            Config.file
-          end #if option
-        end
-
-        #Outputs a friendly explanation of the --help option for
-        #appending to script usage banners.
-        def help_arg_explanation
-          "`#{File.basename($PROGRAM_NAME)} --help` for more information."
-        end
-
-        #Converts a user arg into a Project instance, setting up or
-        #consulting a Config along the way.
-        # ==== Params
-        # [arg]    A user-supplied argument specifying either an absolute
-        #          path to a Project folder (Project#local) or the
-        #          name of a project folder within
-        #          [config]#transcripts.
-        # [config] A Config instance. If [arg] is an absolute path,
-        #          will be modified -- Config#itranscripts will be
-        #          changed to match the implied transcripts dir.
-        # ==== Errors
-        # Will abort with a friendly message on any errors.
-        # ==== Returns
-        # A Project instance.
-        def project_from_arg_and_config(arg, config)
-          path = if (File.exists?(arg) && File.directory?(arg))
-                   config.transcripts = File.dirname(arg)
-                   arg
-                 else
-                   abort "No 'transcripts' dir specified in your config file and '#{arg}' is not a valid path" unless config.transcripts
-                   path = File.join(config.transcripts, arg)
-                   abort "No such project '#{arg}' in dir '#{config.transcripts}'" unless File.exists? path
-                   abort "'#{arg}' is not a directory at '#{path}'" unless File.directory? path
-                   path
-                 end
-          project = with_friendly_exceptions('project name', File.basename(path)) do 
-            Typingpool::Project.new(File.basename(path), config)
-          end
-          abort "Not a project directory at '#{path}'" unless project.local
-          project
-        end
-
-      end #class << self
-      module Formatter
-        require 'highline/import'
-        def cli_bold(text)
-          HighLine.color(text, :bold)
-        end
-
-        def cli_reverse(text)
-          HighLine.color(text, :reverse)
-        end
-      end #Formatter
-    end #CLI
+    require 'typingpool/app/friendlyexceptions'
+    require 'typingpool/app/cli'
   end #App
 end #Typingpool

data/lib/typingpool/config/root.rb

@@ -0,0 +1,114 @@
+module Typingpool
+  class Config    
+
+    #The root level of the config file and all full config
+    #objects. Kept distinct from Config because other subclasses need
+    #to inherit from Config, and we don't want them inheriting the
+    #root level fields.
+    class Root < Config
+      local_path_reader :transcripts, :cache, :templates
+
+      class SFTP < Config
+        never_ends_in_slash_reader :path, :url
+      end
+
+      class Amazon < Config
+        never_ends_in_slash_reader :url
+      end
+
+      class Assign < Config
+        local_path_reader :templates
+        time_accessor :deadline, :approval, :lifetime
+
+        define_accessor(:reward) do |value|
+          value.to_s.match(/(\d+(\.\d+)?)|(\d*\.\d+)/) or raise Error::Argument::Format, "Format should be N.NN"
+          value
+        end
+
+        define_reader(:confirm) do |value|
+          next false if value.to_s.match(/(^n)|(^0)|(^false)/i)
+          next true if value.to_s.match(/(^y)|(^1)|(^true)/i)
+          next if value.to_s.empty?
+          raise Error::Argument::Format, "Format should be 'yes' or 'no'"
+        end
+
+        def qualify
+          self.qualify = (@param['qualify'] || []) unless @qualify
+          @qualify
+        end
+
+        def qualify=(specs)
+          @qualify = specs.map{|spec| Qualification.new(spec) }
+        end
+
+        def add_qualification(spec)
+          self.qualify.push(Qualification.new(spec))
+        end
+
+        def keywords
+          @param['keywords'] ||= []
+        end
+
+        def keywords=(array)
+          @param['keywords'] = array
+        end
+
+        class Qualification < Config
+          def initialize(spec)
+            @raw = spec
+            to_arg #make sure value parses
+          end
+
+          def to_s
+            @raw
+          end
+
+          def to_arg
+            [type, opts]
+          end
+
+          protected
+
+          def type
+            type = @raw.split(/\s+/)[0]
+            if RTurk::Qualification::TYPES[type.to_sym]
+              return type.to_sym
+            elsif (type.match(/\d/) || type.size >= 25)
+              return type
+            else
+              #Seems likely to be qualification typo: Not a known
+              #system qualification, all letters and less than 25
+              #chars
+              raise Error::Argument, "Unknown qualification type and does not appear to be a raw qualification type ID: '#{type.to_s}'"
+            end 
+          end
+
+          def opts
+            args = @raw.split(/\s+/)
+            if (args.count > 3) || (args.count < 2)
+              raise Error::Argument, "Unexpected number of qualification tokens: #{@raw}"
+            end
+            args.shift
+            comparator(args[0]) or raise Error::Argument, "Unknown comparator '#{args[0]}'"
+            value = 1
+            value = args[1] if args.count == 2
+            return {comparator(args[0]) => value}
+          end
+
+          def comparator(value)
+            Hash[
+                 '>' => :gt,
+                 '>=' => :gte,
+                 '<' => :lt,
+                 '<=' => :lte,
+                 '==' => :eql,
+                 '!=' => :not,
+                 'true' => :eql,
+                 'exists' => :exists
+                ][value]
+          end
+        end #Qualification
+      end #Assign
+    end #Root
+  end #Config
+end #Typingpool

data/lib/typingpool/config.rb

@@ -99,9 +99,9 @@ module Typingpool
   #  conf.sftp.url = 'http://luvrecording.s3.amazonaws.com/'
   #  puts conf.sftp.url #'http://luvrecording.s3.amazonaws.com'
   #
-  class Config
-    
+  class Config    
     require 'yaml'
+
     @@default_file = "~/.typingpool"
 
     def initialize(params)
@@ -158,29 +158,32 @@ module Typingpool
         end
       end
 
-      def define_reader(*syms)
+      def define_reader(*syms, &block)
+        #explicit block passing to avoid sefault in 1.9.3-p362
         syms.each do |sym|
           define_method(sym) do
             value = @param[sym.to_s]
-            yield(value)
+            block.call(value)
           end
         end
       end
 
-      def define_writer(*syms)
+      def define_writer(*syms, &block)
+        #explicit block passing to avoid sefault in 1.9.3-p362
         syms.each do |sym|
           define_method("#{sym.to_s}=".to_sym) do |value|
-            @param[sym.to_s] = yield(value)
+            @param[sym.to_s] = block.call(value)
           end
         end
       end
 
-      def define_accessor(*syms)
+      def define_accessor(*syms, &block)
+        #explicit block passing to avoid sefault in 1.9.3-p362
         define_reader(*syms) do |value|
-          yield(value) if value
+          block.call(value) if value
         end
         define_writer(*syms) do |value|
-          yield(value)
+          block.call(value)
         end
       end
 
@@ -230,115 +233,6 @@ module Typingpool
       match = meth.to_s.match(/([^=]+)=$/) or return
       return match[1]
     end
-
-    #The root level of the config file and all full config
-    #objects. Kept distinct from Config because other subclasses need
-    #to inherit from Config, and we don't want them inheriting the
-    #root level fields.
-    class Root < Config
-      local_path_reader :transcripts, :cache, :templates
-
-      class SFTP < Config
-        never_ends_in_slash_reader :path, :url
-      end
-
-      class Amazon < Config
-        never_ends_in_slash_reader :url
-      end
-
-      class Assign < Config
-        local_path_reader :templates
-        time_accessor :deadline, :approval, :lifetime
-
-        define_accessor(:reward) do |value|
-          value.to_s.match(/(\d+(\.\d+)?)|(\d*\.\d+)/) or raise Error::Argument::Format, "Format should be N.NN"
-          value
-        end
-
-        define_reader(:confirm) do |value|
-          next false if value.to_s.match(/(^n)|(^0)|(^false)/i)
-          next true if value.to_s.match(/(^y)|(^1)|(^true)/i)
-          next if value.to_s.empty?
-          raise Error::Argument::Format, "Format should be 'yes' or 'no'"
-        end
-
-        def qualify
-          self.qualify = (@param['qualify'] || []) unless @qualify
-          @qualify
-        end
-
-        def qualify=(specs)
-          @qualify = specs.map{|spec| Qualification.new(spec) }
-        end
-
-        def add_qualification(spec)
-          self.qualify.push(Qualification.new(spec))
-        end
-
-        def keywords
-          @param['keywords'] ||= []
-        end
-
-        def keywords=(array)
-          @param['keywords'] = array
-        end
-
-        class Qualification < Config
-          def initialize(spec)
-            @raw = spec
-            to_arg #make sure value parses
-          end
-
-          def to_s
-            @raw
-          end
-
-          def to_arg
-            [type, opts]
-          end
-
-          protected
-
-          def type
-            type = @raw.split(/\s+/)[0]
-            if RTurk::Qualification::TYPES[type.to_sym]
-              return type.to_sym
-            elsif (type.match(/\d/) || type.size >= 25)
-              return type
-            else
-              #Seems likely to be qualification typo: Not a known
-              #system qualification, all letters and less than 25
-              #chars
-              raise Error::Argument, "Unknown qualification type and does not appear to be a raw qualification type ID: '#{type.to_s}'"
-            end 
-          end
-
-          def opts
-            args = @raw.split(/\s+/)
-            if (args.count > 3) || (args.count < 2)
-              raise Error::Argument, "Unexpected number of qualification tokens: #{@raw}"
-            end
-            args.shift
-            comparator(args[0]) or raise Error::Argument, "Unknown comparator '#{args[0]}'"
-            value = 1
-            value = args[1] if args.count == 2
-            return {comparator(args[0]) => value}
-          end
-
-          def comparator(value)
-            Hash[
-                 '>' => :gt,
-                 '>=' => :gte,
-                 '<' => :lt,
-                 '<=' => :lte,
-                 '==' => :eql,
-                 '!=' => :not,
-                 'true' => :eql,
-                 'exists' => :exists
-                ][value]
-          end
-        end #Qualification
-      end #Assign
-    end #Root
   end #Config
+    require 'typingpool/config/root'
 end #Typingpool

data/lib/typingpool/filer/audio.rb

@@ -0,0 +1,84 @@
+module Typingpool
+  class Filer
+
+    #Convenience wrapper for audio files.You can convert to mp3s,
+    #split into multiple files, and dynamically read the bitrate.
+    class Audio < Filer
+      require 'open3'
+
+      #Does the file have a '.mp3' extension?
+      def mp3?
+        File.extname(@path).downcase.eql?('.mp3')
+      end
+
+      #Convert to mp3 via ffmpeg. 
+      # ==== Params
+      # [dest]    Filer object corresponding to the path the mp3 version
+      #           should end up at.
+      # [bitrate] If passed, bitrate should be an integer
+      #           corresponding to kb/s. If not, we use the bitrate
+      #           from the current file or, if that can't be read,
+      #           default to 192kbps. Does not check if the file is
+      #           already an mp3. Returns a new Filer::Audio
+      #           representing the new mp3 file.
+      # ==== Returns
+      # Filer::Audio containing the new mp3.
+      def to_mp3(dest=self.dir.file("#{File.basename(@path, '.*') }.mp3"), bitrate=nil)
+        bitrate ||= self.bitrate || 192
+        Utility.system_quietly('ffmpeg', '-i', @path, '-acodec', 'libmp3lame', '-ab', "#{bitrate}k", '-ac', '2', dest)
+        File.exists?(dest) or raise Error::Shell, "Could not found output from `ffmpeg` on #{path}"
+        self.class.new(dest.path)
+      end
+
+      #Reads the bitrate of the audio file via ffmpeg. Returns an
+      #integer corresponding to kb/s, or nil if the bitrate could not
+      #be determined.
+      def bitrate
+        out, err, status = Open3.capture3('ffmpeg', '-i', @path)
+        bitrate = err.match(/(\d+) kb\/s/)
+        return bitrate ? bitrate[1].to_i : nil
+      end
+
+      #Splits an mp3 into smaller files. 
+      # ==== Params
+      # [interval_in_min_dot_seconds] Split the file into chunks this
+      #             large. The interval should be of the format
+      #             minute.seconds, for example 2 minutes 15 seconds
+      #             would be written as "2.15". For further details on
+      #             interval format, consult the documentation for
+      #             mp3split, a command-line unix utility.
+      # [basename]  Name the new chunks using this base. Default is the
+      #             basename of the original file.
+      # [dest]      Destination directory for the new chunks as a
+      #             Filer::Dir. Default is the same directory as the
+      #             original file.
+      # ==== Returns
+      # Filer::Files containing the new files.
+      def split(interval_in_min_dot_seconds, basename=File.basename(path, '.*'), dest=dir)
+        #We have to cd into the wrapfile directory and do everything
+        #there because old/packaged versions of mp3splt were
+        #retarded at handling absolute directory paths
+        ::Dir.chdir(dir.path) do
+          Utility.system_quietly('mp3splt', '-t', interval_in_min_dot_seconds, '-o', "#{basename}.@m.@s", File.basename(path)) 
+        end
+        files = Filer::Files::Audio.new(dir.select{|file| File.basename(file.path).match(/^#{Regexp.escape(basename) }\.\d+\.\d+\.mp3$/) })
+        if files.to_a.empty?
+          raise Error::Shell, "Could not find output from `mp3splt` on #{path}"
+        end
+        if dest.path != dir.path
+          files.mv!(dest)
+        end
+        files.sort
+      end
+
+      #Extracts from the filename the offset time of the chunk
+      #relative to the original from which it was split. Format is
+      #minute.seconds. Suitable for use on files created by 'split'
+      #method.
+      def offset
+        match = File.basename(@path).match(/\d+\.\d\d\b/)
+        return match[0] if match
+      end
+    end #Audio
+  end #Filer
+end #Typingpool

data/lib/typingpool/filer/csv.rb

@@ -0,0 +1,57 @@
+module Typingpool
+  class Filer
+
+    #Convenience wrapper for CSV files. Makes them Enumerable, so you
+    #can iterate through rows with each, map, select, etc. You can
+    #also modify in place with each!. See Filer base class for other
+    #methods.
+    class CSV < Filer
+      include Enumerable
+      require 'csv'
+
+      #Reads into an array of hashes, with hash keys determined by the
+      #first row of the CSV file. Parsing rules are the default for
+      #CSV.parse.
+      def read
+        raw = super or return []
+        rows = ::CSV.parse(raw.to_s)
+        headers = rows.shift or raise Error::File, "No CSV at #{@path}"
+        rows.map{|row| Utility.array_to_hash(row, headers) }
+      end
+
+      #Takes array of hashes followed by optional list of keys (by
+      #default keys are determined by looking at all the
+      #hashes). Lines are written per the defaults of
+      #CSV.generate_line.
+      def write(hashes, headers=hashes.map{|h| h.keys}.flatten.uniq)
+        super(
+              ::CSV.generate_line(headers, :encoding => @encoding) + 
+              hashes.map do |hash|
+                ::CSV.generate_line(headers.map{|header| hash[header] }, :encoding => @encoding)
+              end.join
+              )
+      end
+
+      #Takes an array of arrays, corresponding to the rows, and a list
+      #of headers/keys to write at the top.
+      def write_arrays(arrays, headers)
+        write(arrays.map{|array| Utility.array_to_hash(array, headers) }, headers)
+      end
+
+      #Enumerate through the rows, with each row represented by a
+      #hash.
+      def each
+        read.each do |row|
+          yield row
+        end
+      end
+
+      #Same as each, but any changes to the rows will be written back
+      #out to the underlying CSV file.
+      def each!
+        #each_with_index doesn't return the array, so we have to use each
+        write(each{|hash| yield(hash) })
+      end
+    end #CSV
+  end #Filer
+end #Typingpool