resto 0.0.3 → 0.0.4

data/lib/resto/extra/delegation.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+module Resto
+  module Extra
+    module Delegation
+
+      def delegate(*methods)
+        options = methods.pop
+        to = options[:to]
+        unless options.is_a?(Hash) && to
+          raise ArgumentError, "Delegation needs a target. Supply an options
+            hash with a :to key as the last argument
+            (e.g. delegate :hello, :to => :greeter)."
+        end
+
+        methods.each do |method|
+          class_eval <<-EOS
+            def #{method}(*args, &block)
+              #{to}.__send__(#{method.inspect}, *args, &block)
+            end
+          EOS
+        end
+      end
+    end
+  end
+end

data/lib/resto/extra/hash_args.rb

@@ -0,0 +1,56 @@
+# encoding: utf-8
+
+class Resto::Extra::HashArgs; end
+
+class << Resto::Extra::HashArgs
+
+  def key(key)
+    @keys ||= []
+
+    unless key.is_a?(Symbol)
+      raise ArgumentError, "The key '#{key}' must be a symbol"
+    end
+
+    if @keys.include?(key)
+      raise ArgumentError, "The key '#{key}' has already been defined."
+    end
+
+    @keys << key
+  end
+
+private
+  def assert_key(key)
+    unless @keys.include?(key.to_sym)
+      raise ArgumentError, "The key '#{key}' is not valid.
+        Valid keys are: #{@keys.join(' ,')}"
+    end
+  end
+end
+
+class Resto::Extra::HashArgs
+
+  def initialize(hash)
+    hash ||= {}
+    raise ArgumentError, "'#{hash}' must be a Hash" unless hash.is_a?(Hash)
+    keys = hash.keys
+    keys_as_symbols = keys.map(&:to_sym)
+    if (keys_as_symbols.uniq.size != keys_as_symbols.size)
+      raise ArgumentError, "duplicated keys: #{keys.join(', ')}"
+    end
+
+    @hash = {}
+    keys.each do |key|
+      self.class.send(:assert_key, key)
+      @hash[key.to_sym] = hash.fetch(key)
+    end
+  end
+
+  def fetch(key, &block)
+    self.class.send(:assert_key, key)
+    @hash.fetch(key, &block)
+  end
+
+  def keys
+    @hash.keys
+  end
+end

data/lib/resto/format.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+require 'resto/format/default'
+require 'resto/format/plain'
+require 'resto/format/json'
+require 'resto/format/xml'
+
+module Resto
+  module Format
+    def self.get(symbol=:default)
+      format = Resto::Format.const_get("#{symbol.to_s.capitalize}")
+    end
+
+    def extension;                         end
+    def accept;            '*/*';          end
+    def content_type;                      end
+    def encode(*args);    args.first       end
+    def decode(*args);    args.first       end
+  end
+end

data/lib/resto/format/default.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+module Resto
+  module Format
+    class Default; end
+
+    class << Default
+      include Format
+    end
+  end
+end

data/lib/resto/format/json.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+# http://en.wikipedia.org/wiki/JSON
+require 'yajl'
+
+module Resto
+  module Format
+    class Json; end
+
+    class << Json
+      include Format
+
+      def extension;       'json';                   end
+      def accept;          'application/json, */*';  end
+      def content_type;    'application/json';       end
+
+      def encode(hash, options = nil)
+        raise ArgumentError unless hash.is_a?(Hash)
+
+        Yajl::Encoder.encode(hash)
+      end
+
+      def decode(json, options=nil)
+        raise ArgumentError unless json.is_a?(String)
+
+        Yajl::Parser.parse(json)
+      end
+    end
+  end
+end

data/lib/resto/format/plain.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+
+module Resto
+  module Format
+    class Plain; end
+
+    class << Plain
+      include Format
+
+      def accept;        'text/plain, */*';   end
+      def content_type;  'text/plain';        end
+    end
+  end
+end

data/lib/resto/format/xml.rb

