restfulie 0.1.0.beta1 → 0.1

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

@@ -1,23 +0,0 @@
-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,191 +0,0 @@
-# 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

@@ -1,38 +0,0 @@
-# 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 #{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
-
-            # 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

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

@@ -1,57 +0,0 @@
-# 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/common.rb

@@ -1,18 +0,0 @@
-require 'net/http'
-require 'uri'
-
-require 'rubygems'
-require 'active_support'
-require 'action_controller'
-
-module Restfulie
-  module Common
-    autoload :Error, 'restfulie/common/error'
-    autoload :Links, 'restfulie/common/links'
-    autoload :Logger, 'restfulie/common/logger'
-    autoload :Representation, 'restfulie/common/representation'
-    autoload :Converter, 'restfulie/common/converter'
-  end
-end
-
-require 'restfulie/common/core_ext'

data/lib/restfulie/common/converter.rb

@@ -1,43 +0,0 @@
-module Restfulie
-  module Common
-    module Converter
-      Dir["#{File.dirname(__FILE__)}/converter/*.rb"].each {|f| autoload File.basename(f)[0..-4].camelize.to_sym, f }
-
-      # 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
-      
-      def self.register(media_type,representation)
-        representations[media_type] = representation
-      end
-
-      def self.content_type_for(media_type)
-        return nil unless media_type
-        content_type = media_type.split(';')[0] # [/(.*?);/, 1]
-        representations[content_type]
-      end
-      
-      private
-      
-      def self.representations
-        @representations ||= {}
-      end
-      
-      register 'application/atom+xml' , ::Restfulie::Common::Converter::Atom
-      register 'application/xml' , ::Restfulie::Common::Converter::Xml
-      register 'text/xml' , ::Restfulie::Common::Converter::Xml
-      register 'application/json' , ::Restfulie::Common::Converter::Json
-      register 'application/opensearchdescription+xml' , ::Restfulie::Common::Converter::OpenSearch
-      
-      
-    end
-  end
-end
-

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

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

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

@@ -1,91 +0,0 @@
-require 'active_support/core_ext/hash/conversions'
-
-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