restfulie 0.1.0.beta1 → 0.1

data/lib/restfulie/client/feature/verb.rb

@@ -1,119 +0,0 @@
-module Restfulie::Client::Feature::Verb
-
-  # GET HTTP verb without {Error}
-  # * <tt>path: '/posts'</tt>
-  # * <tt>headers: {'Accept' => '*/*', 'Content-Type' => 'application/atom+xml'}</tt>
-  def get(params = {})
-    @verb = :get
-    at query_string(params)
-    request_flow
-  end
-
-  # HEAD HTTP verb without {Error}
-  # * <tt>path: '/posts'</tt>
-  # * <tt>headers: {'Accept' => '*/*', 'Content-Type' => 'application/atom+xml'}</tt>
-  def head
-    @verb = :head
-    request_flow
-  end
-
-  # POST HTTP verb without {Error}
-  # * <tt>path: '/posts'</tt>
-  # * <tt>payload: 'some text'</tt>
-  # * <tt>headers: {'Accept' => '*/*', 'Content-Type' => 'application/atom+xml'}</tt>
-  def post(payload, options = {:recipe => nil})
-    @verb = :post
-    request_flow :body => payload
-  end
-
-  # PATCH HTTP verb without {Error}
-  # * <tt>path: '/posts'</tt>
-  # * <tt>payload: 'some text'</tt>
-  # * <tt>headers: {'Accept' => '*/*', 'Content-Type' => 'application/atom+xml'}</tt>
-  def patch(payload)
-    @verb = :patch
-    request_flow :body => payload
-  end
-
-  # PUT HTTP verb without {Error}
-  # * <tt>path: '/posts'</tt>
-  # * <tt>payload: 'some text'</tt>
-  # * <tt>headers: {'Accept' => '*/*', 'Content-Type' => 'application/atom+xml'}</tt>
-  def put(payload)
-    @verb = :put
-    request_flow :body => payload
-  end
-
-  # DELETE HTTP verb without {Error}
-  # * <tt>path: '/posts'</tt>
-  # * <tt>headers: {'Accept' => '*/*', 'Content-Type' => 'application/atom+xml'}</tt>
-  def delete
-    @verb = :delete
-    request_flow
-  end
-
-  # GET HTTP verb {Error}
-  # * <tt>path: '/posts'</tt>
-  # * <tt>headers: {'Accept' => '*/*', 'Content-Type' => 'application/atom+xml'}</tt>
-  def get!(params = {})
-    @verb = :get
-    at query_string(params)
-    request :throw_error
-    request_flow 
-  end
-
-  # HEAD HTTP verb {Error}
-  # * <tt>path: '/posts'</tt>
-  # * <tt>headers: {'Accept' => '*/*', 'Content-Type' => 'application/atom+xml'}</tt>
-  def head!
-    @verb = :head
-    request :throw_error
-    request_flow 
-  end
-
-  # POST HTTP verb {Error}
-  # * <tt>path: '/posts'</tt>
-  # * <tt>payload: 'some text'</tt>
-  # * <tt>headers: {'Accept' => '*/*', 'Content-Type' => 'application/atom+xml'}</tt>
-  def post!(payload, options = {:recipe => nil})
-    @verb = :post
-    request :throw_error
-    request_flow :body => payload
-  end
-
-  # PATCH HTTP verb {Error}
-  # * <tt>path: '/posts'</tt>
-  # * <tt>payload: 'some text'</tt>
-  # * <tt>headers: {'Accept' => '*/*', 'Content-Type' => 'application/atom+xml'}</tt>
-  def patch!(payload)
-    @verb = :patch
-    request :throw_error
-    request_flow :body => payload
-  end
-
-  # PUT HTTP verb {Error}
-  # * <tt>path: '/posts'</tt>
-  # * <tt>payload: 'some text'</tt>
-  # * <tt>headers: {'Accept' => '*/*', 'Content-Type' => 'application/atom+xml'}</tt>
-  def put!(payload)
-    @verb = :put
-    request :throw_error
-    request_flow :body => payload
-  end
-
-  # DELETE HTTP verb {Error}
-  # * <tt>path: '/posts'</tt>
-  # * <tt>headers: {'Accept' => '*/*', 'Content-Type' => 'application/atom+xml'}</tt>
-  def delete!
-    @verb = :delete
-    request :throw_error
-    request_flow 
-  end
-
-  protected
-
-  def query_string(params)
-    params = params.map { |param, value| "#{param}=#{value}"}.join("&")
-    params.blank? ? "" : URI.escape("?#{params}")
-  end
-end

