resto 0.0.3 → 0.0.4

data/lib/blankslate.rb

@@ -0,0 +1,110 @@
+# encoding: utf-8
+#!/usr/bin/env ruby
+#--
+# Copyright 2004, 2006 by Jim Weirich (jim@weirichhouse.org).
+# All rights reserved.
+
+# Permission is granted for use, copying, modification, distribution,
+# and distribution of modified versions of this work as long as the
+# above copyright notice is included.
+#++
+
+######################################################################
+# BlankSlate provides an abstract base class with no predefined
+# methods (except for <tt>\_\_send__</tt> and <tt>\_\_id__</tt>).
+# BlankSlate is useful as a base class when writing classes that
+# depend upon <tt>method_missing</tt> (e.g. dynamic proxies).
+#
+class BlankSlate
+  class << self
+
+    # Hide the method named +name+ in the BlankSlate class.  Don't
+    # hide +instance_eval+ or any method beginning with "__".
+    def hide(name)
+      if instance_methods.include?(name.to_s) and
+        name !~ /^(__|instance_eval)/
+        @hidden_methods ||= {}
+        @hidden_methods[name.to_sym] = instance_method(name)
+        undef_method name
+      end
+    end
+
+    def find_hidden_method(name)
+      @hidden_methods ||= {}
+      @hidden_methods[name] || superclass.find_hidden_method(name)
+    end
+
+    # Redefine a previously hidden method so that it may be called on a blank
+    # slate object.
+    def reveal(name)
+      hidden_method = find_hidden_method(name)
+      fail "Don't know how to reveal method '#{name}'" unless hidden_method
+      define_method(name, hidden_method)
+    end
+  end
+
+  instance_methods.each { |m| hide(m) }
+end
+
+######################################################################
+# Since Ruby is very dynamic, methods added to the ancestors of
+# BlankSlate <em>after BlankSlate is defined</em> will show up in the
+# list of available BlankSlate methods.  We handle this by defining a
+# hook in the Object and Kernel classes that will hide any method
+# defined after BlankSlate has been loaded.
+#
+module Kernel
+  class << self
+    alias_method :blank_slate_method_added, :method_added
+
+    # Detect method additions to Kernel and remove them in the
+    # BlankSlate class.
+    def method_added(name)
+      result = blank_slate_method_added(name)
+      return result if self != Kernel
+      BlankSlate.hide(name)
+      result
+    end
+  end
+end
+
+######################################################################
+# Same as above, except in Object.
+#
+class Object
+  class << self
+    alias_method :blank_slate_method_added, :method_added
+
+    # Detect method additions to Object and remove them in the
+    # BlankSlate class.
+    def method_added(name)
+      result = blank_slate_method_added(name)
+      return result if self != Object
+      BlankSlate.hide(name)
+      result
+    end
+
+    def find_hidden_method(name)
+      nil
+    end
+  end
+end
+
+######################################################################
+# Also, modules included into Object need to be scanned and have their
+# instance methods removed from blank slate.  In theory, modules
+# included into Kernel would have to be removed as well, but a
+# "feature" of Ruby prevents late includes into modules from being
+# exposed in the first place.
+#
+class Module
+  alias blankslate_original_append_features append_features
+  def append_features(mod)
+    result = blankslate_original_append_features(mod)
+    return result if mod != Object
+    instance_methods.each do |name|
+      BlankSlate.hide(name)
+    end
+    result
+  end
+end

data/lib/resto.rb

