ruby-resty 0.0.1.pre → 0.1.0

data/README.md

@@ -5,8 +5,8 @@
 Ruby-Resty is a ruby port of [Resty][1], which provides a simple way to interact with RESTful services. Ruby-Resty was
 ported to be shell agnostic and for easier community development.
 
-The resty REPL is built on top of [Pry][2] for built-in niceties like history, state management, shell interaction, 
-etc.
+The resty REPL is built on top of [Pry][2] for niceties like [Custom Commands][3], history management, interactive 
+help system, and most importantly, using plain old Ruby.
 
 # Installation
 
@@ -36,20 +36,20 @@ If you would like headers to be attached with every request, you can do so:
 ruby-resty --host http://nyan.cat --headers X-NYAN-CAT-SECRET-KEY=nyan_nyan X-NYAN-TYPE=octo
 ```
 
-### REPL Options
+### Options
 
 The REPL accepts the following options that are attached to each request. This provides an easier way to make multiple
 requests without having to specify headers everytime.
 
 ```
---alias, -a <s>:   The per-host entry to use in ~/.ruby_resty.yml
---host, -h:    The hostname of the REST service. Ex: http://nyan.cat
---headers, -H: The headers attached to each request. Ex: X-NYAN-CAT-SECRET-KEY=nyan_nyan
---verbose, -v: Verbose mode
---config, -c : Use host information from ~/.ruby_resty.yml
+--alias, -a   : The per-host entry to use in ~/.ruby_resty.yml
+--host, -h    : The hostname of the REST service. Ex: http://nyan.cat
+--headers, -H : The headers attached to each request. Ex: X-NYAN-CAT-SECRET-KEY=nyan_nyan
+--verbose, -v : Verbose mode
+--config, -c  : Use host information from ~/.ruby_resty.yml
 ```
 
-### Making Requests
+### Requests
 
 Requests can be sent to services by specifying a path and any associated JSON data. The following methods are 
 supported:
@@ -58,6 +58,7 @@ supported:
 GET     [path]
 PUT     [path] [data]
 POST    [path] [data]
+PATH    [path] [data]
 HEAD    [path]
 DELETE  [path]
 OPTIONS [path]
@@ -79,7 +80,7 @@ resty> GET /api/cats/1
 Or you can send a `POST` request, which does require a body:
 
 ```
