semrush 3.0.0

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2011 YOURNAME
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,88 @@
+= Semrush
+
+Semrush is a ruby wrapper for the SEMRush API.
+
+== Installation
+
+Add the gem to your Gemfile:
+
+  gem install semrush
+
+Create an initializer, for instance semrush.rb with the following:
+
+  Semrush.config do |config|
+    config.api_key = "7899esf6874"
+  end
+
+Replace '7899esf6874' with your SEMRush api key.
+
+== Getting started
+
+First, create a report for a domain, a URL or a phrase with:
+
+  report = Semrush::Report.domain("seobook.com")                 # for the "seobook.com" domain
+  report = Semrush::Report.url("http://tools.seobook.com/")      # for the "http://tools.seobook.com/" url
+  report = Semrush::Report.phrase("search+engine+optimization")  # for the "search+engine+optimization" phrase
+
+Then run the report type you need:
+
+  basic_data = report.basics
+
+or
+
+  keywords_data = report.keywords_organic
+
+== Parameters
+
+You may use the following parameters:
+
+  :db         # (String) select the google engine ('us' for google.comn 'fr' for google.fr)
+  :api_key    # (String) change the api_key
+  :limit      # (Integer) select only the first 'limit' entries
+  :offset     # (Integer) skip the first 'offset' entries
+  :export_columns # (String) select the columns you want to fetch, for instance: :export_columns => "Dn,Rk"
+
+Some examples:
+
+  report = Semrush::Report.domain("seobook.com", :db => 'us', :limit => 100)
+  data = report.basics
+
+or
+
+  report = Semrush::Report.domain("seobook.com")
+  data = report.basics(:db => 'us', :limit => 100)
+
+You will find more information about these parameters at http://www.semrush.com/api.html
+
+== Reports
+
+=== Source of reports
+
+They are 3 sources for the reports: domain, url and phrase.
+
+  report = Semrush::Report.domain("seobook.com")                 # for the "seobook.com" domain
+  report = Semrush::Report.url("http://tools.seobook.com/")      # for the "http://tools.seobook.com/" url
+  report = Semrush::Report.phrase("search+engine+optimization")  # for the "search+engine+optimization" phrase
+
+=== Report types
+
+You may call for one of the following report types:
+
+  data = report.basics                          # main report for either a domain or a phrase
+  data = report.keywords_organic                # keywords organic report for either a domain or a URL
+  data = report.keywords_adwords                # keywords adwords report for either a domain or a URL
+  data = report.competitors_organic             # for a domain
+  data = report.competitors_adwords             # for a domain
+  data = report.competitors_organic_by_adwords  # for a domain
+  data = report.competitors_adwords_by_organic  # for a domain
+  data = report.related                         # keywords related report for a phrase
+
+For more information about the report types, please read http://www.semrush.com/api.html
+
+== About authors
+
+This gem is inspired by the work of Cramer Development for the semrush-client plugin (https://github.com/cramerdev/semrush-client).
+
+It has been rewritten and gemified for the internal use in Weboglobin (http://fr.weboglobin.com).
+
+This project rocks and uses MIT-LICENSE.

data/Rakefile

@@ -0,0 +1,27 @@
+#!/usr/bin/env rake
+
+begin
+  require 'rdoc/task'
+rescue LoadError
+  require 'rdoc/rdoc'
+  require 'rake/rdoctask'
+  RDoc::Task = Rake::RDocTask
+end
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Semrush'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+require "rspec/core/rake_task"
+
+desc "Run all test with spec"
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = %w[--color]
+  t.pattern = 'spec/*_spec.rb'
+end
+desc "Run tests"
+task :default => :spec

data/lib/semrush.rb

@@ -0,0 +1,38 @@
+require 'uri'
+require 'net/http'
+require 'csv'
+require 'rubygems'
+require 'active_support/all'
+require 'pony' #for the warning mails
+require 'semrush/exception'
+require 'semrush/report'
+
+module Semrush
+  API_REPORT_URL = "http://%DB%.api.semrush.com/?action=report&type=%REPORT_TYPE%&%REQUEST_TYPE%=%REQUEST%&key=%API_KEY%&display_limit=%LIMIT%&display_offset=%OFFSET%&export=api&export_columns=%EXPORT_COLUMNS%"
+
+  mattr_accessor :api_key
+  @@api_key = ""
+  mattr_accessor :debug
+  @@debug = false
+
+
+  # Email Options (TODO: remove if unnecessary)
+  # config.email : recipient for the email notifications (default: nil)
+  # config.email_options : Hash with email config (smtp, sendmail, ...). We use the Pony gem to send mails, this hash will be send to Pony.options
+  # config.seconds_between_mails : Minimum time (in seconds) between 2 mails with the same subject
+  mattr_accessor :email
+  mattr_accessor :email_options
+  @@email_options = {}
+  mattr_accessor :seconds_between_mails
+  @@seconds_between_mails = 600
+  mattr_accessor :too_many_queries
+  @@too_many_queries = {:subject => 'SemRush API: too many queries for the day', :body => 'You made too many requests for today. You should upgrade your plan in order to be able to send more requests to SemRush.'}
+  mattr_accessor :too_many_queries_sent_at
+
+  def self.config
+    yield self
+    Pony.options = @@email_options
+    raise Exception::BadApiKey.new if @@api_key.nil? || @@api_key.empty?
+  end
+
+end

data/lib/semrush/exception.rb

@@ -0,0 +1,11 @@
+module Semrush
+  module Exception
+    class Base < ::Exception
+      def initialize query = nil, message = ""
+        message = "[query=#{query.inspect}] #{message}" if !query.nil?
+        super(message)
+      end
+    end
+  end
+end
+Dir[File.expand_path('../exception/', __FILE__)+'/*.rb'].each {|file| require(file) }

data/lib/semrush/exception/api_access_disabled.rb

@@ -0,0 +1,7 @@
+module Semrush
+  module Exception
+    class ApiAccessDisabled < Base
+
+    end
+  end
+end

data/lib/semrush/exception/bad_api_key.rb

@@ -0,0 +1,7 @@
+module Semrush
+  module Exception
+    class BadApiKey < Base
+
+    end
+  end
+end

data/lib/semrush/exception/bad_argument.rb

@@ -0,0 +1,11 @@
+module Semrush
+  module Exception
+    class BadArgument < Base
+
+    end
+    class MandatoryParameterDomainNotSetOrEmtpy <  BadArgument; end
+    class MandatoryParameterUrlNotSetOrEmtpy <  BadArgument; end
+    class MandatoryParameterPhraseNotSetOrEmtpy <  BadArgument; end
+    class WrongFormatOrEmptyKey <  BadArgument; end
+  end
+end

data/lib/semrush/exception/bad_query.rb

@@ -0,0 +1,7 @@
+module Semrush
+  module Exception
+    class BadQuery < Base
+
+    end
+  end
+end

data/lib/semrush/exception/nothing_found.rb

@@ -0,0 +1,7 @@
+module Semrush
+  module Exception
+    class NothingFound < Base
+
+    end
+  end
+end

data/lib/semrush/exception/unknown_error.rb

@@ -0,0 +1,7 @@
+module Semrush
+  module Exception
+    class UnknownError < Base
+
+    end
+  end
+end

data/lib/semrush/report.rb

@@ -0,0 +1,298 @@
+module Semrush
+  # =Report Class
+  # Most of these methods take a hash parameter that may contain the following keys :
+  # * :db (ex: :db => "us")
+  # * :api_key (ex: :api_key => 'gt97s6d4a6w')
+  # * :limit (ex: :limit => 2000)
+  # * :offset (ex: :offset => 5)
+  # * :export_columns (ex: :export_columns => "Dn,Rk")
+  class Report
+    DBS = [:us, :uk, :ru, :de, :fr, :es, :it, :br, :au] #"us" - for Google.com, "uk" - for Google.co.uk, "ru" - for Google.ru, "de" for Google.de, "fr" for Google.fr, "es" for Google.es, "it" for Google.it Beta, "br" for Google.com.br Beta, "au" for Google.com.au Beta.
+    REPORT_TYPES = [:domain_rank, :domain_organic, :domain_adwords, :domain_organic_organic, :domain_adwords_adwords, :domain_organic_adwords, :domain_adwords_organic,
+                    :phrase_this, :phrase_related,
+                    :url_organic, :url_adwords]
+    REQUEST_TYPES = [:domain, :phrase, :url]
+
+
+    # Tries to make the api call for the report called as method (see samples on http://www.semrush.com/api.html).
+    # Allows calls like:
+    # * Semrush::Report.new.domain_rank(:request_type => :domain, :request => 'thedomain.com')
+    # * Semrush::Report.new.domain_organic_organic(:request_type => :domain, :request => 'thedomain.com')
+    # * Semrush::Report.new.phrase_related(:request_type => :phrase, :request => 'the phrase')
+    def method_missing(method, *args)
+      return super unless REPORT_TYPES.include?(method) && args.first.is_a?(Hash)
+      request args.first.merge(:report_type => method)
+    end
+
+    def initialize params = {}
+      @parameters = params
+    end
+
+    # Initializes a report for a specific domain.
+    # Takes a hash parameter that may contain the following keys :
+    # * :db (ex: :db => "us")
+    # * :api_key (ex: :api_key => 'gt97s6d4a6w')
+    # * :limit (ex: :limit => "")
+    # * :offset (ex: :offset => "")
+    # * :export_columns (ex: :export_columns => "")
+    def self.domain domain, params = {}
+      self.new(params.merge(:request_type => :domain, :request => domain))
+    end
+    # Initializes a report for a specific phrase (or keyword).
+    # Takes a hash parameter that may contain the following keys :
+    # * :db (ex: :db => "us")
+    # * :api_key (ex: :api_key => 'gt97s6d4a6w')
+    # * :limit (ex: :limit => "")
+    # * :offset (ex: :offset => "")
+    # * :export_columns (ex: :export_columns => "")
+    def self.phrase phrase, params = {}
+      self.new(params.merge(:request_type => :phrase, :request => phrase))
+    end
+    # Initializes a report for a specific domain.
+    # Takes a hash parameter that may contain the following keys :
+    # * :db (ex: :db => "us")
+    # * :api_key (ex: :api_key => 'gt97s6d4a6w')
+    # * :limit (ex: :limit => "")
+    # * :offset (ex: :offset => "")
+    # * :export_columns (ex: :export_columns => "")
+    def self.url url, params = {}
+      self.new(params.merge(:request_type => :url, :request => url))
+    end
+
+    # Main report.
+    # Available for a phrase or a domain.
+    # Default columns for a domain:
+    # * Dn - A site name.
+    # * Rk - Rating of sites by the number of visitors coming from the first 20 Google search results
+    # * Or - Keywords that this site has in TOP20 Google Organic results
+    # * Ot - Estimated number of visitors coming from the first 20 Google search results (per month)
+    # * Oc - Estimated cost of purchasing the same number of visitors
+    # * Ad - Keywords that this site has in TOP20 Google AdWords
+    # * At - Estimated number of visitors coming from AdWords (per month)
+    # * Ac - Estimated expenses of the site for the advertising in AdWords (per month)
+    # Default columns for a phrase:
+    # * Ph - The search query which the site has within the first 20 Google search results
+    # * Nq - Average number of queries of this keyword in a month, for the corresponding local version of Google
+    # * Cp - Average price of a click on the AdWords ad for this search query, in U.S. dollars
+    # * Co - Competition of advertisers in AdWords for that term, the higher is the number - the higher is the competition
+    # * Nr - The number of search results - how many pages does Google know for this query
+    def basics params = {}
+      domain? ? request(params.merge(:report_type => :domain_rank)) : request(params.merge(:report_type => :phrase_this))
+    end
+    
+    # Organic Keywords report
+    # Can be called for a domain or a URL.
+    # Default columns for a domain:
+    # * Ph - The search query which the site has within the first 20 Google search results
+    # * Po - The position of the site for the search query in Google, at the moment of data collection
+    # * Pp - The position of the site for the search query in Google, for the previous data collection
+    # * Nq - Average number of queries of this keyword in a month, for the corresponding local version of Google
+    # * Cp - Average price of a click on the AdWords ad for this search query, in U.S. dollars
+    # * Ur - URL of a page of the site which is displayed in search results for this query (landing page)
+    # * Tr - The ratio of the number of visitors coming to the site from this search request to all visitors coming from Google search results
+    # * Tc - The ratio of the estimated cost of buying the same number of visitors for this search query to the estimated cost of purchasing the same number of targeted visitors coming to this site from Google search results
+    # * Co - Competition of advertisers in AdWords for that term, the higher is the number - the higher is the competition
+    # * Nr - The number of search results - how many pages does Google know for this query
+    # * Td - Dynamics of change in the number of search queries in the past 12 months (estimated)
+    # Default columns for a URL:
+    # * Ph - Search query that the URL has within the first 20 Google Organic or AdWords results
+    # * Po - The position of this URL for this keyword in Organic or AdWords results
+    # * Nq - Average number of queries of this keyword in a month, for the corresponding local version of Google
+    # * Cp - Average price of a click on the AdWords ad for this search query, in U.S. dollars
+    # * Co - Competition of advertisers in AdWords for that term, the higher is the number - the higher is the competition
+    # * Tr - The ratio of the number of visitors coming to the URL from this keyword to all visitors coming
+    # * Tc - The ratio of the estimated cost of buying the same number of visitors for this search query to the estimated cost of purchasing the same number of targeted visitors coming to this URL
+    # * Nr - The number of search results - how many pages does Google know for this query
+    # * Td - Dynamics of change in the number of search queries in the past 12 months (estimated)
+    def keywords_organic params = {}
+      url? ? request(params.merge(:report_type => :url_organic)) : request(params.merge(:report_type => :domain_organic))
+    end
+
+    # AdWords keywords report
+    # Can be called for a domain or a URL.
+    # Default columns for a domain:
+    # * Ph - Search query which the site buys in AdWords in Google
+    # * Po - The position of the ad at the time of data collection
+    # * Pp - The position of the ad at the time of previous data collection
+    # * Nq - Average number of queries of this keyword in a month, for the corresponding local version of Google
+    # * Cp - Average price of a click on the AdWords ad for this search query, in U.S. dollars
+    # * Vu - Display URL. This is the URL displayed on your ad to identify your site to users.
+    # * Tr - The ratio of the number of visitors coming to the site from this ad to all visitors coming from Google AdWords
+    # * Tc - The ratio of site's expenditures on this particular ad to it's expenditures on all AdWords ads in general
+    # * Co - Competition of advertisers in AdWords for that term, the higher is the number - the higher is the competition
+    # * Nr - The number of search results - how many pages does Google know for this query
+    # * Td - Dynamics of change in the number of search queries in the past 12 months (estimated)
+    # * Ur - The destination URL is the exact URL within your website that you want to send users to from your ad.
+    # Default columns for a URL:
+    # * Ph - Search query that the URL has within the first 20 Google Organic or AdWords results
+    # * Po - The position of this URL for this keyword in Organic or AdWords results
+    # * Nq - Average number of queries of this keyword in a month, for the corresponding local version of Google
+    # * Cp - Average price of a click on the AdWords ad for this search query, in U.S. dollars
+    # * Co - Competition of advertisers in AdWords for that term, the higher is the number - the higher is the competition
+    # * Tr - The ratio of the number of visitors coming to the URL from this keyword to all visitors coming
+    # * Tc - The ratio of the estimated cost of buying the same number of visitors for this search query to the estimated cost of purchasing the same number of targeted visitors coming to this URL
+    # * Nr - The number of search results - how many pages does Google know for this query
+    # * Td - Dynamics of change in the number of search queries in the past 12 months (estimated)
+    def keywords_adwords params = {}
+      url? ? request(params.merge(:report_type => :url_adwords)) : request(params.merge(:report_type => :domain_adwords))
+    end
+
+    # Competitors in organic search report
+    # Default columns:
+    # * Dn - Sites competing with this site in Google search results, sorted by the number of common keywords
+    # * Np - The number of keywords on which the site is displayed in search results next to the analyzed site
+    # * Or - Keywords that this site has in TOP20 Google Organic results
+    # * Ot - Estimated number of visitors coming from the first 20 Google search results (per month)
+    # * Oc - Estimated cost of purchasing the same number of visitors
+    # * Ad - Keywords that this site has in TOP20 Google AdWords
+    def competitors_organic params = {}
+      request(params.merge(:report_type => :domain_organic_organic))
+    end
+
+    # Competitors in AdWords search report
+    # Default columns:
+    # * Dn - Sites competing with this site in AdWords, sorted by the number of common keywords
+    # * Np - Number of common keywords in AdWords that these two sites buy
+    # * Ad - Keywords that this site has in TOP20 Google AdWords
+    # * At - Estimated number of visitors coming from AdWords (per month)
+    # * Ac - Estimated expenses of the site for the advertising in AdWords (per month)
+    # * Or - Keywords that this site has in TOP20 Google Organic results
+    def competitors_adwords params = {}
+      request(params.merge(:report_type => :domain_adwords_adwords))
+    end
+
+    # Potential ad/traffic buyers report
+    # Default columns:
+    # * Dn - The list of sites that buys ads in AdWords for those keywords that the domain under analyzis has within Google TOP20
+    # * Np - Number of keywords on which ads of this particular site appear and the analyzed site gets within Google TOP20
+    # * Ad - Keywords that this site has in TOP20 Google AdWords
+    # * At - Estimated number of visitors coming from AdWords (per month)
+    # * Ac - Estimated expenses of the site for the advertising in AdWords (per month)
+    # * Or - Keywords that this site has in TOP20 Google Organic results
+    def competitors_organic_by_adwords params = {}
+      request(params.merge(:report_type => :domain_organic_adwords))
+    end
+
+    # Potential ad/traffic sellers report
+    # Default columns:
+    # * Dn - Sites that get into Google TOP20 for keyword queries that analyzed site buy in AdWords
+    # * Np - The number of keywords which this site has in search results next to the AdWords ads of the analyzed site
+    # * Or - Keywords that this site has in TOP20 Google Organic results
+    # * Ot - Estimated number of visitors coming from the first 20 Google search results (per month)
+    # * Oc - Estimated cost of purchasing the same number of visitors
+    # * Ad - Keywords that this site has in TOP20 Google AdWords
+    def competitors_adwords_by_organic params = {}
+      request(params.merge(:report_type => :domain_adwords_organic))
+    end
+
+    # Related keyword report
+    # Default columns:
+    # * Ph - The search query which the site has within the first 20 Google search results
+    # * Nq - Average number of queries of this keyword in a month, for the corresponding local version of Google
+    # * Cp - Average price of a click on the AdWords ad for this search query, in U.S. dollars
+    # * Co - Competition of advertisers in AdWords for that term, the higher is the number - the higher is the competition
+    # * Nr - The number of search results - how many pages does Google know for this query
+    # * Td - Dynamics of change in the number of search queries in the past 12 months (estimated)
+    def related params = {}
+      request(params.merge(:report_type => :phrase_related))
+    end
+
+    private
+
+    def request params = {}
+      validate_parameters params
+      temp_url = "#{API_REPORT_URL}" #do not copy the constant as is or else the constant would be modified !!
+      @parameters.each {|k, v|
+        if v.blank?
+          temp_url.gsub!(/&[^&=]+=%#{k.to_s}%/i, '')
+        else
+          temp_url.gsub!("%#{k.to_s.upcase}%", URI.escape(v.to_s))
+        end
+      }
+      puts "[Semrush query] URL: #{temp_url}" if Semrush.debug
+      url = URI.parse(temp_url)
+      response = Net::HTTP.start(url.host, url.port) {|http|
+        http.get(url.path+"?"+url.query)
+      }.body rescue "ERROR :: RESPONSE ERROR (-1)" # Make this error up
+      response.starts_with?("ERROR") ? error(response) : parse(response)
+    end
+
+    # All parameters:
+    # * db - requested database
+    # * report_type - type of the report
+    # * api_key - user identification key, you can find it in your profile on the Semrush site
+    # * request_type - type of the request.
+    # * request - your request
+    # * limit - number of results returned
+    # * offset - says to skip that many results before beginning to return results to you
+    # * export_columns - list of column names, separated by coma. You may list just the column names you need in an order you need.
+    #
+    # more details in http://www.semrush.com/api.html
+    def validate_parameters params = {}
+      params.symbolize_keys!
+      params.delete(:db) unless DBS.include?(params[:db].try(:to_sym))
+      params.delete(:report_type) unless REPORT_TYPES.include?(params[:report_type].try(:to_sym))
+      params.delete(:request_type) unless REQUEST_TYPES.include?(params[:request_type].try(:to_sym))
+      @parameters = {:db => "us", :api_key => Semrush.api_key, :limit => "", :offset => "", :export_columns => ""}.merge(@parameters).merge(params)
+      raise Semrush::Exception::BadArgument.new(self, "Request parameter is missing: Domain name, URL, or keywords are required.") unless @parameters[:request].present?
+      raise Semrush::Exception::BadArgument.new(self, "Bad db: #{@parameters[:db]}") unless DBS.include?(@parameters[:db].try(:to_sym))
+      raise Semrush::Exception::BadArgument.new(self, "Bad report type: #{@parameters[:report_type]}") unless REPORT_TYPES.include?(@parameters[:report_type].try(:to_sym))
+      raise Semrush::Exception::BadArgument.new(self, "Bad request type: #{@parameters[:request_type]}") unless REQUEST_TYPES.include?(@parameters[:request_type].try(:to_sym))
+    end
+
+    # Format and raise an error
+    def error(text = "")
+      e = /ERROR\s(\d+)\s::\s(.*)/.match(text) || {}
+      name = (e[2] || "UnknownError").titleize
+      code = e[1] || -1
+      error_class = name.gsub(/\s/, "")
+
+      if error_class == "NothingFound"
+        []
+      else
+        raise Semrush::Exception.const_get(error_class).new(self, "#{name} (#{code})")
+      end
+    end
+
+    def parse(text = "")
+      csv = CSV.parse(text.to_s, :col_sep => ";")
+      data = {}
+      format_key = lambda do |k|
+        r = {
+          /\s/ => "_",
+          /[|\.|\)|\(]/ => "",
+          /%/ => "percent",
+          /\*/ => "times"
+        }
+        k = k.to_s.downcase
+        r.each_pair {|pattern, replace| k.gsub!(pattern, replace) }
+        k.to_sym
+      end
+
+      # (thanks http://snippets.dzone.com/posts/show/3899)
+      keys = csv.shift.map(&format_key)
+      string_data = csv.map {|row| row.map {|cell| cell.to_s } }
+      string_data.map {|row| Hash[*keys.zip(row).flatten] }
+    rescue CSV::MalformedCSVError => csvife
+      tries ||= 0
+      if (tries += 1) < 3
+        retry
+      else
+        raise CSV::MalformedCSVError.new("Bad format for CSV: #{text.inspect}").tap{|e|
+          e.set_backtrace(csvife.backtrace)}
+      end
+    end
+
+    def domain?
+      @parameters[:request_type].present? && REQUEST_TYPES.include?(@parameters[:request_type].to_sym) && @parameters[:request_type].to_sym==:domain
+    end
+    def url?
+      @parameters[:request_type].present? && REQUEST_TYPES.include?(@parameters[:request_type].to_sym) && @parameters[:request_type].to_sym==:url
+    end
+    def phrase?
+      @parameters[:request_type].present? && REQUEST_TYPES.include?(@parameters[:request_type].to_sym) && @parameters[:request_type].to_sym==:phrase
+    end
+
+
+  end
+end

data/lib/semrush/version.rb

@@ -0,0 +1,3 @@
+module Semrush
+  VERSION = "3.0.0" # we want to follow the API version: for API 3.0, the gem will be version 3.0.x
+end

data/lib/tasks/semrush_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :semrush do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification 
+name: semrush
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 3.0.0
+platform: ruby
+authors: 
+- arambert
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-10-21 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 3.1.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: pony
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.0.0
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.0.0
+  type: :development
+  version_requirements: *id003
+description: 
+email: 
+- arambert@weboglobin.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/semrush/exception/api_access_disabled.rb
+- lib/semrush/exception/bad_api_key.rb
+- lib/semrush/exception/bad_argument.rb
+- lib/semrush/exception/bad_query.rb
+- lib/semrush/exception/nothing_found.rb
+- lib/semrush/exception/unknown_error.rb
+- lib/semrush/exception.rb
+- lib/semrush/report.rb
+- lib/semrush/version.rb
+- lib/semrush.rb
+- lib/tasks/semrush_tasks.rake
+- MIT-LICENSE
+- Rakefile
+- README.rdoc
+homepage: http://www.weboglobin.com
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.9
+signing_key: 
+specification_version: 3
+summary: This gem is a ruby client for the SemRush API.
+test_files: []
+