saper 0.5.0

data/lib/saper/core/runtime.rb

@@ -0,0 +1,237 @@
+module Saper
+  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 subsequent runtime instances.
+    attr_reader :children
+    
+    # Returns the size of action chain.
+    attr_reader :depth
+    
+    # Returns a new Saper::Runtime instance.
+    # @param stack [Array<Saper::Action>] chain of actions 
+    # @param input [Object, nil] action input
+    # @param options [Hash]
+    # @return [Saper::Runtime]
+    def initialize(stack = [], input = nil, options = {})
+      if stack.is_a?(Recipe)
+        stack = stack.actions
+      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 block_given?
+        yield self
+      end
+      execute(stack.dup)
+    end
+    
+    # Returns volume of incoming traffic (in bytes)
+    # @return [Integer]
+    def bytes_received
+      browser.received
+    end
+    
+    # Returns volume of outgoing traffic (in bytes)
+    # @return [Integer]
+    def bytes_sent
+      browser.sent
+    end
+    
+    # Returns number of HTTP requests
+    # @return [Integer]
+    def http_requests
+      browser.requests
+    end
+    
+    # Get variable value
+    # @param name [Symbol]
+    # @return [Object]
+    def [](name)
+      @options[:variables][name]
+    end
+    
+    # Set variable value
+    # @param name [Symbol]
+    # @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)
+    end
+    
+    # Returns access credentials for specified service
+    # @param service [Symbol]
+    # @return [Object, nil]
+    def credentials(service)
+      keychain[service]
+    end
+    
+    # Runs an arbitrary recipe, specified by ID, block or as instance.
+    # @param recipe [Saper::Recipe]
+    # @param input [Object, nil]
+    # @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)
+    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 }
+    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
+    end
+    
+  end
+end

data/lib/saper/core/type.rb

@@ -0,0 +1,45 @@
+module Saper
+  class Type
+    
+    # Returns a new Type instance of a given type.
+    # @param type [Symbol]
+    # @return [Saper::Type]
+    def self.[](type)
+      case type
+        when Type       then type
+        when :attribute then AttributeType.new
+        when :document  then DocumentType.new
+        when :html      then HTMLType.new
+        when :json      then JSONType.new
+        when :options   then OptionsType.new
+        when :regex     then RegexType.new
+        when :recipe    then RecipeType.new
+        when :tag       then TagType.new
+        when :text      then TextType.new
+        when :url       then URLType.new
+        when :variable  then VariableType.new
+        when :xml       then XMLType.new
+        when :xpath     then XPathType.new
+        else raise(InvalidType, "Invalid action argument: %s" % type)
+      end
+    end
+    
+    # Returns normalize value
+    def normalize(value)
+      value # Note: subclass may override this method.
+    end
+    
+    # Returns `true` if specified value matches type.
+    # @return [Boolean]
+    def valid?(value)
+      true  # Note: subclass must override this method.
+    end
+    
+    # Returns `true` if specified value does not match type.
+    # @return [Boolean]
+    def invalid?(value)
+      not valid?(value)
+    end
+    
+  end
+end

data/lib/saper/items/atom.rb

@@ -0,0 +1,64 @@
+module Saper
+  module Items
+    class Atom < Item
+      
+      def self.new(item)
+        super case item
+        when Hash
+          item
+        else
+          raise(InvalidItem, item)
+        end
+      end
+      
+      def initialize(hash)
+        @atts = hash
+      end
+      
+      def serialize
+        @atts.dup
+      end
+      
+      def to_hash
+        @atts.dup
+      end
+      
+      def delete(name)
+        @atts.delete(name)
+      end
+      
+      def [](name)
+        @atts[name]
+      end
+      
+      def to_yaml(*args)
+        @atts.to_yaml(*args)
+      end
+      
+      def to_native(object = nil)
+        if object.nil?
+          return to_native(to_hash)
+        end
+        if object.is_a?(Hash)
+          return Hash[object.map { |key, value| [key, to_native(value)] }]
+        end
+        if object.is_a?(Array)
+          return object.map { |key, value| to_native(value) }
+        end
+        if object.is_a?(Item)
+          return object.to_native
+        end
+        object
+      end
+      
+      def to_json(*args)
+        to_hash.to_json(*args)
+      end
+      
+      def to_s
+        "{ %s }" % @atts.map { |key, value| "%s = %s" % [key, value] }.join(", ")
+      end
+      
+    end
+  end
+end

data/lib/saper/items/document.rb

@@ -0,0 +1,66 @@
+module Saper
+  module Items
+    class Document < Item
+      
+      def self.new(item)
+        super case item
+        when Mechanize::File
+          item
+        else
+          raise(InvalidItem, item)
+        end
+      end
+      
+      def initialize(mechanize)
+        @mech = mechanize
+      end
+      
+      def uri
+        @mech.uri.to_s
+      end
+      
+      def body
+        @mech.body
+      end
+      
+      def size
+        body.size
+      end
+      
+      def mime
+        content_type.split(";").first
+      end
+      
+      def charset
+        content_type.include?("charset=") ? content_type.split("charset=").last : nil
+      end
+      
+      def to_text
+        body
+      end
+      
+      def to_html
+        HTML.new(body)
+      end
+      
+      def to_xml
+        XML.new(body)
+      end
+      
+      def to_json
+        JSON.new(body)
+      end
+      
+      def to_native
+        @body
+      end
+      
+      private
+      
+      def content_type
+        @mech['content-type'] || ""
+      end
+      
+    end
+  end
+end

data/lib/saper/items/html.rb

@@ -0,0 +1,85 @@
+module Saper
+  module Items
+    class HTML < Item
+      
+      def self.new(item)
+        super case item
+        when Nokogiri::XML::Element
+          item
+        when Nokogiri::HTML
+          item
+        when Text
+          parse(item.to_s)
+        when String
+          parse(item)
+        else
+          raise(InvalidItem, item)
+        end
+      end
+      
+      def self.parse(string, uri = nil, charset = nil)
+        begin
+          Nokogiri::HTML.parse(string, uri, charset)
+        rescue
+          raise(InvalidItem, string)
+        end
+      end
+      
+      def initialize(noko)
+        @noko = noko
+        # Force UTF-8 encoding
+        # https://github.com/sparklemotion/nokogiri/issues/117
+        @noko.document.encoding = 'UTF-8'
+      end
+      
+      def name
+        @noko.name
+      end
+      
+      def [](name)
+        @noko[name]
+      end
+      
+      def find(xpath)
+        find_all(xpath).first
+      end
+      
+      def find_all(xpath)
+        @noko.search(xpath).map { |element| HTML.new(element) }
+      end
+      
+      def remove_children_with_content(xpath)
+        @noko.search(xpath).each { |item| item.remove }; self
+      end
+      
+      def remove_children_preserving_content(xpath)
+        @noko.search(xpath).each { |item| item.replace(item.children) }; self
+      end
+      
+      def remove(tag)
+        remove_children_preserving_content(tag)
+      end
+      
+      def inner_html
+        @noko.inner_html
+      end
+      
+      def inner_text
+        @noko.inner_text
+      end
+      
+      def to_markdown
+        Markdown.new self
+      end
+      
+      def to_native
+        inner_html
+      end
+      
+      def to_s
+        inner_html
+      end
+      
+    end
+  end
+end