party_resource 0.0.1

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Eden Development (UK) LTD
+
+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.rdoc

@@ -0,0 +1,19 @@
+= party_resource
+
+Simple REST interface for ruby objects.
+
+party_resource is a framework for building ruby objects which interact with a REST api. Built on top of HTTParty.
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2010 Eden Development (UK) LTD. See LICENSE for details.

data/lib/party_resource/buildable.rb

@@ -0,0 +1,60 @@
+module PartyResource
+  module Buildable
+
+    def builder
+      Builder.new(@options[:as])
+    end
+
+    class Builder
+      def initialize(build_options)
+        @build_options = build_options
+      end
+
+      def call(raw_result, context, included)
+        return nil if raw_result.nil?
+        return raw_result.map{ |value| build_result(value, context, included) } if map_result?(raw_result)
+        build_result(raw_result, context, included)
+      end
+
+      private
+      def builder
+        return lambda {|raw_result, context| raw_result} if wants_raw_result?
+        return lambda {|raw_result, context| return_type(context).send(return_method,raw_result) } if wants_object?
+        return lambda {|raw_result, context| @build_options.call(raw_result) }
+      end
+
+      def build_result(value, context, included)
+        if value.is_a? Hash
+         value.merge!(included)
+        end
+        builder.call(value, context)
+      end
+
+
+      def map_result?(result)
+        result.is_a?(Array) && !wants_raw_result?
+      end
+
+      def wants_raw_result?
+        return_type == :raw
+      end
+
+      def wants_object?
+        @build_options.is_a?(Array) || @build_options.is_a?(Class) || @build_options == :self
+      end
+
+      def return_type(context=nil)
+        return_type = @build_options.is_a?(Array) ? @build_options.first : @build_options
+        if return_type == :self
+          return_type = context.is_a?(Class) ? context : context.class
+        end
+        return_type
+      end
+
+      def return_method
+        @build_options.is_a?(Array) ? @build_options.last : :new
+      end
+
+    end
+  end
+end

data/lib/party_resource/connector/base.rb

@@ -0,0 +1,35 @@
+require 'httparty'
+module PartyResource
+  module Connector
+
+    class Base
+      attr :options
+
+      def initialize(name, options)
+        self.options = options
+        @name = name
+      end
+
+      def fetch(request)
+        response = HTTParty.send(request.verb, request.path, request.http_data(options))
+        unless (200..399).include? response.code
+          raise PartyResource::ConnectionError.build(response)
+        end
+        response
+      end
+
+    private
+
+      def options=(options)
+        @options = {}
+        @options[:base_uri] = HTTParty.normalize_base_uri(options[:base_uri]) if options.has_key?(:base_uri)
+
+        if options.has_key?(:username) || options.has_key?(:password)
+          @options[:basic_auth] = {:username => options[:username], :password => options[:password]}
+        end
+      end
+
+    end
+
+  end
+end

data/lib/party_resource/connector.rb

@@ -0,0 +1,42 @@
+require 'party_resource/connector/base'
+module PartyResource
+  def self.Connector(name = nil)
+    Connector.lookup(name)
+  end
+
+  module Connector
+    def self.lookup(name)
+      name ||= repository.default
+      connector = repository.connectors[name]
+      raise NoConnector.new(name) if connector.nil?
+      connector
+    end
+
+    def self.default=(name)
+      repository.default = name
+    end
+
+    def self.add(name, options)
+      repository.new_connector(name, options)
+    end
+
+    def self.repository
+      @repository ||= Repository.new
+    end
+
+    class Repository
+      attr_accessor :default
+
+      def connectors
+        @connectors ||= {}
+      end
+
+      def new_connector(name, options)
+        connectors[name] = Base.new(name, options)
+        self.default = name if default.nil? || options[:default]
+      end
+
+    end
+
+  end
+end

data/lib/party_resource/exceptions.rb

