eval_in 0.1.6 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4ccfaf7503c99eaaece5c964e2dcbe82271ed1eb
-  data.tar.gz: 87787a87e7f4540c0c021219a6959efb6f2cc247
+  metadata.gz: 9a9e273c4e6a93761fc1f35b47e35242397e8559
+  data.tar.gz: d78b600e459c3adece521d7c2540209e6c138955
 SHA512:
-  metadata.gz: 3fa266438bdf528ec9d025bb63a858beb5aeea37e215d5ba0ace45badd654dd7eb88049c74af616104f58857c6dcb85c910d2386ce817816d041f19d7ebe93d5
-  data.tar.gz: 350cc67567a1f13b103641cdb7517d2cc802b3e797167a34a622bd8447a4b87f2306d1f92093d3e3664731b57df75a692c963c12e7187d4f5d7fa8ea3ae0be27
+  metadata.gz: 3d6b167a6a021c1208dfac00a9de3078f90ee026bdf51198323afd14f2c2429ae00d49b63556ae1f092261a815852ac36c73bae57828d78bb8ab652fac62693e
+  data.tar.gz: 558dd782b6838e5c74945636bc9721cc684fd9ab3db11613de40f394eee39a6b888269a0c6bb40eb715f4547ebce905243c5dc25c2734fc9ab98369d6cd99ffb

data/Readme.md

@@ -153,6 +153,138 @@ What languages can this run?
   </tr>
 </table>
 
