restfulie 0.6.0 → 0.7.0

data/lib/restfulie/server/opensearch.rb

@@ -1,18 +0,0 @@
-#
-#  Copyright (c) 2009 Caelum - www.caelum.com.br/opensource
-#  All rights reserved.
-# 
-#  Licensed under the Apache License, Version 2.0 (the "License"); 
-#  you may not use this file except in compliance with the License. 
-#  You may obtain a copy of the License at 
-#  
-#   http://www.apache.org/licenses/LICENSE-2.0 
-#  
-#  Unless required by applicable law or agreed to in writing, software 
-#  distributed under the License is distributed on an "AS IS" BASIS, 
-#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-#  See the License for the specific language governing permissions and 
-#  limitations under the License. 
-#
-
-require 'restfulie/server/opensearch/description'

data/lib/restfulie/server/transition.rb

@@ -1,93 +0,0 @@
-#
-#  Copyright (c) 2009 Caelum - www.caelum.com.br/opensource
-#  All rights reserved.
-# 
-#  Licensed under the Apache License, Version 2.0 (the "License"); 
-#  you may not use this file except in compliance with the License. 
-#  You may obtain a copy of the License at 
-#  
-#   http://www.apache.org/licenses/LICENSE-2.0 
-#  
-#  Unless required by applicable law or agreed to in writing, software 
-#  distributed under the License is distributed on an "AS IS" BASIS, 
-#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-#  See the License for the specific language governing permissions and 
-#  limitations under the License. 
-#
-
-module Restfulie
-  
-  module Server
-
-    # represents a transition on the server side
-    class Transition
-      attr_reader :body, :name
-      attr_writer :options
-      attr_accessor :result
-      
-      def initialize(*args)
-        args[0].kind_of?(Array) ? from_array(*args) : from(*args)
-      end
-      
-      private
-      def from_array(array)
-        @name = array[0]
-        @options = array.length>0 ? array[1] : nil
-        @result = array.length>1 ? array[2] : nil
-        @body = nil
-      end
-      
-      def from(name, options = {}, result = nil, body = nil)
-        @name = name
-        @options = options
-        @result = result
-        @body = body
-      end
-      
-      public
-      
-      def action
-        @options || {}
-      end
-      
-      # executes this transition in a resource
-      def execute_at(target_object)
-        target_object.status = @result.to_s unless @result.nil?
-      end
-    
-      # return the link to this transitions's uri
-      def link_for(model, controller)
-        specific_action = @body ? @body.call(model) : action.dup
-
-        specific_action = parse_specific_action(specific_action, model)
-
-        rel = specific_action[:rel] || @name
-        specific_action[:rel] = nil
-
-        specific_action[:action] ||= @name
-        uri = controller.url_for(specific_action)
-        
-        return rel, uri
-      end
-      
-      private
-
-      # if you use the class level DSL, you will need to add a lambda for instance level accessors:
-      #   transition :show, {:action => :show, :foo_id => lambda { |model| model.id }}
-      # but you can replace it for a symbol and defer the model call
-      #   transition :show, {:action => :show, :foo_id => :id}
-      def parse_specific_action(action, model)
-        action.inject({}) do |actions, pair|
-          if pair.last.is_a?( Symbol ) && model.attributes.include?(pair.last)
-            actions.merge!( pair.first => model.send(pair.last) )
-          else
-            actions.merge!( pair.first => pair.last )
-          end
-        end
-        action
-      end
-      
-    end
-  end
-
-end

data/lib/restfulie/unmarshalling.rb

