restfulie 0.7.2 → 0.8.0

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

@@ -0,0 +1,7 @@
+module Restfulie::Client
+end
+module Restfulie::Client::HTTP#:nodoc:
+  ::Hash.instance_eval {
+    include Restfulie::Client::HTTP::LinkRequestBuilder
+  }
+end

data/lib/restfulie/client/http.rb

@@ -6,9 +6,9 @@ end
   adapter
   cache
   marshal
-  link
   atom_ext
-  xml
+  xml_ext
+  core_ext
 ).each do |file|
   require "restfulie/client/http/#{file}"
 end

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

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

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

@@ -0,0 +1,44 @@
+# 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
+
+  # initializes with a goal in mind
+  def achieve(goal)
+    @goal = goal
+    self
+  end
+  
+  def at(start)
+    @start = start
+    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)
+    end
+    current
+  end
+  
+end
+
+class Restfulie::Client::UnableToAchieveGoalError < Restfulie::Common::Error::RestfulieError
+end

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

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

@@ -0,0 +1,114 @@
+# a configuration error
+class Restfulie::Client::Mikyung::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
+
+  # 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
+  
+  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

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

@@ -0,0 +1,32 @@
+# A steady walker that tries 3 times each step
+class Restfulie::Client::Mikyung::SteadyStateWalker
+  
+  def move(goal, current, mikyung)
+    step = goal.next_step(current, mikyung)
+    raise Restfulie::Client::UnableToAchieveGoalError, "No step was found for #{current}" unless step
+    Restfulie::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
+
+    if resource.response.code != 200
+      try_to_execute(step, current, max_attempts-1, mikyung)
+    else
+      Restfulie::Common::Logger.logger.debug resource.response.body
+      resource
+    end
+  end
+
+end

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

@@ -0,0 +1,33 @@
+# A conclusion to a step.
+#
+# Whenever a step rule matches, there are a series of conditions to be executed.
+class Restfulie::Client::Mikyung::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)
+    if rule.arity==1
+      rule.call(resource)
+    elsif rule.arity==2
+      rule.call(resource, matches)
+    else
+      rule.call(resource, matches, mikyung)
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# Checks whether one or more rule holds and is capable of executing results.
+class Restfulie::Client::Mikyung::WhenCondition
+
+  # 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' }], "")
+  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

data/lib/restfulie/client/mikyung.rb

@@ -0,0 +1,19 @@
+module Restfulie::Client::Mikyung
+end
+
+%w(
+  when_condition
+  then_condition
+  rest_process_model
+  concatenator
+  core
+  steady_state_walker
+  languages
+).each do |file|
+  require "restfulie/client/mikyung/#{file}"
+end
+
+# Restfulie::Mikyung entry point is based on its core
+# implementation.
+class Restfulie::Mikyung < Restfulie::Client::Mikyung::Core
+end

data/lib/restfulie/client.rb

@@ -6,6 +6,7 @@ module Restfulie::Client; end
   http
   configuration
   base
+  mikyung
 ).each do |file|
   require "restfulie/client/#{file}"
 end

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

@@ -0,0 +1,109 @@
+module Restfulie::Common::Converter::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 = nil, &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 if options
+      
+      yield Restfulie::Common::Converter::Components::Values.new(self)
+    end
+    
+    def members(a_collection = nil, &block)
+      collection = a_collection || @obj 
+      raise Restfulie::Common::Error::BuilderError("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
+      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
+      Restfulie::Common::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

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

@@ -0,0 +1,9 @@
+module Restfulie::Common::Converter::Atom::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

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

@@ -0,0 +1,87 @@
+module Restfulie::Common::Converter
+
+  module Atom
+
+    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 = {}
+
+    class << self
+      
+      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

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

@@ -0,0 +1,29 @@
+module Restfulie::Common::Converter::Components
+  # This is a Blank Slate class to support the renderization of the values block for Resource Representation Interfaces
+  # Every Media type should implement a Builder with a insert_value method that renders the values block to a specific format
+  class Values
+    attr_accessor :builder
+
+    # BlankSlate
+    instance_methods.each do |m|
+      undef_method m unless m.to_s =~ /\[\]|method_missing|respond_to\?|^__/
+    end
+
+    def initialize(builder)
+      @builder = builder
+      @current_prefix = nil
+    end
+
+    def [](prefix)
+      @current_prefix = prefix
+      self
+    end
+
+    def method_missing(symbol, *args, &block)
+      name = symbol.to_s
+      prefix = @current_prefix
+      @current_prefix = nil
+      @builder.insert_value(name, prefix, *args, &block)
+    end
+  end
+end

data/lib/restfulie/common/converter.rb

@@ -0,0 +1,11 @@
+#initialize namespace
+module Restfulie::Common::Converter; end
+
+%w(
+  values
+  atom
+  atom/builder
+  atom/helpers
+).each do |file|
+  require File.join(File.dirname(__FILE__), 'converter', file)
+end

data/lib/restfulie/common/core_ext/proc.rb

@@ -0,0 +1,48 @@
+class Proc
+  attr_accessor :helpers
+  alias_method :old_call, :call
+
+  def call(*args)
+    @helpers.nil? ? old_call(*args): call_include_helpers(@helpers, *args)
+  end
+
+  def call_include_helpers(helpers, *args)
+    helpers      = [helpers] unless helpers.kind_of?(Array) 
+    helpers      = helpers.map { |helper| Object.new.send(:extend, helper) }
+    block_caller = eval("self", self.binding)
+
+    m = extensible_module(block_caller)
+    m.send(:define_method, :method_missing) do |symbol, *args, &block|
+      mod = helpers.find { |h| h.respond_to?(symbol) }
+      mod.nil? ? super : mod.send(symbol, *args, &block)
+    end
+
+    block_caller.extend(m)
+    result = old_call(*args)
+    m.send(:remove_method, :method_missing)
+
+    result
+  end
+
+private
+
+  # Search for extending the module in ancestors
+  def extensible_module(object)
+    ancestors  = object.instance_eval { (class << self; self; end) }.ancestors
+    
+    extend_mod = ancestors.find { |ancestor|
+      !ancestor.instance_methods.include?("method_missing") && ancestor.instance_eval { (class << self; self; end) }.ancestors.include?(ProcIncludedHelpers)
+    }
+
+    if extend_mod.nil?    
+      extend_mod = Module.new
+      extend_mod.extend(ProcIncludedHelpers)
+    end
+
+    extend_mod
+  end
+
+  module ProcIncludedHelpers; end
+
+end
+

data/lib/restfulie/common/core_ext.rb

@@ -0,0 +1,5 @@
+%w(
+  proc
+).each do |file|
+  require File.join(File.dirname(__FILE__), 'core_ext', file)
+end

data/lib/restfulie/common/errors.rb

@@ -6,4 +6,10 @@ module Restfulie::Common::Error
   # Atom marshallinh error
   class AtomMarshallingError < MarshallingError; end
   class NameSpaceError < AtomMarshallingError; end
+
+  # Converter
+  class ConverterError < RestfulieError; end
+  
+  # builder
+  class BuilderError < RestfulieError; end
 end