http_baseline 2.0.0

data/lib/ext_core/string.rb

@@ -0,0 +1,142 @@
+class ::String
+
+  unless method_defined? :camelize
+    # By default, +camelize+ converts strings to UpperCamelCase. If the argument to +camelize+
+    # is set to <tt>:lower</tt> then +camelize+ produces lowerCamelCase.
+    #
+    # +camelize+ will also convert '/' to '::' which is useful for converting paths to namespaces.
+    #
+    # As a rule of thumb you can think of +camelize+ as the inverse of +underscore+,
+    # though there are cases where that does not hold:
+    #
+    #   "SSLError".underscore.camelize # => "SslError"
+    #
+    def camelize(first_letter_in_uppercase = true)
+      lower_case_and_underscored_word = self
+      if first_letter_in_uppercase
+        lower_case_and_underscored_word.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+      else
+        lower_case_and_underscored_word.to_s[0].chr.downcase + camelize(lower_case_and_underscored_word)[1..-1]
+      end
+    end
+  end
+
+  unless method_defined? :underscore
+    # Makes an underscored, lowercase form from the expression in the string.
+    #
+    # Changes '::' to '/' to convert namespaces to paths.
+    #
+    # Examples:
+    #   "FooBar".underscore         # => "foo_bar"
+    #   "FooBar::Errors".underscore # => foo_bar/errors
+    #
+    # As a rule of thumb you can think of +underscore+ as the inverse of +camelize+,
+    # though there are cases where that does not hold:
+    #
+    #   "SSLError".underscore.camelize # => "SslError"
+    #
+    def underscore()
+      camel_cased_word = self
+      word = camel_cased_word.to_s.dup
+      word.gsub!(/::/, '/')
+      word.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+      word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+      word.tr!("-", "_")
+      word.downcase!
+      word
+    end
+  end
+
+  unless method_defined? :constantize
+    # Ruby 1.9 introduces an inherit argument for Module#const_get and
+    # #const_defined? and changes their default behavior.
+    if Module.method(:const_get).arity == 1
+      # Tries to find a constant with the name specified in the argument string:
+      #
+      #   "Module".constantize     # => Module
+      #   "Test::Unit".constantize # => Test::Unit
+      #
+      # The name is assumed to be the one of a top-level constant, no matter whether
+      # it starts with "::" or not. No lexical context is taken into account:
+      #
+      #   C = 'outside'
+      #   module M
+      #     C = 'inside'
+      #     C               # => 'inside'
+      #     "C".constantize # => 'outside', same as ::C
+      #   end
+      #
+      # NameError is raised when the name is not in CamelCase or the constant is
+      # unknown.
+      def constantize()
+        camel_cased_word = self
+        names = camel_cased_word.split('::')
+        names.shift if names.empty? || names.first.empty?
+
+        constant = Object
+        names.each do |name|
+          constant = constant.const_defined?(name) ? constant.const_get(name) : constant.const_missing(name)
+        end
+        constant
+      end
+    else
+      def constantize() #:nodoc:
+        camel_cased_word = self
+        names = camel_cased_word.split('::')
+        names.shift if names.empty? || names.first.empty?
+
+        constant = Object
+        names.each do |name|
+          constant = constant.const_defined?(name, false) ? constant.const_get(name) : constant.const_missing(name)
+        end
+        constant
+      end
+    end
+  end
+
+  def squish
+    dup.squish!
+  end
+
+  # Performs a destructive squish. See String#squish.
+  def squish!
+    gsub!(/\A[[:space:]]+/, '')
+    gsub!(/[[:space:]]+\z/, '')
+    gsub!(/[[:space:]]+/, ' ')
+    self
+  end
+
+  # Truncates a given +text+ after a given <tt>length</tt> if +text+ is longer than <tt>length</tt>:
+  #
+  #   'Once upon a time in a world far far away'.truncate(27)
+  #   # => "Once upon a time in a wo..."
+  #
+  # Pass a string or regexp <tt>:separator</tt> to truncate +text+ at a natural break:
+  #
+  #   'Once upon a time in a world far far away'.truncate(27, separator: ' ')
+  #   # => "Once upon a time in a..."
+  #
+  #   'Once upon a time in a world far far away'.truncate(27, separator: /\s/)
+  #   # => "Once upon a time in a..."
+  #
+  # The last characters will be replaced with the <tt>:omission</tt> string (defaults to "...")
+  # for a total length not exceeding <tt>length</tt>:
+  #
+  #   'And they found that many people were sleeping better.'.truncate(25, omission: '... (continued)')
+  #   # => "And they f... (continued)"
+  def truncate(truncate_at, options = {})
+    return dup unless length > truncate_at
+
+    options[:omission] ||= '...'
+    length_with_room_for_omission = truncate_at - options[:omission].length
+    stop = \
+      if options[:separator]
+                   rindex(options[:separator], length_with_room_for_omission) || length_with_room_for_omission
+      else
+        length_with_room_for_omission
+      end
+
+    "#{self[0...stop]}#{options[:omission]}"
+  end
+
+end

