musicbrainz 0.7.1 → 0.7.2

data/lib/musicbrainz/client_modules/caching_proxy.rb

@@ -0,0 +1,46 @@
+module MusicBrainz
+  module ClientModules
+    module CachingProxy
+      def cache_path
+        MusicBrainz.config.cache_path
+      end
+
+      def clear_cache
+        FileUtils.rm_r(cache_path) if cache_path && File.exist?(cache_path)
+      end
+
+      def get_contents(url)
+        return super unless caching?
+
+        hash = Digest::SHA256.hexdigest(url)
+        dir_path = [cache_path, *(0..2).map{ |i| hash.slice(2*i, 2) }].join(?/)
+        file_path = [dir_path, '/', hash.slice(6, 58), '.xml'].join
+
+        response = { body: nil, status: 500 }
+
+        if File.exist?(file_path)
+          response = {
+            body: File.open(file_path, 'rb').gets,
+            status: 200
+          }
+        else
+          response = super
+          if response[:status] == 200
+            FileUtils.mkpath(dir_path)
+            File.open(file_path, 'wb') do |f|
+              f.puts(response[:body])
+              f.chmod(0755)
+              f.close
+            end
+          end
+        end
+
+        response
+      end
+
+      def caching?
+        MusicBrainz.config.perform_caching
+      end
+    end
+  end
+end

data/lib/musicbrainz/client_modules/failsafe_proxy.rb

@@ -0,0 +1,38 @@
+module MusicBrainz
+  module ClientModules
+    module FailsafeProxy
+      def get_contents(url)
+        return super unless failsafe?
+
+        response = { body: nil, status: 500 }
+        MusicBrainz.config.tries_limit.times do
+          response = super
+          break if response[:status] == 200
+        end
+
+        response
+      end
+
+      def time_passed
+        Time.now.to_f - @last_query_time ||= 0.0
+      end
+
+      def time_to_wait
+        MusicBrainz.config.query_interval - time_passed
+      end
+
+      def ready?
+        time_passed > MusicBrainz.config.query_interval
+      end
+
+      def wait_util_ready!
+        sleep(time_to_wait) unless ready?
+        @last_query_time = Time.now.to_f
+      end
+
+      def failsafe?
+        MusicBrainz.config.tries_limit > 1 && MusicBrainz.config.query_interval.to_f > 0
+      end
+    end
+  end
+end

data/lib/musicbrainz/client_modules/transparent_proxy.rb

@@ -0,0 +1,12 @@
+module MusicBrainz
+  module ClientModules
+    module TransparentProxy
+      def get_contents(url)
+        response = http.get(url)
+        { body: response.body, status: response.status }
+      rescue
+        { body: nil, status: 500 }
+      end
+    end
+  end
+end

data/lib/musicbrainz/configuration.rb

@@ -0,0 +1,60 @@
+module MusicBrainz
+  class Configuration
+    attr_accessor :app_name, :app_version, :contact,
+                  :web_service_url,
+                  :query_interval, :tries_limit,
+                  :cache_path, :perform_caching
+
+    DEFAULT_WEB_SERVICE_URL = "http://musicbrainz.org/ws/2/"
+    DEFAULT_QUERY_INTERVAL = 1.5
+    DEFAULT_TRIES_LIMIT = 5
+    DEFAULT_CACHE_PATH = File.join(File.dirname(__FILE__), "..", "tmp", "cache")
+    DEFAULT_PERFORM_CACHING = false
+
+    def initialize
+      @web_service_url = DEFAULT_WEB_SERVICE_URL
+      @query_interval = DEFAULT_QUERY_INTERVAL
+      @tries_limit = DEFAULT_TRIES_LIMIT
+      @cache_path = DEFAULT_CACHE_PATH
+      @perform_caching = DEFAULT_PERFORM_CACHING
+    end
+
+    def valid?
+      %w[ app_name app_version contact ].each do |param|
+        unless instance_variable_defined?(:"@#{param}")
+          raise Exception.new("Application identity parameter '#{param}' missing")
+        end
+      end
+      unless tries_limit.nil? && query_interval.nil?
+        raise Exception.new("'tries_limit' parameter must be 1 or greater") if tries_limit.to_i < 1
+        raise Exception.new("'query_interval' parameter must be greater than zero") if query_interval.to_f < 0
+      end
+      if perform_caching
+        raise Exception.new("'cache_path' parameter must be set") if cache_path.nil?
+      end
+      true
+    end
+  end
+
+  module Configurable
+    def configure
+      raise Exception.new("Configuration block missing") unless block_given?
+      yield @config ||= MusicBrainz::Configuration.new
+      config.valid?
+    end
+
+    def config
+      raise Exception.new("Configuration missing") unless instance_variable_defined?(:@config)
+      @config
+    end
+
+    def apply_test_configuration!
+      configure do |c|
+        c.app_name = "gem musicbrainz (development mode)"
+        c.app_version = MusicBrainz::VERSION
+        c.contact = `git config user.email`.chomp
+      end
+    end
+  end
+  extend Configurable
+end

