restfulie 0.1.0.beta1

data/lib/restfulie/common/converter/json/builder.rb

@@ -0,0 +1,102 @@
+module Restfulie
+  module Common
+    module Converter
+      module Json
+        class Builder
+          def initialize(obj, initial_obj = {})
+            @doc     = initial_obj
+            @obj     = obj
+            @current = @doc
+          end
+      
+          def values(options = nil, &block)
+            yield Values.new(self)
+          end
+          
+          def members(options = {}, &block)
+            collection = options[:collection] || @obj 
+            raise Error::BuilderError.new("Members method require a collection to execute") unless collection.respond_to?(:each)
+            root = options[:root] || Restfulie::Common::Converter.root_element_for(collection)
+            
+            collection.each do |member|
+              node = {}
+              
+              parent = @current
+              @current = node
+              block.call(self, member)
+              @current = parent
+              
+              add_to_current(root, node)
+            end
+          end
+          
+          def link(relationship, uri, options = {})
+            options["rel"] = relationship.to_s
+            options["href"] = uri
+            options["type"] ||= "application/json"
+            insert_value("link", nil, options)
+          end
+      
+          def insert_value(name, prefix, *args, &block)
+            node = create_element(block_given?, *args)
+            
+            if block_given?
+              parent = @current
+              @current = node
+              block.call
+              @current = parent
+            end
+            
+            add_to_current(name, node)
+          end
+      
+          def representation
+            Representation::Json.create(@doc).to_json
+          end
+          
+        private
+        
+          def create_element(has_block, *args)
+            vals = []
+            hashes = []
+            
+            args.each do |arg|
+              arg.kind_of?(Hash) ? hashes << arg : vals << arg
+            end
+            
+            if hashes.empty?
+              # only simple values
+              unless vals.empty?
+                vals = vals.first if vals.size == 1
+                node = has_block ? {} : vals
+              else
+                node = has_block ? {} : nil
+              end
+            else
+              # yes we have hashes
+              node = {} 
+              hashes.each { |hash| node.merge!(hash) }
+              unless vals.empty?
+                vals = vals.first if vals.size == 1
+                node = has_block ? {} : [node, vals]
+              end
+              node
+            end
+          end
+          
+          def add_to_current(name, value)
+            if @current[name]
+              if @current[name].kind_of?(Array)
+                @current[name] << value
+              else
+                @current[name] = [@current[name], value]
+              end
+            else
+              @current[name] = value
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/restfulie/common/converter/json/helpers.rb

@@ -0,0 +1,17 @@
+module Restfulie
+  module Common
+    module Converter
+      module Json
+        module Helpers
+          def collection(obj, *args, &block)
+            Restfulie::Common::Converter::Json.to_json(obj, &block)
+          end
+        
+          def member(obj, *args, &block)
+            Restfulie::Common::Converter::Json.to_json(obj, &block)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/restfulie/common/converter/json.rb

@@ -0,0 +1,12 @@
+module Restfulie
+  module Common
+    module Converter
+      module Json
+        autoload :Base, 'restfulie/common/converter/json/base'
+        autoload :Builder, 'restfulie/common/converter/json/builder'
+        autoload :Helpers, 'restfulie/common/converter/json/helpers'
+        extend Base::ClassMethods
+      end
+    end
+  end
+end

data/lib/restfulie/common/converter/open_search/descriptor.rb

@@ -0,0 +1,32 @@
+class Restfulie::Common::Converter::OpenSearch::Descriptor
+  
+  def initialize(hash)
+    @hash = hash["OpenSearchDescription"]
+  end
+  
+  def urls
+    uris = @hash["Url"]
+    uris.kind_of?(Array) ? uris : [uris]
+  end
+  
+  def use(content_type)
+    uri = urls.find do |url|
+      url["type"]==content_type
+    end
+    return nil if uri.nil?
+    
+    base_uri, params_pattern = extract_uri(uri)
+    Restfulie.at(base_uri).accepts(content_type).open_search.with_pattern(params_pattern)
+  end
+  
+  private
+  def extract_uri(uri)
+    uri = uri["template"]
+    interrogation = uri.index("?")
+    params = uri[interrogation+1..uri.size]
+    base_uri = uri[0..interrogation-1]
+    [base_uri, params]
+  end
+  
+end
+

