saper 0.5.1 → 0.5.2

data/lib/saper/core/runtime.rb

@@ -1,52 +1,51 @@
 module Saper
+  # Runtime provides a set of auxiliary functions to Saper actions:
+  # browser requests, keychain access, storage of variables.
   class Runtime
     
-    # Returns action input.
-    attr_reader :input
-    
-    # Returns action output.
-    attr_reader :output
-    
-    # Returns error instance (if any)
-    attr_reader :error
-    
-    # Returns action instance.
-    attr_reader :action
-    
-    # Returns embedded recipes
-    attr_reader :subrecipes
+    # Returns Saper::Browser instance used by runtime.
+    # @return [Saper::Browser]
+    attr_reader :browser
     
-    # Returns subsequent runtime instances.
-    attr_reader :children
+    # Returns Saper::Keychain instance used by runtime.
+    # @return [Saper::Keychain]
+    attr_reader :keychain
     
-    # Returns the size of action chain.
-    attr_reader :depth
+    # Returns a Hash of variables stored by runtime.
+    # @return [Hash]
+    attr_reader :variables
     
     # Returns a new Saper::Runtime instance.
-    # @param stack [Array<Saper::Action>] chain of actions 
-    # @param input [Object, nil] action input
+    # @param variables [Hash]
     # @param options [Hash]
+    # @option options [Browser] :browser Browser instance
+    # @option options [String, Keychain] :keychain Keychain file or instance
+    # @option options [String, Symbol] :agent User-Agent type or string
     # @return [Saper::Runtime]
-    def initialize(stack = [], input = nil, options = {})
-      if stack.is_a?(Recipe)
-        stack = stack.actions
+    def initialize(variables = {}, options = {})
+      if options.nil?
+        puts self.inspect
+        raise 'stop'
+      end
+      if options[:keychain].is_a?(Keychain)
+        @keychain = options[:keychain]
+      end
+      if options[:keychain].is_a?(String)
+        @keychain = Keychain.load(options[:keychain])
+      end
+      unless @keychain.is_a?(Keychain)
+        @keychain = Keychain.new
       end
-      @input      = input
-      @output     = nil
-      @error      = nil
-      @action     = nil
-      @children   = []
-      @subrecipes = []
-      @options    = options
-      @depth      = stack.size
-      @options[:keychain]  ||= Keychain.new
-      @options[:logger]    ||= Logger.new(@options[:log])
-      @options[:browser]   ||= Browser.new(:logger => logger)
-      @options[:variables] ||= {}
+      if options[:browser].is_a?(Browser)
+        @browser = options[:browser]
+      end
+      unless @browser.is_a?(Browser)
+        @browser = Browser.new(:agent => options[:agent])
+      end
+      @variables = variables
       if block_given?
         yield self
       end
-      execute(stack.dup)
     end
     
     # Returns volume of incoming traffic (in bytes)
@@ -71,7 +70,7 @@ module Saper
     # @param name [Symbol]
     # @return [Object]
     def [](name)
-      @options[:variables][name]
+      @variables[name]
     end
     
     # Set variable value
@@ -79,62 +78,7 @@ module Saper
     # @param value [Object]
     # @return [Object]
     def []=(name, value)
-      @options[:variables][name] = value
-    end
-    
-    # Return a hash with all variables
-    # @return [Hash]
-    def variables
-      @options[:variables].dup
-    end
-    
-    # Returns descendant runtime instances at a given depth level.
-    # @param level [Integer]
-    # @return [Array<Saper::Runtime>]
-    def descendants(level = 0)
-      level < 1 ? [self] : children.map { |i| i.descendants(level - 1) }.flatten
-    end
-    
-    # Returns runtime results.
-    # @return [Array<Object>, Object]
-    def results
-      native_results
-    end
-    
-    # Returns an array of results.
-    # @return [Array]
-    def result_array
-      native_result_array
-    end
-    
-    # Returns `true` if this or any of the subsequent actions produces multiple results. 
-    # @return [Boolean]
-    def multiple?
-      (action.nil? ? false : action.multiple?) || children.any?(&:multiple?)
-    end
-    
-    # Returns Saper::Browser instance used by runtime.
-    # @return [Saper::Browser]
-    def browser
-      @options[:browser]
-    end
-    
-    # Returns Saper::Keychain instance used by runtime.
-    # @return [Saper::Keychain]
-    def keychain
-      @options[:keychain]
-    end
-    
-    # Returns Saper::Logger.
-    # @return [Saper::Logger]
-    def logger
-      @options[:logger]
-    end
-    
-    # Writes full runtime log to logger instance.
-    # @return [void]
-    def backtrace
-      logger.runtime(self)
+      @variables[name] = value
     end
     
     # Returns access credentials for specified service
