musicbrainz 0.7.1 → 0.7.2

data/Rakefile

@@ -1,13 +0,0 @@
-#!/usr/bin/env rake
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
-
-RSpec::Core::RakeTask.new("spec")
-
-task :default => :spec
-task :test => :spec
-
-desc "Open an irb session preloaded with this library"
-task :console do
-  sh "irb -rubygems -I lib -r musicbrainz.rb"
-end

data/lib/deprecated.rb

@@ -1,25 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-module MusicBrainz
-  class << self
-    def query_interval
-      $stdout.send :puts, "WARNING! MusicBrainz.query_interval is deprecated. Use MusicBrainz::Tools::Proxy.query_interval"
-      MusicBrainz::Tools::Proxy.query_interval
-    end
-
-    def query_interval=(sec)
-      $stdout.send :puts, "WARNING! MusicBrainz.query_interval= is deprecated. Use MusicBrainz::Tools::Proxy.query_interval"
-      MusicBrainz::Tools::Proxy.query_interval = sec
-    end
-
-    def cache_path
-      $stdout.send :puts, "WARNING! MusicBrainz.cache_path is deprecated. Use MusicBrainz::Tools::Cache.cache_path"
-      MusicBrainz::Tools::Cache.cache_path
-    end
-
-    def cache_path=(path)
-      $stdout.send :puts, "WARNING! MusicBrainz.cache_path= is deprecated. Use MusicBrainz::Tools::Cache.cache_path"
-      MusicBrainz::Tools::Cache.cache_path = path
-    end
-  end
-end

data/lib/musicbrainz/artist.rb

@@ -1,63 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-module MusicBrainz
-  class Artist < Base
-
-    field :id, String
-    field :type, String
-    field :name, String
-    field :country, String
-    field :date_begin, Time
-    field :date_end, Time
-    field :urls, Hash
-
-    def release_groups
-      @release_groups ||= nil
-      if @release_groups.nil? and !id.nil?
-        @release_groups = self.class.load({
-          :parser => :artist_release_groups,
-          :create_models => MusicBrainz::ReleaseGroup
-        }, {
-          :resource => :release_group,
-          :artist => id
-        })
-        @release_groups.sort!{ |a, b| a.first_release_date <=> b.first_release_date }
-      end
-      @release_groups
-    end
-
-    class << self
-      def find(mbid)
-        load({
-          :parser => :artist_model,
-          :create_model => MusicBrainz::Artist
-        }, {
-          :resource => :artist,
-          :id => mbid,
-          :inc => [:url_rels]
-        })
-      end
-
-      def search(name)
-        load({
-          :parser => :artist_search
-        }, {
-          :resource => :artist,
-          :query => "artist:" << CGI.escape(name).gsub(/\!/, '\!'),
-          :limit => 10
-        })
-      end
-
-      def discography(mbid)
-        artist = find(mbid)
-        artist.release_groups.each { |rg| rg.releases.each { |r| r.tracks } }
-        artist
-      end
-
-      def find_by_name(name)
-        matches = search(name)
-        matches.length.zero? ? nil : find(matches.first[:mbid])
-      end
-    end
-  end
-end

data/lib/musicbrainz/base.rb

@@ -1,71 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-module MusicBrainz
-  class Base
-    class << self
-      def field(name, type)
-        @fields ||= {}
-        @fields[name] = type
-
-        define_method(name) {
-          instance_variable_get("@#{name}")
-        }
-        define_method("#{name}=") { |val|
-          instance_variable_set("@#{name}", validate_type(val, type))
-        }
-      end
-
-      def load(params, query)
-        parser = MusicBrainz::Parsers.get_by_name(params[:parser])
-        xml = MusicBrainz::Tools::Proxy.query(query)
-        result = parser[:const].send(parser[:method], Nokogiri::XML(xml))
-        if params[:create_model]
-          result_model = params[:create_model].new
-          result.each { |field, value|
-            result_model.send("#{field}=".to_sym, value)
-          }
-          result_model
-        elsif params[:create_models]
-          result_models = []
-          result.each { |item|
-            result_model = params[:create_models].new
-            item.each { |field, value|
-              result_model.send("#{field}=".to_sym, value)
-            }
-            result_models << result_model
-          }
-          result_models
-        else
-          result
-        end
-      end
-    end
-
-    def initialize
-      self.class.instance_variable_get("@fields").each { |name, type|
-        instance_variable_set("@#{name}", nil)
-      }
-    end
-
-    def validate_type(val, type)
-      if type == Integer
-        val.to_i
-      elsif type == Float
-        val.to_f
-      elsif type == String
-        val.to_s
-      elsif type == Time
-        if val.nil? or val == ""
-          val = "2030-12-31"
-        elsif val.split("-").length == 1
-          val << "-12-31"
-        elsif val.split("-").length == 2
-          val << "-31"
-        end
-        Time.utc(*val.split("-"))
-      else
-        val
-      end
-    end
-  end
-end