data/lib/http_baseline/adapter/abstract.rb

@@ -0,0 +1,25 @@
+require 'json'
+require 'uri'
+
+module HttpBaseline
+  module Adapter
+    class Abstract
+
+      def initialize(config)
+        @config   = config
+        @options  = { :ssl => @config.ssl.enabled.true?, :ssl_options => { :verify => @config.ssl.verify } }
+        @protocol = @config.ssl.enabled.true? ? 'https' : 'http'
+        @uri      = URI.parse("#{@protocol}://#{@config.domain}:#{@config.tcp_port}")
+      end
+
+      def ssl?
+        @uri.scheme == 'https'
+      end
+
+      def headers
+        @client.headers
+      end
+
+    end
+  end
+end

data/lib/http_baseline/adapter/rest/response/logger.rb

@@ -0,0 +1,37 @@
+module HttpBaseline
+  module Adapter
+    class Rest
+      module Response
+        class Logger < Faraday::Response::Middleware
+          extend Forwardable
+
+          def initialize(app, logger = nil)
+            super(app)
+            @logger = logger || HttpBaseline.logger
+          end
+
+          def_delegators :@logger, :debug, :info, :warn, :error, :fatal
+
+          def call(env)
+            debug "#{env.method} #{env.url.to_s}"
+            debug('request') { dump_headers env.request_headers }
+            debug('request') { env.body }
+            super
+          end
+
+          def on_complete(env)
+            debug('Status') { env.status.to_s }
+            debug('response') { dump_headers env.response_headers }
+            debug('response') { env.body }
+          end
+
+          private
+
+          def dump_headers(headers)
+            headers.map { |k, v| "#{k}: #{v.inspect}" }.join("\n")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/http_baseline/adapter/rest.rb

@@ -0,0 +1,63 @@
+module HttpBaseline
+  module Adapter
+    class Rest < Abstract
+      require 'faraday'
+      require 'faraday/request/multipart'
+      require 'faraday_middleware'
+      require 'http_baseline/adapter/rest/response/logger'
+
+      attr_reader :uri
+
+      def initialize(config)
+        super
+        @client              = Faraday.new do |pipe|
+          pipe.use Faraday::Request::UrlEncoded
+          pipe.use FaradayMiddleware::EncodeJson
+          pipe.use FaradayMiddleware::FollowRedirects
+          pipe.use FaradayMiddleware::Mashify
+          pipe.use Response::Logger
+          pipe.url_prefix = @uri
+        end
+        headers[:user_agent] = 'WS v%s' % HttpBaseline::VERSION
+      end
+
+
+      def attach_extension(other_module)
+        @client.use other_module
+      end
+
+
+      def get(url, *args)
+        @client.get(configured_path(url), *args)
+      end
+
+
+      def post(url, body = nil, *args)
+        @client.post(configured_path(url), body, *args)
+      end
+
+
+      def delete(url, *args)
+        @client.delete(configured_path(url), *args)
+      end
+
+      def put(url, body = nil, *args)
+        @client.put(configured_path(url), body, *args)
+      end
+
+      private
+
+      def configured_path(url)
+        @config.path_prefix.to_s + url
+      end
+
+      def reset_config
+        @client.url_prefix = @uri.to_s
+        if @options[:ssl_options]
+          @client.ssl.merge!(@options[:ssl_options])
+        end
+      end
+
+    end
+  end
+end

data/lib/http_baseline/evf.rb

@@ -0,0 +1,21 @@
+module HttpBaseline
+  class Abstract < ::Evf::Abstract
+
+    config.comm                  = Evf::Support::Options.new unless config.respond_to?(:comm)
+    config.comm.http             = Evf::Support::Options.new
+    config.comm.http.ssl         = Evf::Support::Options.new
+    config.comm.http.ssl.enabled = 'no'
+
+    invocation 'init.http.config', :before => :load_context_config, group => :all do |env|
+      HttpBaseline.config      = env.config
+      HttpBaseline.logger      = env.config.logger
+      HttpBaseline.broadcaster = env.broadcaster
+
+      %w(debugging header request response user_story).each do |definition|
+        require HttpBaseline::SHARED_DEFINITIONS.join('%s_steps' % definition)
+      end
+
+    end
+
+  end
+end

data/lib/http_baseline/methods.rb

