simplemapper 0.0.1

data/lib/simple_mapper/base.rb

@@ -0,0 +1,138 @@
+require 'simple_mapper/support'
+
+module SimpleMapper
+  class Base
+    class << self
+      attr_reader :format
+      def debug?; @debug end
+      def debug!; @debug = true end
+
+      def connection_adapter=(adapter,debug=nil,&block)
+        # Should complain if the adapter doesn't exist.
+        @connection_adapter = adapter
+        require "#{File.dirname(__FILE__)}/adapters/#{@connection_adapter}_adapter"
+        @connection_init = block if block_given?
+        @connection_debug = debug
+      end
+      alias :set_connection_adapter :connection_adapter=
+
+      # set_format :xml
+      # self.format = :json
+      def format=(format)
+        @format_name = format.to_s
+        require "#{File.dirname(__FILE__)}/formats/#{@format_name}_format"
+        @format = Object.module_eval("::SimpleMapper::#{@format_name.camelize}Format", __FILE__, __LINE__)
+        include @format
+      end
+      alias :set_format :format=
+      attr_reader :format_name
+
+      def connection(refresh=false)
+        @connection = begin
+          # Initialize the connection with the connection adapter.
+          adapter = Object.module_eval("::SimpleMapper::#{@connection_adapter.to_s.camelize}Adapter", __FILE__, __LINE__).new
+          @connection_init.in_context(adapter).call if @connection_init.is_a?(Proc)
+          adapter.set_headers format.mime_type_headers
+          adapter.debug! if @connection_debug
+          adapter
+        end if !@connection || refresh
+        @connection
+      end
+
+      # get
+      def get(*args)
+        extract_from(connection.get(*args))
+      end
+
+      # new.save
+      def create(*args)
+        new(*args).save
+      end
+
+      def persistent?
+        true
+      end
+
+      def extract_from(formatted_data)
+        objs = send(:"from_#{format_name}", formatted_data)
+        objs.is_a?(Array) ? objs.collect {|e| e.extended {@persisted = true}} : objs.extended {@persisted = true}
+      end
+
+      def extract_one(formatted_data, identifier=nil)
+        objs = extract_from(formatted_data)
+        if objs.is_a?(Array)
+          identifier.nil? ? objs.first : objs.reject {|e| e.identifier != identifier}
+        else
+          identifier.nil? ? objs : (objs.identifier == identifier ? objs : nil)
+        end
+      end
+    end
+
+    def initialize(data=nil)
+      self.data = data unless data.nil?
+    end
+    attr_reader :identifier
+
+    def original_data=(data)
+      @original_data = data.freeze
+      @original_attributes = data.keys
+      instantiate(@original_data)
+    end
+    attr_reader :original_data, :original_attributes
+
+    def data=(data)
+      instantiate(data)
+    end
+    def data
+      to_hash
+    end
+
+    # Sets the data into the object. This is provided as a default method, but your model can overwrite it any
+    # way you want. For example, you could set the data to some other object type, or to a Marshalled storage.
+    # The type of data you receive will depend on the format and parser you use. Of course you could make up
+    # your own spin-off of one of those, too.
+    def instantiate(data)
+      raise TypeError, "data must be a hash" unless data.is_a?(Hash)
+      data.each {|k,v| instance_variable_set(:"@#{k}", v)}
+    end
+
+    # Reads the data from the object for saving back to the persisted store. This is provided as a default
+    # method, but you can overwrite it in your model.
+    def formatted_data
+      send(:"to_#{self.class.format_name}")
+    end
+
+    # persisted? ? put : post
+    def save
+      persisted? ? put : post
+    end
+
+    # sends a put request with self.data
+    def put
+      self.data = self.class.extract_one(self.class.connection.put(identifier, formatted_data), identifier).to_hash
+      self
+    end
+
+    # sends a post request with self.data
+    def post
+      self.data = self.class.extract_one(self.class.connection.post(formatted_data)).to_hash
+      @persisted = true
+      self
+    end
+
+    # delete
+    def delete
+      if self.class.connection.delete(identifier)
+        @persisted = false
+        instance_variable_set('@'+self.class.identifier, nil)
+        true
+      else
+        false
+      end
+    end
+
+    def persisted?
+      !!@persisted
+    end
+  end
+end

data/lib/simple_mapper/default_plugins/callbacks.rb

@@ -0,0 +1,12 @@
+module Callbacks
+  def callbacks
+    @callbacks ||= Hash.new {|h,k| h[k] = []}
+  end
+  def add_callback(name,&block)
+    callbacks[name] << block
+  end
+  def run_callback(name, *args)
+    args = args.first if args.length == 1
+    callbacks[name].inject(args) {|args,cb| cb.call(*args)}
+  end
+end

data/lib/simple_mapper/default_plugins/oauth.rb

