tagfile 0.0.4

data/.gitignore

@@ -0,0 +1,3 @@
+*.swp
+Gemfile.lock
+*.gem

data/.rspec

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

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+gem 'taglib2'
+
+group :test do
+  gem 'rspec'
+end

data/LICENSE

@@ -0,0 +1,9 @@
+Copyright (C) 2012 Culley Smith
+
+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.
+
+Released under MIT License.

data/README.md

@@ -0,0 +1,83 @@
+TagFile
+=======
+
+TagFile is a simple Class for building objects from binary audio files.  It currently supports .flac, .mp3, & .ogg file formats.  Using the ultra-fast [TagLib2](http://rubygems.org/gems/taglib2), TagFile extracts embedded metadata and builds a hash from user-defined values.  This hash can be easily serialized and persisted in a database or document store.
+
+Example usage
+-------------
+
+```
+class Track < TagFile::Document
+  extract_tag_for :artist, :album
+end
+
+track = Track.new('valid_file.flac')
+track.tags => {artist: 'artist', album: 'album'}
+```
+
+Extractions
+-----------
+In order to build '#tags' you *must* specify which *tags* to use.  The following tags can be extracted: 
+
+Embedded tags (from TagLib2)
+
+* album
+* artist
+* genre
+* title
+* track
+* year
+
+Custom tags (from TagFile)
+
+* path
+* filename
+* format
+
+```
+class Track < TagFile::Document
+  extract_tag_for :artist
+
+  # extract_tag_for :artist, :path, :title
+  # extract_tag_for :all
+  # extract_tag_for :all, except: [:artist, :album]
+end
+```
+
+Verifications
+-------------
+
+TagFile includes several user-specified verifications.  While **path** and **format** have built-in verifications, format can be customized to verify a subset of formats.  Note: all valid TagFile objects will have a filename, length, path, and format attribute by default.
+
+```
+class Track < TagFile::Document
+  extract_tag_for :artist
+
+  verify_tag_for :artist
+end
+
+class Track < TagFile::Document
+  extract_tags_for :all
+
+  verify_tag_for :artist, :album
+  # verify_tag_for :all
+  # verify_tag_for :all, except: [:artist, :genre]
+  # verify_format_is :flac, :mp3
+end
+```
+
+Errors
+------
+
+With custom verifications in place, all errors are written to '#errors'.
+
+```
+class Track < TagFile::Document
+  extract_tag_for :artist
+  verify_tag_for  :artist
+  verify_format_is  :mp3
+end
+
+track = Track.new('missing_artist.flac')
+track.errors => ["Missing artist tag: missing_artist.flac", "File not of format :mp3: missing_artist.flac"]
+```

data/lib/tagfile.rb

@@ -0,0 +1,8 @@
+require 'tagfile/document'
+require 'tagfile/version'
+require 'taglib2'
+
+EMBEDDED_TAGS = [:album, :artist, :genre, :title, :track, :year]
+CUSTOM_TAGS = [:filename, :path, :format]
+
+ALL_TAGS = EMBEDDED_TAGS + CUSTOM_TAGS

data/lib/tagfile/document.rb

@@ -0,0 +1,22 @@
+require 'tagfile'
+require 'tagfile/extractor'
+require 'tagfile/verifier'
+
+module TagFile
+  class Document
+    include Extractor
+    include Verifier
+
+    attr_reader :path, :tags
+    attr_accessor :errors
+
+    def initialize(path)
+      @path = verify_presence_of(path)
+      @filename = File.basename(@path)
+      @format = verify_format_of(@path)
+      @taglib = TagLib::File.new(@path)
+      @tags = make_tag_attributes
+      @errors = run_all_verifications
+    end
+  end
+end

data/lib/tagfile/extractions.rb

@@ -0,0 +1,30 @@
+require 'tagfile'
+
+module Extractions
+  def extract_tag_for(*tags)
+    tags = build_list_of(tags)
+    tags.each { |tag| define_tag_method(tag) }
+  end
+
+  private
+  def define_tag_method(meth)
+    if EMBEDDED_TAGS.include?(meth)
+      define_embedded_tags(meth)
+    elsif CUSTOM_TAGS.include?(meth)
+      define_custom_tags(meth)
+    else
+      raise("Invalid tag: #{meth}")
+    end
+  end
+
+  def define_embedded_tags(meth)
+    define_method(meth) do
+      taglib = self.instance_variable_get('@taglib')
+      format_embedded_value(meth, taglib)
+    end
+  end
+
+  def define_custom_tags(meth)
+    define_method(meth) { self.instance_variable_get("@#{meth}") }
+  end
+end

data/lib/tagfile/extractor.rb

@@ -0,0 +1,37 @@
+require 'tagfile'
+require 'tagfile/extractions'
+require 'tagfile/shared'
+
+module TagFile
+  module Extractor
+    private
+    def make_tag_attributes
+      attrs = {}
+      self.class.instance_methods(false).sort.each {|a| attrs[a] = self.send(a) if ALL_TAGS.include?(a) }
+      attrs
+    end
+
+    def self.included(base)
+      base.extend(Extractions)
+      base.extend(Shared)
+    end
+
+    def format_embedded_value(meth, taglib)
+      sent = taglib.send(meth)
+      sanitized = remove_zeroes(meth, sent)
+      encoded = utf_encoded(sanitized)
+    end
+
+    def time_format(length)
+      Time.at(length).gmtime.strftime("%R:%S")
+    end
+
+    def remove_zeroes(meth, tag)
+      [:track, :year].include?(meth) && tag == 0 ? "" : tag
+    end
+
+    def utf_encoded(tag)
+      tag.to_s.force_encoding('UTF-8')
+    end
+  end
+end

data/lib/tagfile/shared.rb

@@ -0,0 +1,16 @@
+require 'tagfile'
+
+module Shared
+  private
+  def build_list_of(options)
+    all_tags = ALL_TAGS
+
+    if options == [:all]
+      options = all_tags
+    elsif options[0] == :all && options[1][:except]
+      options = all_tags - options[1][:except]
+    else
+      options
+    end
+  end
+end

data/lib/tagfile/verifications.rb

@@ -0,0 +1,19 @@
+require 'tagfile'
+
+module Verifications
+  def verify_tag_for(*tags)
+    tags = build_list_of(tags)
+    tags.each do |tag|
+      define_method "verify_tag_for_#{tag}" do
+        "Missing #{tag} tag: #{self.path}" if self.send(tag).empty?
+      end
+    end
+  end
+
+  def verify_format_is(*formats)
+    define_method "verify_format_is_#{formats}" do
+      format = self.instance_variable_get('@format').to_sym
+      "File is not of format #{formats}: #{self.path}" unless formats.include?(format)
+    end
+  end
+end

data/lib/tagfile/verifier.rb

@@ -0,0 +1,32 @@
+require 'tagfile'
+require 'tagfile/verifications'
+require 'tagfile/shared'
+
+module TagFile
+  module Verifier
+    private
+    def verify_presence_of(path)
+      raise("Path not found: #{path}") unless File.exists?(path)
+      path
+    end 
+
+    def verify_format_of(path)
+      format = File.extname(self.path).downcase.gsub(/\./,'')
+      formats = %w(flac mp3 ogg)
+      raise("Invalid file format: #{path} *valid formats: #{formats}") unless formats.include?(format)
+      format
+    end
+
+    def run_all_verifications
+      errs = []
+      verification_methods = self.methods.select {|meth| meth =~ /^verify_/}
+      verification_methods.each { |veri| errs << self.send(veri) }
+      errs.compact
+    end
+
+    def self.included(base)
+      base.extend(Verifications)
+      base.extend(Shared)
+    end
+  end
+end

data/lib/tagfile/version.rb

@@ -0,0 +1,3 @@
+module TagFile
+  VERSION = '0.0.4'
+end

data/spec/spec_helper.rb

@@ -0,0 +1,19 @@
+require 'tagfile/document'
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+end
+
+def create_document_with(attr)
+  Class.new(TagFile::Document){ extract_tag_for attr }
+end
+
+def verify_document_with(extracts, tags, formats)
+  Class.new(TagFile::Document) do 
+    extract_tag_for extracts
+    verify_tag_for tags
+    verify_format_is formats
+  end
+end

data/spec/tagfile/document_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+module TagFile
+  describe Document do
+    let(:path) { 'spec/files/valid_file.flac' }
+
+    subject { Document.new(path) }
+
+    it { should respond_to(:path) } 
+    it { should respond_to(:tags) } 
+
+    it { should respond_to(:errors) } 
+    its(:errors) { should == [] } 
+
+    its(:path) { should == path } 
+  end
+end

data/spec/tagfile/encoding_spec.rb

@@ -0,0 +1,20 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+
+describe "file with foreign characters" do
+  let(:document) { create_document_with(:all) }
+  subject { document.new(path) }
+
+  let(:album) { 'trancé' }
+  let(:artist) { 'trancé' }
+  let(:filename) { 'trancé (ft.) _.mp3' }
+  let(:path) { 'spec/files/trancé (ft.) _.mp3' }
+  let(:title) { 'trancé' }
+
+  its(:album) { should == album }
+  its(:artist) { should == artist }
+  its(:filename) { should == filename }
+  its(:path) { should == path }
+  its(:title) { should == title }
+end

data/spec/tagfile/extractor_spec.rb

@@ -0,0 +1,99 @@
+require 'spec_helper'
+
+module TagFile
+  describe Extractor do
+    context "class methods" do
+      let(:document) { create_document_with(:all) }
+      subject { document }
+
+      it { should respond_to(:extract_tag_for) } 
+    end
+
+    describe "#extract_tags_for" do
+      subject { document.new(path) }
+
+      let(:album) { 'Llama Album' }
+      let(:artist) { 'Llama Artist' }
+      let(:filename) { 'valid_file.flac' }
+      let(:genre) { 'Llama Genre' }
+      let(:path) { 'spec/files/valid_file.flac' }
+      let(:title) { 'Llama Title' }
+      let(:track) { '1' }
+      let(:format) { 'flac' }
+      let(:year) { '2012' }
+      let(:all) { { album: album,
+        artist: artist,
+        filename: filename,
+        genre: genre,
+        path: path,
+        title: title,
+        track: track,
+        format: format,
+        year: year
+      } }
+
+      context "embedded" do
+        let(:document) { create_document_with(:artist) }
+
+        it { should respond_to(:artist) }
+        its(:artist) { should == artist }
+        its(:tags) { should == {artist: artist} }
+      end
+
+      context "custom" do
+        let(:document) { create_document_with(:path) }
+
+        it { should respond_to(:path) }
+        its(:path) { should == path }
+        its(:tags) { should == {path: path} }
+      end
+
+      context ":all" do
+        let(:document) { create_document_with(:all) }
+
+        it { should respond_to(:album) }
+        it { should respond_to(:artist) }
+        it { should respond_to(:filename) }
+        it { should respond_to(:genre) }
+        it { should respond_to(:path) }
+        it { should respond_to(:title) }
+        it { should respond_to(:track) }
+        it { should respond_to(:format) }
+        it { should respond_to(:year) }
+
+        its(:album) { should == album }
+        its(:artist) { should == artist }
+        its(:filename) { should == filename }
+        its(:genre) { should == genre }
+        its(:path) { should == path }
+        its(:title) { should == title }
+        its(:track) { should == track }
+        its(:format) { should == format }
+        its(:year) { should == year }
+        its(:tags) { should == all }
+      end
+
+      context ":all, except: [:path, :genre]" do
+        let(:document) { Class.new(TagFile::Document) { extract_tag_for :all, except: [:genre, :path] } }
+
+        its(:tags) { should == { artist: artist,
+          album: album,
+          filename: filename,
+          title: title,
+          track: track,
+          format: format,
+          year: year
+        } }
+      end
+
+      context "raise errors" do
+        it "invalid tag" do
+          expect{
+            document = create_document_with(:none)
+            document.new(path)
+          }.to raise_error("Invalid tag: none")
+        end
+      end
+    end
+  end
+end

data/spec/tagfile/verifier_spec.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+
+module TagFile
+  describe Verifier do
+    let(:document) { Class.new(TagFile::Document) }
+    let(:path) { 'spec/files/valid_file.flac' }
+
+    subject { document }
+
+    it { should respond_to(:verify_tag_for).with(1).argument }
+
+    describe "raise error" do
+      it "path not found" do
+        @bad_path = "bad path"
+        expect{
+          Document.new(@bad_path)
+        }.to raise_error("Path not found: #{@bad_path}")
+      end
+
+      it "invalid file format" do
+        @bad_format = 'spec/files/invalid_file_format.txt'
+        expect{
+          Document.new(@bad_format)
+        }.to raise_error("Invalid file format: #{@bad_format} *valid formats: [\"flac\", \"mp3\", \"ogg\"]")
+      end
+
+      describe "verify_tag_for errors" do
+        let(:missing_artist) { 'spec/files/missing_artist.flac' }
+        let(:missing_all) { 'spec/files/missing_all.flac' }
+
+        context "missing artist" do
+          let(:document) { verify_document_with(:artist, :artist, :flac) }
+          subject { document.new(missing_artist) }
+
+          its(:errors) { should == ["Missing artist tag: #{missing_artist}"] }
+
+          it "tags should not include verify_tag_for errors" do
+            subject.tags.
+              should_not include(:verify_tag_for_artist=>["Missing artist tag: #{missing_artist}"])
+          end
+        end
+
+        context ":all" do
+          let(:document) { verify_document_with(:all, :all, :flac) }
+          subject { document.new(missing_all) }
+
+          its(:errors) { should include("Missing album tag: #{missing_all}") }
+          its(:errors) { should include("Missing artist tag: #{missing_all}") }
+          its(:errors) { should include("Missing genre tag: #{missing_all}") }
+          its(:errors) { should include("Missing title tag: #{missing_all}") }
+          its(:errors) { should include("Missing track tag: #{missing_all}") }
+          its(:errors) { should include("Missing year tag: #{missing_all}") }
+        end
+
+        it ":all, except: [:artist, :album]" do
+          document = Class.new(TagFile::Document) do
+            extract_tag_for :all
+            verify_tag_for :all, except: [:artist]
+          end
+          new = document.new(missing_all)
+
+          new.errors.should_not include("Missing artist tag: #{missing_all}")
+        end
+      end
+
+      describe "verify_format_is" do
+        let(:document) { verify_document_with(:artist, :artist, :flac) }
+        let(:mp3) { 'spec/files/valid_file.mp3' }
+
+        context "not flac" do
+          subject { document.new(mp3) }
+
+          its(:errors) { should include("File is not of format [:flac]: #{mp3}") }
+        end
+
+        context "is flac" do
+          subject { document.new(path) }
+
+          it "format" do
+            puts subject.instance_variable_get('@format')
+          end
+          its(:errors) { should_not include("File is not of format [:flac]: #{path}") }
+        end
+      end
+    end
+  end
+end

data/tagfile.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib/', __FILE__)
+$:.unshift lib unless $:.include?(lib)
+
+require 'tagfile'
+
+Gem::Specification.new do |s|
+  s.name        = 'tagfile'
+  s.version     = TagFile::VERSION
+  s.authors     = ["Culley Smith"]
+  s.email       = ["culley.smith@gmail.com"]
+  s.homepage    = %q{http://madcasts.com}
+  s.summary     = %q{A library for extracting tags from binary files.}
+  s.description = %q{TagFile is a simple Class for building objects from binary audio files. It currently supports .flac, .mp3, & .ogg file formats.}
+
+  s.required_ruby_version     = '>= 1.9.3'
+  s.required_rubygems_version = '>= 1.3.6'
+
+  s.add_dependency 'taglib2', '~> 0.1.5'
+  s.add_development_dependency 'rspec', '~> 2.0'
+
+  git_files            = `git ls-files -z`.split("\0") rescue ''
+  s.files              = git_files
+  s.test_files         = `git ls-files -z -- {test,spec,features}/*`.split("\0")
+  s.require_paths      = ['lib']
+end

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification
+name: tagfile
+version: !ruby/object:Gem::Version
+  version: 0.0.4
+  prerelease: 
+platform: ruby
+authors:
+- Culley Smith
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-07-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: taglib2
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.1.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.1.5
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: TagFile is a simple Class for building objects from binary audio files.
+  It currently supports .flac, .mp3, & .ogg file formats.
+email:
+- culley.smith@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE
+- README.md
+- lib/tagfile.rb
+- lib/tagfile/document.rb
+- lib/tagfile/extractions.rb
+- lib/tagfile/extractor.rb
+- lib/tagfile/shared.rb
+- lib/tagfile/verifications.rb
+- lib/tagfile/verifier.rb
+- lib/tagfile/version.rb
+- spec/files/invalid_file_format.txt
+- spec/files/missing_all.flac
+- spec/files/missing_artist.flac
+- spec/files/trancé (ft.) _.mp3
+- spec/files/valid_file.flac
+- spec/files/valid_file.mp3
+- spec/spec_helper.rb
+- spec/tagfile/document_spec.rb
+- spec/tagfile/encoding_spec.rb
+- spec/tagfile/extractor_spec.rb
+- spec/tagfile/verifier_spec.rb
+- tagfile.gemspec
+homepage: http://madcasts.com
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.21
+signing_key: 
+specification_version: 3
+summary: A library for extracting tags from binary files.
+test_files:
+- spec/files/invalid_file_format.txt
+- spec/files/missing_all.flac
+- spec/files/missing_artist.flac
+- spec/files/trancé (ft.) _.mp3
+- spec/files/valid_file.flac
+- spec/files/valid_file.mp3
+- spec/spec_helper.rb
+- spec/tagfile/document_spec.rb
+- spec/tagfile/encoding_spec.rb
+- spec/tagfile/extractor_spec.rb
+- spec/tagfile/verifier_spec.rb
+has_rdoc: