glyr 0.9.9 → 0.9.9.1

data/README.md

@@ -1,2 +1,41 @@
 ruby-glyr - Ruby wrapper for glyr.
 ==================================
+This is just a simple wrapper library for libglyr.
+
+Example
+-------
+
+```ruby
+>> require 'glyr'
+>> Glyr.query(title: 'The Dead Flag Blues', artist: 'Godspeed You! Black Emperor').lyrics.first
+=> The car's on fire and there's no driver at the wheel
+And the sewers are all muddied with a thousand lonely suicides
+And a dark wind blows
+
+The government is corrupt
+And we're on so many drugs
+With the radio on and the curtains drawn
+We're trapped in the belly of this horrible machine
+And the machine is bleeding to death
+The sun has fallen down
+And the billboards are all leering
+And the flags are all dead at the top of their poles
+It went like this:
+The buildings tumbled in on themselves
+Mothers clutching babies picked through the rubble
+And pulled out their hair
+
+The skyline was beautiful on fire
+All twisted metal stretching upwards
+Everything washed in a thin orange haze
+
+I said: "kiss me, you're beautiful -
+These are truly the last days"
+You grabbed my hand and we fell into it
+Like a daydream or a fever
+We woke up one morning and fell a little further down -
+For sure it's the valley of death
+
+I open up my wallet
+And it's full of blood
+```

data/lib/glyr.rb

@@ -12,4 +12,17 @@ require 'glyr/c'
 
 require 'glyr/version'
 require 'glyr/query'
-require 'glyr/result'
+require 'glyr/results'
+require 'glyr/providers'
+require 'glyr/sources'
+
+module Glyr
+	# helper to create a Query object
+	def self.query (options = {})
+		Query.create(options)
+	end
+
+	def self.providers
+		@providers ||= Providers.create
+	end
+end

data/lib/glyr/providers.rb

@@ -0,0 +1,96 @@
+#--
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#                    Version 2, December 2004
+#
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+#
+#  0. You just DO WHAT THE FUCK YOU WANT TO.
+#++
+
+module Glyr
+
+class Providers
+	def self.create
+		pointer = C.glyr_info_get
+
+		wrap(pointer)
+	end
+
+	def self.wrap (pointer)
+		new(pointer).tap {|x|
+			ObjectSpace.define_finalizer x, finalizer(pointer)
+		}
+	end
+
+	def self.finalizer (pointer)
+		proc {
+			C.glyr_info_free(pointer)
+		}
+	end
+
+	include Enumerable
+
+	def initialize (pointer)
+		@internal = pointer.is_a?(FFI::Pointer) ? C::FetcherInfo.new(pointer) : pointer
+	end
+
+	def each (&block)
+		current = @internal
+
+		until current.null?
+			block.call(Provider.new(current, self))
+
+			current = C::FetcherInfo.new(current[:next])
+		end
+	end
+
+	def [] (name)
+		find { |p| p.name == name || p.type == name }
+	end
+
+	def to_hash
+		Hash[map { |p| [p.to_sym, p] }]
+	end
+
+	def to_native
+		@internal
+	end
+end
+
+class Provider
+	def initialize (pointer, providers)
+		@internal  = pointer.is_a?(FFI::Pointer) ? C::FetcherInfo.new(pointer) : pointer
+		@providers = providers
+	end
+
+	def name
+		to_native[:name]
+	end
+
+	def type
+		to_native[:type]
+	end
+
+	def requirements
+		FieldRequirements[to_native[:reqs]]
+	end
+
+	def sources
+		Sources.new(to_native[:head], self)
+	end
+
+	alias to_s name
+
+	alias to_sym type
+
+	def to_native
+		@internal
+	end
+
+	def inspect
+		"#<Glyr::Provider(#{name}): #{requirements}>"
+	end
+end
+
+end

data/lib/glyr/query.rb

@@ -11,13 +11,13 @@
 module Glyr
 
 class Query