data/lib/musicbrainz/deprecated.rb

@@ -0,0 +1,36 @@
+module MusicBrainz
+  module Deprecated
+    module ProxyConfig
+      def query_interval
+        MusicBrainz.config.query_interval
+      end
+
+      def query_interval=(value)
+        MusicBrainz.config.query_interval = value
+      end
+    end
+
+    module CacheConfig
+      def cache_path
+        MusicBrainz.config.cache_path
+      end
+
+      def cache_path=(value)
+        MusicBrainz.config.cache_path = value
+      end
+    end
+  end
+
+  module Tools
+    module Proxy
+      extend Deprecated::ProxyConfig
+    end
+
+    module Cache
+      extend Deprecated::CacheConfig
+    end
+  end
+
+  extend Deprecated::ProxyConfig
+  extend Deprecated::CacheConfig
+end

data/lib/musicbrainz/middleware.rb

@@ -0,0 +1,23 @@
+module MusicBrainz
+  class Middleware < Faraday::Middleware
+    def call(env)
+      env[:request_headers].merge!(
+        "User-Agent" => user_agent_string,
+        "Via"        => via_string
+      )
+      @app.call(env)
+    end
+
+    def user_agent_string
+      "#{config.app_name}/#{config.app_version} ( #{config.contact} )"
+    end
+
+    def via_string
+      "gem musicbrainz/#{VERSION} (#{GH_PAGE_URL})"
+    end
+
+    def config
+      MusicBrainz.config
+    end
+  end
+end

data/lib/musicbrainz/models/artist.rb

@@ -0,0 +1,47 @@
+module MusicBrainz
+  class Artist < BaseModel
+    field :id, String
+    field :type, String
+    field :name, String
+    field :country, String
+    field :date_begin, Date
+    field :date_end, Date
+    field :urls, Hash
+
+    def release_groups
+      @release_groups ||= client.load(:release_group, { artist: id }, {
+        binding: :artist_release_groups,
+        create_models: :release_group,
+        sort: :first_release_date
+      }) unless @id.nil?
+    end
+
+    class << self
+      def find(id)
+        client.load(:artist, { id: id, inc: [:url_rels] }, {
+          binding: :artist,
+          create_model: :artist
+        })
+      end
+
+      def search(name)
+        name = CGI.escape(name).gsub(/\!/, '\!')
+
+        client.load(:artist, { query: "artist:#{name}", limit: 10 }, {
+          binding: :artist_search
+        })
+      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.empty? ? nil : find(matches.first[:id])
+      end
+    end
+  end
+end

data/lib/musicbrainz/models/base_model.rb