@@ -0,0 +1,57 @@
+module PartyResource
+
+  Error = Class.new(StandardError)
+
+  class MissingParameter < Error
+    def initialize(parameter, context)
+      @parameter = parameter
+      @context = context
+    end
+
+    def to_s
+      "No value for #{@parameter} is available in #{@context}"
+    end
+  end
+
+  class NoConnector < Error
+    def initialize(name)
+      @name = name
+    end
+
+    def to_s
+      "Connector '#{@name}' has not been defined"
+    end
+  end
+
+  class ConnectionError < Error;
+    attr_reader :data
+
+    def self.build(data=nil)
+      klass = case data.code
+        when 404: ResourceNotFound
+        when 422: ResourceInvalid
+        when 400..499: ClientError
+        when 500..599: ServerError
+        else self
+      end
+      klass.new(data)
+    end
+
+    def initialize(data=nil)
+      super()
+      @data = data
+    end
+
+    def to_s
+      code = ''
+      code = "#{data.code} " rescue nil
+      "A #{code}connection error occured"
+    end
+  end
+
+  ClientError = Class.new(ConnectionError) # 4xx
+  ServerError = Class.new(ConnectionError) # 5xx
+
+  ResourceNotFound = Class.new(ClientError) # 404
+  ResourceInvalid = Class.new(ClientError) # 422
+end

data/lib/party_resource/method_define.rb

@@ -0,0 +1,11 @@
+module MethodDefine
+  private
+  def define_meta_method(name, &blk)
+    (class << self; self; end).instance_eval { define_method name, &blk }
+  end
+
+  def define_method_on(level, name, &block)
+    creator = level == :instance ? :define_method : :define_meta_method
+    send(creator, name, &block)
+  end
+end

data/lib/party_resource/party_resource.rb

@@ -0,0 +1,91 @@
+require 'active_support/core_ext/hash/indifferent_access'
+Hash.send(:include, ActiveSupport::CoreExtensions::Hash::IndifferentAccess) unless Hash.method_defined?(:with_indifferent_access)
+
+module PartyResource
+
+  module ClassMethods
+    include MethodDefine
+
+    def connect(name, options={})
+      level = options.delete(:on)
+      options = {:as => :self, :connector => @party_connector}.merge(options)
+      route = Route.new(options)
+
+      define_method_on(level, name) do |*args|
+        route.call(self, *args)
+      end
+    end
+
+    def property(*names)
+      options = names.pop if names.last.is_a?(Hash)
+      names.each do |name|
+        name = name.to_sym
+        define_method name do
+          get_property(name)
+        end
+        @property_list ||= []
+        @property_list << Property.new(name, options)
+      end
+    end
+
+    def party_connector(name)
+      @party_connector = name
+    end
+
+    private
+    def property_list
+      @property_list ||= []
+      if superclass.include?(PartyResource)
+        @property_list + superclass.send(:property_list)
+      else
+        @property_list
+      end
+    end
+  end
+
+  module ParameterValues
+    def parameter_values(list)
+      list.inject({}) do |out, var|
+        begin
+          out[var] = send(var)
+        rescue
+          raise MissingParameter.new(var, self)
+        end
+        out
+      end
+    end
+  end
+
+  def to_properties_hash
+    self.class.send(:property_list).inject({}) do |hash, property|
+      hash.merge(property.to_hash(self))
+    end
+  end
+
+  def properties_equal?(other)
+    begin
+      self.class.send(:property_list).all? {|property| self.send(property.name) == other.send(property.name) }
+    rescue NoMethodError
+      false
+    end
+  end
+
+
+  private
+  def populate_properties(hash)
+    hash = hash.with_indifferent_access
+    self.class.send(:property_list).each do |property|
+      instance_variable_set("@#{property.name}", property.value_from(hash, self)) if property.has_value_in?(hash)
+    end
+  end
+
+  def self.included(klass)
+    klass.extend(ClassMethods)
+    klass.extend(ParameterValues)
+    klass.send(:include, ParameterValues)
+  end
+
+  def get_property(name)
+    instance_variable_get("@#{name}")
+  end
+end

