restfulie-nosqlite 1.0.3

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

@@ -0,0 +1,71 @@
+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
+
+          # load the steps and scenario
+          @goal.steps 
+          @goal.scenario 
+
+          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
+          
+          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/german.rb

@@ -0,0 +1,24 @@
+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
+
+

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

@@ -0,0 +1,23 @@
+module Restfulie
+  module Client
+    module Mikyung
+      module Languages
+        module Portuguese
+          def Quando(concat, &block)
+            When(concat, &block)
+          end
+          def E(concat, &block)
+            And(concat, &block)
+          end
+          def Mas(concat, &block)
+            But(concat, &block)
+          end
+          def Entao(concat, &block)
+            Then(concat, &block)
+          end
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,11 @@
+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/rest_process_model.rb

@@ -0,0 +1,191 @@
+# a configuration error
+module Restfulie
+  module Client
+    module Mikyung
+      class ConfigurationError < Restfulie::Common::Error::RestfulieError
+      end
+
+      class CompletionCriteriaMissingError < Restfulie::Common::Error::RestfulieError
+      end
+
+      class StepsFileNotFoundError < Restfulie::Common::Error::RestfulieError
+      end
+
+      class ScenarioFileNotFoundError < StepsFileNotFoundError
+      end
+
+      # Provides a DSL to build your process in a human readable way.
+      #
+      # Example:
+      # When there is a machine
+      # And  already installed
+      # Then reboot
+      #
+      # Before creating your DSL you should provide your method content:
+      #
+      # When /there (are|is an|is a|is) (.*)/ do |resource, regex|
+      #   resource.keys.first==regex[2]
+      # end
+      # 
+      # When "already installed" do |resource|
+      #   @installed
+      # end
+      # 
+      # Then "reboot" do |resource|
+      #   resource.machine.boot.post! :boot => {:reason => "Installed #{@software[:name]}"}
+      # end
+      class RestProcessModel
+        @@at = ""
+        @@follow = false
+        @@accept = "application/atom+xml"
+        @@current_dir = ""
+
+        def self.at(uri)
+          @@at = uri
+        end
+
+        def self.follow(bool)
+          @@follow = bool
+        end
+
+        def self.accept(type)
+          @@accept = type
+        end
+
+        def self.current_dir(dir)
+          @@current_dir = dir
+        end
+
+        def self.get_restfulie
+          Restfulie.at(@@at).tap do |client|
+            client.follow if @@follow
+            client.accepts(@@accept) if @@accept
+          end
+        end
+
+        # concatenates anything to a current expression
+        def method_missing(sym, *args)
+          Restfulie::Client::Mikyung::Concatenator.new(sym.to_s, *args)
+        end
+        
+        # the list of results
+        def then_rules
+          @then_rules ||= []
+        end
+        
+        # the list of conditions
+        def conditions
+          @conditions ||= []
+        end
+        
+        # the list of conditional rules
+        def when_rules
+          @when_rules ||= []
+        end
+        
+        # creates a When rule or block
+        #
+        # When blocks should return true or false whether the current resource matches what you expect:
+        # When /there (are|is an|is a|is) (.*)/ do |resource, regex|
+        #   resource.keys.first==regex[2]
+        # end
+        #
+        # When rules will group conditions and rules together:
+        # When there is a machine
+        # And  already installed
+        # Then reboot
+        def When(concat, &block)
+          if concat.respond_to? :content
+            @condition = when_factory(concat)
+            conditions << @condition
+          else
+            when_rules << [concat, block]
+          end
+        end
+        
+        # Adds a constraint to the current scenario
+        def And(concat)
+          @condition.and when_factory(concat)
+        end
+        
+        # Adds a negative constraint to the current scenario
+        def But(concat)
+          @condition.but when_factory(concat)
+        end
+        
+        # Creates a result rule
+        #
+        # example:
+        # Then "reboot" do |resource|
+        #   resource.machine.boot.post! :boot => {:reason => "Installed #{@software[:name]}"}
+        # end
+        def Then(concat, &block)
+          if concat.respond_to? :content
+            @condition.results_on Restfulie::Client::Mikyung::ThenCondition.new(concat.content)
+          else
+            then_rules << [concat, block]
+          end
+        end
+      
+        # Goes through every scenario and finds which one fits the current server steady state.
+        # Picks this step and executes the business rule attached to it.
+        def next_step(resource, mikyung)
+          conditions.each do |c|
+            if c.should_run_for(resource, self)
+              return c.execute(resource, self, mikyung)
+            end
+          end
+          nil
+        end
+
+        # load step definitions from the 'steps/[class_name].rb'
+        # otherwise you can simply override this method with a module
+        def steps
+          unless @steps_loaded
+            step_file = File.expand_path("./steps/#{self.class.name.underscore}.rb", @@current_dir)
+            if File.exists?(step_file)
+              self.instance_eval File.read(step_file), __FILE__, __LINE__ + 1
+            else
+              raise StepsFileNotFoundError.new("File #{step_file} not found")
+            end
+            @steps_loaded = true
+          end
+        end
+
+        # load scenario definition from 'scenarios/[class_name].scenario'
+        # otherwise you can simply override this method with a module
+        def scenario
+          unless @scenarios_loaded
+            scenario_file = File.expand_path("./scenarios/#{self.class.name.underscore}.scenario", @@current_dir)
+            if File.exists?(scenario_file)
+              self.instance_eval File.read(scenario_file), __FILE__, __LINE__ + 1
+            else
+              raise ScenarioFileNotFoundError.new("File #{scenario_file} not found")
+            end 
+            @scenarios_loaded = true
+          end
+        end
+
+        # you need to override this method to provide a completion 
+        # criteria. Will raise an error otherwise
+        def completed?(resource)
+          raise CompletionCriteriaMissingError.new
+        end
+
+        private
+        
+          def when_factory(concat)
+            rule = when_rules.find do |rule|
+              concat.content.match(rule[0])
+            end
+            if rule.nil?
+              raise Restfulie::Client::Mikyung::ConfigurationError, "You forgot to create '#{concat.content}' prior to its usage."
+            end
+            Restfulie::Client::Mikyung::WhenCondition.new(concat.content, rule, concat.content.match(rule[0]))
+          end
+      end
+    end
+  end
+end
+
+

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