@@ -144,93 +88,16 @@ module Saper
       keychain[service]
     end
     
-    # Runs an arbitrary recipe, specified by ID, block or as instance.
-    # @param recipe [Saper::Recipe]
-    # @param input [Object, nil]
+    # Returns a duplicate instance of self.
     # @return [Saper::Runtime]
-    def recipe(recipe, input = nil, &block)
-      unless recipe.is_a?(Recipe)
-        raise RecipeNotFound, recipe
-      end
-      runtime = Runtime.new(recipe, input, @options.merge(:variables => {}))
-      if runtime.error?
-        @error = runtime.error
-      end
-      subrecipes << runtime
-      runtime.non_native_results
-    end
-    
-    # Returns `true` if action raised no errors.
-    # @return [Boolean]
-    def success?
-      error.nil?
-    end
-    
-    # Returns `true` if action raised at least one error.
-    # @return [Boolean]
-    def error?
-      !success?
-    end
-    
-    # Returns runtime results as JSON.
-    # @return [Array]
-    def to_json(*args)
-      JSON.generate non_native_results.map(&:serialize)
-    end
-    
-    # Returns runtime results as Saper::Item instances.
-    # @return [Saper::Item, Array<Saper::Item>]
-    def non_native_results
-      multiple? ? non_native_result_array : non_native_result_array.first
-    end
-    
-    # Returns runtime results as native Ruby objects.
-    # @return [Object, Array<Object>]
-    def native_results
-      multiple? ? native_result_array : native_result_array.first
-    end
-    
-    private
-    
-    # Returns runtime results as an array of Saper::Item instances.
-    # @return [Array<Saper::Item>]
-    def non_native_result_array
-      descendants(depth - 1).map(&:output).flatten.compact
-    end
-    
-    # Returns runtime results as an array of native Ruby objects.
-    # @return [Array<Object>]
-    def native_result_array
-      non_native_result_array.map { |result| result.is_a?(Item) ? result.to_native : result }
+    def copy
+      Runtime.new(variables.dup, :browser => browser, :keychain => keychain)
     end
     
-    # Executes recipes.
-    # @return [self]
-    def execute(stack)
-      @output = input
-      @action = stack.shift
-      if action.nil?
-        return self
-      end
-      unless action.is_a?(Saper::Action)
-        raise ActionExpected, action
-      end
-      begin
-        @output = action.run(input, self)
-      rescue Saper::Error => e
-        @output = nil
-        @error = e
-      end
-      unless @output.is_a?(Array)
-        @output = [@output]
-      end
-      if stack.empty?
-        return self
-      end
-      @children = @output.map do |item|
-        Runtime.new(stack, item, @options.dup)
-      end
-      self
+    # Returns a duplicate instance of self without the stored variables.
+    # @return [Saper::Runtime]
+    def copy_without_variables
+      Runtime.new({}, :browser => browser, :keychain => keychain)
     end
     
   end

data/lib/saper/core/stack.rb