+
+Mocking for non-prod environments
+---------------------------------
+
+### Wiring the mock in
+
+The mock that is provided will need to be set into place.
+If the code is directly doing `EvalIn.call(...)`, then it is
+a hard dependency, and there is no ablity to set the mock into place.
+
+You will need to structure your code such that it receives the `eval_in`
+service as an argument, or looks it up in some configuration or something
+(I strongly prefer the former).
+This will allow your test environment to give it a mock that tests that it
+works in all the edge cases, or is just generally benign (doesn't make real http request in tests),
+your dev environment to give it an `EvalIn` that looks so close to the real one you wouldn't even know,
+and your prod environment to give it the actual `EvalIn` that actually uses the service.
+
+If this is still unclear, here is an example:
+
+```ruby
+# == before: hard dependency prevents you from giving a mock ==
+def get_output(code)
+  EvalIn.call(code, language: 'ruby/mri-2.1').output
+end
+
+# == after: receive the thing you're talking to ==
+def get_output(eval_in, code)
+  eval_in.call(code, language: 'ruby/mri-2.1').output
+end
+
+# in test, you call like this
+output = 'the output'
+assert_equal output, get_output(EvalIn::Mock.new(result: EvalIn::Result.new(output: output)), 'some code')
+
+# in prod you call like this:
+get_output(EvalIn, params[:code_sample])
+
+# in dev you call like this:
+get_output(EvalIn::Mock.new(languages: {'ruby/mri-2.1' => {program: RbConfig.ruby, args: []}}),
+           params[:code_sample])
+
+# Now those last_two are probably in the same controller, right?
+# How do you get it to do the right thing in the right env, then?
+# well, you pass it to your controller, the same way you passed the `get_output`
+# for example, you might do this in a rack middleware,
+# then have it get the service from the `env` hash
+# or set it in an environment initializer
+```
+
+### The provided mock
+
+For a test or dev env where you don't care about correctness,
+just that it does something that looks real,
+you can make a mock that has a `Result`,
+instantiated with any values you care about.
+
+```ruby
+require 'eval_in/mock'
+eval_in = EvalIn::Mock.new(result: EvalIn::Result.new(code: 'injected code', output: 'the output')) 
+
+eval_in.call('overridden code', language: 'irrelevant')
+# => #<EvalIn::Result:0x007fb503a7a5e8
+#     @code="injected code",
+#     @exitstatus=-1,
+#     @language="",
+#     @language_friendly="",
+#     @output="the output",
+#     @status="",
+#     @url="">
+```
+
+If you want your environment to behave approximately like the real `eval_in`,
+you can instantiate a mock that knows how to evaluate code locally.
+This is necessary, because it doesn't know how to execute these languages
+(eval.in does that, it just knows how to talk to eval.in).
+So you must provide it with a list of languages and how to execute them
+
+This is probably idea for a dev environment, the results will be the most realistic.
+
+**NOTE THAT THIS DOES NOT WORK ON JRUBY**
+
+```ruby
+require 'eval_in/mock'
+
+# a mock that can execute Ruby code and C code
+eval_in = EvalIn::Mock.new(languages: {
+  'ruby/mri-2.1' => {program: RbConfig.ruby,
+                     args: []
+                    },
+  'c/gcc-4.9.1'  => {program: RbConfig.ruby,
+                     args: ['-e',
+                            'system "gcc -x c -o /tmp/eval_in_c_example #{ARGV.first}"
+                             exec   "/tmp/eval_in_c_example"']
+                    },
+})
+
+eval_in.call 'puts "hello from ruby!"; exit 123', language: 'ruby/mri-2.1'
+# => #<EvalIn::Result:0x007fb503a7d518
+#     @code="puts \"hello from ruby!\"; exit 123",
+#     @exitstatus=123,
+#     @language="ruby/mri-2.1",
+#     @language_friendly="ruby/mri-2.1",
+#     @output="hello from ruby!\n",
+#     @status="OK (0.072 sec real, 0.085 sec wall, 8 MB, 19 syscalls)",
+#     @url="https://eval.in/207744.json">
+
+eval_in.call '#include <stdio.h>
+int main() {
+  puts("hello from c!");
+}', language: 'c/gcc-4.9.1'
+# => #<EvalIn::Result:0x007fb503a850b0
+#     @code="#include <stdio.h>\nint main() {\n  puts(\"hello from c!\");\n}",
+#     @exitstatus=0,
+#     @language="c/gcc-4.9.1",
+#     @language_friendly="c/gcc-4.9.1",
+#     @output="hello from c!\n",
+#     @status="OK (0.072 sec real, 0.085 sec wall, 8 MB, 19 syscalls)",
+#     @url="https://eval.in/207744.json">
+```
+
+You can also provide a callback that will be invoked to handle the request.
+This is probably ideal for testing more nuanced edge cases that the mock
+doesn't inherently provide the ability to do.
+
+```ruby
+require 'eval_in/mock'
+eval_in = EvalIn::Mock.new on_call: -> code, options { raise EvalIn::RequestError, 'does my code do the right thing in the event of an exception?' }
+
+eval_in.call('code', language: 'any') rescue $! # => #<EvalIn::RequestError: does my code do the right thing in the event of an exception?>
+```
+
 Attribution
 -----------
 

data/eval_in.gemspec

@@ -1,6 +1,6 @@
 # -*- encoding: utf-8 -*-
 $:.push File.expand_path("../lib", __FILE__)
-require "eval_in/version"
+require "eval_in/constants"
 
 Gem::Specification.new do |s|
   s.name        = "eval_in"

data/lib/eval_in.rb

@@ -1,80 +1,7 @@
-# encoding: utf-8
-
-require 'uri'
-require 'json'
-require 'net/http'
-require 'pathname'
-require 'eval_in/version'
+require 'eval_in/http'
+require 'eval_in/client'
 
 module EvalIn
-  EvalInError    = Class.new StandardError
-  RequestError   = Class.new EvalInError
-  ResultNotFound = Class.new EvalInError
-
-  # @example Generated with
-  #   nokogiri https://eval.in -e 'puts $_.xpath("//option/@value")'
-  KNOWN_LANGUAGES = %w[
-    c/gcc-4.4.3
-    c/gcc-4.9.1
-    c++/c++11-gcc-4.9.1
-    c++/gcc-4.4.3
-    c++/gcc-4.9.1
-    coffeescript/node-0.10.29-coffee-1.7.1
-    fortran/f95-4.4.3
-    haskell/hugs98-sep-2006
-    io/io-20131204
-    javascript/node-0.10.29
-    lua/lua-5.1.5
-    lua/lua-5.2.3
-    ocaml/ocaml-4.01.0
-    php/php-5.5.14
-    pascal/fpc-2.6.4
-    perl/perl-5.20.0
-    python/cpython-2.7.8
-    python/cpython-3.4.1
-    ruby/mri-1.0
-    ruby/mri-1.8.7
-    ruby/mri-1.9.3
-    ruby/mri-2.0.0
-    ruby/mri-2.1
-    slash/slash-head
-    assembly/nasm-2.07
-  ]
-
-  # The data structure containing the final result
-  # its attributes default to null-objects for their given type
-  class Result
-    @attribute_names = [:exitstatus, :language, :language_friendly, :code, :output, :status, :url].freeze
-    attr_accessor *@attribute_names
-    class << self
-      attr_reader :attribute_names
-    end
-
-    def initialize(attributes={})
-      attributes = attributes.dup
-      self.exitstatus         = attributes.delete(:exitstatus)        || -1
-      self.language           = attributes.delete(:language)          || ""
-      self.language_friendly  = attributes.delete(:language_friendly) || ""
-      self.code               = attributes.delete(:code)              || ""
-      self.output             = attributes.delete(:output)            || ""
-      self.status             = attributes.delete(:status)            || ""
-      self.url                = attributes.delete(:url)               || ""
-      stderr                  = attributes.delete(:stderr)            || $stderr
-      stderr.puts "Unexpected attributes! #{attributes.keys.inspect}" if attributes.any?
-    end
-
-    # Returns representation of the result built out of JSON primitives (hash, string, int)
-    def as_json
-      self.class.attribute_names.each_with_object Hash.new do |name, attributes|
-        attributes[name.to_s] = public_send name
-      end
-    end
-
-    def to_json
-      JSON.dump(as_json)
-    end
-  end
-
   # @param code [String] the code to evaluate.
   # @option options [String] :language Mandatory, a language recognized by eval.in, such as any value in {KNOWN_LANGUAGES}.
   # @option options [String] :url      Override the url to post the code to
@@ -86,7 +13,7 @@ module EvalIn
   #   result = EvalIn.call 'puts "hello, #{gets}"', stdin: 'world', language: "ruby/mri-2.1"
   #   result.output # => "hello, world\n"
   def self.call(code, options={})
-    url = post_code(code, options)
+    url = Client.post_code(code, options)
     fetch_result url, options
   end
 
@@ -97,97 +24,7 @@ module EvalIn
   #   result = EvalIn.fetch_result "https://eval.in/147.json"
   #   result.output # => "Hello Charlie! "
   def self.fetch_result(raw_url, options={})
-    raw_json_url = jsonify_url(raw_url)
-    build_result fetch_result_json(raw_json_url, options)
-  end
-
-  # @api private
-  def self.post_code(code, options)
-    url        = options.fetch(:url, "https://eval.in/")
-    input      = options.fetch(:stdin, "")
-    language   = options.fetch(:language) { raise ArgumentError, ":language is mandatory, but options only has #{options.keys.inspect}" }
-    form_data  = {"utf8" => "√", "code" => code, "execute" => "on", "lang" => language, "input" => input}
-
-    result = post_request url, form_data, user_agent_for(options[:context])
-
-    if result.code == '302'
-      jsonify_url result['location']
-    elsif KNOWN_LANGUAGES.include? language
-      raise RequestError, "There was an unexpected error, we got back a response code of #{result.code}"
-    else
-      raise RequestError, "Perhaps language is wrong, you provided: #{language.inspect}\n"\
-                          "Known languages are: #{KNOWN_LANGUAGES.inspect}"
-    end
-  end
-
-  # @api private
-  def self.fetch_result_json(raw_url, options={})
-    result = get_request raw_url, user_agent_for(options[:context])
-    return JSON.parse(result.body).merge('url' => raw_url) if result.body
-    raise ResultNotFound, "No json at #{raw_url.inspect}"
-  end
-
-  # @api private
-  def self.build_result(response_json)
-    exitstatus = case response_json['status']
-                 when nil             then nil # let it choose default
-                 when /status (\d+)$/ then $1.to_i
-                 when /^Forbidden/    then 1
-                 else                      0
-                 end
-
-    Result.new exitstatus:          exitstatus,
-               language:            response_json['lang'],
-               language_friendly:   response_json['lang_friendly'],
-               code:                response_json['code'],
-               output:              response_json['output'],
-               status:              response_json['status'],
-               url:                 response_json['url']
-  end
-
-  # @api private
-  def self.jsonify_url(url)
-    uri = URI(url)
-    uri.path = Pathname.new(uri.path).sub_ext('.json').to_s
-    uri.to_s
-  end
-
-  # @private
-  def self.user_agent_for(context)
-    'http://rubygems.org/gems/eval_in'.tap do |agent|
-      context && agent.concat(" (#{context})")
-    end
-  end
-
-  # @api private
-  # Can't just use Net::HTTP.get, b/c it doesn't use ssl on 1.9.3
-  # https://github.com/ruby/ruby/blob/v2_1_2/lib/net/http.rb#L478-479
-  # https://github.com/ruby/ruby/blob/v1_9_3_547/lib/net/http.rb#L454
-  def self.get_request(raw_url, user_agent)
-    generic_request_for raw_url:      raw_url,
-                        request_type: Net::HTTP::Get,
-                        user_agent:   user_agent
-  end
-
-  # @private
-  def self.post_request(raw_url, form_data, user_agent)
-    generic_request_for raw_url:      raw_url,
-                        request_type: Net::HTTP::Post,
-                        user_agent:   user_agent,
-                        form_data:    form_data
-  end
-
-  # @private
-  # stole this out of implementation for post_form https://github.com/ruby/ruby/blob/2afed6eceff2951b949db7ded8167a75b431bad6/lib/net/http.rb#L503
-  # can use this to view the request: http.set_debug_output $stdout
-  def self.generic_request_for(params)
-    uri                   = URI params.fetch(:raw_url)
-    path                  = uri.path
-    path                  = '/' if path.empty?
-    request               = params.fetch(:request_type).new(path)
-    request['User-Agent'] = params[:user_agent] if params.key? :user_agent
-    request.form_data     = params[:form_data]  if params.key? :form_data
-    request.basic_auth uri.user, uri.password   if uri.user
-    Net::HTTP.start(uri.hostname, uri.port, use_ssl: (uri.scheme == 'https')) { |http| http.request request }
+    raw_json_url = HTTP.jsonify_url(raw_url)
+    Client.build_result Client.fetch_result_json(raw_json_url, options)
   end
 end

data/lib/eval_in/client.rb

@@ -0,0 +1,77 @@
+# encoding: utf-8
+
+require 'json'
+require 'eval_in/http'
+require 'eval_in/result'
+require 'eval_in/constants'
+
+module EvalIn
+
+  # Code that does the integration with the actual eval.in service
+  # It is primarily in place to help the toplevel methods wire things together
+  # in the ways that they need to.
+  #
+  # **This should be assumed volatile, and you should avoid depending on it.**
+  module Client
+    extend self
+
+    # @api private
+    def post_code(code, options)
+      url        = options.fetch(:url, "https://eval.in/")
+      input      = options.fetch(:stdin, "")
+      language   = language_or_error_from options
+      form_data  = {"utf8" => "√", "code" => code, "execute" => "on", "lang" => language, "input" => input}
+
+      result = HTTP.post_request url, form_data, user_agent_for(options[:context])
+
+      if result.code == '302'
+        HTTP.jsonify_url result['location']
+      elsif KNOWN_LANGUAGES.include? language
+        raise RequestError, "There was an unexpected error, we got back a response code of #{result.code}"
+      else
+        raise RequestError, "Perhaps language is wrong, you provided: #{language.inspect}\n"\
+                            "Known languages are: #{KNOWN_LANGUAGES.inspect}"
+      end
+    end
+
+    # @api private
+    def fetch_result_json(raw_url, options={})
+      result = HTTP.get_request raw_url, user_agent_for(options[:context])
+      return JSON.parse(result.body).merge('url' => raw_url) if result.body
+      raise ResultNotFound, "No json at #{raw_url.inspect}"
+    end
+
+    # @api private
+    def build_result(response_json)
+      exitstatus = case response_json['status']
+                   when nil             then nil # let Result choose default
+                   when /status (\d+)$/ then $1.to_i
+                   when /^Forbidden/    then 1
+                   else                      0
+                   end
+
+      Result.new exitstatus:          exitstatus,
+                 language:            response_json['lang'],
+                 language_friendly:   response_json['lang_friendly'],
+                 code:                response_json['code'],
+                 output:              response_json['output'],
+                 status:              response_json['status'],
+                 url:                 response_json['url']
+    end
+
+    # @api private
+    def user_agent_for(context)
+      'http://rubygems.org/gems/eval_in'.tap do |agent|
+        agent << " (#{context})" if context
+      end
+    end
+
+    # @api private
+    def language_or_error_from(options)
+      options.fetch :language do
+        raise ArgumentError, ":language is mandatory, but options only has #{options.keys.inspect}"
+      end
+    end
+
+  end
+end

data/lib/eval_in/constants.rb

@@ -0,0 +1,37 @@
+module EvalIn
+  VERSION = '0.2.0'
+
+  EvalInError    = Class.new StandardError
+  RequestError   = Class.new EvalInError
+  ResultNotFound = Class.new EvalInError
+
+  # @example Generated with
+  #   nokogiri https://eval.in -e 'puts $_.xpath("//option/@value")'
+  KNOWN_LANGUAGES = %w[
+    c/gcc-4.4.3
+    c/gcc-4.9.1
+    c++/c++11-gcc-4.9.1
+    c++/gcc-4.4.3
+    c++/gcc-4.9.1
+    coffeescript/node-0.10.29-coffee-1.7.1
+    fortran/f95-4.4.3
+    haskell/hugs98-sep-2006
+    io/io-20131204
+    javascript/node-0.10.29
+    lua/lua-5.1.5
+    lua/lua-5.2.3
+    ocaml/ocaml-4.01.0
+    php/php-5.5.14
+    pascal/fpc-2.6.4
+    perl/perl-5.20.0
+    python/cpython-2.7.8
+    python/cpython-3.4.1
+    ruby/mri-1.0
+    ruby/mri-1.8.7
+    ruby/mri-1.9.3
+    ruby/mri-2.0.0
+    ruby/mri-2.1
+    slash/slash-head
+    assembly/nasm-2.07
+  ]
+end