+	# create a Query object with the passed options
 	def self.create (options = {})
 		struct = C::Query.new
 
 		C.glyr_query_init(struct.pointer)
 
 		wrap(struct.pointer, options)
-
 	end
 
 	def self.wrap (pointer, options = {})
@@ -26,7 +26,7 @@ class Query
 		}
 	end
 
-	def self.finalizer (pointer)
+	def self.finalizer (pointer) # :nodoc:
 		proc {
 			C.glyr_query_destroy(pointer)
 		}
@@ -46,84 +46,206 @@ class Query
 		}
 	end
 
-	def type (value)
-		raise_if_error C.glyr_opt_type(to_native, value.is_a?(Symbol) ? value : C::GetType[value])
+	# tell the Query what you want to get
+	def type (value = nil)
+		if value
+			raise_if_error C.glyr_opt_type(to_native, value.is_a?(Symbol) ? value : C::GetType[value])
+		else
+			to_native[:type]
+		end
 	end
 
-	def artist (value)
-		raise_if_error C.glyr_opt_artist(to_native, value)
+	# set the artist
+	def artist (value = nil)
+		if value
+			raise_if_error C.glyr_opt_artist(to_native, value)
+		else
+			to_native[:artist]
+		end
 	end
 
-	def album (value)
-		raise_if_error C.glyr_opt_album(to_native, value)
+	# set the album
+	def album (value = nil)
+		if value
+			raise_if_error C.glyr_opt_album(to_native, value)
+		else
+			to_native[:album]
+		end
 	end
 
-	def title (value)
-		raise_if_error C.glyr_opt_title(to_native, value)
+	# set the title
+	def title (value = nil)
+		if value
+			raise_if_error C.glyr_opt_title(to_native, value)
+		else
+			to_native[:title]
+		end
 	end
 
-	def parallel (value)
-		raise_if_error C.glyr_opt_parallel(to_native, value)
+	# set the image size boundaries
+	def image_boundaries (min = nil, max = min)
+		if min && max
+			raise_if_error C.glyr_opt_img_minsize(to_native, min)
+			raise_if_error C.glyr_opt_img_maxsize(to_native, max)
+		else
+			[to_native[:img_min_size], to_native[:img_max_size]]
+		end
 	end
 
-	def timeout (value)
-		raise_if_error C.glyr_opt_timeout(to_native, value)
+	# set the number of parallel searches
+	def parallel (value = nil)
+		if value
+			raise_if_error C.glyr_opt_parallel(to_native, value)
+		else
+			to_native[:parallel]
+		end
 	end
 
-	def redirects (value)
-		raise_if_error C.glyr_opt_redirects(to_native, value)
+	# set the timeout for the searching
+	def timeout (value = nil)
+		if value
+			raise_if_error C.glyr_opt_timeout(to_native, value)
+		else
+			to_native[:timeout]
+		end
 	end
 
-	def user_agent (value)
-		raise_if_error C.glyr_opt_useragent(to_native, value)
+	# set the max amount of redirects
+	def redirects (value = nil)
+		if value
+			raise_if_error C.glyr_opt_redirects(to_native, value)
+		else
+			to_native[:redirects]
+		end
 	end
 
-	def language (value)
-		raise_if_error C.glyr_opt_lang(to_native, value)
+	# set the user agent to use
+	def user_agent (value = nil)
+		if value
+			raise_if_error C.glyr_opt_useragent(to_native, value)
+		else
+			to_native[:useragent]
+		end
+	end
+
+	# set or get the language to search for
+	def language (value = nil)
+		if value
+			raise_if_error C.glyr_opt_lang(to_native, value)
+		else
+			to_native[:lang]
+		end
 	end
 
+	def language_aware?
+		to_native[:lang_aware_only]
+	end
+
+	# only fetch from language aware providers
 	def language_aware!
 		raise_if_error C.glyr_opt_lang_aware_only(to_native, true)
 	end
 
+	# don't force language aware providers
 	def no_language_aware!
 		raise_if_error C.glyr_opt_lang_aware_only(to_native, false)
 	end
 