@@ -0,0 +1,66 @@
+# encoding: utf-8
+
+# https://tools.ietf.org/html/rfc3023
+require 'resto/format'
+require 'nokogiri'
+
+module Resto
+  module Format
+    class Xml; end
+
+    class << Xml
+      include Format
+
+      def extension;       'xml';                           end
+      def accept;          'application/xml, */*';          end
+      def content_type;    'application/xml;charset=utf-8'; end
+
+      def encode(hash, options = nil)
+        Nokogiri::XML::Builder.new { |xml| to_xml(hash, xml) }.to_xml
+      end
+
+      def decode(xml, options)
+        xpath = options.fetch(:xpath)
+
+        doc =  Nokogiri::XML(xml)
+        nodes =  doc.xpath(xpath)
+
+        case nodes.size
+        when 0
+          {}
+        when 1
+          elements_to_hash(nodes.first.children)
+        else
+          nodes.map { |node| elements_to_hash(node.children) }
+        end
+      end
+
+    private
+
+      def elements_to_hash(children)
+        attributes = {}
+
+        children.each do |element|
+          if element.is_a?(Nokogiri::XML::Element)
+            attributes[element.name] = element.text
+          end
+        end
+
+        attributes
+      end
+
+      #http://nokogiri.org/Nokogiri/XML/Builder.html
+      def to_xml(hash, xml)
+        hash.each do |key, value|
+          xml.send("#{key.to_s}_") do
+            if value.is_a?(Hash)
+              to_xml(value, xml)
+            else
+              xml.text value if value
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/resto/property.rb

@@ -0,0 +1,50 @@
+# encoding: utf-8
+
+require 'resto/validate'
+require 'resto/property/handler'
+require 'resto/property/string'
+require 'resto/property/integer'
+require 'resto/property/time'
+
+module Resto
+  module Property
+
+    def initialize(name, options={})
+      raise ':name must be a symbol' unless name.is_a?(Symbol)
+
+      @name = name
+      @remote_name = options.fetch(:remote_name) { name }
+      @validations = []
+    end
+
+    def remote_key
+      @remote_name.to_s
+    end
+
+    def attribute_key
+      @name
+    end
+
+    def attribute_key_as_string
+      @name.to_s
+    end
+
+    def validate_presence
+      Validate::Presence.new.tap { |validation| @validations.push(validation) }
+    end
+
+    def validate_inclusion
+      Validate::Inclusion.new.tap { |validation| @validations.push(validation) }
+    end
+
+    def validate_length
+      Validate::Length.new.tap { |validation| @validations.push(validation) }
+    end
+
+    def validate(resource, attribute_key)
+      @validations.each do |validate|
+        validate.attribute_value(resource, attribute_key)
+      end
+    end
+  end
+end

data/lib/resto/property/handler.rb

@@ -0,0 +1,57 @@
+# encoding: utf-8
+module Resto
+  module Property
+    class Handler
+      def initialize
+        @properties = {} # TODO fix indifferent access
+        @properties_with_indifferent_access = {}
+      end
+
+      def add(property)
+        @properties_with_indifferent_access.store(property.remote_key, property)
+        @properties_with_indifferent_access
+          .store(property.attribute_key, property)
+        @properties_with_indifferent_access
+          .store(property.attribute_key_as_string, property)
+
+        @properties.store(property.attribute_key, property)
+      end
+
+      def attribute_key(key)
+        get(key, 'attribute_key')
+      end
+
+      def remote_attributes(attributes)
+        remote_attributes = {}
+
+        attributes.each do |key, value|
+          remote_key = get(key, 'remote_key') || key
+          remote_attributes[remote_key] = value
+        end
+
+        remote_attributes
+      end
+
+      def cast(key, value, errors)
+        get(key).cast(value, errors)
+      end
+
+      def validate(resource)
+        @properties.each do |key, property|
+          property.validate(resource, key)
+        end
+      end
+
+    private
+      def get(key, method=nil)
+        property = @properties_with_indifferent_access.fetch(key, false)
+
+        if (property and method)
+          property.send(method)
+        else
+          property
+        end
+      end
+    end
+  end
+end

