req-cli 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9ce6c0c76b2d31aa7e45b63fd8d8af40c40ec826
+  data.tar.gz: d742a1985e3bf964678a5475a1fd0529bc1ee423
+SHA512:
+  metadata.gz: a019e10f8e119d44d24c816ce7b1dcdc4614f54806744a099eaf1c39c24ef12eabd54874f3312c2d13e9f87a6e2b7cc669887e29bb52bf0723cfd0f54351d6c4
+  data.tar.gz: ccac9284dceeb3c273cfedb42d614c7413dce65e6c126d6fd0646d67268ef0925a0762288143e5d10312a9746dabcc889056c12d592dc36822ff6768da194ea7

data/bin/req

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'req-cli'
+
+Req.start(ARGV)

data/lib/config.rb

@@ -0,0 +1,44 @@
+
+class Config
+  attr_accessor :contexts, :environments, :requests
+
+  def initialize(hash)
+    @contexts = hash[:contexts] || hash['contexts'] || {}
+    @contexts = @contexts.map {|ctx| Context.new(ctx) }
+
+    @environments = hash[:environments] || hash['environments'] || {}
+    @environments = @environments.map { |env| Environment.new(env) }
+
+    @requests = hash[:requests] || hash['requests'] || {}
+    @requests = @requests.map { |req| Request.new(req) }
+  end
+
+  def self.create_from_yaml(yaml_string)
+    return Config.new YAML.load(yaml_string)
+  end
+
+  def has_context?(ctx_name)
+    @contexts.any? {|ctx| ctx.name == ctx_name }
+  end
+
+  def get_context(ctx_name)
+    @contexts.find {|ctx| ctx.name == ctx_name }
+  end
+
+  def has_environment?(env_name)
+    @environments.any? {|env| env.name == env_name }
+  end
+
+  def get_environment(env_name)
+    @environments.find {|env| env.name == env_name }
+  end
+
+  def has_request?(env_name)
+    @requests.any? {|env| env.name == env_name }
+  end
+
+  def get_request(env_name)
+    @requests.find {|env| env.name == env_name }
+  end
+
+end

data/lib/context.rb

@@ -0,0 +1,10 @@
+class Context
+  attr_accessor :name, :variables, :headers
+
+  def initialize(hash)
+    @name = hash[:name] || hash['name'] || 'default_context'
+    @variables = hash[:vars] || hash['vars'] || {}
+    @headers = hash[:headers] || hash['headers'] || {}
+  end
+
+end

data/lib/curl_backend.rb

@@ -0,0 +1,30 @@
+class CurlBackend
+
+  def initialize(prepared_request, options={})
+    @request = prepared_request
+    @curl_options = parse_curl_options(options)
+  end
+
+  def execute
+    header_string = @request.headers.map {|key, val| "-H '#{key}: #{val}'"}.join ' '
+    data_string = @request.data ? "-d '#{@request.data}'" : ""
+
+    curl_command = "curl -X #{@request.method.upcase} #{header_string} #{data_string} #{@curl_options}  #{@request.uri}"
+    system curl_command
+  end
+
+  def parse_curl_options(options)
+    opts = ''
+
+    if options.has_key? 'verbose'
+      opts += '--verbose '
+    end
+
+    if options.has_key? 'head'
+      opts += ' --head '
+    end
+
+    opts
+  end
+
+end

data/lib/environment.rb

@@ -0,0 +1,12 @@
+class Environment
+  attr_accessor :name, :variables, :endpoint, :headers
+
+  def initialize(hash)
+    @name = hash[:name] || hash['name'] || ''
+    @endpoint = hash[:endpoint] || hash['endpoint'] || ''
+    @variables = hash[:vars] || hash['vars'] || {}
+    @headers = hash[:headers] || hash['headers'] || {}
+
+    # TODO raise exceptions when @name or @endpoint is nil or empty
+  end
+end

data/lib/prepared_request.rb

@@ -0,0 +1,18 @@
+class PreparedRequest
+
+  attr_accessor :headers, :uri, :method, :data
+
+  def initialize(options={})
+    @headers = options[:headers] || {}
+    @uri = options[:uri] || ''
+    @method = options[:method] || :get
+    @data = options[:data] || nil
+  end
+
+  # Hash of HTTP headers
+
+  # string with full request URI
+
+  # symbol :get, :post, :put, :delete
+
+end

data/lib/req-cli.rb

