restfulie 0.8.0 → 0.8.1

data/lib/restfulie/client/mikyung/steady_state_walker.rb

@@ -1,32 +1,38 @@
 # A steady walker that tries 3 times each step
-class Restfulie::Client::Mikyung::SteadyStateWalker
-  
-  def move(goal, current, mikyung)
-    step = goal.next_step(current, mikyung)
-    raise Restfulie::Client::UnableToAchieveGoalError, "No step was found for #{current}" unless step
-    Restfulie::Common::Logger.logger.debug "Mikyung > next step will be #{step}"
-    step = step.new if step.kind_of? Class
-    try_to_execute(step, current, 3, mikyung)
-  end
-
-  private
-  
-  def try_to_execute(step, current, max_attempts, mikyung)
-    raise "Unable to proceed when trying to #{step}" if max_attempts == 0
-
-    resource = step
-    raise "Step returned 'give up'" if resource.nil?
+module Restfulie
+  module Client
+    module Mikyung
+      class SteadyStateWalker
+        def move(goal, current, mikyung)
+          step = goal.next_step(current, mikyung)
+          raise UnableToAchieveGoalError, "No step was found for #{current}" unless step
+          Common::Logger.logger.debug "Mikyung > next step will be #{step}"
+          step = step.new if step.kind_of? Class
+          try_to_execute(step, current, 3, mikyung)
+        end
+      
+        private
+        
+          def try_to_execute(step, current, max_attempts, mikyung)
+            raise "Unable to proceed when trying to #{step}" if max_attempts == 0
+        
+            resource = step
+            raise "Step returned 'give up'" if resource.nil?
+        
+            if step.respond_to?(:execute)
+              resource = step.execute(current, mikyung)
+            end
 
-    if step.respond_to?(:execute)
-      resource = step.execute(current, mikyung)
-    end
-
-    if resource.response.code != 200
-      try_to_execute(step, current, max_attempts-1, mikyung)
-    else
-      Restfulie::Common::Logger.logger.debug resource.response.body
-      resource
+            # TODO: should it really retry if it is not 200? Or only if it is on the 50x family?
+            # for instance the result could be a 302 redirection
+            unless resource.response.code == 200
+              try_to_execute(step, current, max_attempts-1, mikyung)
+            else
+              Common::Logger.logger.debug resource.response.body
+              resource
+            end
+          end
+      end
     end
   end
-
-end
+end

data/lib/restfulie/client/mikyung/then_condition.rb

@@ -1,33 +1,39 @@
 # A conclusion to a step.
 #
 # Whenever a step rule matches, there are a series of conditions to be executed.
-class Restfulie::Client::Mikyung::ThenCondition
-  
-  attr_reader :description
-  
-  # creates a new result, based on this description
-  def initialize(description)
-    @description = description
-  end
-  
-  # finds the rule for this result and executes it
-  def execute(resource, goal, mikyung)
-    goal.then_rules.each do |rule|
-      if (matches = Regexp.new(rule[0]).match(@description))
-        return invoke_rule(rule[1], resource, matches, mikyung)
+module Restfulie
+  module Client
+    module Mikyung
+      class ThenCondition
+        attr_reader :description
+        
+        # creates a new result, based on this description
+        def initialize(description)
+          @description = description
+        end
+        
+        # finds the rule for this result and executes it
+        def execute(resource, goal, mikyung)
+          goal.then_rules.each do |rule|
+            if (matches = Regexp.new(rule[0]).match(@description))
+              return invoke_rule(rule[1], resource, matches, mikyung)
+            end
+          end
+          nil
+        end
+        
+        private
+          def invoke_rule(rule, resource, matches, mikyung)
+            case rule.arity
+            when 1
+              rule.call(resource)
+            when 2
+              rule.call(resource, matches)
+            else
+              rule.call(resource, matches, mikyung)
+            end
+          end
       end
     end
-    nil
-  end
-  
-  private
-  def invoke_rule(rule, resource, matches, mikyung)
-    if rule.arity==1
-      rule.call(resource)
-    elsif rule.arity==2
-      rule.call(resource, matches)
-    else
-      rule.call(resource, matches, mikyung)
-    end
   end
-end
+end

data/lib/restfulie/client/mikyung/when_condition.rb

@@ -1,53 +1,57 @@
 # Checks whether one or more rule holds and is capable of executing results.
