yandex_detector 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/.rspec

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

data/Gemfile

@@ -0,0 +1,3 @@
+source :rubygems
+gemspec
+gem 'rspec'

data/README.md

@@ -0,0 +1,76 @@
+# Introduction
+
+yandex_detector is a Ruby wrapper for Yandex.Detector API (http://api.yandex.ru/detector/) wich allows to detect mobile device's properties by it's request headers.
+
+This document describes installation and usage of yandex_detector.
+
+Please report issues on [Github](https://github.com/aishek/yandex_detector/issues).
+
+For feedback, suggestions, etc. write to <aishek@gmail.com>.
+
+# Installation
+
+To install:
+
+    gem install yandex_detector
+
+or with a Gemfile:
+
+    gem 'yandex_detector'
+    bundle install
+
+# Usage
+
+Usage in Rails:
+
+    require 'yandex_detector'
+
+    # API call timeout in seconds (default is 2 seconds)
+    timeout = 2
+
+    result = YandexDetector.detect request.headers, timeout
+
+Usage in Ruby program:
+
+    require 'yandex_detector'
+
+    # HTTP headers, you need at least one to perform detect
+    headers = Hash.new[
+      'user-agent',           'value1'
+      'profile',              'value2',
+      'wap-profile',          'value3',
+      'x-wap-profile',        'value4',
+      'x-operamini-phone-ua', 'value1'
+    ]
+    # API call timeout in seconds (default is 2 seconds)
+    timeout = 2
+
+    result = YandexDetector.detect headers, timeout
+
+Result object have following helpers:
+
+    result.error?
+    result.error_message
+    
+    result.success?
+    result.iphone?
+    result.android?
+    result.blackberry?
+
+Please, see [complete list of available helpers](http://rubydoc.info/github/aishek/yandex_detector/master/YandexDetector/Properties).
+
+# Documentation
+
+The [RubyDoc documentation](http://rubydoc.info/github/aishek/yandex_detector/master/frames) is available online.
+
+# How it works
+
+yandex_detector perform Yandex's API service call via network if there are at least one of needed headers provided. Please, consider right timeout value and fallback on timeout for your application to prevent slow execution.
+
+# Author
+
+Idea & implementation&nbsp;— Alexandr Borisov (<aishek@gmail.com>)
+
+# Licence
+
+yandex_detector is licensed under [MIT](https://github.com/afelix/csso/blob/master/MIT-LICENSE.txt)

data/Rakefile

@@ -0,0 +1,5 @@
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new('spec')
+
+task :default => :spec

data/lib/yandex_detector.rb

@@ -0,0 +1,16 @@
+require "yandex_detector/version"
+require "yandex_detector/result"
+
+# @author Alexandr Borisov (aishek@gmail.com)
+module YandexDetector
+  
+  # Performs detectoin by API service call via network if at least one of needed headers specified.
+  #
+  # @param [Hash] headers string-keyed hash of HTTP headers: 'profile', 'wap-profile', 'x-wap-profile', 'user-agent', 'x-operamini-phone-ua'.
+  # @param [Integer, nil] timeout timeout to API service call in seconds
+  # @return [YandexDetector::Result] result detecton object
+  def self.detect(headers, timeout = 2)
+    YandexDetector::Result.new headers, timeout
+  end
+  
+end

data/lib/yandex_detector/config.rb

@@ -0,0 +1,26 @@
+module YandexDetector
+
+  class Config
+
+    # URL of API service according documentation {http://api.yandex.ru/detector/doc/dg/concepts/detector-request.xml}
+    API_URL = 'http://phd.yandex.net/detect/'
+    # Error's tag name according documentation {http://api.yandex.ru/detector/doc/dg/concepts/detector-response.xml}
+    ERROR_TAG_NAME = 'yandex-mobile-info-error'
+  
+    # @private
+    @@timeout = 2
+  
+    # @return [Integer] timeout in seconds to API service call
+    def self.timeout
+      @@timeout
+    end
+  
+    # Set timeout value to API service call in seconds only if integer value passed
+    # @param [Integer] timeout_value specify timeout value in seconds
+    def self.timeout=(timeout_value = nil)
+      @@timeout = timeout_value if timeout_value.is_a?(Integer)
+    end
+  
+  end
+
+end

data/lib/yandex_detector/logger.rb

@@ -0,0 +1,27 @@
+module YandexDetector
+
+  class Result
+
+    class Logger
+  
+      class << self
+
+        def log(result, request_duration)
+          log_info result
+          log_info "Request to Yandex.Detector API completed in #{request_duration}"
+        end
+
+
+        private
+
+        def log_info(message)
+          Rails.logger.info message if defined?(Rails)
+        end
+
+      end
+  
+    end
+
+  end
+
+end

data/lib/yandex_detector/net.rb

@@ -0,0 +1,39 @@
+require 'yandex_detector/config'
+require 'net/http'
+require 'uri'
+
+module YandexDetector
+
+  class Net
+
+    class << self
+
+      def send_detect_request(headers)
+        result = nil
+        uri = URI.parse(prepare_url(headers))
+
+        if YandexDetector::Config.timeout > 0
+          begin
+            timeout YandexDetector::Config.timeout do
+              result = ::Net::HTTP.get uri
+            end        
+          rescue
+          end
+        end
+    
+        result
+      end
+
+
+      private
+
+      def prepare_url(headers)
+        query = headers.collect {|pair| "#{URI.encode_www_form_component(pair[0])}=#{URI.encode_www_form_component(pair[1])}" }.join('&')
+        "#{YandexDetector::Config::API_URL}?#{query}"
+      end
+
+    end
+    
+  end
+
+end

data/lib/yandex_detector/parser.rb

@@ -0,0 +1,67 @@
+require 'rubygems'
+
+module YandexDetector
+
+  class Parser
+    
+    class << self
+
+      def parse(result)
+        error_present?(result) ? parse_error(result) : parse_success(result)
+      end
+      
+      
+      private
+          
+      def parse_error(result)
+        error = match_tag_content(result, YandexDetector::Config::ERROR_TAG_NAME) if result_present?(result)
+        {
+          :text => result,
+          :error => error
+        }
+      end
+
+      def result_present?(result)
+        !result.nil? and !result.strip.empty?
+      end
+
+      def error_present?(result)
+        !result_present?(result) or result.include?(YandexDetector::Config::ERROR_TAG_NAME)
+      end
+
+      def parse_success(result)
+        begin
+          {
+            :text => result,
+            :data => {
+              :yandex_mobile_info => {
+                :name => match_tag_content(result, 'name'),
+                :vendor => match_tag_content(result, 'vendor'),
+                :device_class => match_tag_content(result, 'device-class'),
+                :device_class_desc => match_tag_content(result, 'device-class-desc'),
+                :screenx => match_tag_content(result, 'screenx'),
+                :screeny => match_tag_content(result, 'screeny'),
+                :java => {
+                  :cam_access => match_tag_content(result, 'cam-access'),
+                  :fs_accesss => match_tag_content(result, 'fs-access'),
+                  :certificate_prefix => match_tag_content(result, 'certificate-prefix'),
+                  :iconsize => match_tag_content(result, 'iconsize')
+                }
+              }
+            }
+          }
+        rescue
+          parse_error result
+        end          
+      end
+    
+      def match_tag_content(result, tagname)
+        matches = result.match("<#{tagname}>(.*)</#{tagname}>")
+        !matches.nil? and matches.length > 1 ? matches[1] : ""
+      end
+    
+    end
+  
+  end
+
+end

data/lib/yandex_detector/result.rb

@@ -0,0 +1,48 @@
+require 'yandex_detector/config'
+require 'yandex_detector/net'
+require 'yandex_detector/parser'
+require 'yandex_detector/logger'
+
+require 'yandex_detector/result/headers'
+require 'yandex_detector/result/properties'
+require 'yandex_detector/result/stats'
+
+module YandexDetector
+
+  class Result
+    include YandexDetector::Headers
+    include YandexDetector::Properties
+    include YandexDetector::Stats
+  
+    attr_reader :error, :data, :request_duration
+  
+    def initialize(request, timeout = 2)
+      YandexDetector::Config.timeout = timeout
+    
+      init_headers request
+    
+      @request_performed = false
+      detect
+    end
+  
+      
+    private
+      
+    def detect
+      return unless headers_present?
+    
+      result = nil
+      measure do
+        result = YandexDetector::Net.send_detect_request @headers
+      end
+      
+      unless result.nil?
+        Logger::log result, request_duration
+        @data = YandexDetector::Parser.parse result
+        @request_performed = true
+      end
+    end
+          
+  end
+
+end

data/lib/yandex_detector/result/headers.rb

@@ -0,0 +1,34 @@
+module YandexDetector
+
+  module Headers
+    
+    
+    private
+
+    def init_headers(headers)
+      @headers = create_headers headers
+    end
+
+    def headers_present?
+      !@headers.empty?
+    end
+    
+    def create_headers(headers)
+      result = []
+
+      push_header_if_present result, headers, 'profile'
+      push_header_if_present result, headers, 'wap-profile'
+      push_header_if_present result, headers, 'x-wap-profile'
+      push_header_if_present result, headers, 'user-agent'
+      push_header_if_present result, headers, 'x-operamini-phone-ua'
+
+      result
+    end
+  
+    def push_header_if_present(result, headers, header)
+      result << [header, headers[header]] unless headers[header].nil? or headers[header].strip.empty?
+    end
+    
+  end
+
+end

data/lib/yandex_detector/result/properties.rb

@@ -0,0 +1,78 @@
+module YandexDetector
+
+  # This module contain YandexDetector::Result instance's methods, which allow to determine concrete properties of result
+  module Properties
+  
+    # @return [Bool] network request to API service was performed
+    def request_performed?
+      @request_performed
+    end
+  
+  
+    # @return [Bool] any error occured
+    def error?
+      !request_performed? or @data.nil? or !@data[:error].nil?
+    end
+    
+    # @return [String, nil] error message if present, or nil otherwise
+    def error_message
+      begin
+        @data[:error]
+      rescue
+        nil
+      end
+    end
+
+    # @return [Bool] no error occured
+    def success?
+      !error?
+    end
+
+
+    # @return [Bool] iphone detected
+    def iphone?
+      device_class === 'iphoneos'
+    end
+  
+    # @return [Bool] android detected
+    def android?
+      device_class === 'android'
+    end
+  
+    # @return [Bool] blackberry detected
+    def blackberry?
+      device_class === 'rim'
+    end
+
+
+    # @return [String, nil] device_class string according to documentation {http://api.yandex.ru/detector/doc/dg/concepts/detector-response.xml}
+    def device_class
+      begin
+        @data[:data][:yandex_mobile_info][:device_class]
+      rescue
+        nil
+      end
+    end
+    
+    # @return [Hash] Hash representation of API service's answer according to documentation {http://api.yandex.ru/detector/doc/dg/concepts/detector-response.xml}.
+    #   All '-' signs in tag names replaced by '_' and tag names converted to symbols to use as Hash's keys.
+    def data
+      begin
+        @data[:data]
+      rescue
+        nil
+      end
+    end
+    
+    # @return [String] Text representation of API service's answer according to documentation {http://api.yandex.ru/detector/doc/dg/concepts/detector-response.xml}.
+    def text
+      begin
+        @data[:text]
+      rescue
+        nil
+      end      
+    end
+    
+  end
+
+end

data/lib/yandex_detector/result/stats.rb

@@ -0,0 +1,15 @@
+module YandexDetector
+
+  module Stats
+ 
+    private
+
+    def measure
+      start = Time.now
+      yield
+      @request_duration = Time.now - start
+    end
+    
+  end
+
+end

data/lib/yandex_detector/version.rb

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

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require 'yandex_detector'
+
+RSpec.configure do |config|
+  # some (optional) config here
+end

data/spec/yandex_detector/detector_spec_helper.rb

@@ -0,0 +1,72 @@
+module DetectorSpecHelper
+  
+  def should_provide_result_on(headers)
+    result = YandexDetector.detect headers
+    result.should be_an_instance_of(YandexDetector::Result)
+    result
+  end
+  
+  def should_result_on(headers, options = { :request_performed => true, :error => false, :success => true })
+    result = should_provide_result_on headers
+    result = check_properties result, options
+
+    result
+  end
+  
+  def check_properties(result, options = { :request_performed => true, :error => false, :success => true })
+    result.request_performed?.should(eql(options[:request_performed]), "request_performed? flag not equals to #{options[:request_performed]}") unless options[:request_performed].nil?
+    
+    result.error?.should(eql(options[:error]), "error? flag not equals to #{options[:error]}") unless options[:error].nil?
+    result.success?.should(eql(options[:success]), "success? flag not equals to #{options[:success]}") unless options[:success].nil?
+
+    result
+  end
+  
+  def android_headers
+    Hash[
+      'user-agent', 'Mozilla/5.0 (Linux; U; Android 2.3.3; pl-pl; HTC Vision Build/GRI40) AppleWebKit/533.1 (KHTML, like Gecko) Version/4.0 Mobile Safari/533.1'
+    ]
+  end
+  
+  def blackberry_headers
+    Hash[
+      'user-agent', 'BlackBerry9700/5.0.0.862 Profile/MIDP-2.1 Configuration/CLDC-1.1 VendorID/120'
+    ]
+  end
+  
+  def iphone_headers
+    Hash[
+      'user-agent', 'Mozilla/5.0 (iPhone; U; CPU like Mac OS X; en) AppleWebKit/420+ (KHTML, like Gecko) Version/3.0 Mobile/1A543a Safari/419.3'
+    ]    
+  end
+  
+  def valid_headers
+    Hash[
+      'user-agent', 'Alcatel-CTH3/1.0 UP.Browser/6.2.ALCATEL MMP/1.0',
+      'wap-profile', 'http://www-ccpp-mpd.alcatel.com/files/ALCATEL-CTH3_MMS10_1.0.rdf'
+    ]
+  end
+  
+  def headers_with_unknown_values
+    Hash[
+      'user-agent', 'unknown'
+    ]
+  end
+  
+  def empty_headers
+    Hash.new
+  end
+
+  def wrong_headers
+    Hash['test-header', 'test-value']
+  end
+
+  def headers_with_whitespaces_values
+    Hash[
+      'profile', '',
+      'user-agent', "\t\t\n\r\n\r",
+      'wap-profile', '            '
+    ]
+  end
+
+end

data/spec/yandex_detector/parser_spec_helper.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+module ParserSpecHelper
+  
+  def error_xml_text
+    error_text = 'my brand new error'
+    [error_text, "<#{YandexDetector::Config::ERROR_TAG_NAME}>#{error_text}</#{YandexDetector::Config::ERROR_TAG_NAME}>"]
+  end
+  
+  def result_xml_text
+    "<yandex-mobile-info>
+    <name>One Touch C651</name><!-- название модели телефона -->
+    <vendor>Alcatel</vendor><!-- название производителя телефона -->
+    <device-class>midp2ss</device-class><!-- класс устройства -->
+    <device-class-desc>Java MIDP2 (small)</device-class-desc><!-- описание класса устройства -->
+    <screenx>128</screenx><!-- разрешение экрана в пикселах по ширине -->
+    <screeny>160</screeny><!-- разрешение экрана в пикселах по высоте -->
+    <java><!-- контейнер для Java-параметров -->
+        <cam-access>1</cam-access><!-- есть ли у Java-приложений доступ к камере устройства -->
+        <fs-access>1</fs-access><!-- есть ли у Java-приложений доступ к файловой системе устройства -->
+        <certificate-prefix></certificate-prefix> <!-- префикс Java-сертификата -->
+        <iconsize>18x18</iconsize><!-- размер значка Java-приложения -->
+    </java> 
+</yandex-mobile-info>"
+  end
+  
+  def result_xml_text_data
+    {
+      :yandex_mobile_info => {
+        :name => "One Touch C651",
+        :vendor => "Alcatel",
+        :device_class => "midp2ss",
+        :device_class_desc => "Java MIDP2 (small)",
+        :screenx => "128",
+        :screeny => "160",
+        :java => {
+          :cam_access => "1",
+          :fs_accesss => "1",
+          :certificate_prefix => "",
+          :iconsize=>"18x18"
+        }
+      }
+    }
+  end
+  
+  def result_whitespaces
+    "\r\n\t\   \n"
+  end
+  
+end

data/spec/yandex_detector/yandex_detector/config_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+describe YandexDetector do
+  
+  describe YandexDetector::Config do
+    
+    it "should set timeout only for integer" do
+      first_value = YandexDetector::Config::timeout
+      
+      YandexDetector::Config::timeout = nil
+      YandexDetector::Config::timeout.should == first_value
+
+      YandexDetector::Config::timeout = 'a'
+      YandexDetector::Config::timeout.should == first_value
+
+      YandexDetector::Config::timeout = Object.new
+      YandexDetector::Config::timeout.should == first_value
+
+      YandexDetector::Config::timeout = 0.2
+      YandexDetector::Config::timeout.should == first_value
+      
+      YandexDetector::Config::timeout = first_value + 1
+      YandexDetector::Config::timeout.should == first_value + 1
+    end
+    
+    it "should define corrent API_URL" do
+      YandexDetector::Config::API_URL.should == "http://phd.yandex.net/detect/"
+    end
+    
+    it "should define corrent ERROR_TAG_NAME" do
+      YandexDetector::Config::ERROR_TAG_NAME.should == "yandex-mobile-info-error"
+    end
+    
+  end
+  
+end

data/spec/yandex_detector/yandex_detector/parser_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+require 'yandex_detector/parser_spec_helper'
+
+describe YandexDetector do
+  include ParserSpecHelper
+  
+  describe YandexDetector::Parser do
+
+    it "should return hash" do
+      result = YandexDetector::Parser.parse nil
+      result.should be_an_instance_of(Hash)
+    end
+    
+    it "should return error key on nil result" do
+      result = YandexDetector::Parser.parse nil
+
+      result.should be_an_instance_of(Hash)
+
+      result.should have_key(:error)
+      result.should_not have_key(:data)
+      
+      result.should have_key(:text)
+      result[:text].should == nil
+    end
+
+    it "should return error key on whitespaces result" do
+      result = YandexDetector::Parser.parse result_whitespaces
+
+      result.should be_an_instance_of(Hash)
+
+      result.should have_key(:error)
+      result.should_not have_key(:data)
+      
+      result.should have_key(:text)
+      result[:text].should == result_whitespaces
+    end
+    
+    it "should return error text in error tag present" do      
+      error_text, xml_text = error_xml_text
+      
+      result = YandexDetector::Parser.parse xml_text
+
+      result.should be_an_instance_of(Hash)
+
+      result.should have_key(:error)
+      result.should_not have_key(:data)
+
+      result[:error].should == error_text
+      
+      result.should have_key(:text)
+      result[:text].should == xml_text
+    end
+    
+    it "should return data key in hash if result passed" do
+      result = YandexDetector::Parser.parse result_xml_text
+
+      result.should be_an_instance_of(Hash)
+
+      result.should_not have_key(:error)
+      result.should have_key(:data)
+
+      result.should have_key(:text)
+      result[:text].should == result_xml_text
+    end
+    
+    it "should return equals hash by data key in hash if result passed" do
+      result = YandexDetector::Parser.parse result_xml_text
+
+      result.should be_an_instance_of(Hash)
+
+      result.should_not have_key(:error)
+      result.should have_key(:data)
+      result[:data].should == result_xml_text_data
+
+      result.should have_key(:text)
+      result[:text].should == result_xml_text
+    end
+    
+  end
+  
+end

data/spec/yandex_detector/yandex_detector_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+require 'yandex_detector/detector_spec_helper'
+
+describe YandexDetector do
+  include DetectorSpecHelper
+  
+  it "should provide result on empty" do
+    should_provide_result_on empty_headers
+  end
+  
+  it "should raise ArgumentError on empty" do
+    expect {
+      YandexDetector.detect
+    }.to raise_error(ArgumentError)
+  end
+
+  it "should apply timeout" do
+    result = YandexDetector.detect iphone_headers, 0
+    check_properties result, { :request_performed => false, :success => false, :error => true }
+  end
+
+  it "should provide result on wrong headers" do
+    should_result_on wrong_headers, :request_performed => false, :success => false, :error => true
+  end
+
+  it "should provide result and error message on unknown header value" do
+    result = should_result_on headers_with_unknown_values, :request_performed => true, :success => false, :error => true
+    result.error_message.should_not eql(nil)
+  end
+  
+  it "should no net request perform on empty" do
+    should_result_on empty_headers, :request_performed => false, :success => false, :error => true
+  end
+  
+  it "should no net request perform on headers with whitespace-values" do
+    should_result_on headers_with_whitespaces_values, :request_performed => false, :success => false, :error => true
+  end
+  
+  it "should provide result on valid" do
+    should_result_on valid_headers
+  end
+  
+  it "should provide result on iphone headers" do
+    result = should_result_on iphone_headers
+    result.iphone?.should eql(true)
+  end
+  
+  it "should provide result on blackberry headers" do
+    result = should_result_on blackberry_headers
+    result.blackberry?.should eql(true)
+  end
+  
+  it "should provide result on android" do
+    result = should_result_on android_headers
+    result.android?.should eql(true)
+  end
+
+end

data/yandex_detector.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "yandex_detector/version"
+
+Gem::Specification.new do |s|
+  s.name        = "yandex_detector"
+  s.version     = YandexDetector::VERSION
+  s.authors     = ["Alexandr Borisov"]
+  s.email       = ["aishek@gmail.com"]
+  s.platform    = Gem::Platform::RUBY
+  s.homepage    = "http://github.com/aishek/yandex_detector"
+  s.summary     = %q{yandex_detector is a gem, wich uses Yandex.Detector API to detect via request's headers.}
+  s.description = %q{yandex_detector is a gem, wich uses Yandex.Detector API to detect via request's headers (see http://api.yandex.ru/detector/).}
+  s.license = 'MIT'
+
+  s.rubyforge_project = "yandex_detector"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]  
+end

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification 
+name: yandex_detector
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Alexandr Borisov
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-10-14 00:00:00 +04:00
+default_executable: 
+dependencies: []
+
+description: yandex_detector is a gem, wich uses Yandex.Detector API to detect via request's headers (see http://api.yandex.ru/detector/).
+email: 
+- aishek@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .rspec
+- Gemfile
+- README.md
+- Rakefile
+- lib/yandex_detector.rb
+- lib/yandex_detector/config.rb
+- lib/yandex_detector/logger.rb
+- lib/yandex_detector/net.rb
+- lib/yandex_detector/parser.rb
+- lib/yandex_detector/result.rb
+- lib/yandex_detector/result/headers.rb
+- lib/yandex_detector/result/properties.rb
+- lib/yandex_detector/result/stats.rb
+- lib/yandex_detector/version.rb
+- spec/spec_helper.rb
+- spec/yandex_detector/detector_spec_helper.rb
+- spec/yandex_detector/parser_spec_helper.rb
+- spec/yandex_detector/yandex_detector/config_spec.rb
+- spec/yandex_detector/yandex_detector/parser_spec.rb
+- spec/yandex_detector/yandex_detector_spec.rb
+- yandex_detector.gemspec
+has_rdoc: true
+homepage: http://github.com/aishek/yandex_detector
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: yandex_detector
+rubygems_version: 1.4.2
+signing_key: 
+specification_version: 3
+summary: yandex_detector is a gem, wich uses Yandex.Detector API to detect via request's headers.
+test_files: 
+- spec/spec_helper.rb
+- spec/yandex_detector/detector_spec_helper.rb
+- spec/yandex_detector/parser_spec_helper.rb
+- spec/yandex_detector/yandex_detector/config_spec.rb
+- spec/yandex_detector/yandex_detector/parser_spec.rb
+- spec/yandex_detector/yandex_detector_spec.rb