@@ -0,0 +1,264 @@
+# encoding: utf-8
+
+require 'resto/request/base'
+require 'resto/response/base'
+require 'resto/property'
+require 'resto/attributes'
+require 'resto/extra/copy'
+
+module Resto
+  def self.included(klass)
+    klass.extend ClassMethods
+    klass.class_eval do
+      @request  = Request::Base.new
+      @response = Response::Base.new.klass(klass)
+    end
+  end
+
+  def self.url(url)
+    Request::Base.new.url(url)
+  end
+end
+
+module Resto
+  module ClassMethods
+
+    def inherited(sub_class)
+      sub_class.class_exec(self) do |parent_class|
+        @request   = parent_class.request
+        @response  = parent_class.base_response.klass(sub_class)
+      end
+    end
+
+    def resto_request(&block)
+      @request.instance_exec(&block)
+    end
+
+
+    def resto_response(&block)
+      @response.instance_exec(&block)
+    end
+
+    def resource_id
+      @resource_identifier
+    end
+
+    def resource_identifier(id)
+      @resource_identifier = id
+    end
+
+    def has_many(name, options)
+      class_name = options.fetch(:class_name)
+
+      params = options.fetch(:params, {})
+      params = params.map { |key, value| ":#{key} => #{value}" }.join(', ')
+
+      relation = options.fetch(:relation, {})
+      relation = relation.map { |key, value| ":#{key} => #{value}" }.join(', ')
+
+      method_definition = %Q{
+        def #{name}(params = {})
+          params ||= {}
+          raise ArgumentError unless params.is_a?(Hash)
+
+          @#{name} ||= {}
+
+          @#{name}[params] ||= #{class_name.capitalize}.
+            all({#{params}}.update(params), {#{relation}})
+        end
+      }
+
+      class_eval(method_definition, __FILE__, __LINE__)
+    end
+
+    def belongs_to(name)
+
+      method_definition = %Q{
+        def #{name}(reload = false)
+          if reload
+            @#{name} = #{name.capitalize}.get(#{name}_id)
+          else
+            @#{name} ||= #{name.capitalize}.get(#{name}_id)
+          end
+        end
+      }
+
+      class_eval(method_definition, __FILE__, __LINE__)
+    end
+
+    def property(name, property, options={}, &block)
+      property = Resto::Property.const_get(property.to_s).new(name, options)
+      property.instance_exec(&block) if block_given?
+
+      property_handler.add(property)
+
+      attribute_methods = %Q{
+        def #{name}
+          @attributes.get(:#{name})
+        end
+
+        def #{name}_without_cast
+          @attributes.get_without_cast(:#{name})
+        end
+
+        def #{name}?
+          @attributes.present?(:#{name})
+        end
+
+        def #{name}=(value)
+          @attributes.set(:#{name}, value)
+        end
+      }
+
+      class_eval(attribute_methods, __FILE__, __LINE__)
+    end
+
+
+    def all(params = {}, request_path_options = {}, &block)
+      req = @request.construct_path(request_path_options)
+      block.call(req) if block_given?
+
+      res =
+        if params.keys.empty?
+          req.get
+        else
+          req.params(params).get
+        end
+
+      response(res).to_collection
+    end
+
+    def head(request_path_options = {})
+      req = @request.construct_path(request_path_options)
+      response(req.head)
+    end
+
+    def get(id, request_path_options = {}, &block)
+      req = @request.construct_path(request_path_options)
+      block.call(req) if block_given?
+
+      response(req.append_path(id).get).to_object
+    end
+
+    def fetch(params = {}, request_path_options = {}, &block)
+      req = @request.construct_path(request_path_options)
+      block.call(req) if block_given?
+
+      res =
+        if params.keys.empty?
+          req.get
+        else
+          req.params(params).get
+        end
+
+      response(res).to_object
+    end
+
+    def post(attributes, request_path_options = {}, &block)
+      req = @request.construct_path(request_path_options)
+      block.call(req) if block_given?
+
+      attributes.delete(resource_id)
+      remote_attributes = property_handler.remote_attributes(attributes)
+      response(req.body(remote_attributes).post).to_object
+    end
+
+    def put(attributes, request_path_options = {},  &block)
+      req = @request.construct_path(request_path_options)
+      block.call(req) if block_given?
+
+      id = attributes.delete(resource_id)
+      remote_attributes = property_handler.remote_attributes(attributes)
+      response(req.append_path(id).body(remote_attributes).put).to_object
+    end
+
+    def delete(id, request_path_options = {}, &block)
+      req = @request.construct_path(request_path_options)
+      block.call(req) if block_given?
+
+      response(req.append_path(id).delete).to_object
+    end
+
+    def request
+      Extra::Copy.request_base(@request)
+    end
+
+    def response(response)
+      base_response.http_response(response)
+    end
+
+    def base_response
+      Extra::Copy.response_base(@response)
+    end
+
+    def property_handler
+      @property_handler ||= Property::Handler.new
+    end
+
+  end
+end
+
+module Resto
+  def initialize(attributes)
+    raise "Must be a hash" unless attributes.is_a?(Hash)
+
+    @attributes = Attributes.new(attributes, self)
+  end
+
+  attr_accessor :response
+
+  def get
+    id = attributes.fetch(self.class.resource_id)
+    self.class.get(id, request_path_options) { add_to_request }
+  end
+
+  alias reload get
+
+  def put
+    self.class.put(attributes, request_path_options) { add_to_request }
+  end
+
+  def delete
+    id = attributes.fetch(self.class.resource_id)
+    self.class.delete(id, request_path_options) { add_to_request }
+  end
+
+  def add_to_request
+    lambda { |request| request }
+  end
+
+  def request_path_options
+    {}
+  end
+
+  def valid?
+    @attributes.valid? and valid_response?(false)
+  end
+
+  def valid_response?(must_have_a_response_variable=true)
+    if must_have_a_response_variable
+      response ? response.valid? : false
+    else
+      response ? response.valid? : true
+    end
+  end
+
+  def add_error(key, value)
+    @attributes.add_error(key, value)
+  end
+
+  def errors
+    @attributes.errors
+  end
+
+  def update_attributes(attributes)
+    tap { @attributes.update_attributes(attributes) }
+  end
+
+  alias body update_attributes
+
+  def attributes
+    @attributes.to_hash
+  end
+
+end

data/lib/resto/attributes.rb

@@ -0,0 +1,56 @@
+# encoding: utf-8
+
+module Resto
+  class Attributes
+    def initialize(attributes, resource, property_handler = nil)
+      @resource = resource
+      @property_handler = property_handler || resource.class.property_handler
+      @attributes = {} # TODO must handle indifferent access :name and 'name'
+      @attributes_before_cast = {}
+      @errors = {}
+
+      update_attributes(attributes)
+    end
+
+    def update_attributes(attributes)
+      attributes.each do |key, value|
+        key = @property_handler.attribute_key(key)
+        set(key, value) if key
+      end
+    end
+
+    def set(key, value)
+      @attributes_before_cast.store(key, value)
+      @attributes.store(key, @property_handler.cast(key, value, @errors))
+    end
+
+    def get(key)
+      @attributes.fetch(key, nil)
+    end
+
+    def get_without_cast(key)
+       @attributes_before_cast.fetch(key, nil)
+    end
+
+    def present?(key)
+      @attributes.fetch(key, false) ? true : false
+    end
+
+    def valid?
+      @property_handler.validate(@resource)
+      errors.empty?
+    end
+
+    def add_error(key, value)
+      @errors.store(key, value)
+    end
+
+    def errors
+      @errors.map {|key, value| value }.compact
+    end
+
+    def to_hash
+      @attributes.merge({})
+    end
+  end
+end

data/lib/resto/extra/copy.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+require 'resto/request/base'
+require 'resto/response/base'
+
+module Resto
+  module Extra
+    module Copy
+
+      def self.request_base(request_base)
+        Resto::Request::Base.new.tap do |copy|
+          copy_instance_variables(request_base, copy, ["@request"])
+
+          request_klass = request_base.instance_variable_get("@request_klass")
+          copy.instance_variable_set("@request", request_klass.new(copy))
+        end
+      end
+
+      def self.response_base(response_base)
+        Resto::Response::Base.new.tap do |copy|
+          copy_instance_variables(response_base, copy, ["@response"])
+        end
+      end
+
+      def self.copy_instance_variables(from, to, exclude = [])
+        (from.instance_variables.map(&:to_s) - exclude).each do |name|
+          instance_variable = from.instance_variable_get(name)
+
+          to.instance_variable_set(name, instance_variable)
+        end
+      end
+    end
+  end
+end