data/lib/restfulie/common/converter/open_search.rb

@@ -0,0 +1,16 @@
+module Restfulie
+  module Common
+    class Converter::OpenSearch#:nodoc:
+      autoload :Descriptor, 'restfulie/common/converter/open_search/descriptor'
+    end
+  end
+end
+
+class Restfulie::Common::Converter::OpenSearch
+  
+  def self.unmarshal(xml)
+    hash = Hash.from_xml(xml)
+    descriptor = Descriptor.new(hash)
+  end
+  
+end

data/lib/restfulie/common/converter/values.rb

@@ -0,0 +1,33 @@
+module Restfulie
+  module Common
+    module Converter
+      # This is a Blank Slate class to support the renderization of the values block for Resource Representation Interfaces
+      # Every Media type should implement a Builder with a insert_value method that renders the values block to a specific format
+      class Values
+        attr_accessor :builder
+    
+        # BlankSlate
+        instance_methods.each do |m|
+          undef_method m unless m.to_s =~ /\[\]|method_missing|respond_to\?|^__/
+        end
+    
+        def initialize(builder)
+          @builder = builder
+          @current_prefix = nil
+        end
+    
+        def [](prefix)
+          @current_prefix = prefix
+          self
+        end
+    
+        def method_missing(symbol, *args, &block)
+          name = symbol.to_s
+          prefix = @current_prefix
+          @current_prefix = nil
+          @builder.insert_value(name, prefix, *args, &block)
+        end
+      end
+    end
+  end
+end

data/lib/restfulie/common/converter/xml/base.rb

@@ -0,0 +1,63 @@
+require 'active_support/core_ext/hash/conversions'
+
+module Restfulie
+  module Common
+    module Converter
+      module Xml
+        module Base
+          module ClassMethods
+            mattr_reader :media_type_name
+            @@media_type_name = 'application/xml'
+        
+            mattr_reader :headers
+            @@headers = { 
+              :post => { 'Content-Type' => media_type_name }
+            }
+        
+            def marshal(entity, options = {})
+              to_xml(entity, options)
+            end
+        
+            def unmarshal(string)
+              Hash.from_xml string
+            end
+        
+            mattr_reader :recipes
+            @@recipes = {}
+        
+            def describe_recipe(recipe_name, options={}, &block)
+              raise 'Undefined recipe' unless block_given?
+              raise 'Undefined recipe_name'   unless recipe_name
+              @@recipes[recipe_name] = block
+            end
+        
+            def to_xml(obj, options = {}, &block)
+              return obj if obj.kind_of?(String)
+              
+              if block_given?
+                recipe = block 
+              elsif options[:recipe]
+                recipe = @@recipes[options[:recipe]]
+              elsif obj.kind_of?(Hash) && obj.size==1
+                return obj.values.first.to_xml(:root => obj.keys.first)
+              else
+                return obj.to_xml
+              end
+              
+              # Create representation and proxy
+              builder = Builder.new(obj, options)
+        
+              # Check recipe arity size before calling it
+              recipe.call(*[builder, obj, options][0,recipe.arity])
+              builder.doc.to_xml
+            end
+            
+            def helper
+              Helpers
+            end
+          end
+        end
+      end
+    end
+  end
+end 

data/lib/restfulie/common/converter/xml/builder.rb