@@ -0,0 +1,63 @@
+module MusicBrainz
+  class BaseModel
+    def self.inherited(klass)
+      klass.send(:include, InstanceMethods)
+      klass.send(:extend, ClassMethods)
+    end
+
+    module ClassMethods
+      def field(name, type)
+        fields[name] = type
+        attr_reader name
+
+        define_method("#{name}=") do |val|
+          instance_variable_set("@#{name}", validate_type(val, type))
+        end
+      end
+
+      def fields
+        instance_variable_set(:@fields, {}) unless instance_variable_defined?(:@fields)
+        instance_variable_get(:@fields)
+      end
+
+      def client
+        MusicBrainz.client
+      end
+    end
+
+    module InstanceMethods
+      def initialize(params = {})
+        params.each do |field, value|
+          self.send(:"#{field}=", value)
+        end
+      end
+
+      def client
+        MusicBrainz.client
+      end
+
+    private
+
+      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 == Date
+          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
+          Date.new(*val.split(?-).map(&:to_i))
+        else
+          val
+        end
+      end
+    end
+  end
+end

data/lib/musicbrainz/models/release.rb

@@ -0,0 +1,27 @@
+module MusicBrainz
+  class Release < BaseModel
+    field :id, String
+    field :title, String
+    field :status, String
+    field :format, String
+    field :date, Date
+    field :country, String
+
+    def tracks
+      @tracks ||= client.load(:release, { id: id, inc: [:recordings, :media], limit: 100 }, {
+        binding: :release_tracks,
+        create_models: :track,
+        sort: :position
+      }) unless @id.nil?
+    end
+
+    class << self
+      def find(id)
+        client.load(:release, { id: id, inc: [:media] }, {
+          binding: :release,
+          create_model: :release
+        })
+      end
+    end
+  end
+end

data/lib/musicbrainz/models/release_group.rb

@@ -0,0 +1,28 @@
+module MusicBrainz
+  class ReleaseGroup < BaseModel
+    field :id, String
+    field :type, String
+    field :title, String
+    field :desc, String
+    field :first_release_date, Date
+
+    alias_method :disambiguation, :desc
+
+    def releases
+      @releases ||= client.load(:release, { release_group: id, inc: [:media], limit: 100 }, {
+        binding: :release_group_releases,
+        create_models: :release,
+        sort: :date
+      }) unless @id.nil?
+    end
+
+    class << self
+      def find(id)
+        client.load(:release_group, { id: id }, {
+          binding: :release_group,
+          create_model: :release_group
+        })
+      end
+    end
+  end
+end

data/lib/musicbrainz/models/track.rb

@@ -0,0 +1,17 @@
+module MusicBrainz
+  class Track < BaseModel
+    field :position, Integer
+    field :recording_id, String
+    field :title, String
+    field :length, Integer
+
+    class << self
+      def find(id)
+        client.load(:recording, { id: id }, {
+          binding: :track,
+          create_model: :track
+        })
+      end
+    end
+  end
+end

data/lib/musicbrainz/version.rb

@@ -0,0 +1,3 @@
+module MusicBrainz
+  VERSION = "0.7.2"
+end

data/musicbrainz.gemspec

@@ -1,23 +1,21 @@
-# -*- encoding: utf-8 -*-
-
-require File.expand_path('../lib/version', __FILE__)
+require File.expand_path('../lib/musicbrainz/version', __FILE__)
 
 Gem::Specification.new do |gem|
   gem.authors       = ["Gregory Eremin"]
   gem.email         = ["magnolia_fan@me.com"]
-  gem.summary       = %q{MusicBrainz Web Service wrapper with ActiveRecord-style models}
+  gem.summary       = %q{ MusicBrainz Web Service wrapper with ActiveRecord-style models }
   gem.homepage      = "http://github.com/magnolia-fan/musicbrainz"
 
-  gem.files         = `git ls-files`.split($\)
-  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
-  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.files         = %x{ git ls-files }.split($\)
+  gem.executables   = []
+  gem.test_files    = gem.files.grep(%r{^spec/})
   gem.name          = "musicbrainz"
-  gem.require_paths = ["lib"]
+  gem.require_paths = %w[ lib ]
   gem.version       = MusicBrainz::VERSION
   gem.license       = "MIT"
 
-  gem.add_dependency("nokogiri")
-  gem.add_development_dependency("rake")
-  gem.add_development_dependency("awesome_print")
-  gem.add_development_dependency("rspec")
+  gem.add_dependency('faraday')
+  gem.add_dependency('nokogiri')
+  gem.add_development_dependency('rspec')
+  gem.add_development_dependency('awesome_print')
 end