yandex-webmaster 0.1.1

data/lib/yandex-webmaster/base.rb

@@ -0,0 +1,120 @@
+# encoding: utf-8
+
+require 'yandex-webmaster/configuration'
+
+require 'yandex-webmaster/authorization'
+require 'yandex-webmaster/connection'
+require 'yandex-webmaster/request'
+
+module Yandex
+  module Webmaster
+    class Base
+      include Authorization
+      include Connection
+      include Request
+
+      class << self
+        def define_attributes(options = {}, &block)
+          options[:as] ||= :attributes        
+          
+          cattr_accessor options[:as].to_sym
+          class_eval(<<-EOS, __FILE__, __LINE__ + 1)          
+            @@#{options[:as].to_s} ||= {}
+          EOS
+
+          unless options[:inspect] == false          
+            define_method(:inspect) do
+              inspection = self.send(options[:as].to_s).map { |key, value|              
+                self.inspect_attribute(key, value[:instance_variable_name])
+              }.compact.join(', ')
+
+              "#<#{self.class} #{inspection}>"
+            end
+
+            define_method(:inspect_attribute) do |attribute_name, instance_variable_name|
+              value = instance_variable_get(instance_variable_name.to_s)
+
+              if value.is_a?(String) && value.length > 50
+                "#{attribute_name.to_s}[#{value.size}]: " + "#{value[0..50]}...".inspect
+              elsif value.is_a?(Array) && value.length > 5
+                "#{attribute_name.to_s}[#{value.size}]: " + "#{value[0..5]}...".inspect
+              else
+                "#{attribute_name.to_s}: " + value.inspect
+              end
+            end
+            
+          end
+
+          Yandex::Webmaster::Api::AttributesBuilder.new(self, options, &block)
+        end
+
+        def const_missing(name)
+          Yandex::Webmaster::Api::AttributesBuilder.cast_type(name) || super
+        end
+      end
+
+      attr_accessor :configuration
+
+      def initialize(attributes = {})
+        self.attributes = attributes
+      end
+
+      def attributes=(attributes = {})
+        attributes.each do |attr,value|
+          self.send("#{attr}=", value) if self.respond_to?("#{attr}=")
+        end
+      end
+
+      def configuration=(value)
+        value = Yandex::Webmaster::Configuration.new(value) if !value.is_a?(Yandex::Webmaster::Configuration)
+        @configuration = value
+      end
+
+      # Responds to attribute query or attribute clear
+      def method_missing(method, *args, &block) # :nodoc:
+        case method.to_s
+        when /^(.*)\?$/
+          return !!self.send($1.to_s)
+        when /^clear_(.*)$/
+          self.send("#{$1.to_s}=", nil)
+        else
+          super
+        end
+      end
+
+      # Acts as setter and getter for api requests arguments parsing.
+      #
+      # Returns Arguments instance.
+      #
+      # def arguments(args=(not_set = true), options={}, &block)
+      #   if not_set
+      #     @arguments
+      #   else
+      #     @arguments = Arguments.new(self, options).parse(*args, &block)
+      #   end
+      # end
+
+    protected
+
+      def objects_from_response(klass, response, prefix)        
+        self.objects_from_array(klass, self.fetch_value(response, prefix))
+      end
+
+      def fetch_value(response, prefix)
+        response.body[prefix]
+      end
+
+      # @param klass [Class]
+      # @param array [Array]      
+      # @return [Array<Class>]
+      def objects_from_array(klass, array)
+        array.map do |attributes|
+          instance = klass.new
+          instance.configuration = self.configuration
+          instance.attributes = attributes
+          instance
+        end
+      end
+    end
+  end
+end

data/lib/yandex-webmaster/client.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+module Yandex
+  module Webmaster
+    class Client < Base
+      def hosts(reload = false)
+        @hosts = nil if reload
+        @hosts ||= Yandex::Webmaster::ApiFactory.new({
+          :klass => Yandex::Webmaster::Host,
+          :url => '/hosts',
+          :configuration => self.configuration
+        })
+      end
+    end
+  end
+end

data/lib/yandex-webmaster/configuration.rb