@@ -0,0 +1,113 @@
+module Restfulie
+  module Common
+    module Converter
+      module Xml
+        # Implements the interface for marshal Xml media type requests (application/xml)
+        class Builder
+          attr_reader :doc
+          def initialize(obj, options = {})
+            @doc    = Nokogiri::XML::Document.new
+            @obj    = obj
+            root = options[:root] || Restfulie::Common::Converter.root_element_for(obj)
+            @parent = @doc.create_element(root)
+            @parent.parent = @doc
+          end
+          
+          def values(options = {}, &block)
+            options.each do |key,value|
+              attr = key.to_s
+              if attr =~ /^xmlns(:\w+)?$/
+                ns = attr.split(":", 2)[1]
+                @parent.add_namespace_definition(ns, value)
+              end
+            end             
+            yield Values.new(self)
+          end
+        
+          def insert_value(name, prefix, *args, &block)
+            node = create_element(name.to_s, prefix, *args)
+            node.parent = @parent
+            
+            if block_given?
+              @parent = node
+              block.call
+              @parent = node.parent
+            end
+          end
+          
+          def link(relationship, uri, options = {})
+            options["rel"] = relationship.to_s
+            options["href"] = uri
+            options["type"] ||= "application/xml"
+            insert_value("link", nil, options)
+          end
+          
+          def members(a_collection = nil, options = {}, &block)
+            collection = a_collection || @obj 
+            raise Error::BuilderError("Members method require a collection to execute") unless collection.respond_to?(:each)
+            collection.each do |member|
+              root = options[:root] || Restfulie::Common::Converter.root_element_for(member)
+              entry = @doc.create_element(root)
+              entry.parent = @parent
+              @parent = entry
+              block.call(self, member)
+              @parent = entry.parent
+            end
+          end
+          
+          private
+          
+          def create_element(node, prefix, *args)
+            node = @doc.create_element(node) do |n|
+              if prefix
+                if namespace = prefix_valid?(prefix)
+                  # Adding namespace prefix
+                  n.namespace = namespace
+                  namespace = nil
+                end
+              end
+        
+              args.each do |arg|
+                case arg
+                # Adding XML attributes
+                when Hash
+                  arg.each { |k,v|
+                    key = k.to_s
+                    if key =~ /^xmlns(:\w+)?$/
+                      ns_name = key.split(":", 2)[1]
+                      n.add_namespace_definition(ns_name, v)
+                      next
+                    end
+                    n[k.to_s] = v.to_s
+                  }
+                # Adding XML node content
+                else            
+                  content = if arg.kind_of?(Time) || arg.kind_of?(DateTime)
+                      arg.xmlschema
+                    else
+                      arg
+                    end
+                  n.content = content
+                end
+              end
+            end
+          end
+          
+          def prefix_valid?(prefix)
+            ns = @parent.namespace_definitions.find { |x| x.prefix == prefix.to_s }
+            
+            unless ns
+              @parent.ancestors.each do |a|
+                next if a == @doc
+                ns = a.namespace_definitions.find { |x| x.prefix == prefix.to_s }
+                break if ns
+              end      
+            end
+            
+            return ns
+          end
+        end
+      end
+    end
+  end
+end

data/lib/restfulie/common/converter/xml/helpers.rb

@@ -0,0 +1,17 @@
+module Restfulie
+  module Common
+    module Converter
+      module Xml
+        module Helpers
+          def collection(obj, opts = {}, &block)
+            Xml.to_xml(obj, opts, &block)
+          end
+        
+          def member(obj, opts = {}, &block)
+            Xml.to_xml(obj, opts, &block)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/restfulie/common/converter/xml/link.rb

@@ -0,0 +1,30 @@
+module Restfulie
+  module Common
+    module Converter
+      module Xml
+        class Link
+          def initialize(options = {})
+            @options = options
+          end
+          def href
+            @options["href"]
+          end
+          def rel
+            @options["rel"]
+          end
+          def content_type
+            @options["type"]
+          end
+          def type
+            content_type
+          end
+          def follow
+            r = Restfulie.at(href)
+            r = r.as(content_type) if content_type
+            r
+          end
+        end
+      end
+    end
+  end
+end

data/lib/restfulie/common/converter/xml/links.rb

@@ -0,0 +1,21 @@
+module Restfulie
+  module Common
+    module Converter
+      module Xml
+        class Links
+          def initialize(links)
+            links = [links] unless links.kind_of? Array
+            links = [] unless links
+            @links = links.map { |l| Restfulie::Common::Converter::Xml::Link.new(l) }
+          end
+          
+          def method_missing(sym, *args)
+            @links.find do |link|
+              link.rel == sym.to_s
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/restfulie/common/converter/xml.rb

