reg.api2 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--format progress
+--require spec_helper.rb

data/.travis.yml

@@ -0,0 +1,7 @@
+notifications:
+  recipients:
+    - akzhan.abdulin@gmail.com
+rvm:
+  - 1.9.2
+  - 1.9.3
+  - 2.0.0

data/.yardopts

@@ -0,0 +1,7 @@
+--markup markdown
+--markup-provider redcarpet
+--charset utf-8
+--readme README.md
+-
+README.md
+LICENSE

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in reg.api2.gemspec
+gemspec
+
+gem "coveralls", :require => false, :platforms => [:mri_19, :mri_20], :group => :development

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Akzhan Abdulin
+
+MIT License
+
+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.md

@@ -0,0 +1,56 @@
+# REG.API 2 for Ruby
+
+[![build status](https://secure.travis-ci.org/regru/reg_api2-ruby.png)](https://travis-ci.org/regru/reg_api2-ruby)
+[![Code Climate](https://codeclimate.com/github/regru/reg_api2-ruby.png)](https://codeclimate.com/github/regru/reg_api2-ruby)
+[![Coverage Status](https://coveralls.io/repos/regru/reg_api2-ruby/badge.png?branch=master)](https://coveralls.io/r/regru/reg_api2-ruby)
+
+REG.API v2 Implementation.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'reg.api2'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install reg.api2
+
+## Usage
+
+### List of services by specified identifiers
+
+```ruby
+require "reg_api2"
+
+RegApi2.service.nop(services: [
+  { dname:"test.ru" },
+  { dname: "test.su", servtype: "srv_hosting_ispmgr" },
+  { service_id: 111111 },
+  { service_id: "22bug22" },
+  { surprise: "surprise.ru" }
+])
+```
+
+## Documentation
+
+Simply do
+
+```bash
+bundle exec rake yard
+open doc/index.html
+```
+
+Also documentation available at https://www.reg.com/support/help/API-version2
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,32 @@
+require 'rubygems'
+require 'rake'
+require "bundler/gem_tasks"
+
+APP_ROOT = File.dirname(__FILE__).freeze
+
+begin
+  require 'rspec/core/rake_task'
+
+  RSpec::Core::RakeTask.new
+
+  RSpec::Core::RakeTask.new(:rcov) do |t|
+    t.rcov = true
+    t.ruby_opts = '-w'
+    t.rcov_opts = %q[-Ilib --exclude "spec/*,gems/*"]
+  end
+rescue LoadError
+  $stderr.puts "RSpec not available. Install it with: gem install rspec-core rspec-expectations"
+end
+
+task :default => :spec
+
+begin
+  require 'yard'
+
+  YARD::Rake::YardocTask.new do |yard|
+    version = File.exists?('VERSION') ? IO.read('VERSION') : ""
+    yard.options << "--title='reg.api2 #{version}'"
+  end
+rescue LoadError
+  $stderr.puts "Please install YARD with: gem install yard"
+end

data/lib/reg_api2/builder.rb

@@ -0,0 +1,29 @@
+# -*- encoding : utf-8 -*-
+module RegApi2
+  # Internal DSL Builder. Provides metamethods.
+  module Builder
+
+    # Extends module by metamethods `category` and `define`.
+    def self.included(mod)
+      mod.module_eval do
+
+        class << self
+          # @!method Sets method category
+          # @param category [String or NilClass] Category of methods
+          # @see define 
+          def category category
+            @cat = category
+          end
+
+          # @!method Defines API method.
+          # @param name Name of specified method.
+          def define name, defopts = {} 
+            define_method name do |opts = {}|
+              RegApi2.make_action(@cat, name, defopts, opts)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/reg_api2/clients.rb

@@ -0,0 +1,14 @@
+# -*- encoding : utf-8 -*-
+module RegApi2
+  # REG.API clients category
+  module Clients
+
+    include RegApi2::Builder
+
+    category :clients
+    define :nop
+
+    extend self
+  end
+end
+

data/lib/reg_api2/common.rb

@@ -0,0 +1,46 @@
+# -*- encoding : utf-8 -*-
+
+require 'reg_api2/result_contract/single_field'
+
+module RegApi2
+
+  # REG.API common category
+  module Common
+
+    include RegApi2::Builder
+
+    category nil
+
+    # @!method nop
+    # @param None
+    # For testing purposes (do nothing + get the login and identifier of the user logged into the system).
+    # @return [Hash("login", "user_id")]
+    define :nop
+
+    # @!method reseller_nop
+    # @param None
+    # Similar to the nop function, except for the following  aspects.
+    # @note Accessibility: partners
+    # @note Access mode: Secure HTTPS only
+    # @note Support of service lists: no
+    # @return [Hash("login", "user_id")]
+    define :reseller_nop
+
+
+    # @!method get_user_id
+    # @param None
+    # For testing purposes (returns the identifier of the user logged into the system).
+    # @return [String] user_id
+    define :get_user_id, result: :single_field, field: 'user_id'
+
+    # @!method get_service_id(opts = {})
+    # @param [Hash] opts The options.
+    # @option opts [FixNum] :service_id Service identifier.
+    # Gets service/domain identifier
+    # @return [String] service_id
+    define :get_service_id, result: :single_field, field: 'service_id'
+
+    extend self
+  end
+end
+

data/lib/reg_api2/domains.rb

@@ -0,0 +1,13 @@
+# -*- encoding : utf-8 -*-
+module RegApi2
+  # REG.API domains category
+  module Domains
+
+    include RegApi2::Builder
+
+    category :domains
+    define :nop
+
+    extend self
+  end
+end

data/lib/reg_api2/entity/entity_base.rb

@@ -0,0 +1,57 @@
+require 'yajl'
+
+module RegApi2
+  # Optional entities that can be used instead of clean hashes.
+  module Entity
+    # Base entity class.
+    class EntityBase
+
+      # Skipped property names.
+      SKIPPED_MEMBERS = [
+        "taguri" # from YAML mixin
+      ].freeze
+
+      # Gets instance property names
+      # @return [Array(String)]
+      def property_names
+        methods = self.class.public_instance_methods(false).map(&:to_s)
+        methods.select do |n|
+          true &&
+          !SKIPPED_MEMBERS.detect { |n3| n3 == n } &&
+          n =~ /^[^=\?!]+$/ &&
+          methods.detect { |n2| "#{n}=" == n2 } &&
+          true
+        end
+      end
+
+      # All r/w properties interpreted as symbol hash.
+      # @return [Hash] properties as hash.
+      def to_hash
+        h = {}
+        property_names.each do |n|
+          v = self.send n.to_sym
+          h[n.to_sym] = v  unless v.nil?
+        end
+        h
+      end
+
+      # Returns JSON
+      # @return [String] JSON
+      # @see #to_hash
+      def to_json
+        Yajl::Encoder.encode to_hash
+      end
+
+      # Initializes the instance.
+      # opts values are assigned to properties if exist.
+      # @param [Hash] opts
+      def initialize opts = {}
+        methods = self.class.public_instance_methods(false).map(&:to_s)
+        opts.keys.each do |key|
+          next  unless methods.detect { |m| m == "#{key}=" }
+          send("#{key}=", opts[key])
+        end
+      end
+    end
+  end
+end

data/lib/reg_api2/entity/user.rb

@@ -0,0 +1,36 @@
+require 'reg_api2/entity/entity_base'
+
+module RegApi2
+  module Entity
+    # Represents REG.API user.
+    class User < EntityBase
+      # @note Required property.
+      attr_accessor :user_login
+      # @note Required property.
+      attr_accessor :user_password
+      # @note Required property.
+      attr_accessor :user_email
+      # @note Required property.
+      attr_accessor :user_country_code
+
+      attr_accessor :user_first_name
+      attr_accessor :user_last_name
+      attr_accessor :user_company
+      attr_accessor :user_jabber_id
+      attr_accessor :user_icq
+      attr_accessor :user_phone
+      attr_accessor :user_fax
+      attr_accessor :user_addr
+      attr_accessor :user_city
+      attr_accessor :user_state
+      attr_accessor :user_postcode
+      attr_accessor :user_wmid
+      attr_accessor :user_website
+
+      attr_accessor :user_subsribe
+      attr_accessor :user_mailnotify
+      attr_accessor :set_me_as_referrer
+      attr_accessor :check_only
+    end
+  end
+end

data/lib/reg_api2/impl.rb

@@ -0,0 +1,175 @@
+# -*- encoding : utf-8 -*-
+require 'net/http'
+require 'net/https'
+require 'yajl'
+
+require 'reg_api2/util'
+
+module RegApi2
+  # Networking Error
+  class NetError < Exception
+  end
+  # API Contract Error
+  class ContractError < Exception
+  end
+  # API Error
+  class ApiError < Exception
+    # @!attribute [r] description
+    # Localized error description.
+    attr_reader :description
+    # @!attribute [r] params
+    # Optional error params.
+    attr_reader :params
+
+    def initialize code,  description, params
+      super code
+      @description = description
+      @params = params
+    end
+  end
+
+  class << self
+    # @!attribute [rw] username
+    # @return [String] User name.
+    attr_accessor :username
+    # @!attribute [rw] password
+    # @return [String] Password.
+    attr_accessor :password
+    # @!attribute [rw] io_encoding
+    # @return [String] IO encoding ('utf-8' by default).
+    attr_accessor :io_encoding
+    # @!attribute [rw] lang
+    # @return [String] Language ('en' by default).
+    attr_accessor :lang
+
+    # Default IO encoding
+    DEFAULT_IO_ENCODING = 'utf-8'
+    # Default lang.
+    DEFAULT_LANG = 'en'
+    # Default API contract for requests
+    DEFAULT_REQUEST_CONTRACT = RegApi2::RequestContract::Default
+    # Default API contract for results
+    DEFAULT_RESULT_CONTRACT = RegApi2::ResultContract::Default
+
+    # REG.API base URI
+    API_URI = URI.parse("https://api.reg.ru/api/regru2")
+
+    # Creates or gets HTTPS handler.
+    # @return [Net::HTTP] HTTPS handler.
+    def http
+      @http ||= begin
+        http = Net::HTTP.new(
+          API_URI.host, 
+          API_URI.port
+        )
+        http.use_ssl = true
+        http
+      end
+    end
+
+    # Placeholder to inspect sent form
+    # @param [String] path
+    # @param [Hash] form
+    # @return Doesn't matter
+    def form_to_be_sent(path, form)
+    end
+
+    # Placeholder to inspect got response.
+    # @param [Net::HTTPResponse] response
+    # @return Doesn't matter
+    def got_response(response)
+    end
+
+    # Gets {Class} by its name.
+    # @param [Class] ancestor
+    # @param [NilClass, Class, String] name
+    # @param [Class] default_value
+    # @return [Class] {RegApi2::RequestContract}
+    def get_contract ancestor, name, default_value
+      return default_value  unless name
+      return name  if name.kind_of?(Class)
+      ancestor.const_get(RegApi2::Util.constantize name)
+    end
+
+    # Gets {RegApi2::RequestContract} by its name.
+    # @param [NilClass, Class, String] name
+    # @return [Class] {RegApi2::RequestContract}
+    def get_request_contract_by_name name
+      get_contract(RegApi2::RequestContract, name, DEFAULT_REQUEST_CONTRACT)
+    end
+
+    # Gets {RegApi2::ResultContract} by its name.
+    # @param [NilClass, Class, String] name
+    # @return [Class] {RegApi2::ResultContract}
+    def get_result_contract_by_name name
+      get_contract(RegApi2::ResultContract, name, DEFAULT_RESULT_CONTRACT)
+    end
+
+    # Gets form data for POST request
+    # @param [Hash] defopts
+    # @param [Hash] opts
+    # @return [Hash] Form data to be sent.
+    # @raise [ContractError]
+    def get_form_data(defopts, opts)
+      # HACK: REG.API doesn't know about utf-8.
+      io_encoding = 'utf8'  if !io_encoding || io_encoding == DEFAULT_IO_ENCODING
+      opts = opts.to_hash  if opts.respond_to?(:to_hash)
+      get_request_contract_by_name(defopts[:request]).new(defopts).validate(opts)
+      form = {
+        'username' => username,
+        'password' => password,
+        'io_encoding' => io_encoding,
+        'lang' => lang || DEFAULT_LANG,
+        'output_format' => 'json',
+        'input_format' => 'json',
+        'show_input_params' => 0,
+        'input_data' => Yajl::Encoder.encode(opts)
+      }
+      form
+    end
+
+    # Handles response
+    # @param [Hash] defopts
+    # @param [Net::HTTPResponse] res HTTP Response
+    # @return [Object] Contracted response.
+    # @raise [NetError]
+    # @raise [ApiError]
+    # @raise [ContractError]
+    def handle_response(defopts, res)
+      raise NetError.new(res.body)  unless res.code == '200'
+
+      json = Yajl::Parser.parse(res.body)
+      raise ApiError.new(
+        json['error_code'],
+        json['error_text'],
+        json['error_params']
+      )  if json['result'] == 'error'
+
+      get_result_contract_by_name(defopts[:result]).new(defopts).handle_result(json)
+    end
+
+    # Do actual call to REG.API using POST/JSON convention.
+    # @param [Symbol] category
+    # @param [Symbol] name
+    # @param [Hash] defopts
+    # @param [Hash] opts
+    # @return [Hash] Result answer field.
+    # @raise [NetError]
+    # @raise [ApiError]
+    # @raise [ContractError]
+    def make_action category, name, defopts, opts = {}
+      req = Net::HTTP::Post.new(
+        category.nil? ? "#{API_URI.path}/#{name}" : "#{API_URI.path}/#{category}/#{name}"
+      )
+      form = get_form_data(defopts, opts)
+      form_to_be_sent(req.path, form)
+
+      req.set_form_data(form)
+      res = http.request(req)
+      got_response(res)
+
+      handle_response(defopts, res)
+    end
+
+    end
+  end

data/lib/reg_api2/request_contract/default.rb

@@ -0,0 +1,66 @@
+# -*- encoding : utf-8 -*-
+module RegApi2
+  # Contracts for API requests.
+  # Take a look at {RegApi2::DEFAULT_REQUEST_CONTRACT} for defaults.
+  module RequestContract
+    # Checks for specified `required` fields.
+    # Also checks for `optional` fields.
+    # Take in care :re option.
+    class Default
+      attr_reader :opts
+
+      def initialize(opts = {})
+        @opts = opts
+      end
+
+      # Normalizes `required` and `optional` fields to the form of Hash with options.
+      # @param [NilClass,Hash,Array, etc.] arr Something to normalize.
+      def to_hash arr
+        return {}   if arr.nil?
+        return arr  if arr.kind_of?(Hash)
+        arr = [ arr.to_sym ]  unless arr.kind_of?(Array)
+        ret = {}
+        arr.each { |key| ret[key.to_sym] = {} }
+        ret
+      end
+
+      # Gets fields to validate
+      # @return [Hash] Fields to validate.
+      def fields_to_validate
+        required_fields = to_hash opts[:required]
+        optional_fields = to_hash opts[:optional]
+        required_fields.keys.each { |key| required_fields[key][:required] = true }
+        optional_fields.merge(required_fields)
+      end
+
+      # Validates specified `form` with `required` and `optional` fields.
+      # @param [Hash] form Form to validate.
+      # @raise ContractError
+      def validate(form)
+        fields = fields_to_validate
+        return  if fields.empty?
+        absent_fields = []
+        fields.each_pair do |key, opts|
+          if !form.has_key?(key) || form[key].nil?
+            if opts[:required]
+              absent_fields << key
+            end
+            next
+          end
+          if opts[:re]
+            if form[key] !~ opts[:re]
+              raise RegApi2::ContractError.new(
+                "Field #{key} mismatch regular expression: #{form[key]}"
+              )
+            end
+          end
+        end
+        unless absent_fields.empty?
+          raise RegApi2::ContractError.new(
+            "Required fields missed: #{absent_fields.join(', ')}"
+          )
+        end
+      end
+    end
+  end
+end

data/lib/reg_api2/result_contract/default.rb

@@ -0,0 +1,25 @@
+# -*- encoding : utf-8 -*-
+module RegApi2
+  # Contracts for API results.
+  # Take a look at {RegApi2::DEFAULT_RESULT_CONTRACT} for defaults.
+  module ResultContract
+    # Waits for answer field and returns it only.
+    class Default
+      attr_reader :opts
+
+      def initialize(opts = {})
+        @opts = opts
+      end
+
+      # Extracts answer field and returns it wrapped by {#handle_answer}.
+      def handle_result(result)
+        handle_answer(result['answer'])
+      end
+   
+      # Return passed argument by default.
+      def handle_answer(answer)
+        answer
+      end
+    end
+  end
+end

data/lib/reg_api2/result_contract/single_field.rb

@@ -0,0 +1,16 @@
+# -*- encoding : utf-8 -*-
+
+require 'reg_api2/result_contract/default'
+
+# Waits for single field in answer field and returns it only.
+class RegApi2::ResultContract::SingleField < RegApi2::ResultContract::Default
+  def handle_answer answer
+    field = opts[:field]
+    unless answer[field]
+      raise RegApi2::ContractError.new(
+        "#{field} field should be found in API result."
+      )
+    end
+    answer[field]
+  end
+end

data/lib/reg_api2/service.rb

@@ -0,0 +1,27 @@
+# -*- encoding : utf-8 -*-
+module RegApi2
+  # REG.API service category
+  module Service
+
+    include RegApi2::Builder
+
+    category :service
+
+    # @!method nop(opts = {})
+    # @param opts
+    # @option opts [Array] services
+    # Return list of specified services with its stats if specified.
+    # @return [Hash("services" => [])]
+    # @example List of services by specified identifiers
+    #  RegApi2.service.nop(services: [
+    #    { dname:"test.ru" },
+    #    { dname: "test.su", servtype: "srv_hosting_ispmgr" },
+    #    { service_id: 111111 },
+    #    { service_id: "22bug22" },
+    #    { surprise: "surprise.ru" }
+    #  ])
+    define :nop
+
+    extend self
+  end
+end