resto 0.0.3 → 0.0.4

data/lib/resto/request/factory.rb

@@ -0,0 +1,66 @@
+# encoding: utf-8
+
+require 'net/https'
+require 'resto/extra/delegation'
+
+module Resto
+  module Request
+    class Factory
+      extend Resto::Extra::Delegation
+
+      delegate :read_host, :read_port, :options, :read_body, :composed_path,
+        :composed_headers, :scheme, :use_ssl, :to => :@request
+
+      def initialize(request)
+        @request = request
+      end
+
+      def head
+        http.start do |http|
+          http.request(Net::HTTP::Head.new(composed_path, composed_headers))
+        end
+      end
+
+      def get
+        http.start do |http|
+          http.request(Net::HTTP::Get.new(composed_path, composed_headers))
+        end
+      end
+
+      def post
+        http.start do |http|
+          http.request(Net::HTTP::Post.new(composed_path, composed_headers),
+                       read_body)
+        end
+      end
+
+      def put
+        http.start do |http|
+          http.request(Net::HTTP::Put.new(composed_path, composed_headers),
+                       read_body)
+        end
+      end
+
+      def delete
+        http.start do |http|
+          http.request(Net::HTTP::Delete.new(composed_path, composed_headers))
+        end
+      end
+
+      def http
+        ::Net::HTTP.new(read_host, read_port).tap do |http|
+
+          use_ssl if scheme == "https"
+
+          unless options.keys.empty?
+            http.methods.grep(/\A(\w+)=\z/) do |meth|
+              key = $1.to_sym
+              options.key?(key) or next
+              http.__send__(meth, options[key])
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/resto/request/header.rb

@@ -0,0 +1,58 @@
+# encoding: utf-8
+require 'resto/format'
+
+require 'resto/extra/hash_args'
+class BasicAuth < Resto::Extra::HashArgs
+  key :username
+  key :password
+end
+
+class FormatExtension < Resto::Extra::HashArgs
+  key :extension
+end
+
+module Resto
+  module Request
+    module Header
+
+      def format(symbol, options=nil)
+        formatter(Resto::Format.get(@symbol = symbol), options)
+      end
+
+      def formatter(formatter, options=nil)
+        @add_extension =
+          FormatExtension.new(options).fetch(:extension) { false }
+        @formatter = formatter
+        accept(formatter.accept)
+        content_type(formatter.content_type)
+      end
+
+      def composed_headers
+        @headers ||= { 'accept'=> '*/*' , 'user-agent'=> 'Ruby' }
+      end
+
+      def headers(headers)
+        tap { composed_headers.merge!(headers) }
+      end
+
+      def accept(accept)
+        tap { composed_headers.store('accept', accept) }
+      end
+
+      def content_type(content_type)
+        tap { composed_headers.store('content-type', content_type) }
+      end
+
+      def basic_auth(options)
+        options = BasicAuth.new(options)
+
+        username = options.fetch(:username)
+        password = options.fetch(:password)
+        base64_encode = ["#{username}:#{password}"].pack('m').delete("\r\n")
+        basic_encode = 'Basic ' + base64_encode
+
+        tap { composed_headers.store('authorization', basic_encode) }
+      end
+    end
+  end
+end

data/lib/resto/request/option.rb

