webmaster 0.1.0

data/lib/webmaster/api/request.rb

@@ -0,0 +1,62 @@
+# encoding: utf-8
+
+module Webmaster
+  module Api
+
+    # Defines HTTP verbs
+    module Request
+
+      METHODS = [:get, :post, :put, :delete]
+      METHODS_WITH_BODIES = [:post, :put]
+
+      def get_request(path, params={}, options={})
+        request(:get, path, params, options)
+      end      
+
+      def post_request(path, params={}, options={})
+        request(:post, path, params, options)
+      end
+
+      def put_request(path, params={}, options={})
+        request(:put, path, params, options)
+      end
+
+      def delete_request(path, params={}, options={})
+        request(:delete, path, params, options)
+      end
+
+      def request(method, path, params = {}, options = {})
+        if !METHODS.include?(method)
+          raise ArgumentError, "unkown http method: #{method}"
+        end
+
+        puts "EXECUTED: #{method} - #{path} with #{params} and #{options}" if ENV['DEBUG']
+
+        conn = connection(options)
+        if conn.path_prefix != '/' && path.index(conn.path_prefix) != 0 && !path.start_with?('https://', 'http://')
+          path = (conn.path_prefix + path).gsub(/\/(\/)*/, '/')
+        end
+
+        response = conn.send(method) do |request|
+          case method.to_sym
+          when *(METHODS - METHODS_WITH_BODIES)
+            request.body = params.delete('data') if params.has_key?('data')
+            request.url(path, params)
+          when *METHODS_WITH_BODIES            
+            request.url(path)            
+            request.body = self.extract_data_from_params(params) unless params.empty?            
+            request.headers['Content-Length'] = request.body.size.to_s
+          end
+        end        
+      end
+
+    protected
+
+      def extract_data_from_params(params) # :nodoc:
+        return params['data'] if params.is_a?(Hash) && params.has_key?('data') && !params['data'].nil?
+        return params[:data] if params.is_a?(Hash) && params.has_key?(:data) && !params[:data].nil?
+        return params
+      end
+    end
+  end
+end

data/lib/webmaster/base.rb

@@ -0,0 +1,159 @@
+# encoding: utf-8
+
+require 'webmaster/configuration'
+
+require 'webmaster/api/authorization'
+require 'webmaster/api/connection'
+require 'webmaster/api/request'
+
+module Webmaster
+  class Base
+    include Api::Authorization
+    include Api::Connection
+    include Api::Request
+
+    attr_accessor :configuration
+
+    def initialize(attributes = {})
+      self.configuration = Webmaster::Configuration.instance.setup(attributes.delete(:configuration) || {})
+      self.attributes = attributes
+    end
+
+    def attributes=(attributes = {})
+      attributes.each do |attr,value|
+        self.send("#{attr}=", value) if self.respond_to?("#{attr}=")
+      end
+    end
+
+    def inspect
+      inspection = if self.respond_to?(:attributes) && self.attributes.any?
+        self.attributes.collect { |attribute, value|
+          "#{attribute}: #{value}" if value.present?
+        }.compact.join(', ')
+      else
+        self.instance_variables.map{ |variable|
+          "#{variable}: #{instance_variable_get(variable).inspect}"
+        }.compact.join(', ')
+      end
+
+      "#<#{self.class} #{inspection}>"
+    end
+
+    # Configure options and process basic authorization    
+    # def setup(options={})
+    #   options = Webmaster.options.merge(options)
+    #   self.current_options = options
+    #   Configuration.keys.each do |key|
+    #     send("#{key}=", options[key])
+    #   end    
+    # 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
+
+    # Scope for passing request required arguments.
+    #
+    def with(args)
+      case args
+      when Hash
+        set args
+      when /.*\/.*/i
+        user, repo = args.split('/')
+        set :user => user, :repo => repo
+      else
+        ::Kernel.raise ArgumentError, 'This api does not support passed in arguments'
+      end
+    end
+
+    # Set an option to a given value
+    def set(option, value=(not_set=true), ignore_setter=false, &block)
+      raise ArgumentError, 'value not set' if block and !not_set
+      return self if !not_set and value.nil?
+
+      if not_set
+        set_options option
+        return self
+      end
+
+      if respond_to?("#{option}=") and not ignore_setter
+        return __send__("#{option}=", value)
+      end
+
+      define_accessors option, value
+      self
+    end
+
+  protected
+
+    # Set multiple options
+    #
+    def set_options(options)
+      unless options.respond_to?(:each)
+        raise ArgumentError, 'cannot iterate over value'
+      end
+      options.each { |key, value| set(key, value) }
+    end
+
+    def define_accessors(option, value)
+      setter = proc { |val|  set option, val, true }
+      getter = proc { value }
+
+      define_singleton_method("#{option}=", setter) if setter
+      define_singleton_method(option, getter) if getter
+    end
+
+    # Dynamically define a method for setting request option
+    #
+    def define_singleton_method(method_name, content=Proc.new)
+      (class << self; self; end).class_eval do
+        undef_method(method_name) if method_defined?(method_name)
+        if String === content
+          class_eval("def #{method_name}() #{content}; end")
+        else
+          define_method(method_name, &content)
+        end
+      end
+    end
+
+    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

data/lib/webmaster/client.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+module Webmaster
+  class Client < Base
+    def hosts(reload = false)      
+      @hosts = nil if reload
+      @hosts ||= self.objects_from_response(Webmaster::Host, self.request(:get, '/hosts'), :host)      
+    end
+
+    def create_host(name)
+      xml = "<host><name>#{name}</name></host>"
+      self.request(:post, '/hosts', xml)
+    end
+  end
+end

data/lib/webmaster/configuration.rb

@@ -0,0 +1,111 @@
+# encoding: utf-8
+
+require 'singleton'
+
+module Webmaster
+  class Configuration
+    include Singleton
+
+    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
+
+    # By default, don't set a user login name
+    DEFAULT_LOGIN = nil
+
+    # By default, don't set a user password
+    DEFAULT_PASSWORD = nil
+
+    # By default, don't set a user basic authentication
+    DEFAULT_BASIC_AUTH = 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 #{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
+      super
+      self.reset!
+    end
+
+    def keys
+      VALID_OPTIONS_KEYS
+    end
+
+    def current
+      VALID_OPTIONS_KEYS.inject({}) { |h, k| h[k] = send(k); h }
+    end
+
+    def setup(options = {})
+      raise ArgumentError if (options.symbolize_keys!.keys - VALID_OPTIONS_KEYS).any?
+      options.each { |k,v| send("#{k}=", v) }        
+
+      self
+    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

data/lib/webmaster/core_ext/hash.rb

@@ -0,0 +1,87 @@
+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 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

data/lib/webmaster/core_ext/object.rb

@@ -0,0 +1,9 @@
+class Object
+  def blank?
+    !self     
+  end unless method_defined? :blank?
+
+  def present?
+    !blank?
+  end unless method_defined? :present?
+end