data/lib/musicbrainz/release.rb

@@ -1,43 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-module MusicBrainz
-  class Release < Base
-
-    field :id, String
-    field :title, String
-    field :status, String
-    field :format, String
-    field :date, Time
-    field :country, String
-
-    def tracks
-      @tracks ||= nil
-      if @tracks.nil? and !id.nil?
-        @tracks = self.class.load({
-          :parser => :release_tracks,
-          :create_models => MusicBrainz::Track
-        }, {
-          :resource => :release,
-          :id => id,
-          :inc => [:recordings, :media],
-          :limit => 100
-        })
-        @tracks.sort{ |a, b| a.position <=> b.position }
-      end
-      @tracks
-    end
-
-    class << self
-      def find(mbid)
-        load({
-          :parser => :release_model,
-          :create_model => MusicBrainz::Release
-        }, {
-          :resource => :release,
-          :id => mbid,
-          :inc => [:media]
-        })
-      end
-    end
-  end
-end

data/lib/musicbrainz/release_group.rb

@@ -1,41 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-module MusicBrainz
-  class ReleaseGroup < Base
-
-    field :id, String
-    field :type, String
-    field :title, String
-    field :disambiguation, String
-    field :first_release_date, Time
-
-    def releases
-      @releases ||= nil
-      if @releases.nil? and !id.nil?
-        @releases = self.class.load({
-          :parser => :release_group_releases,
-          :create_models => MusicBrainz::Release
-        }, {
-          :resource => :release,
-          :release_group => self.id,
-          :inc => [:media],
-          :limit => 100
-        })
-        @releases.sort!{ |a, b| a.date <=> b.date }
-      end
-      @releases
-    end
-
-    class << self
-      def find(mbid)
-        load({
-          :parser => :release_group_model,
-          :create_model => MusicBrainz::ReleaseGroup
-        }, {
-          :resource => :release_group,
-          :id => mbid
-        })
-      end
-    end
-  end
-end

data/lib/musicbrainz/track.rb

@@ -1,23 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-module MusicBrainz
-  class Track < Base
-
-    field :position, Integer
-    field :recording_id, String
-    field :title, String
-    field :length, Integer
-
-    class << self
-      def find(mbid)
-        load({
-          :parser => :track_model,
-          :create_model => MusicBrainz::Track
-        }, {
-          :resource => :recording,
-          :id => mbid
-        })
-      end
-    end
-  end
-end

data/lib/parsers/artist.rb

