restfulie 0.1.0.beta1

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 #{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

@@ -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.rb

@@ -0,0 +1,26 @@
+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'
+    
+    mattr_accessor :cache_provider, :cache_store
+
+    Restfulie::Client.cache_store = ActiveSupport::Cache::MemoryStore.new
+    Restfulie::Client.cache_provider = Restfulie::Client::Cache::Basic.new
+
+  end
+end
+
+require 'restfulie/client/ext/http_ext'
+require 'restfulie/client/ext/atom_ext'
+require 'restfulie/client/ext/json_ext'
+

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

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

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

@@ -0,0 +1,111 @@
+module Restfulie
+  module Common
+    module Converter
+      module Atom
+        class Builder
+          attr_accessor :atom_type
+          def initialize(atom_type, obj)
+            @doc    = Nokogiri::XML::Document.new
+            @obj    = obj
+            @parent = @doc.create_element(atom_type.to_s)
+            @parent.add_namespace_definition(nil, "http://www.w3.org/2005/Atom")
+            @parent.parent = @doc
+          end
+      
+          def values(options = {}, &block)
+            options.each do |key,value|
+              attr = key.to_s
+              if attr =~ /^xmlns(:\w+)?$/
+                ns = attr.split(":", 2)[1]
+                @parent.add_namespace_definition(ns, value)
+              end
+            end            
+            yield Values.new(self)
+          end
+          
+          def members(options = {}, &block)
+            collection = options[:collection] || @obj 
+            raise Error::BuilderError.new("Members method require a collection to execute") unless collection.respond_to?(:each)
+            collection.each do |member|
+              entry = @doc.create_element("entry")
+              entry.parent = @parent
+              @parent = entry
+              block.call(self, member)
+              @parent = entry.parent
+            end
+          end
+          
+          def link(relationship, uri, options = {})
+            options["rel"] = relationship.to_s
+            options["href"] = uri
+            options["type"] ||= "application/atom+xml"
+            insert_value("link", nil, options)
+          end
+      
+          def insert_value(name, prefix, *args, &block)
+            node = create_element(name.to_s, prefix, *args)
+            node.parent = @parent            
+            if block_given?
+              @parent = node
+              block.call
+              @parent = node.parent
+            end
+          end
+      
+          def representation
+            Representation::Atom::Factory.create(@doc)
+          end
+          
+        private
+        
+          def create_element(node, prefix, *args)
+            node = @doc.create_element(node) do |n|
+              if prefix
+                if namespace = prefix_valid?(prefix)
+                  # Adding namespace prefix
+                  n.namespace = namespace
+                  namespace = nil
+                end
+              end
+      
+              args.each do |arg|
+                case arg
+                # Adding XML attributes
+                when Hash
+                  arg.each { |k,v|
+                    key = k.to_s
+                    if key =~ /^xmlns(:\w+)?$/
+                      ns_name = key.split(":", 2)[1]
+                      n.add_namespace_definition(ns_name, v)
+                      next
+                    end
+                    n[k.to_s] = v.to_s
+                  }
+                # Adding XML node content
+                else            
+                  arg.kind_of?(Time) || arg.kind_of?(DateTime) ? content = arg.xmlschema : content = arg
+                  n.content = content
+                end
+              end
+            end
+          end
+          
+          def prefix_valid?(prefix)
+            ns = @parent.namespace_definitions.find { |x| x.prefix == prefix.to_s }
+            
+            unless ns
+              @parent.ancestors.each do |a|
+                next if a == @doc
+                ns = a.namespace_definitions.find { |x| x.prefix == prefix.to_s }
+                break if ns
+              end      
+            end
+            
+            return ns
+            #TODO: raise ArgumentError, "Namespace #{prefix} has not been defined" if wanted
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module Restfulie
+  module Common
+    module Converter
+      module Atom
+        module Helpers
+          def collection(obj, *args, &block)
+            Restfulie::Common::Converter::Atom.to_atom(obj, :atom_type => :feed, &block)
+          end
+      
+          def member(obj, *args, &block)
+            Restfulie::Common::Converter::Atom.to_atom(obj, :atom_type => :entry, &block)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+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/json/base.rb

@@ -0,0 +1,87 @@
+module Restfulie
+  module Common
+    module Converter
+      module Json
+        module Base
+          module ClassMethods
+            mattr_reader :media_type_name
+            @@media_type_name = 'application/json'
+        
+            mattr_reader :headers
+            @@headers = { 
+              :get  => { 'Accept'       => media_type_name },
+              :post => { 'Content-Type' => media_type_name }
+            }
+        
+            mattr_reader :recipes
+            @@recipes = {}
+        
+            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_json(obj = nil, options = {:root => {}}, &block)
+              # just instantiate the string with the atom factory
+              return Restfulie::Common::Representation::Json.create(obj) if obj.kind_of?(String)
+              
+              if block_given?
+                recipe = block
+              else
+                recipe = options[:recipe]     
+              end
+              
+              # Check if the object is already an json
+              unless recipe
+                if obj.kind_of?(Hash) || obj.kind_of?(Array)
+                  return Restfulie::Common::Representation::Json.create(obj)
+                else
+                  raise Restfulie::Common::Error::ConverterError.new("Recipe required")
+                end
+              end
+                      
+              # Get recipe already described
+              recipe = @@recipes[recipe] unless recipe.respond_to?(:call)
+      
+              # Create representation and proxy
+              builder = Restfulie::Common::Converter::Json::Builder.new(obj, (options[:root] || {}))
+      
+              # Check recipe arity size before calling it
+              recipe.call(*[builder, obj, options][0,recipe.arity])
+      
+              builder.representation
+            end
+            
+            alias_method :unmarshal, :to_json
+      
+            def to_hash(obj)
+              return obj if obj.kind_of?(Hash) || obj.kind_of?(Array)
+              
+              if obj.kind_of?(::String)
+                Restfulie::Common::Representation::Json.create(obj)
+              else
+                raise Restfulie::Common::Error::ConverterError.new("It was not possible to convert this object to a Hash")
+              end
+            end
+      
+            def to_s(obj)
+              return obj if obj.kind_of?(String)
+              Restfulie::Common::Representation::Json.create(obj).to_s
+            end
+      
+            def marshal(obj, options = nil)
+              return obj if obj.kind_of? String
+              to_json(obj, options).to_json
+            end
+            
+            # returns the current helper
+            def helper
+              Helpers
+            end
+          end
+        end
+      end
+    end
+  end
+end