@@ -0,0 +1,167 @@
+# gem 'oauth', '=0.2.2'
+$:.unshift('gems/gems/oauth-0.2.2/lib')
+require 'oauth'
+require 'oauth/consumer'
+require 'oauth/client/net_http'
+module OAuth
+  module Signature
+    class Base
+      def initialize(request, options = {}, &block)
+        raise TypeError unless request.kind_of?(OAuth::RequestProxy::Base)
+        @request = request
+        if block_given?
+          @token_secret, @consumer_secret = yield block.arity == 1 ? token : [token, consumer_key,nonce,request.timestamp]
+        else
+          @consumer_secret = options[:consumer].respond_to?(:secret) ? options[:consumer].secret : options[:consumer]
+          @token_secret = options[:token].respond_to?(:secret) ? options[:token].secret : (options[:token] || '')
+        end
+      end
+    end
+  end
+
+  module RequestProxy
+    class Base
+      def inspect
+        "#<OAuth::RequestProxy::MerbRequest:#{object_id}\n\tconsumer_key: #{consumer_key}\n\ttoken: #{token}\n\tparameters: #{parameters.inspect}\n>"
+      end
+    end
+  end
+end
+
+module SimpleMapper
+  module HttpOAuthExtension
+    def requires_oauth(consumer_key, consumer_secret, options={})
+      @consumer_key = consumer_key
+      @consumer_secret = consumer_secret
+      @oauth_options = options
+
+      # Ingeniousity here... ;)
+      # Duplicates the class to give it a temporary session-attached oauth scope, sets oauth to the Model-Controller-OAuth class,
+      # then makes the class use the original class for all of its instantiation.
+      # NOTE: This only really makes the class methods use OAuth. Object methods, like associations, won't play the trick as well.
+      def self.with_oauth(controller)
+        self.element_name = self.element_name
+        self.collection_name = self.collection_name
+        duped = self.dup
+        duped.set_oauth(controller)
+        yield if block_given?
+        duped
+      end
+
+      def oauth
+        @oauth
+      end
+
+      def set_oauth(controller)
+        @oauth = OAuthController.new(controller, self, @consumer_key, @consumer_secret, @oauth_options)
+        connection.add_callback('initialize_request') do |request|
+          @oauth.authenticate! if !@oauth.authorized? && @oauth.scriptable?
+          raise RuntimeError, "Must authorize OAuth before attempting to get data from the provider." unless @oauth.authorized?
+          @oauth.request_signed!(request)
+        end
+        @oauth
+      end
+
+      true
+    end
+  end
+end
+
+# We'll have an instance of these for each controller-model pair.
+class OAuthController
+  DEFAULT_OPTIONS = {
+    # Signature method used by server. Defaults to HMAC-SHA1
+    :signature_method=>'HMAC-SHA1',
+
+    # default paths on site. These are the same as the defaults set up by the generators
+    :request_token_path=>'/oauth/request_token',
+    :authorize_path=>'/oauth/authorize',
+    :access_token_path=>'/oauth/access_token',
+
+    # How do we send the oauth values to the server see 
+    # http://oauth.googlecode.com/svn/spec/branches/1.0/drafts/6/spec.html#consumer_req_param for more info
+    #
+    # Possible values:
+    #
+    #   :authorize - via the Authorize header (Default) ( option 1. in spec)
+    #   :post - url form encoded in body of POST request ( option 2. in spec)
+    #   :query - via the query part of the url ( option 3. in spec)
+    :auth_method=>:authorize, 
+
+    # Default http method used for OAuth Token Requests (defaults to :post)
+    :http_method=>:post, 
+
+    :version=>"1.0",
+
+    # Default authorization method: have the controller redirect to the authorize_url.
+    :authorization_method => lambda {|model| redirect(model.oauth.consumer.authorize_url)},
+
+    # Default session: grab session from the controller's session method -- session['Person_oauth'] for the Person ActiveResource model.
+    :session => lambda {|model| session[model.name.to_s + '_oauth'] ||= {} }
+  }
+  attr_accessor :options, :consumer
+
+  def initialize(controller, model, consumer_key, consumer_secret, options={})
+    @controller = controller
+    @model = model
+    @options = DEFAULT_OPTIONS.merge(options)
+    @model = @options.delete(:model)
+    @consumer = OAuth::Consumer.new(consumer_key, consumer_secret, options)
+  end
+
+  def authorized?
+    !!session[:access_token]
+  end
+
+  def scriptable?
+    @options[:authorization_method] == :scriptable
+  end
+
+  # The session is what holds which models are authenticated with what tokens.
+  # We just need the controller to retreive the session and to send back redirects when necessary.
+  def authenticate!
+    # 1) If we have no tokens, get a request_token and run the authorization method.
+    # 2) If we have a request_token, assume the user has already answered the question, go ahead and try to get an access_token.
+    if access_token
+      return true
+    elsif request_token
+      return @controller.begin_pathway(@options[:authorization_method].in_context(controller).call(@model)) if @options[:authorization_method].is_a?(Proc)
+      return true if access_token # For scriptables
+    end
+  end
+
+  def request_signed!(request)
+    @consumer.sign!(request, current_token)
+    request
+  end
+
+  private
+    # If none exist, go ahead and get one.
+    def request_token
+      session[:request_token] || begin
+        token = @consumer.get_request_token
+        session[:request_token] = token if token.token && token.secret
+        session[:request_token]
+      end
+    end
+
+    # If none exist but request_token exists, go ahead and request one.
+    def access_token
+      return nil if session[:request_token].nil?
+      session[:access_token] || begin
+        token = session[:request_token].get_access_token
+        session[:access_token] = token if token.token && token.secret
+        session[:access_token]
+      end
+    end
+
+    def current_token
+      access_token || request_token
+    end
+
+    def session
+      @session || begin
+        @session = @options[:session].in_context(@controller).call
+      end
+    end
+end