@@ -1,47 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-module MusicBrainz
-  module Parsers
-    class Artist < Base
-      class << self
-        def model(xml)
-          res = {
-            :id => safe_get_attr(xml, "artist", "id"),
-            :type => safe_get_attr(xml, "artist", "type"),
-            :name => safe_get_value(xml, "artist > name").gsub(/[`’]/, "'"),
-            :country => safe_get_value(xml, "artist > country"),
-            :date_begin => safe_get_value(xml, "artist > life-span > begin"),
-            :date_end => safe_get_value(xml, "artist > life-span > end"),
-            :urls => {}
-          }
-          xml.css("relation-list[target-type='url'] > relation").each { |rel|
-            res[:urls][rel.attr("type").downcase.split(" ").join("_").to_sym] = rel.css("target").text
-          }
-          res
-        end
-
-        def search(xml)
-          xml.css("artist-list > artist").map do |a|
-            {
-              :name => a.first_element_child.text.gsub(/[`’]/, "'"),
-              :sort_name => safe_get_value(a, "sort-name").gsub(/[`’]/, "'"),
-              :score => (safe_get_attr(a, nil, "score").to_i rescue 0),
-              :desc => safe_get_value(a, "disambiguation"),
-              :type => safe_get_attr(a, nil, "type"),
-              :mbid => safe_get_attr(a, nil, "id"),
-              :aliases => a.css("alias-list > alias").map { |item| item.text }
-            }
-          end
-        end
-
-        def release_groups(xml)
-          release_groups = []
-          xml.css("release-group").each do |rg|
-            release_groups << MusicBrainz::Parsers::ReleaseGroup.model(rg)
-          end
-          release_groups
-        end
-      end
-    end
-  end
-end

data/lib/parsers/base.rb

@@ -1,41 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-module MusicBrainz
-  module Parsers
-    class << self
-      def get_by_name(name)
-        case name
-        when :artist_model
-          { :const => MusicBrainz::Parsers::Artist, :method => :model }
-        when :artist_search
-          { :const => MusicBrainz::Parsers::Artist, :method => :search }
-        when :artist_release_groups
-          { :const => MusicBrainz::Parsers::Artist, :method => :release_groups }
-        when :release_group_model
-          { :const => MusicBrainz::Parsers::ReleaseGroup, :method => :model }
-        when :release_group_releases
-          { :const => MusicBrainz::Parsers::ReleaseGroup, :method => :releases }
-        when :release_model
-          { :const => MusicBrainz::Parsers::Release, :method => :model }
-        when :release_tracks
-          { :const => MusicBrainz::Parsers::Release, :method => :tracks }
-        when :track_model
-          { :const => MusicBrainz::Parsers::Track, :method => :model }
-        end
-      end
-    end
-
-    class Base
-      class << self
-        def safe_get_attr(xml, path, name)
-          node = path.nil? ? xml : (xml.css(path).first unless xml.css(path).empty?)
-          node.attr(name) unless node.nil? or node.attr(name).nil?
-        end
-
-        def safe_get_value(xml, path)
-          xml.css(path).first.text unless xml.css(path).empty?
-        end
-      end
-    end
-  end
-end

data/lib/parsers/release.rb

@@ -1,28 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-module MusicBrainz
-  module Parsers
-    class Release < Base
-      class << self
-        def model(xml)
-          {
-            :id => safe_get_attr(xml, nil, "id") || safe_get_attr(xml, "release", "id"),
-            :title => safe_get_value(xml, "title"),
-            :status => safe_get_value(xml, "status"),
-            :country => safe_get_value(xml, "country"),
-            :format => safe_get_value(xml, "medium-list > medium > format"),
-            :date => safe_get_value(xml, "date")
-          }
-        end
-
-        def tracks(xml)
-          tracks = []
-          xml.css("medium-list > medium > track-list > track").each do |r|
-            tracks << MusicBrainz::Parsers::Track.model(r)
-          end
-          tracks
-        end
-      end
-    end
-  end
-end

data/lib/parsers/release_group.rb

@@ -1,27 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-module MusicBrainz
-  module Parsers
-    class ReleaseGroup < Base
-      class << self
-        def model(xml)
-          {
-            :id => safe_get_attr(xml, nil, "id") || safe_get_attr(xml, "release-group", "id"),
-            :type => safe_get_attr(xml, nil, "type") || safe_get_attr(xml, "release-group", "type"),
-            :title => safe_get_value(xml, "title"),
-            :disambiguation => safe_get_value(xml, "disambiguation"),
-            :first_release_date => safe_get_value(xml, "first-release-date")
-          }
-        end
-
-        def releases(xml)
-          releases = []
-          xml.css("release").each do |r|
-            releases << MusicBrainz::Parsers::Release.model(r)
-          end
-          releases
-        end
-      end
-    end
-  end
-end

data/lib/parsers/track.rb

@@ -1,18 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-module MusicBrainz
-  module Parsers
-    class Track < Base
-      class << self
-        def model(xml)
-          {
-            :position => safe_get_value(xml, "position"),
-            :recording_id => safe_get_attr(xml, "recording", "id"),
-            :title => safe_get_value(xml, "recording > title"),
-            :length => safe_get_value(xml, "length") || safe_get_value(xml, "recording > length")
-          }
-        end
-      end
-    end
-  end
-end