@@ -0,0 +1,126 @@
+# encoding: utf-8
+
+require 'openssl'
+
+module Resto
+  module Request
+    module Option
+
+      def options
+        @options ||= {}
+      end
+
+    begin :ssl_attributes
+
+      def use_ssl(use_ssl=true)#
+        tap do
+          { :verify_mode => OpenSSL::SSL::VERIFY_PEER }.update(options)
+          options.store(:use_ssl, use_ssl)
+        end
+      end
+
+       # Sets the SSL version.  See OpenSSL::SSL::SSLContext#ssl_version=
+      def ssl_version(ssl_version)#1.9
+        tap { options.store(:ssl_version, ssl_version) }
+      end
+
+      # Sets an OpenSSL::PKey::RSA or OpenSSL::PKey::DSA object.
+      # (This method is appeared in Michal Rokos's OpenSSL extension.)
+      def key(key)#
+        tap { options.store(:key, key) }
+      end
+
+      # Sets an OpenSSL::X509::Certificate object as client certificate.
+      # (This method is appeared in Michal Rokos's OpenSSL extension).
+      def cert(cert)#
+        tap { options.store(:cert, cert) }
+      end
+
+      # Sets path of a CA certification file in PEM format.
+      # The file can contain several CA certificates.
+      def ca_file(ca_file)#
+        tap { options.store(:ca_file, ca_file) }
+      end
+
+      # Sets path of a CA certification directory containing certifications in
+      # PEM format.
+      def ca_path(ca_path)#
+        tap { options.store(:ca_path, ca_path) }
+      end
+
+      # Sets the X509::Store to verify peer certificate.
+      def cert_store(cert_store)#
+        tap { options.store(:cert_store, cert_store) }
+      end
+
+      # Sets the available ciphers.  See OpenSSL::SSL::SSLContext#ciphers=
+      def ciphers(ciphers) # 1.9
+        tap { options.store(:ciphers, ciphers) }
+      end
+
+      # Sets the flags for server the certification verification at beginning of
+      # SSL/TLS session.
+      #
+      # OpenSSL::SSL::VERIFY_NONE or OpenSSL::SSL::VERIFY_PEER are acceptable.
+      def verify_mode(verify_mode)#
+        tap { options.store(:verify_mode, verify_mode) }
+      end
+
+      def verify_none
+        tap { verify_mode(OpenSSL::SSL::VERIFY_NONE) }
+      end
+
+      def verify_peer
+        tap { verify_mode(OpenSSL::SSL::VERIFY_PEER) }
+      end
+
+      # Sets the verify callback for the server certification verification.
+      def verify_callback(verify_callback)#
+        tap { options.store(:verify_callback, verify_callback)}
+      end
+
+      def verify_depth(verify_depth)#
+        tap { options.store(:verify_depth, verify_depth)}
+      end
+
+      # Sets the SSL timeout seconds.
+      def ssl_timeout(ssl_timeout)#
+        tap { options.store(:ssl_timeout, ssl_timeout)}
+      end
+    end #:ssl_attributes
+
+      def close_on_empty_response(close_on_empty_response)#
+        tap { options.store(:close_on_empty_response, close_on_empty_response) }
+      end
+
+      # Number of seconds to wait for the connection to open.
+      # If the HTTP object cannot open a connection in this many seconds,
+      # it raises a TimeoutError exception.
+      def open_timeout(time)#
+        tap { options.store(:open_timeout, time)}
+      end
+
+      # Number of seconds to wait for one block to be read (via one read(2) call).
+      # If the HTTP object cannot read data in this many seconds,
+      # it raises a TimeoutError exception.
+      def read_timeout(time)#
+        tap { options.store(:read_timeout, time)}
+      end
+
+      #Seconds to wait until reading one block (by one read(2) call).
+      def timeout(timeout) # 1.8.7 1.9??
+        tap { options.store(:timeout, timeout)}
+      end
+
+      # *WARNING* This method opens a serious security hole.
+      # Never use this method in production code.
+      #
+      # Sets an output stream for debugging.
+      #
+      #   Resto.url('www.google.com').set_debug_output($stderr).get
+      def set_debug_output(output)
+        tap { options.store(:set_debug_output, output)}
+      end
+    end
+  end
+end

data/lib/resto/request/uri.rb

@@ -0,0 +1,50 @@
+# encoding: utf-8
+require 'uri'
+require 'cgi'
+
+module Resto
+  module Request
+    module Uri
+      def read_host
+        return nil unless @host
+
+        normalize_uri(@host)
+        @uri.host
+      end
+
+      def read_port; @port ||= 80; end
+
+      def composed_path
+        path    = ["/#{@path}", @append_path].compact.join('/').gsub('//', "/")
+        path    = "#{path}.#{current_formatter.extension}" if @add_extension
+        params = hash_to_params
+        return path unless (@query or params)
+
+        [path, [@query, params].compact.join('&')].join('?')
+      end
+
+      attr_reader :scheme
+      def normalize_uri(url)
+        @uri = URI.parse(url.match(/^https?:/) ? url : "http://#{url}")
+        @scheme ||= @uri.scheme
+        @host   ||= @uri.host
+        @port   ||= @uri.port
+        @path   ||= @uri.path
+        @query  ||= @uri.query
+      end
+
+      def parse_url(url)
+        normalize_uri(url)
+      end
+
+      def hash_to_params
+        return nil unless @params
+        raise ArgumentError unless @params.is_a?(Hash)
+
+        @params.sort.map do |a|
+          "#{CGI.escape(a.fetch(0).to_s)}=#{CGI.escape(a.fetch(1).to_s)}"
+        end.join('&')
+      end
+    end
+  end
+end