data/lib/simple_mapper/default_plugins/simple_model.rb

@@ -0,0 +1,36 @@
+module SimpleMapper
+  module SimpleModel
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    def to_hash(options={})
+      self.class.properties.inject({}) {|h,k| h[k] = instance_variable_get("@#{k}"); h}
+    end
+
+    def identifier
+      instance_variable_get('@'+self.class.identifier)
+    end
+
+    def method_missing(method, *args)
+      if self.class.properties.include?(method.to_s)
+        instance_variable_get('@'+method.to_s)
+      elsif method.to_s =~ /=$/ && self.class.properties.include?(method.to_s.gsub(/=/, ''))
+        instance_variable_set('@'+method.to_s.gsub(/=/, ''), *args)
+      else
+        super
+      end
+    end
+
+    module ClassMethods
+      def properties(*properties)
+        @properties = properties.collect {|e| e.to_s} if properties.length > 0
+        @properties
+      end
+      def identifier(id=nil)
+        @identifier = id.to_s unless id.nil?
+        @identifier
+      end
+    end
+  end
+end

data/lib/simple_mapper/formats/xml_format.rb

@@ -0,0 +1,48 @@
+require 'simple_mapper/support/bliss_serializer'
+
+module SimpleMapper
+  module XmlFormat
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    def self.mime_type_headers
+      {'Accept' => 'application/xml', 'Content-type' => 'application/xml'}
+    end
+
+    def to_xml
+      Serialize.object_to_xml(self, :key_name => 'self').to_s
+    end
+
+    module ClassMethods
+      # This assumes a standard xml format:
+      #   <person attribute="">
+      #     <another_att>value</another_att>
+      #   </person>
+      # And for a collection of objects:
+      #   <people>
+      #     <person attribute="">
+      #       <another_att>value 1</another_att>
+      #     </person>
+      #     <person attribute="">
+      #       <another_att>value 2</another_att>
+      #     </person>
+      #   </people>
+      def from_xml(xml)
+        doc = Serialize.hash_from_xml(xml)
+        # doc could include a single 'model' element, or a 'models' wrapper around several.
+        puts "Top-level XML key(s): #{doc.keys.inspect}" if @debug
+        key = doc.keys.first
+        if doc[key].keys.uniq == [key.singularize] && doc[key][key.singularize].is_a?(Array)
+          puts "Several objects returned under key '#{key}'/'#{key.singularize}':" if @debug
+          doc[key][key.singularize].collect do |e|
+            puts "Obj: #{e.inspect}" if @debug
+            Object.module_eval("::#{key.singularize.camelize}", __FILE__, __LINE__).new(e)
+          end
+        else # top-level must be single object
+          Object.module_eval("::#{key.singularize.camelize}", __FILE__, __LINE__).new(Serialize.hash_from_xml(xml)[self.name.underscore])
+        end
+      end
+    end
+  end
+end

data/lib/simple_mapper/support/bliss_serializer.rb