data/lib/restfulie/client/http.rb

@@ -1,7 +0,0 @@
-module Restfulie
-  module Client
-    module HTTP#:nodoc:
-      Dir["#{File.dirname(__FILE__)}/http/*.rb"].each {|f| autoload File.basename(f)[0..-4].camelize.to_sym, f }
-    end
-  end
-end

data/lib/restfulie/client/http/cache.rb

@@ -1,28 +0,0 @@
-module Restfulie
-  module Client
-    module HTTP
-      module Cache
-        def store
-          @store || @store = ::ActiveSupport::Cache::MemoryStore.new
-        end
-    
-        def get
-          store.fetch(@uri) do
-            request(:get, @uri, @headers)
-          end
-        end
-    
-        def head
-          store.fetch(@uri) do
-            request(:head, @uri, @headers)
-          end
-        end
-      end
-    
-      class RequestBuilderExecutorWithCache < RequestBuilderExecutor
-        include Cache
-      end
-    end
-  end
-end
-

data/lib/restfulie/client/http/error.rb

@@ -1,77 +0,0 @@
-module Restfulie
-  module Client
-    module HTTP#:nodoc:
-      #Client errors
-      module Error
-      # Standard error thrown on major client exceptions
-        class RESTError < StandardError
-          attr_reader :response
-          attr_reader :request
-  
-          def initialize(request, response)
-            @request  = request
-            @response = response
-          end
-  
-          def to_s
-            "HTTP error #{@response.code} when invoking #{@request.host} via #{@response.method}. " +
-              ((@response.body.blank?) ? "No additional data was sent." : "The complete response was:\n" + @response.body)
-          rescue
-            super
-          end
-        end
-  
-        class AutoFollowWithoutLocationError < RESTError; end
-        
-        # Represents the HTTP code 503
-        class ServerNotAvailableError < RESTError
-          def initialize(request, response, exception)
-            super(request, response)
-            set_backtrace(exception.backtrace)
-          end
-        end
-  
-        class UnknownError < RESTError;  end
-  
-        # Represents the HTTP code 300 range
-        class Redirection < RESTError; end 
-  
-        class ClientError < RESTError; end
-  
-        # Represents the HTTP code 400
-        class BadRequest < ClientError; end 
-  
-        # Represents the HTTP code 401
-        class Unauthorized < ClientError; end 
-  
-        # Represents the HTTP code 403
-        class Forbidden < ClientError; end 
-  
-        # Represents the HTTP code 404
-        class NotFound < ClientError; end 
-  
-        # Represents the HTTP code 405
-        class MethodNotAllowed < ClientError; end 
-  
-        # Represents the HTTP code 412
-        class PreconditionFailed < ClientError; end 
-  
-        # Represents the HTTP code 407
-        class ProxyAuthenticationRequired < ClientError; end 
-  
-        # Represents the HTTP code 409
-        class Conflict < ClientError; end 
-  
-        # Represents the HTTP code 410
-        class Gone < ClientError; end 
-  
-        # Represents the HTTP code 500
-        class ServerError < RESTError; end 
-  
-        # Represents the HTTP code 501
-        class NotImplemented < ServerError; end 
-      end
-    end
-  end
-end
-

data/lib/restfulie/client/http/response_holder.rb

@@ -1,29 +0,0 @@
-module Restfulie::Client::HTTP
-  module ResponseHolder
-    attr_reader :response, :request
-    
-    def resource
-      type = headers['content-type'] || response['Content-Type']
-      representation = Restfulie::Common::Converter.content_type_for(type[0]) || Restfulie::Common::Representation::Generic.new
-      representation.unmarshal(response.body)
-    end
-    
-    def at(uri)
-      request.clone.at(uri)
-    end
-    
-    def headers
-      response.to_hash
-    end
-    
-    def results_from(request, response)
-      @request = request
-      @response = response
-    end
-
-    def verb
-      @request.verb
-    end
-        
-  end
-end

data/lib/restfulie/client/master_delegator.rb