@@ -0,0 +1,99 @@
+# encoding: utf-8
+
+require 'singleton'
+
+module Yandex
+  module Webmaster
+    class Configuration
+      VALID_OPTIONS_KEYS = [
+        :adapter,
+        :app_id,
+        :app_password,
+        :oauth_token,
+        :endpoint,
+        :site,
+        :ssl,        
+        :user_agent,
+        :connection_options        
+      ].freeze
+
+      # Other adapters are :typhoeus, :patron, :em_synchrony, :excon, :test
+      DEFAULT_ADAPTER = :net_http
+
+      # By default, don't set an application id
+      DEFAULT_APP_ID = nil
+
+      # By default, don't set an application password
+      DEFAULT_APP_PASSWORD = nil
+
+      # By default, don't set a user oauth access token
+      DEFAULT_OAUTH_TOKEN = nil
+
+      # The api endpoint used to connect to Yandex.Webmaster if none is set
+      DEFAULT_ENDPOINT = 'https://webmaster.yandex.ru/api/v2/'.freeze
+
+      # The web endpoint used to connect to Yandex.Webmaster if none is set
+      DEFAULT_SITE = 'https://oauth.yandex.ru/'.freeze
+
+      # The default SSL configuration
+      DEFAULT_SSL = {}
+
+      # The value sent in the http header for 'User-Agent' if none is set
+      DEFAULT_USER_AGENT = "Webmaster Ruby Gem #{Yandex::Webmaster::Version::STRING}".freeze
+
+      # By default uses the Faraday connection options if none is set
+      DEFAULT_CONNECTION_OPTIONS = {}
+
+      attr_accessor *VALID_OPTIONS_KEYS
+
+      def initialize(options = {})        
+        raise ArgumentError if (options.symbolize_keys!.keys - VALID_OPTIONS_KEYS).any?
+
+        self.reset!
+        options.each { |k,v| send("#{k}=", v) }
+      end
+
+      def keys
+        VALID_OPTIONS_KEYS
+      end
+
+      def current
+        VALID_OPTIONS_KEYS.inject({}) { |h, k| h[k] = send(k); h }
+      end
+
+      # Reset configuration options to their defaults
+      #
+      def reset!
+        self.adapter            = DEFAULT_ADAPTER
+        self.app_id             = DEFAULT_APP_ID
+        self.app_password       = DEFAULT_APP_PASSWORD
+        self.oauth_token        = DEFAULT_OAUTH_TOKEN
+        self.endpoint           = DEFAULT_ENDPOINT
+        self.site               = DEFAULT_SITE
+        self.ssl                = DEFAULT_SSL
+        self.user_agent         = DEFAULT_USER_AGENT
+        self.connection_options = DEFAULT_CONNECTION_OPTIONS        
+        self
+      end      
+
+      # Convenience method to allow for global setting of configuration options
+      # 
+      def configure
+        yield self
+      end
+
+      # Responds to attribute query or attribute clear
+      # 
+      def method_missing(method, *args, &block) # :nodoc:
+        case method.to_s
+        when /^(.*)\?$/
+          return !!self.send($1.to_s)
+        when /^clear_(.*)$/
+          self.send("#{$1.to_s}=", nil)
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/yandex-webmaster/connection.rb

@@ -0,0 +1,87 @@
+# encoding: utf-8
+
+require 'faraday'
+
+module Yandex
+  module Webmaster
+    module Connection
+      extend self
+
+      USER_AGENT = 'User-Agent'.freeze
+
+      ACCEPT = 'Accept'.freeze
+
+      ACCEPT_CHARSET = 'Accept-Charset'.freeze
+
+      CONTENT_TYPE = 'Content-Type'.freeze
+
+      ALLOWED_OPTIONS = [
+        :headers,
+        :url,
+        :params,
+        :request,
+        :ssl
+      ].freeze
+
+      # Returns a Fraday::Connection object
+      #
+      def connection(options = {})
+
+        options = self.connection_options(options)
+        
+        if @connection_options != options        
+          @connection = nil
+          @connection_options = options          
+        end
+
+        @connection ||= Faraday.new(@connection_options.merge(:builder => self.stack))
+      end
+
+    protected
+        
+      def connection_options(options = {})
+        options.slice!(*ALLOWED_OPTIONS)
+
+        {
+          :headers => {            
+            ACCEPT_CHARSET   => "utf-8",
+            USER_AGENT       => self.configuration.user_agent,
+            # Due to error in Yandex.Webmaster API I had to change this header
+            # http://clubs.ya.ru/webmaster-api/replies.xml?item_no=150
+            # CONTENT_TYPE     => 'application/xml'
+            CONTENT_TYPE     => 'application/x-www-form-urlencoded'
+          },
+          :ssl => options.fetch(:ssl) { self.configuration.ssl },
+          :url => options.fetch(:endpoint) { self.configuration.endpoint }
+        }.merge(options)
+      end
+
+      # Exposes middleware builder to facilitate custom stacks and easy
+      # addition of new extensions such as cache adapter.
+      #
+      def stack(&block)
+        @stack ||= begin
+          block_given? ? Faraday::Builder.new(&block) : Faraday::Builder.new(&default_middleware)
+        end
+      end
+
+      # Default middleware stack that uses default adapter as specified at
+      # configuration stage.
+      #
+      def default_middleware
+        Proc.new do |builder|          
+          builder.use Faraday::Request::Multipart
+          builder.use Faraday::Request::UrlEncoded
+          builder.use Yandex::Webmaster::Request::OAuth2, self.configuration.oauth_token
+
+          builder.use Faraday::Response::Logger if ENV['DEBUG']
+          builder.use Yandex::Webmaster::Response::Hashify
+          # builder.use Yandex::Webmaster::Response::RaiseError
+          
+          builder.adapter self.configuration.adapter
+        end
+      end  
+
+    end
+  end
+end