@@ -0,0 +1,168 @@
+require 'rexml/light/node'
+require 'rexml/document'
+
+# This is a slighly modified version of the XMLUtilityNode from
+# http://merb.devjavu.com/projects/merb/ticket/95 (has.sox@gmail.com)
+# It's mainly just adding vowels, as I ht cd wth n vwls :)
+# This represents the hard part of the work, all I did was change the underlying
+# parser
+class REXMLUtilityNode # :nodoc:
+  attr_accessor :name, :attributes, :children
+  
+  def initialize(name, attributes = {})
+    @name       = name.tr("-", "_")
+    @attributes = undasherize_keys(attributes)
+    @children   = []
+    @text       = false
+  end
+  
+  def add_node(node)
+    @text = true if node.is_a? String
+    @children << node
+  end
+  
+  def to_hash
+    if @text
+      return { name => typecast_value( translate_xml_entities( inner_html ) ) }
+    else
+      #change repeating groups into an array
+      # group by the first key of each element of the array to find repeating groups
+      groups = @children.group_by{ |c| c.name }
+      
+      hash = {}
+      groups.each do |key, values|
+        if values.size == 1
+          hash.merge! values.first
+        else
+          hash.merge! key => values.map { |element| element.to_hash[key] }
+        end
+      end
+      
+      # merge the arrays, including attributes
+      hash.merge! attributes unless attributes.empty?
+      
+      { name => hash }
+    end
+  end
+  
+  def typecast_value(value)
+    return value unless attributes["type"]
+    
+    case attributes["type"]
+      when "integer"  then value.to_i
+      when "boolean"  then value.strip == "true"
+      when "datetime" then ::Time.parse(value).utc
+      when "date"     then ::Date.parse(value)
+      else                 value
+    end
+  end
+  
+  def translate_xml_entities(value)
+    value.gsub(/&lt;/,   "<").
+          gsub(/&gt;/,   ">").
+          gsub(/&quot;/, '"').
+          gsub(/&apos;/, "'").
+          gsub(/&amp;/,  "&")
+  end
+  
+  def undasherize_keys(params)
+    params.keys.each do |key, vvalue|
+      params[key.tr("-", "_")] = params.delete(key)
+    end
+    params
+  end
+  
+  def inner_html
+    @children.join
+  end
+  
+  def to_html
+    "<#{name}#{attributes.to_xml_attributes}>#{inner_html}</#{name}>"
+  end
+  
+  def to_s 
+    to_html
+  end
+end
+
+module Serialize
+  XML_OPTIONS = {
+    :include_key => :attribute, # Can be false, :element, or :attribute
+    :report_nil => true, # Sets an attribute nil="true" on elements that are nil, so that the reader doesn't read as an empty string
+    :key_name => 'id', # Default key name
+  }
+  def self.object_to_xml(obj, options={})
+    # Automatically set the key_name for DataMapper objects
+    options.merge!(:key_name => obj.class.table.key.name) if obj.class.respond_to?(:table) && obj.class.respond_to?(:persistent?) && obj.class.persistent?
+    # Should do the above also for ActiveRecord...
+    to_xml(obj.class.name.underscore, obj.to_hash(options), options)
+  end
+  def self.to_xml(root, attributes={}, options={})
+    options = XML_OPTIONS.merge(options)
+    attributes = attributes.dup.stringify_keys!
+
+    doc = REXML::Document.new
+    root_element = doc.add_element(root)
+
+    case options[:include_key]
+    when :attribute
+      root_element.add_attribute(options[:key_name], attributes.delete(options[:key_name].to_s).to_s).extended do
+        def self.to_string; %Q[#@expanded_name="#{to_s().gsub(/"/, '&quot;')}"] end
+      end
+    when :element
+      root_element.add_element(options[:key_name]) << REXML::Text.new(attributes.delete(options[:key_name].to_s).to_s)
+    end
+
+    attributes.each do |key,value|
+      node = root_element.add_element(key)
+      node << REXML::Text.new(value.to_s) unless value.nil?
+      node.add_attribute('nil', 'true') if value.nil? && options[:report_nil]
+    end
+
+    doc
+  end
+  
+  def self.hash_from_xml(xml,options={})
+    options = XML_OPTIONS.merge(options)
+
+    stack = []
+    parser = REXML::Parsers::BaseParser.new(xml)
+
+    while true
+      event = parser.pull
+      case event[0]
+      when :end_document
+        break
+      when :end_doctype, :start_doctype
+        # do nothing
+      when :start_element
+        stack.push REXMLUtilityNode.new(event[1], event[2])
+      when :end_element
+        if stack.size > 1
+          temp = stack.pop
+          stack.last.add_node(temp)
+        end
+      when :text, :cdata
+        stack.last.add_node(event[1]) unless event[1].strip.length == 0
+      end
+    end
+    data = stack.pop.to_hash
+
+    # Turn any {"nil" => "true"} into just nil
+    data.crawl {|h,k,v| h[k] = nil if v == {}; v} unless options[:report_nil]
+    data.crawl {|h,k,v| h[k] = nil if v == {} || v == {'nil' => 'true'}; v} if options[:report_nil]
+    data
+  end
+end
+
+module Merb
+  class Request
+    def xml_params
+      @xml_params ||= begin
+        if Merb::Const::XML_MIME_TYPE_REGEXP.match(content_type)
+          Serialize.hash_from_xml(raw_post) rescue Mash.new
+        end
+      end
+    end
+  end
+end