@@ -1,31 +0,0 @@
-class MasterDelegator
-
-  alias_method :original_respond_to?, :respond_to?
-
-  def respond_to?(sym)
-    original_respond_to?(sym) || @requester.respond_to?(sym)
-  end
-
-  def method_missing(sym, *args, &block)
-    if original_respond_to?(sym)
-      result = super(sym, *args, &block)
-    elsif @requester.respond_to?(sym)
-      result = @requester.send(sym, *args, &block)
-    else
-      # let it go
-      return super(sym, *args, &block)
-    end
-    delegate_parse result
-  end
-  
-  protected
-  
-  def delegate(what, *args, &block)
-    delegate_parse @requester.send(what, *args, &block)
-  end
-  
-  def delegate_parse(result)
-    (result == @requester) ? self : result
-  end
-  
-end

data/lib/restfulie/client/mikyung.rb

@@ -1,15 +0,0 @@
-module Restfulie
-  module Client
-    module Mikyung
-      Dir["#{File.dirname(__FILE__)}/mikyung/*.rb"].each {|f| autoload File.basename(f)[0..-4].camelize.to_sym, f }
-    end
-  end
-end
-
-# Restfulie::Mikyung entry point is based on its core
-# implementation.
-module Restfulie
-  class Mikyung < Restfulie::Client::Mikyung::Core
-    Restfulie::Common::Logger.logger.level = Logger::INFO
-  end
-end

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

@@ -1,18 +0,0 @@
-module Restfulie
-  module Client
-    module Mikyung
-      # Concatenates pure text in order to build messages
-      # that are used as patterns.
-      # Usage:
-      # When there is a machine
-      #
-      # Will invoke concatenate 'machine' with 'a' with 'is' with 'there'
-      class Concatenator
-        attr_reader :content
-        def initialize(content, *args)
-          @content = args.inject(content) { |buf, arg| buf << " " << arg.content }
-        end
-      end
-    end
-  end
-end

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

@@ -1,70 +0,0 @@
-module Restfulie
-  module Client
-    module Mikyung
-      # iterates following a series of steps provided a goal and a starting uri.
-      #
-      # Restfulie::Client::Mikyung.achieve(objective).at(uri).run
-      #
-      # In order to implement your own walker, supply an object that respond to the move method.
-      # Check the run method code.
-      class Core
-        attr_reader :start, :goal, :walker, :accepts, :follow
-        
-        def initialize
-          @walker = Restfulie::Client::Mikyung::SteadyStateWalker.new
-        end
-        
-        def walks_with(walker)
-          @walker = walker
-          self
-        end
-      
-        # initializes with a goal in mind
-        def achieve(goal)
-          @goal = goal
-          self
-        end
-        
-        def at(start)
-          @start = start
-          self
-        end
-
-        def follow
-          @follow = true
-          self
-        end
-
-        def accepts(accepts)
-          @accepts = accepts
-          self
-        end
-      
-        # keeps changing from a steady state to another until its goal has been achieved
-        def run
-          if @start.kind_of? String
-            client = Restfulie.at(@start)
-            client = client.follow if @follow
-            client = client.accepts(@accepts) if @accepts
-            @start = current = client.get
-          else
-            # probably configured thru the Rest Process Model class
-            @start = current = @goal.class.get_restfulie.get
-          end
-          
-          # load the steps and scenario
-          @goal.steps 
-          @goal.scenario 
-          
-          while(!@goal.completed?(current))
-            current = @walker.move(@goal, current, self)
-          end
-          current
-        end
-      end
-    end
-
-    class UnableToAchieveGoalError < Restfulie::Common::Error::RestfulieError
-    end
-  end
-end

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

@@ -1,11 +0,0 @@
-module Restfulie
-  module Client
-    module Mikyung
-      module Languages
-        autoload :German, 'restfulie/client/mikyung/german'
-        autoload :Portuguese, 'restfulie/client/mikyung/portuguese'
-      end
-    end
-  end
-end
-

data/lib/restfulie/client/mikyung/languages/german.rb

@@ -1,24 +0,0 @@
-module Restfulie
-  module Client
-    module Mikyung
-      module Languages
-        module German
-          def Wenn(concat, &block)
-            When(concat, &block)
-          end
-          def Und(concat, &block)
-            And(concat, &block)
-          end
-          def Aber(concat, &block)
-            But(concat, &block)
-          end
-          def Dann(concat, &block)
-            Then(concat, &block)
-          end
-        end
-      end
-    end
-  end
-end
-
-