-	def number (value)
-		raise_if_error C.glyr_opt_number(to_native, value)
+	# set the maximum number of results
+	def maximum (value = nil)
+		if value
+			raise_if_error C.glyr_opt_number(to_native, value)
+		else
+			to_native[:number]
+		end
+	end
+
+	# set the maximum number of results per provider
+	def maximum_per_provider (value = nil)
+		if value
+			raise_if_error C.glyr_opt_plugmax(to_native, value)
+		else
+			to_native[:plugmax]
+		end
 	end
 
-	def verbosity (value)
-		raise_if_error C.glyr_opt_verbosity(to_native, value)
+	# set the level of verbosity
+	def verbosity (value = nil)
+		if value
+			raise_if_error C.glyr_opt_verbosity(to_native, value)
+		else
+			to_native[:verbosity]
+		end
 	end
 
+	# use only the passed providers (you can use all and disable single providers by prefixing
+	# them with a -)
 	def from (*providers)
-		raise_if_error C.glyr_opt_from(to_native, providers.flatten.compact.uniq.join(';'))
+		unless providers.empty?
+			raise_if_error C.glyr_opt_from(to_native, providers.flatten.compact.uniq.join(';'))
+		else
+			to_native[:from] && to_native[:from].split(/\s*;\s*/)
+		end
 	end
 
+	# use only the passed formats
 	def allowed_formats (*formats)
-		raise_if_error C.glyr_opt_allowed_formats(to_native, formats.flatten.compact.uniq.join(';'))
+		unless formats.empty?
+			raise_if_error C.glyr_opt_allowed_formats(to_native, formats.flatten.compact.uniq.join(';'))
+		else
+			to_native[:allowed_formats] && to_native[:allowed_formats].split(/\s*;\s*/)
+		end
 	end
 
+	def download?
+		to_native[:download]
+	end
+
+	# download the data instead of just passing a URL
 	def download!
 		raise_if_error C.glyr_opt_download(to_native, true)
 	end
 
+	# don't download the data, just pass the URL
 	def no_download!
 		raise_if_error C.glyr_opt_download(to_native, false)
 	end
 
-	def fuzzyness (value)
-		raise_if_error C.glyr_opt_fuzzyness(to_native, value)
+	def fuzzyness (value = nil)
+		if value
+			raise_if_error C.glyr_opt_fuzzyness(to_native, value)
+		else
+			to_native[:fuzzyness]
+		end
 	end
 
-	def ratio (value)
-		raise_if_error C.glyr_opt_qsratio(to_native, value)
+	def ratio (value = nil)
+		if value
+			raise_if_error C.glyr_opt_qsratio(to_native, value)
+		else
+			to_native[:qsratio]
+		end
 	end
 
-	def proxy (value)
-		raise_if_error C.glyr_opt_proxy(to_native, value)
+	# use the passed proxy to fetch the stuff
+	def proxy (value = nil)
+		if value
+			raise_if_error C.glyr_opt_proxy(to_native, value)
+		else
+			to_native[:proxy]
+		end
+	end
+
+	def path (value = nil)
+		if value
+			raise_if_error C.glyr_opt_musictree_path(to_native, vlaue)
+		else
+			to_native[:musictree_path]
+		end
+	end
+
+	def force_utf8?
+		to_native[:force_utf8]
 	end
 
 	def force_utf8!
@@ -134,33 +256,53 @@ class Query
 		raise_if_error C.glyr_opt_force_utf8(to_native, false)
 	end
 
-	def get
+	def get (&block)
 		error  = FFI::MemoryPointer.new :int
