restfulie 0.8.0 → 0.8.1

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

@@ -1,15 +1,18 @@
-# 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 Restfulie::Client::Mikyung::Concatenator
-  attr_reader :content
-  def initialize(content, *args)
-    @content = content
-    args.each do |arg|
-      @content << " " << arg.content
+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,44 +1,70 @@
-# 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 Restfulie::Client::Mikyung::Core
-  
-  attr_reader :start, :goal, :walker
-  
-  def initialize
-    @walker = Restfulie::Client::Mikyung::SteadyStateWalker.new
-  end
-  
-  def walks_with(walker)
-    @walker = walker
-    self
-  end
+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
 
-  # 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
 
-  # keeps changing from a steady state to another until its goal has been achieved
-  def run
-    @start = current = (@start.kind_of? String) ? Restfulie.at(@start).get : @start
-    
-    while(!@goal.completed?(current))
-      current = @walker.move(@goal, current, self)
+        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
-    current
-  end
-  
-end
 
-class Restfulie::Client::UnableToAchieveGoalError < Restfulie::Common::Error::RestfulieError
+    class UnableToAchieveGoalError < Restfulie::Common::Error::RestfulieError
+    end
+  end
 end

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

@@ -1,29 +1,11 @@
-module Restfulie::Client::Mikyung::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)
+module Restfulie
+  module Client
+    module Mikyung
+      module Languages
+        autoload :German, 'restfulie/client/mikyung/german'
+        autoload :Portuguese, 'restfulie/client/mikyung/portuguese'
+      end
+    end
   end
 end
 
-module Restfulie::Client::Mikyung::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

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/rest_process_model.rb

@@ -1,114 +1,191 @@
 # a configuration error
-class Restfulie::Client::Mikyung::ConfigurationError < Restfulie::Common::Error::RestfulieError
-end
+module Restfulie
+  module Client
+    module Mikyung
+      class ConfigurationError < Restfulie::Common::Error::RestfulieError
+      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 Restfulie::Client::Mikyung::RestProcessModel
-  
-  # 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
+      class CompletionCriteriaMissingError < Restfulie::Common::Error::RestfulieError
+      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)
+      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
-    nil
-  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
+
+