@@ -0,0 +1,38 @@
+# A steady walker that tries 3 times each step
+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 analyze #{step.body}" 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
+
+            # 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

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

@@ -0,0 +1,39 @@
+# A conclusion to a step.
+#
+# Whenever a step rule matches, there are a series of conditions to be executed.
+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
+  end
+end

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

@@ -0,0 +1,57 @@
+# Checks whether one or more rule holds and is capable of executing results.
+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
+end

data/lib/restfulie/client/mikyung.rb

@@ -0,0 +1,15 @@
+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/stack_navigator.rb

@@ -0,0 +1,39 @@
+module Restfulie
+  module Client
+    class StackNavigator
+  
+      def initialize(stack)
+        @stack = stack.dup
+      end
+
+      def continue(request, env)
+        current = @stack.pop
+        if current.nil?
+          return nil
+        end
+        filter = instantiator.new(current[:type], current[:args])
+        Restfulie::Common::Logger.logger.debug "invoking filter #{filter.class.name} with #{request} at #{env}"
+        filter.execute(self.dup, request, env)
+      end
+  
+      def instantiator
+        BasicInstantiator.new
+      end
+    
+      def dup
+        StackNavigator.new(@stack)
+      end
+  
+    end
+
+    class BasicInstantiator
+      def new(type, args)
+        if type.instance_method(:initialize).arity==1
+          type.new(args)
+        else
+          type.new
+        end
+      end
+    end
+  end
+end

data/lib/restfulie/client.rb

@@ -0,0 +1,24 @@
+require 'restfulie/common'
+
+module Restfulie
+  module Client
+    autoload :MasterDelegator, 'restfulie/client/master_delegator'
+    autoload :HTTP, 'restfulie/client/http'
+    autoload :Configuration, 'restfulie/client/configuration'
+    autoload :EntryPoint, 'restfulie/client/entry_point'
+    autoload :Base, 'restfulie/client/base'
+    autoload :Mikyung, 'restfulie/client/mikyung'
+    autoload :Cache, 'restfulie/client/cache'
+    autoload :Feature, 'restfulie/client/feature'
+    autoload :Dsl, 'restfulie/client/dsl'
+    autoload :StackNavigator, 'restfulie/client/stack_navigator'
+    
+    mattr_accessor :cache_provider, :cache_store
+
+    Restfulie::Client.cache_store = ActiveSupport::Cache::MemoryStore.new
+    Restfulie::Client.cache_provider = Restfulie::Client::Cache::Fake.new
+
+  end
+end
+
+require 'restfulie/client/ext'

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/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

data/lib/restfulie/common.rb

@@ -0,0 +1,17 @@
+require 'net/http'
+require 'uri'
+
+require 'rubygems'
+require 'hypertemplate'
+require 'medie'
+
+module Restfulie
+  
+  # Code common to both client and server side is contained in the common module.
+  module Common
+    autoload :Error, 'restfulie/common/error'
+    autoload :Logger, 'restfulie/common/logger'
+  end
+
+end
+

data/lib/restfulie/server/action_controller/base.rb

@@ -0,0 +1,46 @@
+module Restfulie
+  module Server
+    module ActionController
+      module Base
+        def self.included(base)
+          # Sets a default responder for this controller. 
+          # Needs to require responder_legacy.rb
+          base.responder = Restfulie::Server::ActionController::RestfulResponder
+          base.extend(Restfulie::Server::ActionController::Base::ClassMethods)
+        end
+
+        module ClassMethods
+          def call(env)
+            if include_restfulie? && env.has_key?("action_controller.restfulie.response")
+              if logger && logger.info?
+                information = "Status: #{env["action_controller.restfulie.response"][0]} "
+                information << ::ActionController::StatusCodes::STATUS_CODES[env["action_controller.restfulie.response"][0]]
+                logger.info(information) 
+              end
+              return env["action_controller.restfulie.response"] 
+            end
+            super
+          end
+
+          def include_restfulie?
+            defined?(Restfulie::Server::ActionController::Base) && self.include?(Restfulie::Server::ActionController::Base)
+          end
+        end
+        
+          # If your controller inherits from Restfulie::Server::Controller::Base,
+          # it will have an :atom option, very similar to render :xml
+          def render(options = nil, extra_options = {}, &block)
+            if options && atom = options[:atom]
+              response.content_type ||= Mime::ATOM
+              representation = atom.respond_to?(:to_atom) ? atom.to_atom.to_xml : atom.to_xml
+              options[:text] = representation
+              options[:atom] = nil
+              super options
+            else
+              super
+            end
+          end
+      end
+    end
+  end
+end