data/lib/party_resource/property.rb

@@ -0,0 +1,53 @@
+require 'party_resource/buildable'
+module PartyResource
+  class Property
+    include Buildable
+
+    attr :name
+
+    def initialize(name, options)
+      @name = name
+      @options = {:as => :raw}.merge(options || {})
+    end
+
+    def value_from(hash, context)
+      builder.call retrieve_value(hash), context, {}
+    end
+
+    def has_value_in?(hash)
+      input_hash(hash).has_key?(input_key) || hash.has_key?(name)
+    end
+
+    def to_hash(context)
+      value = context.send(name)
+      return {} if value.nil?
+      value = value.to_properties_hash if value.respond_to?(:to_properties_hash)
+      output_keys.reverse.inject(value) do |value, key|
+        {key => value}
+      end
+    end
+
+    private
+    def retrieve_value(hash)
+      input_hash(hash)[input_key] || hash[name]
+    end
+
+    def input_hash(hash)
+      input_keys[0..-2].inject(hash) do |value, name|
+        value[name] || {}
+      end
+    end
+
+    def input_keys
+      [@options[:from] || name].flatten
+    end
+
+    def output_keys
+      [@options[:to] || input_keys].flatten
+    end
+
+    def input_key
+      input_keys.last
+    end
+  end
+end

data/lib/party_resource/request.rb

@@ -0,0 +1,36 @@
+module PartyResource
+  class Request
+    attr_reader :verb
+    def initialize(verb, path, context, args, params)
+      @verb = verb
+      @path = path
+      @args = args
+      @context = context
+      @params = params || {}
+    end
+
+    def path
+      args = @context.parameter_values(path_params - @args.keys).merge(@args)
+      URI.encode(path_params.inject(@path) do |path, param|
+        path.gsub(":#{param}", args[param].to_s)
+      end)
+    end
+
+    def data
+      @params.merge(@args).reject{|name,value| path_params.include?(name)}
+    end
+
+    def http_data(options={})
+      options = options.merge(self.params_key => self.data) unless self.data.empty?
+      options
+    end
+
+    def params_key
+      verb == :get ? :query : :body
+    end
+
+    def path_params
+      @path.scan(/:([\w]+)/).flatten.map{|p| p.to_sym}
+    end
+  end
+end

data/lib/party_resource/route.rb

@@ -0,0 +1,77 @@
+require 'party_resource/buildable'
+module PartyResource
+
+  class Route
+    include Buildable
+
+    VERBS = [:get, :post, :put, :delete]
+
+    def initialize(options = {})
+      @options = transform_options(options)
+    end
+
+    def call(context, *args)
+      options = args.pop if args.last.is_a?(Hash) && args.size == expected_args.size + 1
+      raise ArgumentError, "wrong number of arguments (#{args.size} for #{expected_args.size})" unless expected_args.size == args.size
+      begin
+        builder.call(connector.fetch(request(context, args, options)), context, included(context))
+      rescue Error => e
+        name = e.class.name.split(/::/).last
+        return @options[:rescue][name] if @options[:rescue].has_key?(name)
+        raise
+      end
+    end
+
+    def connector
+      PartyResource::Connector(@options[:connector])
+    end
+
+    private
+    def request(context, args, params)
+      Request.new(@options[:verb], @options[:path], context, args_hash(args), params)
+    end
+
+    def args_hash(args)
+      Hash[*expected_args.zip(args).flatten]
+    end
+
+    def transform_options(options)
+      options = {:with => [], :including => {}, :rescue => {}}.merge(options)
+      transform_with_option(options)
+      transform_location_options(options)
+      options
+    end
+
+    def transform_with_option(options)
+      options[:with] = [options[:with]] unless options[:with].is_a?(Array)
+    end
+
+    def transform_location_options(options)
+      verbs = options.keys & VERBS
+      raise ArgumentError, "Must define only one verb (#{verbs.inspect} defined)" unless verbs.size == 1
+      options[:verb] = verbs.first
+      options[:path] = options.delete(options[:verb])
+    end
+
+    def expected_args
+      @options[:with]
+    end
+
+    def including
+      @options[:including]
+    end
+
+    def included(context)
+      return {} if including.empty?
+
+      context_hash = context.parameter_values(including.values)
+
+      including.inject({}) do |hash, pair|
+        hash[pair.first] = context_hash[pair.last]
+        hash
+      end
+    end
+
+  end
+end
+