data/lib/yandex-webmaster/core_ext/array.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+class Array # :nodoc:
+  def extract_options!
+    if last.is_a?(Hash) && last.extractable_options?
+      pop
+    else
+      {}
+    end
+  end unless method_defined?(:extract_options!)
+
+  class << self
+    def wrap(object)
+      if object.nil?
+        []
+      elsif object.respond_to?(:to_ary)
+        object.to_ary || [object]
+      else
+        [object]
+      end
+    end unless method_defined?(:wrap)
+  end
+end

data/lib/yandex-webmaster/core_ext/class.rb

@@ -0,0 +1,55 @@
+# encoding: utf-8
+
+class Class
+  def cattr_reader(*syms)
+    options = syms.extract_options!
+    syms.each do |sym|
+      class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+
+        def self.#{sym}
+          @@#{sym}
+        end
+      EOS
+
+      unless options[:instance_reader] == false || options[:instance_accessor] == false
+        class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+          def #{sym}
+            @@#{sym}
+          end
+        EOS
+      end
+    end
+  end unless method_defined?(:cattr_reader)
+
+  def cattr_writer(*syms)
+    options = syms.extract_options!
+    syms.each do |sym|
+      class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+
+        def self.#{sym}=(obj)
+          @@#{sym} = obj
+        end
+      EOS
+
+      unless options[:instance_writer] == false || options[:instance_accessor] == false
+        class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+          def #{sym}=(obj)
+            @@#{sym} = obj
+          end
+        EOS
+      end
+      self.send("#{sym}=", yield) if block_given?
+    end
+  end unless method_defined?(:cattr_writer)
+
+  def cattr_accessor(*syms, &blk)
+    cattr_reader(*syms)
+    cattr_writer(*syms, &blk)
+  end unless method_defined?(:cattr_accessor) 
+end

data/lib/yandex-webmaster/core_ext/date.rb

@@ -0,0 +1,7 @@
+# encoding: utf-8
+
+class Date
+  def inspect
+    self.strftime("%a, %d %b %Y")
+  end
+end

data/lib/yandex-webmaster/core_ext/date_time.rb

@@ -0,0 +1,7 @@
+# encoding: utf-8
+
+class DateTime
+  def inspect
+    self.strftime("%a, %d %b %Y %H:%M:%S %z")
+  end
+end

data/lib/yandex-webmaster/core_ext/hash.rb

@@ -0,0 +1,92 @@
+# encoding: utf-8
+
+class Hash # :nodoc:
+  def except(*items) # :nodoc:
+    self.dup.except!(*items)
+  end unless method_defined?(:except)
+
+  def except!(*keys) # :nodoc:
+    copy = self.dup
+    keys.each { |key| copy.delete!(key) }
+    copy
+  end unless method_defined?(:except!)
+
+  def slice(*keys)
+    keys = keys.map! { |key| convert_key(key) } if respond_to?(:convert_key, true)
+    hash = self.class.new
+    keys.each { |k| hash[k] = self[k] if has_key?(k) }
+    hash
+  end unless method_defined?(:slice)
+
+  def slice!(*keys)
+    keys = keys.map! { |key| convert_key(key) } if respond_to?(:convert_key, true)
+    omit = slice(*self.keys - keys)
+    hash = slice(*keys)
+    replace(hash)
+    omit
+  end unless method_defined?(:slice!)
+
+  def symbolize_keys  # :nodoc:
+    inject({}) do |hash, (key, value)|
+      hash[(key.to_sym rescue key) || key] = value
+      hash
+    end
+  end unless method_defined?(:symbolize_keys)
+
+  def symbolize_keys! # :nodoc:
+    hash = symbolize_keys
+    hash.each do |key, val|
+      hash[key] = case val
+        when Hash
+          val.symbolize_keys!
+        when Array
+          val.map do |item|
+            item.is_a?(Hash) ? item.symbolize_keys! : item
+          end
+        else
+          val
+        end
+    end
+    return hash
+  end unless method_defined?(:symbolize_keys!)
+
+  def extractable_options?
+    instance_of?(Hash)
+  end unless method_defined?(:extractable_options?)
+
+  def serialize # :nodoc:
+    self.map { |key, val| [key, val].join("=") }.join("&")
+  end unless method_defined?(:serialize)
+
+  def all_keys # :nodoc:
+    keys = self.keys
+    keys.each do |key|
+      if self[key].is_a?(Hash)
+        keys << self[key].all_keys.compact.flatten
+        next
+      end
+    end
+    keys.flatten
+  end unless method_defined?(:all_keys)
+
+  def has_deep_key?(key)
+    self.all_keys.include? key
+  end unless method_defined?(:has_deep_key?)
+
+  def self.hash_traverse(hash, &block)
+    hash.each do |key, val|
+      block.call(key)
+      case val
+      when Hash
+        val.keys.each do |k|
+          _hash_traverse(val, &block)
+        end
+      when Array
+        val.each do |item|
+          _hash_traverse(item, &block)
+        end
+      end
+    end
+    return hash
+  end  
+end # Hash