-resty> POST /api/cats '{"nyan_cat": {"name": "oliver", "color": "blue"} }'
+resty> POST /api/cats {"nyan_cat": {"name": "oliver", "color": "blue"} }
 { 
   "nyan_cat": { 
     "name": "oliver"
@@ -88,12 +89,44 @@ resty> POST /api/cats '{"nyan_cat": {"name": "oliver", "color": "blue"} }'
 }
 ```
 
-### REPL Commands
+Ruby hashes are also accepted:
+```
+resty> POST /api/cats {nyan_cat: {name: "oliver", color: "blue"} }
+```
+
+As are ruby variables:
+```
+resty> data = {nyan_cat: {name: "oliver", color: "blue"} }
+resty> POST /api/cats data
+```
+
+### Responses
+
+After a request is returned, the resulting JSON response is parsed into a ruby hash and stored in `response`:
+
+```
+resty> POST /api/cats {nyan_cat: {name: "oliver", color: "blue"} }
+resty> response
+{ 
+  "nyan_cat" => { 
+    "name" => "oliver"
+    "color" => "blue"
+  }
+}
+```
 
-There are also REPL specific commands ruby-resty is aware of. For example, you can type `exit` to quit the REPL.
+Since the response object is a ruby hash, the values can be changed and sent on another request:
 
 ```
-exit: Quits the REPL
+resty> response
+{ 
+  "nyan_cat" => { 
+    "name" => "oliver"
+    "color" => "blue"
+  }
+}
+resty> response["nyan_cat"]["name"] = "grumpy"
+resty> PUT /api/cats response
 ```
 
 ## Per Host Configuration
@@ -141,3 +174,4 @@ Don't forget to run the tests with `rake`
 
 [1]: https://github.com/micha/resty
 [2]: https://github.com/pry/pry
+[3]: https://github.com/pry/pry/wiki/Custom-commands

data/lib/resty/commands/method_command.rb

@@ -1,30 +1,99 @@
-Pry::Commands.create_command /(get|put|post|delete|head|option|patch|trace)/i do
-  description "Echo the input: echo [ARGS]"
+Pry::Commands.create_command /(get|put|post|delete|head|option|patch|trace)/i, listing: "method-command" do
+  description "Performs an HTTP request to the specified path: METHOD PATH [DATA]"
+
+  banner <<-BANNER
+  Performs an HTTP request to the specified path with optional data: METHOD PATH [DATA]
+
+  Examples: 
+  --------- 
+  GET    /api/nyan
+  DELETE /api/nyan
+  PUT    /api/nyan {"name": "Jan"}
+  POST   /api/nyan {"name": "Jeff"}
+
+  Ruby hashes can also be used:
+  -----------------------------
+  PUT  /api/nyan {name: "Jan"}
+
+  And even ruby variables:
+  ------------------------
+  data = {name: "j3"}
+  PUT  /api/nyan data
+
+  BANNER
+
+  command_options(
+    shellwords: false
+  )
 
   def process
-    params = { method: args[0], path: args[1], data: data(args) }
-
-    Resty::Request.new(cli_options, params).tap do |request|
-      if !request.path_valid?
-        output.puts("A path must be included. Ex: http://nyan.cat/<path>")
-      elsif request.data_required? && !request.data_valid?
-        output.puts("Invalid data. Check if you have valid JSON at: http://jsonlint.com/")
-      else
-        request.send_request do |response, request|
-          method_output = Resty::Commands::MethodOutput.new(cli_options.verbose?, response, request)
-          output.puts(method_output.generate)
-        end
+    if path_missing?
+      output.puts("Missing path\n\n")
+      run("help method-command")
+    elsif data_invalid?
+      output.puts("Invalid data\n\n")
+      run("help method-command")
+    else
+      params = { method: http_method, path: path, data: data }
+      request = Resty::Request.new(cli_options, params)
+      request.send_request do |response, request|
+        method_output = Resty::Commands::MethodOutput.new(cli_options.verbose?, response, request)
+        output.puts(method_output.generate)
+        eval_response(response)
       end
     end
   end
 
   private
 
-  def data(args)
-    args[2] ? args[2..-1].join(" ") : ""
+  def path_missing?
+    path.nil?
+  end
+
+  def data_invalid?
+    data.nil? && Resty::Request.data_required?(http_method)
+  end
+
+  def eval_response(response)
+    target.eval("response = #{JSON.parse(response)}")
+  rescue
+    target.eval("response = nil")
+  end
+
+  def build_data
+    return nil unless args[2]
+
+    input = args[2..-1].join(" ")
+    parse_json(input) || eval_ruby(input) || nil
+  end
+
+  def eval_ruby(input)
+    parsed_input = target.eval(input)
+    if parsed_input.is_a?(String)
+      JSON.parse(parsed_input)
+    else
+      parsed_input
+    end
+  rescue
+  end
+
+  def parse_json(input)
+    JSON.parse(input) rescue nil
   end
 
   def cli_options
     @cli_options ||= eval "self", target
   end
+
+  def http_method
+    args[0]
+  end
+
+  def path
+    args[1]
+  end
+
+  def data
+    @data ||= build_data
+  end
 end

data/lib/resty/commands/method_output.rb

@@ -18,6 +18,8 @@ module Resty
 
             output += build_line("Response Code: #{response.code}")
             response.headers.each { |key, value| output += build_line("#{key}: #{value}") }
+        else
+            output += build_line("Response Code: #{response.code}")
         end
 
         output += pretty_json(response)

data/lib/resty/request.rb

@@ -3,33 +3,22 @@ require 'json'
 module Resty
   class Request
 
-    attr_accessor :data, :data_valid
-    attr_reader :params, :printer, :cli_options
+    attr_reader :params, :cli_options
 
     def initialize(cli_options, params)
       @cli_options = cli_options
       @params = params
-      @data_valid = false
-      load_data
     end
 
     def send_request
-      if data_required?
+      if Resty::Request.data_required?(method)
         RestClient.send(method, url, data, cli_options.headers) { |*params| yield params }
       else
         RestClient.send(method, url, cli_options.headers) { |*params| yield params }
       end
     end
 
-    def path_valid?
-      path.nil? ? false : true
-    end
-
-    def data_valid?
-      data_valid
-    end
-
-    def data_required?
+    def self.data_required?(method)
       (method =~ %r{put|post|patch}) == 0
     end
 
@@ -47,11 +36,8 @@ module Resty
       params[:path]
     end
 
-    def load_data
-      self.data = JSON.parse(params[:data]) || {}
-      self.data_valid = true
-    rescue => e
-      self.data = {}
+    def data
+      params[:data]
     end
   end
 end

data/lib/version.rb

@@ -1,3 +1,3 @@
 module Resty
-  VERSION = "0.0.1.pre"
+  VERSION = "0.1.0"
 end

data/spec/lib/resty/cli_options_spec.rb

@@ -86,6 +86,7 @@ describe Resty::CliOptions do
 
     context "alias doesn't exist" do
       it "raises ConfigFileError" do
+        YAML.stubs(:load_file).returns({"ice_cream" => {} } )
         File.stubs(:exist?).returns(true)
         expect { Resty::CliOptions.new(alias: "nyan") }.to raise_error(Resty::ConfigFileError)
       end

data/spec/lib/resty/commands/method_command_spec.rb

@@ -2,69 +2,156 @@ require 'spec_helper'
 require 'json'
 
 describe "MethodCommand" do
+  let(:request) { stub }
+  let(:response) { stub }
+  let(:returned_request) { stub }
+
   before(:each) do
     Resty::Request.stubs(:new).returns(request)
+    Object.any_instance.stubs(:verbose?).returns(false)
   end
 
   context "command regex" do
-    let(:request) { stub(path_valid?: false) }
+    before(:each) do
+      request.stubs(:send_request)
+    end
 
     it "responds lower case method" do
       %w{get put post delete head option patch trace}.each do |method|
-        pry_eval(method)
+        pry_eval("#{method}").start_with?("Missing").should be_true
       end
-      Resty::Request.should have_received(:new).times(8)
     end
 
     it "responds to case-insentivity" do
       %w{GET Put PoSt delete head option patch trace}.each do |method|
-        pry_eval(method)
+        pry_eval("#{method}").start_with?("Missing").should be_true
       end
-      Resty::Request.should have_received(:new).times(8)
     end
   end
 
-  context "process" do
-    context "invalid path" do
-      let(:request) { stub(path_valid?: false) }
+  context "invalid path" do
+    it "doesn't send request" do
+      pry_eval("get")
+      request.should have_received(:send_request).never
+    end
+  end
+
+  context "invalid data" do
+    context "request requires data" do
+      before(:each) do
+        pry_eval("post /api/nyan")
+      end
+
+      it "never sends request" do
+        Resty::Request.should have_received(:new).never
+      end
+    end
 
-      it "doesn't send request" do
-        pry_eval("get")
-        request.should have_received(:send_request).never
+    context "request doesn't require data" do
+      before(:each) do
+        Resty::Commands::MethodOutput.stubs(:new).returns(stub(:generate))
+        Resty::Request.stubs(:new).returns(request)
+        request.stubs(:send_request).yields(response, request)
+        pry_eval("get /api/nyan")
+      end
+
+      it "returns sends request with nil data" do
+        params  = { method: "get", path: "/api/nyan", data: nil }
+        Resty::Request.should have_received(:new).with(anything, params)
       end
     end
+  end
+
+  context "process" do
+    let(:method_output) { stub(generate: "")}
+
+    before(:each) do
+      Resty::Commands::MethodOutput.stubs(:new).returns(method_output)
+      request.stubs(:send_request).yields(response, request)
+    end
+
+    context "with data" do
+      context "as json string" do
+        before(:each) do
+          pry_eval("get /api/nyan {\"foo\": \"bar\"}")
+        end
 
-    context "invalid data" do
-      let(:request) { stub(path_valid?: :true, data_valid?: false, data_required?: true) }
+        it "creates request" do
+          params  = { method: "get", path: "/api/nyan", data: {"foo" => "bar"} }
+          Resty::Request.should have_received(:new).with(anything, params)
+        end
 
-      it "doesn't send request" do
-        pry_eval("get")
-        request.should have_received(:send_request).never
+        it "sends request" do
+          Resty::Commands::MethodOutput.should have_received(:new).with(false, response,request)
+          method_output.should have_received(:generate)
+        end
       end
     end
-    
-    context "valid arguments" do
-      let(:response) { stub }
-      let(:request) { stub(path_valid?: :true, data_valid?: true, data_required?: true) }
-      let(:params) { { method: "get", path: "/api/nyan", data: "#{JSON.dump(foo: 'bar')}"} }
-      let(:method_output) { stub(generate: "")}
 
+    context "as ruby hash" do
       before(:each) do
-        Resty::Commands::MethodOutput.stubs(:new).returns(method_output)
-        Object.any_instance.stubs(:verbose?).returns(false)
-        request.stubs(:send_request).yields(response, request)
-        pry_eval("get /api/nyan '#{JSON.dump(foo: 'bar')}'")
+        pry_eval("get /api/nyan {foo: 'bar'}")
       end
 
       it "creates request" do
+        params  = { method: "get", path: "/api/nyan", data: {foo: "bar"} }
         Resty::Request.should have_received(:new).with(anything, params)
       end
 
       it "sends request" do
         Resty::Commands::MethodOutput.should have_received(:new).with(false, response,request)
+        method_output.should have_received(:generate)
       end
+    end
 
-      it "generates output" do
+    context "as variable" do
+      context "with ruby hash" do
+        before(:each) do
+          Object.any_instance.stubs(:foo).returns(foo: "bar")
+          pry_eval("get /api/nyan foo")
+        end
+
+        it "creates request" do
+          params  = { method: "get", path: "/api/nyan", data: {foo: "bar"} }
+          Resty::Request.should have_received(:new).with(anything, params)
+        end
+
+        it "sends request" do
+          Resty::Commands::MethodOutput.should have_received(:new).with(false, response,request)
+          method_output.should have_received(:generate)
+        end
+      end
+
+      context "with json string" do
+        before(:each) do
+          Object.any_instance.stubs(:foo).returns('{"foo": "bar"}')
+          pry_eval("get /api/nyan foo")
+        end
+
+        it "creates request" do
+          params  = { method: "get", path: "/api/nyan", data: {"foo" => "bar"} }
+          Resty::Request.should have_received(:new).with(anything, params)
+        end
+
+        it "sends request" do
+          Resty::Commands::MethodOutput.should have_received(:new).with(false, response,request)
+          method_output.should have_received(:generate)
+        end
+      end
+    end
+
+    context "without data" do
+      before(:each) do
+        pry_eval("get /api/nyan")
+      end
+
+      it "creates request" do
+        params  = { method: "get", path: "/api/nyan", data: nil }
+        Resty::Request.should have_received(:new).with(anything, params)
+      end
+
+      it "sends request" do
+        Resty::Commands::MethodOutput.should have_received(:new).with(false, response,request)
         method_output.should have_received(:generate)
       end
     end

data/spec/lib/resty/commands/method_output_spec.rb

@@ -6,9 +6,8 @@ describe Resty::Commands::MethodOutput do
   let(:response) { JSON.dump({foo: "bar"}) }
 
   context "#print" do
-    it "returns empty string with no json output" do
-      method_output = Resty::Commands::MethodOutput.new(false, "", request)
-      method_output.generate.should eq("")
+    before(:each) do
+      response.stubs(:code).returns(200)
     end
 
     context "non-verbose" do
@@ -16,6 +15,7 @@ describe Resty::Commands::MethodOutput do
 
       it "returns output" do
          output = <<-eos.unindent
+           > Response Code: 200
            {
              "foo": "bar"
            }
@@ -33,7 +33,6 @@ describe Resty::Commands::MethodOutput do
         request.stubs(:method).returns("get")
         request.stubs(:url).returns("foo.com")
         request.stubs(:processed_headers).returns(header: "value", header2: "value2")
-        response.stubs(:code).returns(200)
         response.stubs(:headers).returns(response_header: "value", response_header2: "value2")
       end
 

data/spec/lib/resty/request_spec.rb

@@ -61,7 +61,7 @@ describe Resty::Request do
     end
 
     context "PUT" do
-      let(:params) { { method: "put", path: "/api/merchants", data: JSON.dump(foo: "bar") } }
+      let(:params) { { method: "put", path: "/api/merchants", data: {"foo" => "bar"} } }
 
       before(:each) do
         Resty::Request.new(cli_options, params).send_request
@@ -74,7 +74,7 @@ describe Resty::Request do
     end
 
     context "POST" do
-      let(:params) { { method: "post", path: "/api/merchants", data: JSON.dump(foo: "bar") } }
+      let(:params) { { method: "post", path: "/api/merchants", data: {"foo" => "bar"} } }
 
       before(:each) do
         Resty::Request.new(cli_options, params).send_request

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: ruby-resty
 version: !ruby/object:Gem::Version
-  version: 0.0.1.pre
-  prerelease: 6
+  version: 0.1.0
+  prerelease: 
 platform: ruby
 authors:
 - Austen Ito
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-01 00:00:00.000000000 Z
+date: 2013-07-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: active_support
@@ -232,7 +232,6 @@ files:
 - spec/lib/resty/cli_options_spec.rb
 - spec/lib/resty/commands/method_command_spec.rb
 - spec/lib/resty/commands/method_output_spec.rb
-- spec/lib/resty/repl_spec.rb
 - spec/lib/resty/request_spec.rb
 - spec/spec_helper.rb
 - templates/ruby_resty.yml
@@ -251,9 +250,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
-  - - ! '>'
+  - - ! '>='
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24
@@ -264,6 +263,5 @@ test_files:
 - spec/lib/resty/cli_options_spec.rb
 - spec/lib/resty/commands/method_command_spec.rb
 - spec/lib/resty/commands/method_output_spec.rb
-- spec/lib/resty/repl_spec.rb
 - spec/lib/resty/request_spec.rb
 - spec/spec_helper.rb

data/spec/lib/resty/repl_spec.rb

@@ -1,6 +0,0 @@
-require 'spec_helper'
-
-describe Resty::Repl do
-  let(:printer) { stub(write: "") }
-
-end