-		result = C.glyr_get(to_native, error, nil)
+		length = FFI::MemoryPointer.new :int
+
+		if block
+			raise_if_error C.glyr_opt_dlcallback(to_native, proc {|data, query|
+				result = block.call(Result.copy(C::MemCache.new(data)))
+
+				if result.respond_to? :to_i
+					C::Error[result.to_i]
+				elsif result.respond_to? :to_sym
+					result.to_sym.downcase
+				else
+					:ok
+				end
+			}, nil)
+		else
+			C.glyr_opt_dlcallback(to_native, nil, nil)
+		end
+
+		result = C.glyr_get(to_native, error, length)
 
 		raise_if_error error.typecast(:int)
 
-		Result.wrap(result)
+		Results.wrap(result, length.typecast(:int))
 	end
 
 	%w[cover_art lyrics artist_photos artist_bio similar_artists similar_songs album_reviews tracklist tags relations album_list guitar_tabs backdrops].each {|name|
 		name = name.to_sym
 
-		define_method name do
-			type(name).get
+		define_method name do |&block|
+			type(name).get(&block)
 		end
 	}
 
+	# stop the current fetching
 	def stop
 		C.glyr_signal_exit(to_native)
 	end
 
+	# get the FFI::Struct
 	def to_native
 		@internal
 	end
 
 private
-	def raise_if_error (value)
+	def raise_if_error (value) # :nodoc:
 		value = C::Error[value] unless value.is_a? Symbol
 
 		if value != :ok

data/lib/glyr/results.rb

@@ -0,0 +1,216 @@
+#--
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#                    Version 2, December 2004
+#
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+#
+#  0. You just DO WHAT THE FUCK YOU WANT TO.
+#++
+
+module Glyr
+
+class Results
+	def self.wrap (pointer, length = nil) # :nodoc:
+		new(pointer, length).tap {|x|
+			ObjectSpace.define_finalizer x, finalizer(pointer)
+		}
+	end
+
+	def self.finalizer (pointer) # :nodoc:
+		proc {
+			C.glyr_free_list(pointer)
+		}
+	end
+
+	include Enumerable
+
+	attr_reader :length
+
+	def initialize (pointer, length = nil)
+		@internal = pointer.is_a?(FFI::Pointer) ? C::MemCache.new(pointer) : pointer
+		@length   = length
+	end
+
+	def each (&block)
+		current = @internal
+
+		until current.null?
+			block.call(Result.wrap(current, self))
+
+			current = C::MemCache.new(current[:next])
+		end
+
+		self
+	end
+
+	def to_native
+		@internal
+	end
+end
+
+class Result
+	def self.wrap (struct, result) # :nodoc:
+		return if struct[:type] == :noidea
+
+		::Glyr.const_get(struct[:type].to_s.capitalize.gsub(/_(\w)/) { $1.upcase }).
+			new(struct, result)
+	end
+
+	def self.copy (struct) # :nodoc:
+		return if struct[:type] == :noidea
+
+		pointer = C.glyr_cache_copy(struct)
+
+		::Glyr.const_get(struct[:type].to_s.capitalize.gsub(/_(\w)/) { $1.upcase }).
+			new(pointer).tap {|data|
+				ObjectSpace.define_finalizer data, finalizer(pointer)
+			}
+	end
+
+	def self.finalizer (pointer) # :nodoc:
+		proc {
+			C.glyr_cache_free(pointer)
+		}
+	end
+
+	def initialize (pointer, result = nil)
+		@internal = pointer.is_a?(FFI::Pointer) ? C::MemCache.new(pointer) : pointer
+		@result   = result
+	end
+
+	def clone
+		self.class.copy(to_native)
+	end
+
+	alias dup clone
+
+	def data
+		to_native[:data].typecast(:string, to_native[:size])
+	end
+
+	def url
+		to_native[:dsrc].typecast(:string)
+	end
+
+	def source
+		Glyr.providers[type].sources[to_native[:prov].typecast(:string)]
+	end
+
+	def rating
+		to_native[:rating]
+	end
+
+	def rating= (value)
+		to_native[:rating] = value
+	end
+
+	def type
+		to_native[:type]
+	end
+
+	def to_native
+		@internal
+	end
+
+	module Image
+		def to_blob
+			data
+		end
+
+		def format
+			to_native[:img_format].typecast(:string)
+		end
+	end
+
+	module Text
+		def to_s
+			data
+		end
+
+		alias to_str to_s
+	end
+
+end
+
+class CoverArt < Result
+	include Result::Image
+end
+
+class Lyrics < Result
+	include Result::Text
+end
+
+class AlbumReview < Result
+	include Result::Text
+end
+
+class ArtistPhoto < Result
+	include Result::Image
+end
+
+class SimilarArtist < Result
+	attr_reader :name, :url
+
+	def initialize (*)
+		super
+
+		@name, _, @url = data.lines.map(&:chomp)
+	end
+
+end
+
+class SimilarSong < Result
+	attr_reader :title, :artist, :url
+
+	def initialize (*)
+		super
+
+		@title, @artist, _, @url = data.lines.map(&:chomp)
+	end
+end
+
+class AlbumList < Result
+end
+
+class Tag < Result
+	include Result::Text
+end
+
+class TagArtist < Result
+	include Result::Text
+end
+
+class TagAlbum < Result
+	include Result::Text
+end
+
+class TagTitle < Result
+	include Result::Text
+end
+
+class Relation < Result
+	include Result::Text
+end
+
+class ImageUrl < Result
+	include Result::Text
+end
+
+class TextUrl < Result
+	include Result::Text
+end
+
+class Track < Result
+	include Result::Text
+end
+
+class GuitarTabs < Result
+	include Result::Text
+end
+
+class Backdrops < Result
+	include Result::Text
+end
+
+end