data/lib/resto/property/integer.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+module Resto
+  module Property
+    class Integer; end
+
+    class << Integer
+    end
+
+    class Integer
+      include Property
+
+      def initialize(name, options={})
+        @key = (name.to_s + "_integer").to_sym
+        super
+      end
+
+      def cast(value, errors)
+        errors.store(@key, nil)
+
+        begin
+          value.to_s.strip.empty? ? nil : Integer(value)
+        rescue ArgumentError, TypeError
+          nil.tap { errors.store(@key, ":#{attribute_key} is not an integer.") }
+        end
+      end
+    end
+  end
+end

data/lib/resto/property/string.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+module Resto
+  module Property
+    class String; end
+
+    class << String
+    end
+
+    class String
+      include Property
+
+      def cast(value, errors=nil)
+        value.to_s
+      end
+    end
+
+  end
+end

data/lib/resto/property/time.rb

@@ -0,0 +1,43 @@
+# encoding: utf-8
+
+require 'time'
+
+module Resto
+  module Property
+    class Time; end
+
+    class << Time
+    end
+
+    class Time
+      include Property
+
+      def initialize(name, options={})
+        @key = (name.to_s + "_time").to_sym
+        super
+      end
+
+      def cast(value, errors)
+        errors.store(@key, nil)
+
+        formatted_value = value.to_s.strip
+        if formatted_value.gsub(/([a-z|A-Z]{1,5}\Z)/, '') =~ /[^T\d\-:\+\/\s]/
+          formatted_value = "invalid"
+        end
+
+        number_of_digits = formatted_value.gsub(/\D/, '').length
+        if (1..10).include?(number_of_digits)
+          formatted_value = "invalid"
+        end
+
+        begin
+          formatted_value.empty? ? nil : ::Time.parse(formatted_value)
+        rescue ArgumentError
+          nil.tap do
+            errors.store(@key, ":#{attribute_key} is not a valid time format.")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/resto/request/base.rb

@@ -0,0 +1,88 @@
+# encoding: utf-8
+
+require 'resto/extra/delegation'
+require 'resto/request/uri'
+require 'resto/request/header'
+require 'resto/request/option'
+require 'resto/request/factory'
+require 'resto/translator/request_factory'
+require 'resto/extra/copy'
+
+module Resto
+  module Request
+    class Base
+      extend  Resto::Extra::Delegation
+      include Resto::Request::Header
+      include Resto::Request::Uri
+      include Resto::Request::Option
+
+      delegate :head, :get, :post, :put, :delete, :to => :@request
+
+      def initialize(request=Resto::Request::Factory)
+        @request_klass = request
+        @request = @request_klass.new(self)
+      end
+
+      def construct_path(options)
+        new_path = @path.clone
+
+        @path_substitute_keys.each do |substitute|
+          new_path.gsub!(/:#{substitute}/, options[substitute].to_s)
+        end
+
+        Extra::Copy.request_base(self).path(new_path)
+      end
+
+      def url(url)
+        tap { parse_url(url) }
+      end
+
+      def host(host)
+        tap { @host = host }
+      end
+
+      def port(port)
+        tap { @port = port }
+      end
+
+      def path(path)
+        @path = path
+        keys = path.scan(/\/(:\w+)/).flatten
+        @path_substitute_keys = keys.map {|key| key.gsub(/:/, "").to_sym }
+        self
+      end
+
+      def append_path(append_path)
+        tap { @append_path = append_path }
+      end
+
+      def query(query)
+        tap { @query = query }
+      end
+
+      def params(hash)
+        tap { @params = hash }
+      end
+
+      def body(body)
+        tap { @body = body }
+      end
+
+      def translator(translator)
+        @translator = Resto::Translator::RequestFactory.create(translator)
+        self
+      end
+
+      def read_body
+        if @body
+          body = @translator ? @translator.call(@body) : @body
+          current_formatter.encode(body)
+        end
+      end
+
+      def current_formatter
+        @formatter ||= Resto::Format.get(@symbol || :default)
+      end
+    end
+  end
+end