data/lib/party_resource.rb

@@ -0,0 +1,8 @@
+require File.expand_path(File.dirname(__FILE__) + '/party_resource/method_define')
+require File.expand_path(File.dirname(__FILE__) + '/party_resource/exceptions')
+require File.expand_path(File.dirname(__FILE__) + '/party_resource/property')
+require File.expand_path(File.dirname(__FILE__) + '/party_resource/party_resource')
+require File.expand_path(File.dirname(__FILE__) + '/party_resource/route')
+require File.expand_path(File.dirname(__FILE__) + '/party_resource/request')
+require File.expand_path(File.dirname(__FILE__) + '/party_resource/connector')
+

data/spec/fixtures/other_class.rb

@@ -0,0 +1,19 @@
+class OtherClass < TestBaseClass
+  def self.make_boolean(data)
+    data =~ /OK/
+  end
+end
+
+
+class OtherPartyClass
+  include PartyResource
+  party_connector :other_connector
+
+  connect :test, :get => '/url', :as => :raw
+
+  property :thing
+
+  def initialize(args)
+    populate_properties(args)
+  end
+end

data/spec/fixtures/test_base_class.rb

@@ -0,0 +1,17 @@
+class TestBaseClass
+  attr :args
+
+  def initialize(args={})
+    @args = args
+  end
+
+  def method_missing(name, *params)
+    return args[name] if params.empty? && args.has_key?(name)
+    super
+  end
+
+  def ==(other)
+    self.class == other.class && args == other.args
+  end
+end
+

data/spec/fixtures/test_class.rb

@@ -0,0 +1,44 @@
+PartyResource::Connector.add(:other_connector, {:base_uri => 'http://otherserver/'})
+PartyResource::Connector.add(:my_connector, {:base_uri => 'http://myserver/path', :username => 'fred', :password => 'pass', :default => true})
+
+class TestClass < TestBaseClass
+  include PartyResource
+
+  connect :find, :get => '/find/:id.ext', :with => :id, :on => :class
+
+  connect :update, :put => '/update/:var.ext', :on => :instance, :as => OtherClass
+
+  connect :save, :post => '/save/file', :with => :data, :as => :raw
+
+  connect :destroy, :delete => '/delete', :as => [OtherClass, :make_boolean]
+
+  connect :foo, :get => '/foo', :with => :value, :as => lambda {|data| "New #{data} Improved" }
+
+  connect :fetch_json, :get => '/big_data', :as => [:self, :from_json], :rescue => {'ResourceNotFound' => nil}
+
+  connect :include, :get => '/include', :on => :instance, :as => OtherClass, :including => {:thing => :value2}
+
+  property :value, :from => :input_name
+
+  property :value2, :value3
+
+  property :nested_value, :from => [:block, :var]
+
+  property :other, :as => OtherClass
+
+  property :processed, :as => lambda { |data| "Processed: #{data}" }, :to => :output_name
+
+  property :child, :as => OtherPartyClass
+
+  def self.from_json(args)
+    obj = self.new
+    obj.send(:populate_properties, args)
+    obj
+  end
+
+end
+
+class InheritedTestClass < TestClass
+  property :child_property
+end
+