@@ -0,0 +1,14 @@
+module Restfulie
+  module Common
+    module Converter
+      module Xml
+        autoload :Base, 'restfulie/common/converter/xml/base'
+        autoload :Builder, 'restfulie/common/converter/xml/builder'
+        autoload :Helpers, 'restfulie/common/converter/xml/helpers'
+        autoload :Links, 'restfulie/common/converter/xml/links'
+        autoload :Link, 'restfulie/common/converter/xml/link'
+        extend Base::ClassMethods
+      end
+    end
+  end
+end

data/lib/restfulie/common/converter.rb

@@ -0,0 +1,43 @@
+module Restfulie
+  module Common
+    module Converter
+      Dir["#{File.dirname(__FILE__)}/converter/*.rb"].each {|f| autoload File.basename(f)[0..-4].camelize.to_sym, f }
+
+      # Returns the default root element name for an item or collection
+      def self.root_element_for(obj)
+        if obj.kind_of?(Hash) && obj.size==1
+          obj.keys.first.to_s
+        elsif obj.kind_of?(Array) && !obj.empty?
+          root_element_for(obj.first).to_s.underscore.pluralize
+        else
+          obj.class.to_s.underscore
+        end
+      end
+      
+      def self.register(media_type,representation)
+        representations[media_type] = representation
+      end
+
+      def self.content_type_for(media_type)
+        return nil unless media_type
+        content_type = media_type.split(';')[0] # [/(.*?);/, 1]
+        representations[content_type]
+      end
+      
+      private
+      
+      def self.representations
+        @representations ||= {}
+      end
+      
+      register 'application/atom+xml' , ::Restfulie::Common::Converter::Atom
+      register 'application/xml' , ::Restfulie::Common::Converter::Xml
+      register 'text/xml' , ::Restfulie::Common::Converter::Xml
+      register 'application/json' , ::Restfulie::Common::Converter::Json
+      register 'application/opensearchdescription+xml' , ::Restfulie::Common::Converter::OpenSearch
+      
+      
+    end
+  end
+end
+

data/lib/restfulie/common/core_ext/hash.rb

@@ -0,0 +1,18 @@
+class Hash
+
+  def links(*args)
+    links = fetch("link", [])
+    Restfulie::Common::Converter::Xml::Links.new(links)
+  end
+
+  include Restfulie::Common::Links
+
+  def method_missing(sym, *args)
+    self[sym.to_s].nil? ? super(sym, args) : self[sym.to_s]
+  end
+  
+  def respond_to?(sym)
+    include?(sym.to_s) || super(sym)
+  end
+  
+end

data/lib/restfulie/common/core_ext.rb

@@ -0,0 +1 @@
+require 'restfulie/common/core_ext/hash'

data/lib/restfulie/common/error.rb

@@ -0,0 +1,19 @@
+module Restfulie
+  module Common
+    module Error
+      class RestfulieError < StandardError; end
+      class MarshallingError < RestfulieError; end
+      class UndefinedMarshallingError < MarshallingError; end
+      
+      # Atom marshallinh error
+      class AtomMarshallingError < MarshallingError; end
+      class NameSpaceError < AtomMarshallingError; end
+    
+      # Converter
+      class ConverterError < RestfulieError; end
+      
+      # builder
+      class BuilderError < RestfulieError; end
+    end
+  end
+end

data/lib/restfulie/common/links.rb

@@ -0,0 +1,9 @@
+module Restfulie
+  module Common
+    module Links
+      def refresh
+        links.self.follow.get
+      end
+    end
+  end
+end

data/lib/restfulie/common/logger.rb

@@ -0,0 +1,19 @@
+module Restfulie
+  module Common
+    class Logger
+      # Configure the logger used by Restfulie
+      # 
+      # The logger defaults to ActiveSupport::BufferedLogger.new(STDOUT)
+      def self.logger
+        @@logger
+      end
+
+      def self.logger=(value)
+        @@logger = value
+      end
+
+      @@logger = ActiveSupport::BufferedLogger.new(STDOUT)
+      @@logger.level = ::Logger::DEBUG
+    end
+  end
+end