@@ -1,131 +0,0 @@
-#
-#  Copyright (c) 2009 Caelum - www.caelum.com.br/opensource
-#  All rights reserved.
-# 
-#  Licensed under the Apache License, Version 2.0 (the "License"); 
-#  you may not use this file except in compliance with the License. 
-#  You may obtain a copy of the License at 
-#  
-#   http://www.apache.org/licenses/LICENSE-2.0 
-#  
-#  Unless required by applicable law or agreed to in writing, software 
-#  distributed under the License is distributed on an "AS IS" BASIS, 
-#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-#  See the License for the specific language governing permissions and 
-#  limitations under the License. 
-#
-
-module Hashi
-  class CustomHash
-    def initialize(hash = {})
-      @internal_hash = hash
-      link = hash['link'] if hash.kind_of? Hash
-      add_transitions([link]) if link.kind_of? Hash
-      add_transitions(link) if link.kind_of? Array
-    end
-  end
-end
-
-# module Jeokkarak
-#   module Base
-#     alias_method :old_from_hash_parse, :from_hash_parse
-#     def from_hash_parse(result,h,key,value)
-#       return old_from_hash_parse(result, h, key, value) if key!='link'
-#       link = h[key]
-#       result.add_transitions([link]) if link.kind_of? Hash
-#       result.add_transitions(link) if link.kind_of? Array
-#     end
-#   end
-# end
-
-module Restfulie
-  module Unmarshalling
-    # basic code from Matt Pulver
-    # found at http://www.xcombinator.com/2008/08/11/activerecord-from_xml-and-from_json-part-2/
-    # addapted to support links
-    
-    def from_hash( hash )
-      h = hash ? hash.dup : {}
-      links = nil
-      h.each do |key, value|
-        if key == "link"
-          links = value.instance_of?(Array) ? h[key] : [h[key]]
-        elsif [Array, Hash].include? value.class
-          klazz = get_the_class(key)
-          if value.instance_of?(Array)
-            h[key].map! { |e| (klazz || Hashi::CustomHash).send(:from_hash, e) }
-          elsif value.instance_of?(Hash)
-            h[key] = klazz.array_from_hash(value)
-          else
-            h[key] = klazz.from_hash value
-          end
-        end
-         h.delete key if ["xmlns", "link"].include?(key)
-       end
-       
-       result = make_new_object h
-       result.add_transitions(links) if !(links.nil?) && self.include?(Restfulie::Client::Instance)
-       result
-     end
-     
-     # creates an array of this type based on a hash created using rails Hash.from_xml method
-     # because Hash.from_xml returns some no-cute hash structure when dealing with aligned elements
-     # we had to support it in a variety of ways.
-     # usage example:
-     #
-       # hash = {"player" => {"name" => "guilherme silveira"}}
-       # player = Player.array_from_hash(hash)
-       # puts player[0].name
-       # 
-       # hash = {"player" => [{"name" => "guilherme silveira"}, {"name" => "andre de santi"}]}
-       # player = Player.array_from_hash(hash)
-       # puts player[0].name
-       # puts player[1].name
-     def array_from_hash(hash)
-       
-       return self.from_hash(hash) unless (hash.size == 1 && hash.keys.first == self.to_s.underscore)
-       
-       children = hash.values.first
-       
-       return [self.from_hash(children)] unless children.instance_of?(Array)
-
-       children.map { |child| self.from_hash(child) }
-       
-     end
-     
-    def from_json(json)
-      from_hash(safe_json_decode(json).values.first)
-    end
-
-    # The xml has a surrounding class tag (e.g. ship-to),
-    # but the hash has no counterpart (e.g. 'ship_to' => {} )
-    def from_xml(xml)
-      hash = Hash.from_xml xml
-      head = hash[self.to_s.underscore]
-      result = self.from_hash head
-      return nil if result.nil?
-      result._came_from = :xml if self.include?(Restfulie::Client::Instance)
-      result
-    end
-    
-    private
-    def make_new_object(hash = {})
-      obj = self.new
-      hash.keys.each { |key| obj.send("#{key}=", hash[key]) }
-      obj
-    end
-    
-    def get_the_class(name)
-      respond_to?(:reflect_on_association) ? reflect_on_association(name.to_sym).klass.to_s.constantize : nil
-    end
-  end
-end  
-
-private
-def safe_json_decode(json)
-  return {} if !json
-  begin
-    ActiveSupport::JSON.decode json
-  rescue ; {} end
-end
-# end of code based on Matt Pulver's

data/lib/vendor/jeokkarak/hashi.rb