data/lib/glyr/sources.rb

@@ -0,0 +1,89 @@
+#--
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#                    Version 2, December 2004
+#
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+#
+#  0. You just DO WHAT THE FUCK YOU WANT TO.
+#++
+
+module Glyr
+
+class Sources
+	include Enumerable
+
+	attr_reader :provider
+
+	def initialize (pointer, provider)
+		@internal = pointer.is_a?(FFI::Pointer) ? C::SourceInfo.new(pointer) : pointer
+		@provider = provider
+	end
+
+	def each (&block)
+		current = @internal
+
+		until current.null?
+			block.call(Source.new(current, provider))
+
+			current = C::SourceInfo.new(current[:next])
+		end
+	end
+
+	def [] (name)
+		find { |p| p.name == name || p.key == name }
+	end
+
+	def to_hash
+		Hash[map { |p| [p.to_sym, p] }]
+	end
+
+	def to_native
+		@internal
+	end
+end
+
+class Source
+	attr_reader :provider
+
+	def initialize (pointer, provider)
+		@internal = pointer.is_a?(FFI::Pointer) ? C::SourceInfo.new(pointer) : pointer
+		@provider = provider
+	end
+
+	def name
+		to_native[:name]
+	end
+
+	def key
+		to_native[:key].chr
+	end
+
+	def quality
+		to_native[:quality]
+	end
+	
+	def speed
+		to_native[:speed]
+	end
+
+	def language_aware?
+		to_native[:lang_aware]
+	end
+
+	alias to_s name
+
+	def to_sym
+		to_s.to_sym
+	end
+
+	def to_native
+		@internal
+	end
+
+	def inspect
+		"#<Glyr::Source(#{name}): quality=#{quality} speed=#{speed}#{' language_aware' if language_aware?}>"
+	end
+end
+
+end

data/lib/glyr/version.rb

@@ -12,6 +12,6 @@ require 'glyr'
 
 module Glyr
 	def self.version
-		'0.9.9'
+		'0.9.9.1'
 	end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: glyr
 version: !ruby/object:Gem::Version
-  version: 0.9.9
+  version: 0.9.9.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-06-22 00:00:00.000000000 Z
+date: 2012-06-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -71,8 +71,10 @@ files:
 - lib/glyr/c.rb
 - lib/glyr/c/functions.rb
 - lib/glyr/c/types.rb
+- lib/glyr/providers.rb
 - lib/glyr/query.rb