@@ -0,0 +1,57 @@
+module Saper
+  class Stack
+    
+    # Returns Runtime instance used by the stack
+    # @return [Saper::Runtime]
+    attr_reader :runtime
+    
+    # Returns all items in the stack.
+    # @return [Array<Saper::Item>]
+    attr_reader :items
+    
+    # Returns a new Stack instance.
+    # @param runtime [Saper::Runtime]
+    # @param items [Saper::Item]
+    # @return [Saper::Stack]
+    def initialize(runtime, *items)
+      @runtime, @items = runtime, items.flatten
+    end
+    
+    # Returns a duplicate instance of self.
+    # @return [Saper::Stack]
+    def copy
+      Stack.new(runtime.copy, *to_a)
+    end
+    
+    # Adds action result to the end of the stack and returns self.
+    # @param item [Saper::Item]
+    # @return [self]
+    def add(item)
+      @items.push(item); self
+    end
+    
+    # Returns the result of the last action or nil (in case of an error).
+    # @return [Saper::Item]
+    def result
+      error? ? Items::Nothing.new : last
+    end
+    
+    # Returns the result of the last action.
+    # @return [Saper::Item]
+    def last
+      @items.last || Items::Nothing.new
+    end
+    
+    # @todo
+    def error?
+      last.is_a?(Saper::Error)
+    end
+    
+    # Returns an array of action results.
+    # @return [Array<Saper::Item>]
+    def to_a
+      @items.dup
+    end
+  
+  end
+end

data/lib/saper/items/atom.rb

@@ -2,6 +2,7 @@ module Saper
   module Items
     class Atom < Item
       
+      # @todo
       def self.new(item)
         super case item
         when Hash
@@ -11,22 +12,32 @@ module Saper
         end
       end
       
+      # @todo
       def initialize(hash)
         @atts = hash
       end
       
+      # @todo
+      def ==(other)
+        to_hash == other
+      end
+      
+      # @todo
       def to_hash
         @atts.dup
       end
       
+      # @todo
       def [](name)
         @atts[name]
       end
       
+      # @todo
       def serialize
-        @atts.dup
+        Hash[@atts.map { |key, value| [key, value.respond_to?(:serialize) ? value.serialize : value] }]
       end
       
+      # @todo
       def to_native(object = nil)
         if object.nil?
           return to_native(to_hash)
@@ -43,10 +54,16 @@ module Saper
         object
       end
       
+      # @todo
       def to_json
         JSON.new(@hash, true)
       end
       
+      # @todo
+      def to_s
+        to_json
+      end
+      
     end
   end
 end

data/lib/saper/items/document.rb

@@ -2,67 +2,87 @@ module Saper
   module Items
     class Document < Item
       
-      def self.new(item)
-        super case item
-        when Mechanize::File
-          item
-        else
-          raise(InvalidItem, item)
-        end
-      end
+      # @todo
+      attr_reader :body
       
-      def initialize(mechanize)
-        @mech = mechanize
-      end
+      # @todo
+      attr_reader :uri
       
-      def uri
-        @mech.uri.to_s
+      # @todo
+      attr_reader :headers
+      
+      # @todo
+      def self.new(body, uri = nil, headers = {})
+        unless body.is_a?(String)
+          raise(InvalidItem)
+        end
+        unless headers.is_a?(Hash)
+          raise(InvalidItem)
+        end
+        super
       end
       
-      def body
-        @mech.body
+      # @todo
+      def initialize(body, uri = nil, headers = {})
+        @uri     = (uri.nil? ? nil : uri.to_s)
+        @body    = body
+        @headers = headers
       end
       
+      # @todo
       def size
         body.size
       end
       
+      # @todo
       def mime
         content_type.split(";").first
       end
       
+      # @todo
       def charset
         content_type.include?("charset=") ? content_type.split("charset=").last : nil
       end
       
+      # @todo
       def to_text
-        body
+        Text.new(body)
       end
       
+      # @todo
       def to_html
-        HTML.new(body)
+        HTML.new(self)
       end
       
+      # @todo
       def to_xml
         XML.new(body)
       end
       
+      # @todo
       def to_json
         JSON.new(body)
       end
       
+      # @todo
       def to_markdown
         Markdown.new(to_html)
       end
       
+      # @todo
       def to_native
-        @body
+        body
+      end
+      
+      def to_s
+        to_native
       end
       
       private
       
+      # @todo
       def content_type
-        @mech['content-type'] || ""
+        headers['content-type'] || ""
       end
       
     end