@@ -1,65 +0,0 @@
-module Hashi
-  class UndefinedMethod < Exception
-    attr_reader :msg
-    def initialize(msg)
-      @msg = msg
-    end
-    def to_s
-      @msg
-    end
-  end
-  
-  class CustomHash
-    
-    attr_reader :internal_hash
-
-    def initialize(hash = {})
-      @internal_hash = hash
-    end
-    
-    def method_missing(name, *args, &block)
-      name = name.to_s if name.kind_of? Symbol
-      if name[-1,1] == "?"
-        parse(name, @internal_hash[name.chop])
-      elsif name[-1,1] == "="
-        @internal_hash[name.chop] = args[0]
-      elsif @internal_hash.kind_of?(Array) && name == "each"
-        @internal_hash.each do |k| block.call(transform(k)) end
-      elsif name.respond_to? name
-        @internal_hash.send(name, *args, &block)
-      else
-        return nil if @internal_hash.has_key?(name) && @internal_hash[name].nil?
-        parse(name, transform(@internal_hash[name]))
-      end
-    end
-    
-    def respond_to?(symbol)
-      super(symbol) || @internal_hash.key?(symbol.to_s)
-    end
-    
-    def [](x)
-      transform(@internal_hash[x])
-    end
-    
-    private
-    def transform(value)
-      return CustomHash.new(value) if value.kind_of?(Hash) || value.kind_of?(Array)
-      value
-    end
-    
-    def parse(name, value)
-      raise Hashi::UndefinedMethod.new("undefined method '#{name}'") if value.nil?
-      value
-    end
-    
-  end
-  
-  def self.from_hash(hash)
-    CustomHash.new(hash)
-  end
-  
-  def self.to_object(hash)
-    CustomHash.new(hash)
-  end
-  
-end

data/lib/vendor/jeokkarak/jeokkarak.rb

@@ -1,81 +0,0 @@
-#
-#  Copyright (c) 2009 Caelum - www.caelum.com.br/opensource
-#  All rights reserved.
-# 
-#  Licensed under the Apache License, Version 2.0 (the "License"); 
-#  you may not use this file except in compliance with the License. 
-#  You may obtain a copy of the License at 
-#  
-#   http://www.apache.org/licenses/LICENSE-2.0 
-#  
-#  Unless required by applicable law or agreed to in writing, software 
-#  distributed under the License is distributed on an "AS IS" BASIS, 
-#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-#  See the License for the specific language governing permissions and 
-#  limitations under the License. 
-
-require 'vendor/jeokkarak/hashi'
- 
-module Jeokkarak
-  module Base
-    
-    # defines that this type has a child element
-    def has_child(type, options={})
-      resource_children[options[:as]] = type
-    end
-    
-    # checks what is the type element for this type (supports rails ActiveRecord, has_child and Hashi)
-    def child_type_for(name)
-      return reflect_on_association(name.to_sym ).klass if respond_to? :reflect_on_association
-      resource_children[name] || Hashi
-    end
-    
-    # returns the registered children list for this resource
-    def resource_children
-      @children ||= {}
-      @children
-    end
-    
-    # creates an instance of this type based on this hash
-    def from_hash(h)
-      h = {} if h.nil? # nasty required check
-      h = h.dup
-      result = self.new
-      result._internal_hash = h
-      h.each do |key,value|
-        from_hash_parse result, h, key, value
-      end
-      def result.method_missing(name, *args, &block)
-        Hashi.to_object(@_internal_hash).send(name, args[0], block)
-      end
-      result
-    end
-    
-    # extension point to parse a value
-    def from_hash_parse(result,h,key,value)
-      case value.class.to_s
-      when 'Array'
-        h[key].map! { |e| child_type_for(key).from_hash e }
-      when /\AHash(WithIndifferentAccess)?\Z/
-        h[key] = child_type_for(key ).from_hash value
-      end
-      name = "#{key}="
-      result.send(name, value) if result.respond_to?(name)
-    end
-  end
-end
- 
-module Jeokkarak
-  module Config
-    
-    # entry point to define a jeokkarak type
-    def acts_as_jeokkarak
-      self.module_eval do
-        attr_accessor :_internal_hash
-      end
-      self.extend Jeokkarak::Base
-    end
-  end
-end
- 
-Object.extend Jeokkarak::Config