-class Restfulie::Client::Mikyung::WhenCondition
-
-  # Creates a conditional execution based on a description.
-  # Its rule is an array where its first element represents a rule name and second a lambda that returns true or false
-  # Its params are extra params that might be passed to the rule
-  # Example
-  # WhenCondition.new("when running", ["", lambda { |resource| resource.human.state=='running' }], "")
-  def initialize(description, rule, params)
-    @description = description
-    @results = []
-    @extra = []
-    @rule = rule
-    @params = params
-  end
-
-  # will execute the first attached result
-  def execute(resource, goal, mikyung)
-    @results.each do |result|
-      Restfulie::Common::Logger.logger.info("will '#{result.description}'")
-      return result.execute(resource, goal, mikyung)
-    end
-  end
-
-  # checks whether this step should execute for a specific resource
-  def should_run_for(resource, goal)
-    if @rule[1].arity==2
-      rule_accepts = @rule[1].call(resource, @params)
-    else
-      rule_accepts = @rule[1].call(resource)
-    end
-    return false unless rule_accepts
-    !@extra.find do |condition|
-      !condition.should_run_for(resource, goal)
+module Restfulie
+  module Client
+    module Mikyung
+      # Creates a conditional execution based on a description.
+      # Its rule is an array where its first element represents a rule name and second a lambda that returns true or false
+      # Its params are extra params that might be passed to the rule
+      # Example
+      # WhenCondition.new("when running", ["", lambda { |resource| resource.human.state=='running' }], "")
+      class WhenCondition
+        def initialize(description, rule, params)
+          @description = description
+          @results = []
+          @extra = []
+          @rule = rule
+          @params = params
+        end
+      
+        # will execute the first attached result
+        def execute(resource, goal, mikyung)
+          @results.each do |result|
+            Restfulie::Common::Logger.logger.info("will '#{result.description}'")
+            return result.execute(resource, goal, mikyung)
+          end
+        end
+      
+        # checks whether this step should execute for a specific resource
+        def should_run_for(resource, goal)
+          if @rule[1].arity == 2
+            rule_accepts = @rule[1].call(resource, @params)
+          else
+            rule_accepts = @rule[1].call(resource)
+          end
+          return false unless rule_accepts
+          !@extra.find do |condition|
+            !condition.should_run_for(resource, goal)
+          end
+        end
+      
+        # adds an extra condition to this step
+        def and(condition)
+          @extra << condition
+        end
+        
+        # adds an extra condition to this step
+        def but(condition)
+          @extra << condition
+        end
+        
+        # adds an extra result to this step
+        def results_on(result)
+          @results << result
+        end
+      end
     end
   end
-
-  # adds an extra condition to this step
-  def and(condition)
-    @extra << condition
-  end
-  
-  # adds an extra condition to this step
-  def but(condition)
-    @extra << condition
-  end
-  
-  # adds an extra result to this step
-  def results_on(result)
-    @results << result
-  end
-  
 end

data/lib/restfulie/common.rb

@@ -4,19 +4,14 @@ require 'uri'
 require 'rubygems'
 require 'active_support'
 require 'action_controller'
+require 'restfulie/common/core_ext'
 
 module Restfulie
-  module Common; end
+  module Common
+    autoload :Error, 'restfulie/common/error'
+    autoload :Logger, 'restfulie/common/logger'
+    autoload :Representation, 'restfulie/common/representation'
+    autoload :Converter, 'restfulie/common/converter'
+  end
 end
 
-%w(
-  errors
-  logger
-  core_ext
-  representation
-  converter
-).each do |file| 
-  require "restfulie/common/#{file}"
-end
-
-include ActiveSupport::CoreExtensions::Hash

data/lib/restfulie/common/converter.rb

@@ -1,11 +1,22 @@
-#initialize namespace
-module Restfulie::Common::Converter; end
+module Restfulie
+  module Common
+    module Converter
+      autoload :Values, 'restfulie/common/converter/values'
+      autoload :Atom, 'restfulie/common/converter/atom'
+      autoload :Json, 'restfulie/common/converter/json'
+      autoload :Xml, 'restfulie/common/converter/xml'
 
-%w(
-  values
-  atom
-  atom/builder
-  atom/helpers
-).each do |file|
-  require File.join(File.dirname(__FILE__), 'converter', file)
+      # 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
+    end
+  end
 end
+

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

@@ -1,87 +1,12 @@
-module Restfulie::Common::Converter
-
-  module Atom
-
-    mattr_reader :media_type_name
-    @@media_type_name = 'application/atom+xml'
-
-    mattr_reader :headers
-    @@headers = { 
-      :get  => { 'Accept'       => media_type_name },
-      :post => { 'Content-Type' => media_type_name }
-    }
-
-    mattr_reader :recipes
-    @@recipes = {}
-
-    class << self
-      
-      def helper
-        Restfulie::Common::Converter::Atom::Helpers
+module Restfulie
+  module Common
+    module Converter
+      module Atom
+        autoload :Base, 'restfulie/common/converter/atom/base'
+        autoload :Builder, 'restfulie/common/converter/atom/builder'
+        autoload :Helpers, 'restfulie/common/converter/atom/helpers'
+        extend Base::ClassMethods
       end