@@ -0,0 +1,139 @@
+require 'thor'
+require 'yaml'
+
+require 'context'
+require 'environment'
+require 'request'
+require 'state'
+require 'config'
+require 'prepared_request'
+require 'request_factory'
+require 'variable_interpolator'
+require 'curl_backend'
+
+STATEFILE = '.reqstate'
+REQFILE = 'Reqfile'
+
+
+class Req < Thor
+
+  attr_accessor :config, :state
+  @config = nil
+  @state = nil
+
+  def self.create_with_config(config)
+    req = Req.new
+    req.config = config
+    req.state = State.new
+    req
+  end
+
+  desc "contexts", "list all contexts"
+  def contexts
+    init # TODO avoid this
+    @config.contexts.each {|ctx| puts ctx.name }
+  end
+
+  desc "context NAME", "switch to context NAME"
+  def context(name)
+    init
+    if @config.contexts.any? { |ctx| ctx.name == name }
+      puts "switching to context #{name}"
+      @state.context = name
+      save_state
+    else
+      puts "context not found"
+      exit 1
+    end
+  end
+
+  desc "environments", "list all environments"
+  def environments
+    init
+    @config.environments.each {|env| puts env.name }
+  end
+
+  desc "environment", "switch to environment"
+  def environment(name)
+    init
+    if @config.has_environment? name
+      puts "switching to environment #{name}"
+      @state.environment = name
+      save_state
+    else
+      puts "environment not found"
+      exit 1
+    end
+  end
+
+  desc "variable NAME VALUE", "add variable with key NAME and value VALUE"
+  def variable(name, value)
+    init
+    @state.variables[name] = value
+    save_state
+  end
+
+  desc "variables", "list all custom variables"
+  def variables
+    init
+    @state.variables.each {|key, val| put "#{key}: #{val}" }
+  end
+
+  desc "status", "print current environment and context info"
+  def status
+    init
+    puts "context: #{@state.context}"
+    puts "environment: #{@state.environment}"
+    puts "variables: "
+    @state.variables.each { |key,val| puts "    #{key}: #{val}" }
+  end
+
+  desc "clear", "clear current context, environment and vars"
+  def clear
+    @state = State.new
+    save_state
+  end
+
+  desc "exec REQUESTNAME", "execute request with name REQUESTNAME"
+  option :verbose, aliases: '-v'
+  option :head, aliases: '-I'
+  def exec(requestname)
+    init
+    valid_for_execution?
+    request = @config.get_request(requestname)
+    prepared_request = RequestFactory.create(@config, @state, request)
+    backend = CurlBackend.new prepared_request, options
+    backend.execute
+  end
+
+  desc "requests", "list all requests"
+  def requests
+    init
+    @config.requests.each {|req| puts "#{req.name} \t#{req.method} \t#{req.path}"}
+  end
+
+  no_commands do
+    def init
+      return if @config
+      @state = State.new
+      @config = Config.create_from_yaml(File.read(REQFILE))
+      if File.exist? '.reqstate'
+        @state = YAML.load(File.read(STATEFILE))
+      end
+    end
+
+    def valid_for_execution?
+      env = @config.get_environment(@state.environment)
+      puts "No valid environment specified, use req environment NAME to choose an environment" if env.nil?
+      exit 1 if env.nil?
+
+      ctx = @config.get_context(@state.context)
+      puts "No valid context specified, use req context NAME to choose a context" if ctx.nil?
+      exit 1 if ctx.nil?
+    end
+
+    def save_state
+      File.write(STATEFILE, @state.to_yaml)
+    end
+  end
+end

data/lib/request.rb

@@ -0,0 +1,15 @@
+class Request
+  attr_accessor :name, :path, :method, :headers, :variables, :data
+  
+  def initialize(hash)
+    @name = hash[:name] || hash['name'] || ''
+    @path = hash[:path] || hash['path'] || ''
+    @method = hash[:method] || hash['method'] || ''
+
+    @headers = hash[:headers] || hash['headers'] || {}
+    @variables = hash[:vars] || hash['vars'] || {}
+    @data = hash[:data] || hash['data'] || nil
+
+  end
+
+end

data/lib/request_factory.rb

@@ -0,0 +1,42 @@
+class RequestFactory 
+  def self.create(config, state, request)
+    environment = config.get_environment(state.environment) || Environment.new
+    context = config.get_context(state.context) || Context.new
+
+    variables = merge_variables(environment, context, request, state.variables)
+    interpolator = VariableInterpolator.new(variables)
+
+    PreparedRequest.new({
+      headers: build_headers(environment, context, request, interpolator),
+      method: request.method.downcase.to_sym,
+      uri: build_uri(environment, context, request, interpolator),
+      data: build_data(request, interpolator)
+    })
+  end
+
+  def self.merge_variables(environment, context, request, custom_variables)
+    (environment.variables || {})
+      .merge(context.variables || {})
+      .merge(request.variables || {})
+      .merge(custom_variables || {})
+  end
+
+  def self.build_headers(environment, context, request, interpolator)
+    environment.headers
+      .merge(context.headers)
+      .merge(request.headers)
+      .map {|key, value| [key, interpolator.interpolate(value)]}.to_h
+  end
+
+  def self.build_uri(environment, context, request, interpolator)
+    uri = environment.endpoint + request.path
+    interpolator.interpolate(uri)
+  end
+
+  def self.build_data(request, interpolator)
+    return nil if request.data.nil?
+
+    interpolator.interpolate(request.data)
+  end
+
+end

data/lib/state.rb

@@ -0,0 +1,8 @@
+class State
+  attr_accessor :context, :environment, :variables
+
+  def initialize
+    @variables = {}
+  end
+
+end

data/lib/variable_interpolator.rb

@@ -0,0 +1,16 @@
+class VariableInterpolator
+
+  attr_accessor :variables
+
+  def initialize(variables = {})
+    @variables = variables.map { |key, value| [key.to_sym, value] }.to_h
+  end
+
+  def interpolate(input)
+    input.gsub(/\${[a-zA-Z0-9\-_]*}/) do |m|
+      var = m.scan(/[a-zA-Z0-9\-_]+/).first.to_sym
+      variables[var]
+    end
+  end
+
+end

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification
+name: req-cli
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Steven Van Bael
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-08-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.19'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.19'
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.14'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.14'
+description: ''
+email: steven@quantus.io
+executables:
+- req
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/req
+- lib/config.rb
+- lib/context.rb
+- lib/curl_backend.rb
+- lib/environment.rb
+- lib/prepared_request.rb
+- lib/req-cli.rb
+- lib/request.rb
+- lib/request_factory.rb
+- lib/state.rb
+- lib/variable_interpolator.rb
+homepage: http://github.com/vbsteven/req
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: CLI tool for templating HTTP requests from a config file and execute them
+  with curl.
+test_files: []