search_biomodel 0.1.2 → 1.0.0

data/search_biomodel/ruby/1.8/gems/nori-1.0.1/lib/nori/core_ext.rb

@@ -0,0 +1,3 @@
+require "nori/core_ext/object"
+require "nori/core_ext/string"
+require "nori/core_ext/hash"

data/search_biomodel/ruby/1.8/gems/nori-1.0.1/lib/nori/core_ext/hash.rb

@@ -0,0 +1,70 @@
+require "uri"
+
+module Nori
+  module CoreExt
+    module Hash
+
+      # @return <String> This hash as a query string
+      #
+      # @example
+      #   { :name => "Bob",
+      #     :address => {
+      #       :street => '111 Ruby Ave.',
+      #       :city => 'Ruby Central',
+      #       :phones => ['111-111-1111', '222-222-2222']
+      #     }
+      #   }.to_params
+      #     #=> "name=Bob&address[city]=Ruby Central&address[phones][]=111-111-1111&address[phones][]=222-222-2222&address[street]=111 Ruby Ave."
+      def to_params
+        params = self.map { |k, v| normalize_param(k,v) }.join
+        params.chop! # trailing &
+        params
+      end
+
+      # @param key<Object> The key for the param.
+      # @param value<Object> The value for the param.
+      #
+      # @return <String> This key value pair as a param
+      #
+      # @example normalize_param(:name, "Bob Jones") #=> "name=Bob%20Jones&"
+      def normalize_param(key, value)
+        param = ''
+        stack = []
+
+        if value.is_a?(Array)
+          param << value.map { |element| normalize_param("#{key}[]", element) }.join
+        elsif value.is_a?(Hash)
+          stack << [key,value]
+        else
+          param << "#{key}=#{URI.encode(value.to_s, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]"))}&"
+        end
+
+        stack.each do |parent, hash|
+          hash.each do |key, value|
+            if value.is_a?(Hash)
+              stack << ["#{parent}[#{key}]", value]
+            else
+              param << normalize_param("#{parent}[#{key}]", value)
+            end
+          end
+        end
+
+        param
+      end
+
+      # @return <String> The hash as attributes for an XML tag.
+      #
+      # @example
+      #   { :one => 1, "two"=>"TWO" }.to_xml_attributes
+      #     #=> 'one="1" two="TWO"'
+      def to_xml_attributes
+        map do |k, v|
+          %{#{k.to_s.snakecase.sub(/^(.{1,1})/) { |m| m.downcase }}="#{v}"}
+        end.join(' ')
+      end
+
+    end
+  end
+end
+
+Hash.send :include, Nori::CoreExt::Hash

data/search_biomodel/ruby/1.8/gems/nori-1.0.1/lib/nori/core_ext/object.rb

@@ -0,0 +1,13 @@
+module Nori
+  module CoreExt
+    module Object
+
+      def blank?
+        respond_to?(:empty?) ? empty? : !self
+      end unless method_defined?(:blank?)
+
+    end
+  end
+end
+
+Object.send :include, Nori::CoreExt::Object

data/search_biomodel/ruby/1.8/gems/nori-1.0.1/lib/nori/core_ext/string.rb

@@ -0,0 +1,21 @@
+module Nori
+  module CoreExt
+    module String
+
+      # Returns the String in snake_case.
+      def snakecase
+        str = dup
+        str.gsub! /::/, '/'
+        str.gsub! /([A-Z]+)([A-Z][a-z])/, '\1_\2'
+        str.gsub! /([a-z\d])([A-Z])/, '\1_\2'
+        str.tr! ".", "_"
+        str.tr! "-", "_"
+        str.downcase!
+        str
+      end unless method_defined?(:snakecase)
+
+    end
+  end
+end
+
+String.send :include, Nori::CoreExt::String

data/search_biomodel/ruby/1.8/gems/nori-1.0.1/lib/nori/parser.rb

@@ -0,0 +1,51 @@
+module Nori
+
+  # = Nori::Parser
+  #
+  # Manages the parser classes. Currently supports:
+  #
+  # * REXML
+  # * Nokogiri
+  module Parser
+
+    # The default parser.
+    DEFAULT = :rexml
+
+    # List of available parsers.
+    PARSERS = { :rexml => "REXML", :nokogiri => "Nokogiri" }
+
+    # Returns the parser to use. Defaults to <tt>Nori::Parser::REXML</tt>.
+    def self.use
+      @use ||= DEFAULT
+    end
+
+    # Sets the +parser+ to use. Raises an +ArgumentError+ unless the +parser+ exists.
+    def self.use=(parser)
+      validate_parser! parser
+      @use = parser
+    end
+
+    # Returns the parsed +xml+ using the parser to use. Raises an +ArgumentError+
+    # unless the optional or default +parser+ exists.
+    def self.parse(xml, parser = nil)
+      load_parser(parser).parse xml
+    end
+
+  private
+
+    # Raises an +ArgumentError+ unless the +parser+ exists.
+    def self.validate_parser!(parser)
+      raise ArgumentError, "Invalid Nori parser: #{parser}" unless PARSERS[parser]
+    end
+
+    # Requires and returns the +parser+ to use.
+    def self.load_parser(parser)
+      parser ||= use
+      validate_parser! parser
+
+      require "nori/parser/#{parser}"
+      const_get PARSERS[parser]
+    end
+
+  end
+end

data/search_biomodel/ruby/1.8/gems/nori-1.0.1/lib/nori/parser/nokogiri.rb

@@ -0,0 +1,45 @@
+require "nokogiri"
+
+module Nori
+  module Parser
+
+    # = Nori::Parser::Nokogiri
+    #
+    # Nokogiri SAX parser.
+    module Nokogiri
+
+      class Document < ::Nokogiri::XML::SAX::Document
+
+        def stack
+          @stack ||= []
+        end
+
+        def start_element(name, attrs = [])
+          stack.push Nori::XMLUtilityNode.new(name, Hash[*attrs.flatten])
+        end
+
+        def end_element(name)
+          if stack.size > 1
+            last = stack.pop
+            stack.last.add_node last
+          end
+        end
+
+        def characters(string)
+          stack.last.add_node(string) unless string.strip.length == 0 || stack.empty?
+        end
+
+        alias cdata_block characters
+
+      end
+
+      def self.parse(xml)
+        document = Document.new
+        parser = ::Nokogiri::XML::SAX::Parser.new document
+        parser.parse xml
+        document.stack.length > 0 ? document.stack.pop.to_hash : {}
+      end
+
+    end
+  end
+end

data/search_biomodel/ruby/1.8/gems/nori-1.0.1/lib/nori/parser/rexml.rb

@@ -0,0 +1,38 @@
+require "rexml/parsers/baseparser"
+
+module Nori
+  module Parser
+
+    # = Nori::Parser::REXML
+    #
+    # REXML pull parser.
+    module REXML
+
+      def self.parse(xml)
+        stack = []
+        parser = ::REXML::Parsers::BaseParser.new(xml)
+
+        while true
+          event = parser.pull
+          case event[0]
+          when :end_document
+            break
+          when :end_doctype, :start_doctype
+            # do nothing
+          when :start_element
+            stack.push Nori::XMLUtilityNode.new(event[1], event[2])
+          when :end_element
+            if stack.size > 1
+              temp = stack.pop
+              stack.last.add_node(temp)
+            end
+          when :text, :cdata
+            stack.last.add_node(event[1]) unless event[1].strip.length == 0 || stack.empty?
+          end
+        end
+        stack.length > 0 ? stack.pop.to_hash : {}
+      end
+    end
+
+  end
+end

data/search_biomodel/ruby/1.8/gems/nori-1.0.1/lib/nori/string_io_file.rb

@@ -0,0 +1,7 @@
+module Nori
+  class StringIOFile < StringIO
+
+    attr_accessor :original_filename, :content_type
+
+  end
+end

data/search_biomodel/ruby/1.8/gems/nori-1.0.1/lib/nori/string_with_attributes.rb

@@ -0,0 +1,7 @@
+module Nori
+  class StringWithAttributes < String
+
+    attr_accessor :attributes
+
+  end
+end

data/search_biomodel/ruby/1.8/gems/nori-1.0.1/lib/nori/version.rb

@@ -0,0 +1,5 @@
+module Nori
+
+  VERSION = "1.0.1"
+
+end

data/search_biomodel/ruby/1.8/gems/nori-1.0.1/lib/nori/xml_utility_node.rb

@@ -0,0 +1,230 @@
+require "rexml/text"
+require "date"
+require "time"
+require "yaml"
+require "bigdecimal"
+
+require "nori/string_with_attributes"
+require "nori/string_io_file"
+
+module Nori
+
+  # This is a slighly modified version of the XMLUtilityNode from
+  # http://merb.devjavu.com/projects/merb/ticket/95 (has.sox@gmail.com)
+  #
+  # John Nunemaker:
+  # It's mainly just adding vowels, as I ht cd wth n vwls :)
+  # This represents the hard part of the work, all I did was change the
+  # underlying parser.
+  class XMLUtilityNode
+
+    # Simple xs:time Regexp.
+    XS_TIME = /\d{2}:\d{2}:\d{2}/
+
+    # Simple xs:date Regexp.
+    XS_DATE = /\d{4}-\d{2}-\d{2}/
+
+    # Simple xs:dateTime Regexp.
+    XS_DATE_TIME = /\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/
+
+    def self.typecasts
+      @@typecasts
+    end
+
+    def self.typecasts=(obj)
+      @@typecasts = obj
+    end
+
+    def self.available_typecasts
+      @@available_typecasts
+    end
+
+    def self.available_typecasts=(obj)
+      @@available_typecasts = obj
+    end
+
+    self.typecasts = {}
+    self.typecasts["integer"]       = lambda { |v| v.nil? ? nil : v.to_i }
+    self.typecasts["boolean"]       = lambda { |v| v.nil? ? nil : (v.strip != "false") }
+    self.typecasts["datetime"]      = lambda { |v| v.nil? ? nil : Time.parse(v).utc }
+    self.typecasts["date"]          = lambda { |v| v.nil? ? nil : Date.parse(v) }
+    self.typecasts["dateTime"]      = lambda { |v| v.nil? ? nil : Time.parse(v).utc }
+    self.typecasts["decimal"]       = lambda { |v| v.nil? ? nil : BigDecimal(v.to_s) }
+    self.typecasts["double"]        = lambda { |v| v.nil? ? nil : v.to_f }
+    self.typecasts["float"]         = lambda { |v| v.nil? ? nil : v.to_f }
+    self.typecasts["symbol"]        = lambda { |v| v.nil? ? nil : v.to_sym }
+    self.typecasts["string"]        = lambda { |v| v.to_s }
+    self.typecasts["yaml"]          = lambda { |v| v.nil? ? nil : YAML.load(v) }
+    self.typecasts["base64Binary"]  = lambda { |v| v.unpack('m').first }
+
+    self.available_typecasts = self.typecasts.keys
+
+    def initialize(name, normalized_attributes = {})
+      # unnormalize attribute values
+      attributes = Hash[* normalized_attributes.map do |key, value|
+        [ key, unnormalize_xml_entities(value) ]
+      end.flatten]
+
+      @name = name.tr("-", "_")
+      @name = @name.split(":").last if Nori.strip_namespaces?
+      @name = Nori.convert_tag(@name) if Nori.convert_tags?
+
+      # leave the type alone if we don't know what it is
+      @type = self.class.available_typecasts.include?(attributes["type"]) ? attributes.delete("type") : attributes["type"]
+
+      @nil_element = false
+      attributes.keys.each do |key|
+        if result = /^((.*):)?nil$/.match(key)
+          @nil_element = attributes.delete(key) == "true"
+          attributes.delete("xmlns:#{result[2]}") if result[1]
+        end
+      end
+      @attributes = undasherize_keys(attributes)
+      @children = []
+      @text = false
+    end
+
+    attr_accessor :name, :attributes, :children, :type
+
+    def prefixed_attributes
+      attributes.inject({}) do |memo, (key, value)|
+        memo["@#{key}"] = value
+        memo
+      end
+    end
+
+    def add_node(node)
+      @text = true if node.is_a? String
+      @children << node
+    end
+
+    def to_hash
+      if @type == "file"
+        f = StringIOFile.new((@children.first || '').unpack('m').first)
+        f.original_filename = attributes['name'] || 'untitled'
+        f.content_type = attributes['content_type'] || 'application/octet-stream'
+        return { name => f }
+      end
+
+      if @text
+        t = typecast_value unnormalize_xml_entities(inner_html)
+        t = advanced_typecasting(t) if t.is_a?(String) && Nori.advanced_typecasting?
+
+        if t.is_a?(String)
+          t = StringWithAttributes.new(t)
+          t.attributes = attributes
+        end
+
+        return { name => t }
+      else
+        #change repeating groups into an array
+        groups = @children.inject({}) { |s,e| (s[e.name] ||= []) << e; s }
+
+        out = nil
+        if @type == "array"
+          out = []
+          groups.each do |k, v|
+            if v.size == 1
+              out << v.first.to_hash.entries.first.last
+            else
+              out << v.map{|e| e.to_hash[k]}
+            end
+          end
+          out = out.flatten
+
+        else # If Hash
+          out = {}
+          groups.each do |k,v|
+            if v.size == 1
+              out.merge!(v.first)
+            else
+              out.merge!( k => v.map{|e| e.to_hash[k]})
+            end
+          end
+          out.merge! prefixed_attributes unless attributes.empty?
+          out = out.empty? ? nil : out
+        end
+
+        if @type && out.nil?
+          { name => typecast_value(out) }
+        else
+          { name => out }
+        end
+      end
+    end
+
+    # Typecasts a value based upon its type. For instance, if
+    # +node+ has #type == "integer",
+    # {{[node.typecast_value("12") #=> 12]}}
+    #
+    # @param value<String> The value that is being typecast.
+    #
+    # @details [:type options]
+    #   "integer"::
+    #     converts +value+ to an integer with #to_i
+    #   "boolean"::
+    #     checks whether +value+, after removing spaces, is the literal
+    #     "true"
+    #   "datetime"::
+    #     Parses +value+ using Time.parse, and returns a UTC Time
+    #   "date"::
+    #     Parses +value+ using Date.parse
+    #
+    # @return <Integer, TrueClass, FalseClass, Time, Date, Object>
+    #   The result of typecasting +value+.
+    #
+    # @note
+    #   If +self+ does not have a "type" key, or if it's not one of the
+    #   options specified above, the raw +value+ will be returned.
+    def typecast_value(value)
+      return value unless @type
+      proc = self.class.typecasts[@type]
+      proc.nil? ? value : proc.call(value)
+    end
+
+    def advanced_typecasting(value)
+      split = value.split
+      return value if split.size > 1
+
+      case split.first
+        when "true"       then true
+        when "false"      then false
+        when XS_DATE_TIME then DateTime.parse(value)
+        when XS_DATE      then Date.parse(value)
+        when XS_TIME      then Time.parse(value)
+        else                   value
+      end
+    end
+
+    # Take keys of the form foo-bar and convert them to foo_bar
+    def undasherize_keys(params)
+      params.keys.each do |key, value|
+        params[key.tr("-", "_")] = params.delete(key)
+      end
+      params
+    end
+
+    # Get the inner_html of the REXML node.
+    def inner_html
+      @children.join
+    end
+
+    # Converts the node into a readable HTML node.
+    #
+    # @return <String> The HTML node in text form.
+    def to_html
+      attributes.merge!(:type => @type ) if @type
+      "<#{name}#{attributes.to_xml_attributes}>#{@nil_element ? '' : inner_html}</#{name}>"
+    end
+
+    alias to_s to_html
+
+  private
+
+    # TODO: replace REXML
+    def unnormalize_xml_entities value
+      REXML::Text.unnormalize(value)
+    end
+  end
+
+end