-
-      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_atom(obj = nil, options = {}, &block)
-        # just instantiate the string with the atom factory
-        return Restfulie::Common::Representation::Atom::Factory.create(obj) if obj.kind_of?(String)
-        
-        if block_given?
-          recipe = block
-        elsif options[:recipe]          
-          recipe = @@recipes[options[:recipe]]
-        else
-          return obj if obj.respond_to?(:atom_type) && (obj.atom_type == "feed" || obj.atom_type == "entry")
-          raise Restfulie::Common::Error::ConverterError.new("Recipe required")
-        end
-        
-        # execute with the builder if a recipe is set (even if the obj is an atom)
-        options[:atom_type] ||= obj.respond_to?(:each) ? :feed : :entry
-        raise Restfulie::Common::Error::ConverterError.new("Undefined atom type #{options[:atom_type]}") unless [:entry,:feed].include?(options[:atom_type])
-
-        # Create representation and proxy
-        builder = Builder.new(options[:atom_type], obj)
-
-        # Check recipe arity size before calling it
-        recipe.call(*[builder, obj, options][0,recipe.arity])
-
-        builder.representation
-      end
-      
-      alias_method :unmarshal, :to_atom
-
-      def to_hash(obj)
-        return obj if obj.kind_of?(Hash)
-
-        xml = nil
-        
-        if obj.kind_of?(::String)
-           xml = obj
-        elsif obj.respond_to?(:to_xml)
-           xml = obj.to_xml
-        end
-
-        Hash.from_xml(xml).with_indifferent_access unless xml.nil?
-      end
-
-
-      def to_s(obj)
-        return obj if obj.kind_of?(String)
-        if obj.respond_to?(:to_xml)
-          obj.to_xml.to_s
-        else
-          obj.to_s
-        end
-      end
-
-      def marshal(obj, options = nil)
-        to_atom(obj, options).to_xml
-      end
-
     end
   end
 end

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

@@ -0,0 +1,89 @@
+module Restfulie
+  module Common
+    module Converter
+      module Atom
+        module Base
+          module ClassMethods 
+            mattr_reader :media_type_name
+            @@media_type_name = 'application/atom+xml'
+        
+            mattr_reader :headers
+            @@headers = { 
+              :get  => { 'Accept'       => media_type_name },
+              :post => { 'Content-Type' => media_type_name }
+            }
+        
+            mattr_reader :recipes
+            @@recipes = {}
+        
+            def helper
+              Restfulie::Common::Converter::Atom::Helpers
+            end
+      
+            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_atom(obj = nil, options = {}, &block)
+              # just instantiate the string with the atom factory
+              return Restfulie::Common::Representation::Atom::Factory.create(obj) if obj.kind_of?(String)
+              
+              if block_given?
+                recipe = block
+              elsif options[:recipe]          
+                recipe = @@recipes[options[:recipe]]
+              else
+                return obj if obj.respond_to?(:atom_type) && (obj.atom_type == "feed" || obj.atom_type == "entry")
+                raise Restfulie::Common::Error::ConverterError.new("Recipe required")
+              end
+              
+              # execute with the builder if a recipe is set (even if the obj is an atom)
+              options[:atom_type] ||= obj.respond_to?(:each) ? :feed : :entry
+              raise Restfulie::Common::Error::ConverterError.new("Undefined atom type #{options[:atom_type]}") unless [:entry,:feed].include?(options[:atom_type])
+      
+              # Create representation and proxy
+              builder = Builder.new(options[:atom_type], obj)
+      
+              # Check recipe arity size before calling it
+              recipe.call(*[builder, obj, options][0,recipe.arity])
+      
+              builder.representation
+            end
+            
+            alias_method :unmarshal, :to_atom
+      
+            def to_hash(obj)
+              return obj if obj.kind_of?(Hash)
+      
+              xml = nil
+              
+              if obj.kind_of?(::String)
+                 xml = obj
+              elsif obj.respond_to?(:to_xml)
+                 xml = obj.to_xml
+              end
+      
+              Hash.from_xml(xml).with_indifferent_access unless xml.nil?
+            end
+      
+      
+            def to_s(obj)
+              return obj if obj.kind_of?(String)
+              if obj.respond_to?(:to_xml)
+                obj.to_xml.to_s
+              else
+                obj.to_s
+              end
+            end
+      
+            def marshal(obj, options = nil)
+              to_atom(obj, options).to_xml
+            end
+          end
+        end
+      end
+    end
+  end
+end