freesound-ruby 0.0.1

data/freesound-ruby.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "freesound/version"
+
+Gem::Specification.new do |s|
+  s.name        = "freesound-ruby"
+  s.version     = Freesound::VERSION
+  s.authors     = ["Alex Genco"]
+  s.email       = ["alexgenco@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{Freesound.org API wrapper in Ruby.}
+  s.description = %q{Freesound.org API wrapper in Ruby.}
+
+  s.rubyforge_project = "freesound-ruby"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {spec}/*`.split("\n")
+  #s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency("rspec")
+  s.add_development_dependency("bundler", "~> 1.0.0")
+  s.add_development_dependency("webmock")
+  s.add_runtime_dependency("crack")
+end

data/lib/core_ext.rb

@@ -0,0 +1,50 @@
+class Hash
+  def symbolize_keys
+    Hash[ map { |k, v| [k.to_sym, v] } ]
+  end
+
+  # converting xml into a hash sometimes gives you things like:
+  # { 'element' => ['just_one_value'] }
+  # this method converts this to the more useful
+  # { 'element' => 'just_one_value' }
+  def flatten_single_element_array_values
+    Hash[ map do |k, v|
+      [k, (v.is_a?(Array) && v.size == 1) ? v[0] : v]
+    end ]
+  end
+
+  # convert to a uri string
+  def to_uri
+    map { |k, v| "#{k}=#{v}" }.join("&")
+  end
+
+  def numberize_values
+    Hash[ map { |k, v| [k, ( (v.numberizeable? rescue false) ? v.numberize : v )] } ]
+  end
+
+  def underscore_keys
+    Hash[ map { |k, v| [(k.underscore rescue k), v] } ]
+  end
+end
+
+class String
+  def numberize
+    if numberizeable?
+      float? ? to_f : to_i
+    end
+  end
+
+  def numberizeable?
+    !scan(/^\-?\d*\.?\d*$/).empty?
+  end
+
+  def underscore
+    gsub(/\W/, '_')
+  end
+
+  private
+
+  def float?
+    scan(/\./).size == 1
+  end
+end

data/lib/freesound.rb

@@ -0,0 +1,58 @@
+require 'net/http'
+require 'uri'
+require 'crack'
+require 'core_ext'
+
+YAML::ENGINE.yamler = 'syck'
+
+module Freesound
+  def self.root_dir
+    File.expand_path('..', File.dirname(__FILE__))
+  end
+
+  class InvalidConfigurationParameterError < ArgumentError; end
+
+  module Configuration
+    DEFAULTS = {
+      :api_key    => ENV['FREESOUND_KEY'],
+      :base_url   => 'http://www.freesound.org/api',
+      :sounds_url => 'http://www.freesound.org/api/sounds'
+    }
+
+    DEFAULTS.each_key do |key|
+      eval <<-EOS
+        def self.#{key}
+          @@#{key} ||= DEFAULTS[:#{key}]
+        end
+
+        def self.#{key}=(val)
+          @@#{key} = val
+        end
+      EOS
+    end
+
+    def self.method_missing(name, *args)
+      raise(InvalidConfigurationParameterError, "#{name} is not a recognized configuration parameter")
+    end
+  end # module Configuration
+
+  def self.configure(params={})
+    params.each do |key, value|
+      Configuration.send("#{key}=", value)
+    end
+
+    yield Configuration if block_given?
+  end
+
+  def self.config
+    Configuration
+  end
+end # module Freesound
+
+require 'freesound/version'
+require 'freesound/client'
+require 'freesound/request'
+require 'freesound/uri_compiler'
+require 'freesound/response'
+require 'freesound/response_parser'
+require 'freesound/sound'

data/lib/freesound/client.rb

@@ -0,0 +1,27 @@
+module Freesound
+  class InvalidApiKeyError < ArgumentError; end
+
+  class Client
+    attr_reader :api_key, :requests, :responses
+
+    def initialize(api_key, options={})
+      @api_key   = api_key
+      @requests  = []
+      @responses = []
+    end
+
+    def get_sound(id)
+      request = Request.new(:sound_id => id)
+      response = request.get!
+      @requests << request
+      @responses << response
+      response.sounds.first
+    end
+
+    def search_sounds(query, options={})
+      request = Request.new(:search => {:q => query})
+      response = request.get!
+      response.sounds
+    end
+  end
+end

data/lib/freesound/request.rb

@@ -0,0 +1,27 @@
+module Freesound
+  class InvalidRequestFormatError < ArgumentError; end
+
+  class Request
+    attr_reader :uri, :params, :response, :format
+
+    def initialize(params={})
+      self.format = params[:format] || :json
+      @params = params
+      @response = nil
+    end
+
+    def format=(format)
+      raise(InvalidRequestFormatError, "#{format} is not a valid request format") unless [:json, :xml, :yaml, :yml].include?(format.to_sym)
+      @format = format.to_sym
+    end
+
+    def uri
+      @uri ||= URICompiler.new(@params.dup.merge({:format => @format})).uri
+    end
+
+    def get!
+      response_body = Net::HTTP.get_response(self.uri).body
+      @response ||= Response.new(response_body, @format)
+    end
+  end
+end

data/lib/freesound/response.rb

@@ -0,0 +1,27 @@
+module Freesound
+  class Response
+    attr_reader :content, :parser
+
+    def initialize(raw, format=:json)
+      @content = raw
+      @format  = format
+      @parser  = ResponseParser.new(format)
+    end
+
+    def data
+      @data ||= @parser.parse(@content)
+    end
+
+    def num_results
+      self.data[:num_results] || 1
+    end
+
+    def sounds
+      @sounds ||= if num_results == 1
+                    [ Sound.new(*self.data.values) ]
+                  else
+                    self.data[:sounds].map { |data| Sound.new(data) }
+                  end
+    end
+  end
+end

data/lib/freesound/response_parser.rb

@@ -0,0 +1,43 @@
+module Freesound
+  class ResponseParser
+    attr_reader :format
+
+    def initialize(format)
+      @format = format
+    end
+
+    def parse(raw)
+      case @format
+      when :xml
+        parse_xml(raw)
+      when :yaml, :yml
+        parse_yaml(raw)
+      else
+        parse_json(raw)
+      end
+    end
+
+    private
+
+    def parse_json(raw)
+      ::Crack::JSON.parse(raw).underscore_keys.symbolize_keys
+    end
+
+    # xml gets parsed slightly differently than json and yaml.
+    # the result needs to convert single element arrays to strings,
+    # convert strings like "2" to their corresponding number object i.e. 2
+    # and remove the nesting of the :tags key under "resource"
+    def parse_xml(raw)
+      result = ::Crack::XML.parse(raw)["response"].underscore_keys
+      .symbolize_keys
+      .flatten_single_element_array_values
+      .numberize_values
+      result[:tags] = result[:tags]["resource"]
+      result
+    end
+
+    def parse_yaml(raw)
+      ::YAML::load(raw).underscore_keys.symbolize_keys
+    end
+  end
+end

data/lib/freesound/sound.rb

@@ -0,0 +1,10 @@
+module Freesound
+  Sound = Struct.new(
+    :similarity, :num_ratings, :duration, :samplerate, :preview_hq_ogg,
+    :id, :preview_lq_ogg, :bitdepth, :num_comments, :filesize,
+    :preview_hq_mp3, :type, :analysis_stats, :description, :tags,
+    :serve, :spectral_m, :spectral_l, :user, :bitrate, :num_downloads,
+    :analysis_frames, :channels, :license, :created, :url, :ref,:avg_rating, 
+    :preview_lq_mp3, :original_filename, :waveform_l, :waveform_m, :pack
+  )
+end

data/lib/freesound/uri_compiler.rb

@@ -0,0 +1,32 @@
+module Freesound
+  class Freesound::URICompiler
+    attr_reader :uri
+
+    def initialize(params)
+      search_params = params.delete(:search)
+      sound_id      = params.delete(:sound_id)
+      format        = params.delete(:format)
+      @uri          = URI.parse(compile_uri_string(search_params, sound_id, format))
+    end
+
+    def compile_uri_string(search_params, sound_id, format)
+      format_string = format ? "&format=#{format}" : ""
+
+      if search_params
+        search_uri(search_params, format_string)
+      elsif sound_id
+        sound_id_uri(sound_id, format_string)
+      end
+    end
+
+    private
+
+    def search_uri(search_params, format_string)
+      "#{Freesound.config.sounds_url}/search/?api_key=#{Freesound.config.api_key}#{format_string}&#{search_params.to_uri}"
+    end
+
+    def sound_id_uri(id, format_string)
+      "#{Freesound.config.sounds_url}/#{id}/?api_key=#{Freesound.config.api_key}#{format_string}"
+    end
+  end
+end

data/lib/freesound/version.rb

@@ -0,0 +1,3 @@
+module Freesound
+  VERSION = "0.0.1"
+end

data/spec/core_ext_spec.rb

@@ -0,0 +1,71 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Hash do
+  describe '#symbolize_keys' do
+    it 'symbolizes keys' do
+      {"one" => 1, "two" => 2}.symbolize_keys.should == {:one => 1, :two => 2}
+    end
+  end
+
+  describe '#flatten_single_element_array_values' do
+    it 'converts values that are single element arrays into just the first element of that array' do
+      {"one" => [1], "two_and_three" => [2, 3], "four" => 4}
+      .flatten_single_element_array_values.should == {"one" => 1, "two_and_three" => [2, 3], "four" => 4}
+    end
+  end
+
+  describe '#to_uri' do
+    it 'converts hash to a uri string' do
+      {"one" => 1, :api_key => "1234"}.to_uri.should == "one=1&api_key=1234"
+    end
+  end
+
+  describe '#numberize_values' do
+    it 'turns all numerical string values to ints or floats' do
+      {:one => "1", :one_point_two => "1.2", :negative_three => "-3", :something => "anything"}.numberize_values.should ==
+        {:one => 1, :one_point_two => 1.2, :negative_three => -3, :something => "anything"}
+    end
+  end
+
+  describe '#underscore_keys' do
+    it 'underscores keys' do
+      {"one-two" => 12}.underscore_keys.should == {"one_two" => 12}
+    end
+  end
+end
+
+describe String do
+  describe '#numberize' do
+    it 'converts to an integer' do
+      '123'.numberize.should == 123
+    end
+
+    it 'converts to a float' do
+      '123.456'.numberize.should == 123.456
+    end
+
+    it 'returns nil for non-numerical strings' do
+      'abc123'.numberize.should be_nil
+    end
+  end
+
+  describe '#numberizeable?' do
+    it 'returns true' do
+      %w{ 123 -2 1.23 -1.56 .900 23. 023 }.each { |str| str.should be_numberizeable }
+    end
+
+    it 'returns false' do
+      %w{ 1.2.3 12a3 alex 1-23 --345 ..45 98..}.each { |str| str.should_not be_numberizeable }
+    end
+  end
+
+  describe '#underscore' do
+    it 'underscores -s' do
+      'one-two'.underscore.should == 'one_two'
+    end
+
+    it 'underscores whitespace' do
+      'one two'.underscore.should == 'one_two'
+    end
+  end
+end

data/spec/freesound/client_spec.rb

@@ -0,0 +1,49 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Client do
+  it 'has an api key' do
+    Client.new('123abc').api_key.should == '123abc'
+  end
+
+  context 'with valid api key' do
+    subject { Client.new(Freesound.config.api_key) }
+
+    before do
+      json = File.read("#{Freesound.root_dir}/data/sample.json")
+      path = "http://www.freesound.org/api/sounds/10/?api_key=#{Freesound.config.api_key}&format=json"
+
+      stub_request(:get, path).to_return(:body => json)
+    end
+
+    describe '#get_sound' do
+      it 'returns a Sound' do
+        subject.get_sound(10).should be_a(Sound)
+      end
+
+      it 'returns a Response corresponding to the given id' do
+        subject.get_sound(10).id.should == 10
+      end
+
+      it 'adds to @requests' do
+        expect { subject.get_sound(10) }.to change(subject.requests, :size).by(1)
+      end
+
+      it 'adds to @responses' do
+        expect { subject.get_sound(10) }.to change(subject.responses, :size).by(1)
+      end
+    end
+
+    describe '#search_sounds' do
+      before do
+        json = File.read("#{Freesound.root_dir}/data/sample_query.json")
+        path = "http://www.freesound.org/api/sounds/search/?api_key=#{Freesound.config.api_key}&format=json&q=badass"
+        stub_request(:get, path).to_return(:body => json)
+      end
+
+      it 'returns a response' do
+        subject.search_sounds("badass").should be_a(Array)
+        subject.search_sounds("badass").first.should be_a(Sound)
+      end
+    end
+  end
+end

data/spec/freesound/request_spec.rb

@@ -0,0 +1,26 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Request do
+  subject { Request.new({:sound_id => 10}) }
+
+  it 'initializes with a params hash' do
+    subject.params.should == {:sound_id => 10}
+  end
+
+  it 'fails with invalid format' do
+    expect { Request.new({:format => :pdf}) }.to raise_error(InvalidRequestFormatError)
+  end
+
+  describe '#get!' do
+    before do
+      json = File.read("#{Freesound.root_dir}/data/sample.json")
+      path = "http://www.freesound.org/api/sounds/10/?api_key=#{Freesound.config.api_key}&format=json"
+
+      stub_request(:get, path).to_return(:body => json)
+    end
+
+    it 'returns a Response' do
+      subject.get!.should be_a(Response)
+    end
+  end
+end