-- lib/glyr/result.rb
+- lib/glyr/results.rb
+- lib/glyr/sources.rb
 - lib/glyr/version.rb
 homepage: http://github.com/meh/ruby-glyr
 licenses: []

data/lib/glyr/result.rb

@@ -1,176 +0,0 @@
-#--
-#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
-#                    Version 2, December 2004
-#
-#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
-#   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-#
-#  0. You just DO WHAT THE FUCK YOU WANT TO.
-#++
-
-module Glyr
-
-class Result
-	def self.wrap (pointer)
-		new(pointer).tap {|x|
-			ObjectSpace.define_finalizer x, finalizer(pointer)
-		}
-	end
-
-	def self.finalizer (pointer)
-		proc {
-			C.glyr_free_list(pointer)
-		}
-	end
-
-	class Data
-		def self.wrap (struct, result)
-			return new(struct, result) if struct[:type] == :noidea
-
-			::Glyr.const_get(struct[:type].to_s.capitalize.gsub(/_(\w)/) { $1.upcase }).
-				new(struct, result)
-		end
-
-		attr_reader   :result
-		attr_accessor :rating
-
-		def initialize (pointer, result)
-			@internal = pointer.is_a?(FFI::Pointer) ? C::MemCache.new(pointer) : pointer
-			@result   = result
-		end
-
-		def source
-			to_native[:dsrc].read_string
-		end
-
-		def provider
-			to_native[:prov].read_string
-		end
-
-		def to_native
-			@internal
-		end
-
-		module Image
-			def to_blob
-				to_native[:data].read_string(to_native[:size]).force_encoding('BINARY')
-			end
-
-			def format
-				to_native[:img_format].read_string
-			end
-		end
-
-		module Text
-			def to_s
-				to_native[:data].read_string(to_native[:size])
-			end
-
-			alias to_str to_s
-		end
-
-		class ::Glyr::CoverArt < self
-			include Image
-		end
-
-		class ::Glyr::Lyrics < self
-			include Text
-		end
-
-		class ::Glyr::AlbumReview < self
-			include Text
-		end
-
-		class ::Glyr::ArtistPhoto < self
-			include Image
-		end
-
-		class ::Glyr::SimilarArtist < self
-			attr_reader :name, :url
-
-			def initialize (*)
-				super
-
-				@name, _, @url = to_native[:data].read_string(to_native[:size]).lines.map(&:chomp)
-			end
-
-		end
-
-		class ::Glyr::SimilarSong < self
-			attr_reader :title, :artist, :url
-
-			def initialize (*)
-				super
-
-				@title, @artist, _, @url = to_native[:data].read_string(to_native[:size]).lines.map(&:chomp)
-			end
-		end
-
-		class ::Glyr::AlbumList < self
-		end
-
-		class ::Glyr::Tag < self
-			include Text
-		end
-
-		class ::Glyr::TagArtist < self
-			include Text
-		end
-
-		class ::Glyr::TagAlbum < self
-			include Text
-		end
-
-		class ::Glyr::TagTitle < self
-			include Text
-		end
-
-		class ::Glyr::Relation < self
-			include Text
-		end
-
-		class ::Glyr::ImageUrl < self
-			include Text
-		end
-
-		class ::Glyr::TextUrl < self
-			include Text
-		end
-
-		class ::Glyr::Track < self
-			include Text
-		end
-
-		class ::Glyr::GuitarTabs < self
-			include Text
-		end
-
-		class ::Glyr::Backdrops < self
-			include Text
-		end
-	end
-
-	include Enumerable
-
-	def initialize (pointer)
-		@internal = pointer.is_a?(FFI::Pointer) ? C::MemCache.new(pointer) : pointer
-	end
-
-	def each (&block)
-		current = @internal
-
-		until current.null?
-			block.call(Data.wrap(current, self))
-
-			current = C::MemCache.new(@internal[:next])
-		end
-
-		self
-	end
-
-	def to_native
-		@internal
-	end
-end
-
-end