data/lib/resto/response/base.rb

@@ -0,0 +1,85 @@
+# encoding: utf-8
+
+require 'resto/format'
+require 'resto/translator/response_factory'
+
+module Resto
+  module Response
+    class Base
+
+      def klass(klass)
+        tap { @klass = klass }
+      end
+
+      def translator(translator)
+        @translator = Resto::Translator::ResponseFactory.create(translator)
+        self
+      end
+
+      def format(symbol, options = {})
+        xpath = options[:xpath]
+        xpath(xpath) if xpath
+        formatter(Resto::Format.get(@symbol = symbol))
+      end
+
+      def xpath(xpath)
+        tap { @xpath = xpath }
+      end
+
+      def read_xpath
+        @xpath || "//#{@klass.to_s.downcase}"
+      end
+
+      def formatter(formatter)
+        tap { @formatter = formatter }
+      end
+
+      def current_formatter
+        @formatter ||= Resto::Format.get(@symbol || :default)
+      end
+
+      def http_response(response)
+        tap { @response = response }
+      end
+
+      def read_body
+        body ? current_formatter.decode(body, :xpath => read_xpath) : nil
+      end
+
+      def body
+        @response ? @response.body : nil
+      end
+
+      def code
+        @response ? @response.code : nil
+      end
+
+      def valid?
+        (/\A20\d{1}\z/ =~ code.to_s) == 0
+      end
+
+      attr_reader :response
+
+      def to_object
+        return self unless @translator
+
+        @translator.call(@klass, read_body).tap do |instance|
+          instance.response = self
+        end
+      end
+
+      def to_collection
+        return self unless @translator
+
+        body = read_body.is_a?(Hash) ? [read_body] : read_body
+
+        (body || []).map do |hash|
+          @translator.call(@klass, hash).tap do |instance|
+            instance.response = self
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/resto/translator/request_factory.rb

@@ -0,0 +1,44 @@
+# encoding: utf-8
+
+module Resto
+  module Translator
+    class Factory; end
+
+    class << Factory
+      def create(translator)
+        if translator.is_a?(Symbol) and :default == translator
+          new([])
+        elsif translator.is_a?(Array)
+          new(translator)
+        elsif translator.is_a?(Proc)
+          translator
+        elsif translator.is_a?(Class)
+          translator.new
+        else
+          raise(ArgumentError,
+                "Invalid argument. Valid symbol is :default. Array, Class or a
+                Proc is also a valid translator.")
+        end
+      end
+    end
+
+    class Factory
+      def initialize(keys)
+        @keys = keys
+      end
+    end
+
+    class RequestFactory < Factory
+
+      def call(attributes)
+        attributes ||= {}
+        raise ArgumentError unless attributes.is_a?(Hash)
+
+        @keys.reverse.inject(attributes) do |memo, item|
+          Hash.new.tap {|h| h[item] = memo }
+        end
+      end
+
+    end
+  end
+end

data/lib/resto/translator/response_factory.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+require 'resto/translator/request_factory'
+module Resto
+  module Translator
+    class ResponseFactory < Factory
+
+      def call(klass, hash)
+        hash ||= {}
+        raise ArgumentError unless hash.is_a?(Hash)
+
+        klass.new(traverse(hash, 0))
+      end
+
+    private
+
+      def traverse(hash, index)
+        next_hash = hash[@keys.at(index)] || hash[@keys.at(index).to_s]
+
+        if next_hash
+          traverse(next_hash, index + 1)
+        else
+          hash
+        end
+      end
+    end
+  end
+end