@@ -0,0 +1,17 @@
+module HttpBaseline
+  module Methods
+
+    def set_headers_by(c_type)
+      type = case c_type
+               when /json/i
+                 'application/json'
+               when /form/i
+                 'application/x-www-form-urlencoded'
+               else
+                 c_type
+             end
+      connection.add_header 'Content-Type', type unless c_type.nil? || c_type.empty?
+    end
+
+  end
+end

data/lib/http_baseline/null_broadcaster.rb

@@ -0,0 +1,21 @@
+module HttpBaseline
+  class NullBroadcaster
+
+    def initialize(logger)
+      @logger = logger
+    end
+
+    def notify_all_with(object, notification_type, *args)
+      @logger.debug '[%s]: %s -> accepted :%s with %s' % [uname, object.class.name, notification_type, args.join(', ')]
+    end
+
+    def uname
+      @uname ||= self.class.name.split('::').last
+    end
+
+    def subscribe(other)
+      (@null_storage ||= []) << other
+    end
+
+  end
+end

data/lib/http_baseline/version.rb

@@ -0,0 +1,8 @@
+module HttpBaseline
+  module Version
+    MAJOR, MINOR, PATCH = 2, 0, 0
+    STRING = [MAJOR, MINOR, PATCH].join('.')
+  end
+
+  VERSION = Version::STRING
+end

data/lib/http_baseline.rb

@@ -0,0 +1,67 @@
+$:.unshift File.expand_path '../', __FILE__
+require 'http_baseline/version'
+require 'base64'
+require 'bigdecimal'
+require 'cgi'
+require 'date'
+require 'digest/sha1'
+require 'enumerator'
+require 'forwardable'
+require 'net/http'
+require 'net/https'
+require 'openssl'
+require 'stringio'
+require 'time'
+require 'zlib'
+require 'builder'
+require 'json'
+require 'jsonpath'
+require 'logger'
+require 'addressable/uri'
+require 'ext_core/query'
+require 'ext_core/object'
+require 'ext_core/array'
+require 'ext_core/hash'
+require 'ext_core/string'
+require 'hashie'
+
+module HttpBaseline
+  SHARED_DEFINITIONS = Pathname(__FILE__).join('..', '..', 'features', 'step_definitions', 'generic')
+
+  autoload :Methods, 'http_baseline/methods'
+  autoload :NullBroadcaster, 'http_baseline/null_broadcaster'
+
+  module Adapter
+    autoload :Abstract, 'http_baseline/adapter/abstract'
+    autoload :Rest, 'http_baseline/adapter/rest'
+  end
+
+  class << self
+    attr_writer :config
+  end
+
+  def self.config
+    @config ||= Hashie::Mash.new
+  end
+
+  def self.logger
+    @logger ||= begin
+      logger       = ::Logger.new $stdout
+      logger.level = ::Logger::DEBUG
+      logger
+    end
+  end
+
+  def self.logger=(val)
+    @logger = val
+  end
+
+  def self.broadcaster
+    @broadcaster ||= NullBroadcaster.new(self.logger)
+  end
+
+  def self.broadcaster=(other_bundle)
+    @broadcaster = other_bundle
+  end
+
+end

data/spec/lib/root_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+
+describe HttpBaseline do
+
+  describe 'ResHTTPot namespace' do
+
+    it 'should have VERSION constant' do
+      HttpBaseline.constants.include?(:VERSION).should == true
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,18 @@
+require 'bundler/setup'
+require 'yaml'
+
+$:.unshift File.expand_path('../', File.dirname(__FILE__))
+
+require 'http_baseline'
+
+Dir[File.expand_path('support/**/*.rb', File.dirname(__FILE__))].each do |file|
+  require file if File.file?(file)
+end
+
+RSpec.configure do |config|
+  config.color     = true
+  config.formatter = :documentation
+  config.include Fixtures
+end
+
+include Fixtures

data/spec/support/fixtures.rb

@@ -0,0 +1,23 @@
+require 'pathname'
+
+module Fixtures
+  def fixture_path(name)
+    File.join '../fixtures', name
+  end
+
+  def absolute_fixture_path(name)
+    File.expand_path fixture_path(name), File.dirname(__FILE__)
+  end
+
+  def fixture(name)
+    File.read absolute_fixture_path(name)
+  end
+
+  def binary_fixture(name)
+    File.open(absolute_fixture_path(name), "rb") { |f| f.read }
+  end
+
+  def fixtures_path
+    Pathname(absolute_fixture_path '')
+  end
+end

data/spec/support/simplecov_setup.rb

@@ -0,0 +1,12 @@
+begin
+  require 'simplecov'
+
+  SimpleCov.root(File.expand_path(File.dirname(__FILE__) + '/../..'))
+  SimpleCov.start do
+    add_filter '/features/'
+    add_filter '/spec/'
+  end
+
+rescue LoadError
+  warn('Unable to load simplecov gem')
+end