knod 0.4.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 28667421fdff9da10d052b49cc759c0510e685be
+  data.tar.gz: b9e50bfb52f5f594ab291edd520117959e55af87
+SHA512:
+  metadata.gz: 411502ef0abac71bfdd536c4e94e38e28ca25324b1f42fa8cf1ef988480e4787b482e6ee38bbecef713bd7b161b067c14d2165c5e5ad0f91e71da8f640a5dd9d
+  data.tar.gz: b881af2bbe11b777bf3661a6560f77fecfc9a01e36304cc962045dec56b84f4e0d1b9a3902ea9d080c9650fd5c9bd0cbd79368e09a0928ca8f12fa207d23ac73

data/.gitignore

@@ -0,0 +1,4 @@
+.DS_Store
+/items
+index.html
+*.gem

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.1.0
+  - 2.1.2

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,16 @@
+PATH
+  remote: .
+  specs:
+    knod (0.4.3)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    rake (10.3.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  knod!
+  rake (~> 10)

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Ryan Moser
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,39 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+end
+
+def gem_version
+  @version ||= Dir.glob("*.gem").sort.last
+end
+
+def report_error(task)
+  puts "There is no .gem file to #{task}"
+end
+
+desc 'Run tests'
+task :default => :test
+
+desc 'build gem'
+task :build do
+  puts `gem build knod.gemspec`
+end
+
+desc 'Install a locally generated version of the gem'
+task :install do |t|
+  if gem_version
+    puts `gem install ./#{gem_version}`
+  else
+    report_error(t.name)
+  end
+end
+
+desc 'Deploy the gem to Rubygems'
+task :deploy do |t|
+  if gem_version
+    puts `gem push #{gem_version}`
+  else
+    report_error(t.name)
+  end
+end

data/Readme.md

@@ -0,0 +1,31 @@
+#Knod
+
+[![Gem Version](https://badge.fury.io/rb/knod.svg)](http://badge.fury.io/rb/knod) [![Build Status](https://travis-ci.org/moserrya/knod.svg?branch=master)](https://travis-ci.org/moserrya/knod) [![Code Climate](https://codeclimate.com/github/moserrya/knod.png)](https://codeclimate.com/github/moserrya/knod)
+
+Knod is a lightweight HTTP server designed to facilitate front end development when the corresponding back end is missing or incomplete. It responds to GET, PUT, POST, PATCH, and DELETE, serving up, writing to, and deleting from the directory of your choosing. Knod has no dependencies outside of the Ruby standard library.
+
+## Installation
+
+```gem install knod```
+
+## Usage
+
+The Knod gem comes with an executable; you can run it from the command line with `knod`. Knod will default to port 4444 and the current directory. You can change these with command line arguments (-p and -d, respectively).
+
+You can also run it by requiring `knod` and calling `Knod.start`. Knod accepts an options hash that lets you change the port, root directory, and logging:
+
+```ruby
+options = {port: 1234, root: './some/directory', logging: false}
+Knod.start options
+```
+
+Logging is enabled by default. The server will select an open ephemeral port at random if you pass in 0 as the port.
+
+Knod sanitizes the path on all requests and does not allow access to folders outside of the root directory where it is run.
+
+GET requests map suffixes into MIME types. Data is considered to be `application/octet-stream` if the content type is unrecognized.
+
+All data from PUT, POST, and PATCH requests is stored as JSON. If the pathway specified in the request does not exist, Knod will create it.
+
+POST requests auto-increment in the specified path and return the id of the file written as JSON (e.g if a POST request led to the server writing 56.json, the server would respond with `"{\"id\":56}"`.
+

data/bin/knod

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+
+require 'knod'
+require 'optparse'
+
+options = {}
+OptionParser.new do |opts|
+  cmd = File.basename($0)
+
+  opts.banner = "Usage: #{cmd} [options]"
+
+  opts.separator ''
+  opts.separator 'Specific options:'
+
+  opts.on('-p', '--port [PORT]', 'Set the port') do |p|
+    options[:port] = p
+  end
+
+  opts.on('-d', '--directory [DIR]', 'Set the root directory') do |dir|
+    options[:root] = dir
+  end
+
+  opts.on('--[no-]logging', "Use this flag to disable logging") do |logging|
+    options[:logging] = logging
+  end
+
+  opts.on('-v', '--version', 'Show version') do
+    puts "#{cmd} v#{Knod::VERSION}"
+    exit
+  end
+
+end.parse!
+
+trap("INT") { exit }
+Knod.start(options)

data/knod.gemspec

@@ -0,0 +1,25 @@
+#coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'knod/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = 'knod'
+  gem.version       = Knod::VERSION
+  gem.date          = '2014-05-27'
+  gem.authors       = ['Ryan Moser']
+  gem.email         = 'ryanpmoser@gmail.com'
+  gem.homepage      = 'https://github.com/moserrya/knod'
+  gem.summary       = 'A tiny RESTful http server'
+  gem.description   = 'An http server built using Ruby\'s standard library'
+  gem.license       = 'MIT'
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ['lib']
+
+  gem.required_ruby_version = '>= 1.9.3'
+
+  gem.add_development_dependency "rake", '~> 10'
+end

data/lib/knod.rb

@@ -0,0 +1,18 @@
+require 'socket'
+require 'uri'
+require 'fileutils'
+require 'json'
+require 'knod/request'
+require 'knod/server'
+require 'knod/version'
+
+module Knod
+  def self.start(options = {})
+    Server.new(options).start
+  end
+end
+
+if __FILE__ == $0
+  Knod.start
+end
+

data/lib/knod/request.rb

@@ -0,0 +1,42 @@
+module Knod
+  class Request
+    attr_reader :socket, :headers, :request_line
+
+    def initialize(socket)
+      @socket = socket
+      @request_line = socket.gets
+      parse_request
+    end
+
+    def parse_request
+      headers = {}
+      loop do
+        line = socket.gets
+        break if line == "\r\n"
+        name, value = line.strip.split(": ")
+        headers[name] = value
+      end
+      @headers = headers
+    end
+
+    def content_length
+      headers["Content-Length"].to_i
+    end
+
+    def content_type
+      headers["Content-Type"]
+    end
+
+    def uri
+      @uri ||= request_line.split[1]
+    end
+
+    def method
+      @verb ||= request_line.split.first.upcase
+    end
+
+    def body
+      @body ||= socket.read(content_length)
+    end
+  end
+end

data/lib/knod/server.rb

@@ -0,0 +1,168 @@
+module Knod
+  class Server
+    attr_reader :server, :socket, :request
+
+    DEFAULT_PORT = 4444
+    DEFAULT_WEB_ROOT = './'
+
+    def initialize(options={})
+      port     = options.fetch(:port) { DEFAULT_PORT }
+      @root    = options.fetch(:root) { DEFAULT_WEB_ROOT }
+      @logging = options.fetch(:logging) { true }
+      @server  = TCPServer.new('0.0.0.0', port)
+    end
+
+    def start
+      log "Starting server on port #{port}"
+      loop do
+        Thread.start(server.accept) do |socket|
+          parse_request_and_respond(socket)
+        end
+      end
+    end
+
+    def parse_request_and_respond(socket)
+      @socket = socket
+      @request = Request.new(socket)
+      log request_line
+      public_send "do_#{request.method}"
+    rescue => e
+      log "#{e.class}: #{e.message}"
+      log e.backtrace
+      respond 500
+    ensure
+      socket.close if socket
+    end
+
+    def do_GET(head=false)
+      path = requested_path
+      path = File.join(path, 'index.html') if File.directory?(path)
+
+      if File.file?(path)
+        File.open(path, 'rb') do |file|
+          socket.print file_response_header(file)
+          IO.copy_stream(file, socket) unless head
+        end
+      else
+        message = head ? '' : "\"File not found\""
+        respond(404, message)
+      end
+    end
+
+    def do_HEAD
+      do_GET(head=true)
+    end
+
+    def do_DELETE
+      path = requested_path
+      File.delete(path) if File.file?(path)
+      respond 204
+    end
+
+    def do_PUT
+      write_to_path(requested_path) do |path|
+        File.write(path, request.body)
+      end
+    end
+
+    def do_POST
+      path = requested_path
+      FileUtils.mkdir_p(path)
+      records = Dir.glob(path + "/*.json")
+      next_id = (records.map {|r| File.basename(r, ".json") }.map(&:to_i).max || 0) + 1
+      File.write(File.join(path, "#{next_id}.json"), request.body)
+      respond(201, "{\"id\":#{next_id}}")
+    end
+
+    def port
+      server.addr[1]
+    end
+
+    private
+
+    def write_to_path(path)
+      directory = File.dirname(path)
+      FileUtils.mkdir_p(directory)
+      yield path
+      respond(200, "\"Success\"")
+    end
+
+    def log(message)
+      STDERR.puts message if @logging
+    end
+
+    def request_line
+      request.request_line
+    end
+
+    STATUS_CODE_MAPPINGS = {
+      200 => "OK",
+      201 => "Created",
+      204 => "No Content",
+      404 => "Not Found",
+      500 => "Internal Server Error",
+      501 => "Not Implemented"
+    }
+
+    def response_header(status_code, message)
+      header = "HTTP/1.1 #{status_code} #{STATUS_CODE_MAPPINGS.fetch(status_code)}\r\n"
+      header << "Content-Type: application/json\r\n" unless message.empty?
+      header << "Content-Length: #{message.size}\r\n"
+      header << "Connection: close\r\n\r\n"
+    end
+
+    def respond(status_code, message='')
+      socket.print response_header(status_code, message)
+      socket.print message unless message.empty?
+    end
+
+    def file_response_header(file)
+      "HTTP/1.1 200 OK\r\n" <<
+      "Content-Type: #{content_type(file)}\r\n" <<
+      "Content-Length: #{file.size}\r\n" <<
+      "Connection: close\r\n\r\n"
+    end
+
+    CONTENT_TYPE_MAPPING = {
+      'json' => 'application/json',
+      'bmp'  => 'image/bmp',
+      'gif'  => 'image/gif',
+      'jpg'  => 'image/jpeg',
+      'png'  => 'image/png',
+      'css'  => 'text/css',
+      'html' => 'text/html',
+      'txt'  => 'text/plain',
+      'xml'  => 'text/xml'
+    }
+
+    DEFAULT_CONTENT_TYPE = 'application/octet-stream'
+
+    def content_type(path)
+      ext = File.extname(path).split('.').last
+      CONTENT_TYPE_MAPPING[ext] || DEFAULT_CONTENT_TYPE
+    end
+
+    def requested_path
+      local_path = URI.unescape(URI(request.uri).path)
+
+      clean = []
+
+      parts = local_path.split("/")
+
+      parts.each do |part|
+        next if part.empty? || part == '.'
+        part == '..' ? clean.pop : clean << part
+      end
+
+      File.join(@root, *clean)
+    end
+
+    def method_missing(method_sym, *args, &block)
+      if method_sym.to_s.start_with?("do_")
+        respond(501, "\"not implemented\"")
+      else
+        super
+      end
+    end
+  end
+end

data/lib/knod/version.rb

@@ -0,0 +1,3 @@
+module Knod
+  VERSION = '0.4.3'
+end

data/test/connection.rb

@@ -0,0 +1,53 @@
+require 'net/http'
+require 'json'
+
+class Connection
+
+  def initialize(endpoint)
+    uri = URI.parse(endpoint)
+    @http = Net::HTTP.new(uri.host, uri.port)
+  end
+
+  VERB_MAP = {
+    get:    Net::HTTP::Get,
+    post:   Net::HTTP::Post,
+    put:    Net::HTTP::Put,
+    patch:  Net::HTTP::Patch,
+    delete: Net::HTTP::Delete,
+    head:   Net::HTTP::Head,
+    options: Net::HTTP::Options
+  }
+
+  VERB_MAP.keys.each do |method|
+    define_method method, ->(path, params=nil) {request_json method, path, params}
+  end
+
+  private
+
+  def request_json(method, path, params)
+    response = request(method, path, params)
+    response.body = JSON.parse(response.body, symbolize_names: true)
+    response
+  rescue
+    response
+  end
+
+  def request(method, path, params = {})
+    case method
+    when :get, :head
+      full_path = encode_path_params(path, params)
+      request = VERB_MAP[method.to_sym].new(full_path)
+    else
+      request = VERB_MAP[method.to_sym].new(path)
+      request.body = params.to_json
+    end
+
+    @http.request(request)
+  end
+
+  def encode_path_params(path, params)
+    return path if params.nil?
+    encoded = URI.encode_www_form(params)
+    [path, encoded].join("?")
+  end
+end

data/test/test_knod.rb

@@ -0,0 +1,158 @@
+require 'knod'
+require 'connection'
+require 'minitest/autorun'
+
+$knod = Knod::Server.new(port: 0, logging: false)
+$port = $knod.port
+
+Thread.new do
+  $knod.start
+end
+
+def parse_json_file(file)
+  JSON.parse(File.read(file), symbolize_names: true)
+end
+
+describe Knod, "a tiny http server" do
+  let(:connection) {Connection.new("http://0.0.0.0:#{$port}")}
+
+  describe 'non-writing methods' do
+    before do
+      @path = 'index.html'
+      @body  = "<h1>Squids are fun!</h1>"
+      File.write(@path, @body)
+    end
+
+    after do
+      FileUtils.remove_entry(@path, true)
+    end
+
+    it 'responds with 200 when the route is valid' do
+      response = connection.get @path
+      response.code.must_equal '200'
+    end
+
+    it 'responds with the body of the requested file' do
+      response = connection.get @path
+      response.body.must_equal @body
+    end
+
+    it 'implictly serves up the index' do
+      response = connection.get "/"
+      response.body.must_equal @body
+    end
+
+    it 'returns a 404 if the file does not exist' do
+      response = connection.get "/squidbat.random"
+      response.code.must_equal '404'
+    end
+
+    it 'responds to HEAD requests without a body' do
+      response = connection.head @path
+      response.body.must_be_nil
+    end
+
+    it 'responds to unsupported methods with a 501' do
+      response = connection.options @path
+      response.code.must_equal '501'
+    end
+
+    it 'deletes files at the specified path' do
+      response = connection.delete @path
+      File.exists?(@path).must_equal false
+    end
+
+    it 'responds to delete requests with a 204' do
+      response = connection.delete @path
+      response.code.must_equal '204'
+    end
+  end
+
+  describe 'PUT' do
+    let(:directory) {'index'}
+    let(:path) {"#{directory}/81.json"}
+    let(:data) {{state: 'swell', predeliction: 'good challenges'}}
+
+    it 'returns a 200 on success' do
+      response = connection.put path, data
+      response.code.must_equal '200'
+    end
+
+    it 'writes to the local path' do
+      connection.put path, data
+      File.file?(path).must_equal true
+    end
+
+    it 'writes the data to the file as json' do
+      connection.put path, data
+      parse_json_file(path).must_equal data
+    end
+
+    after do
+      FileUtils.remove_entry(directory, true)
+    end
+  end
+
+  describe 'POST' do
+    let(:path) {'/items'}
+    let(:local_path) {File.join('.', path)}
+    let(:data) {{id: 81, state: 'swell', predeliction: 'good challenges'}}
+
+    before do
+      FileUtils.mkdir_p(local_path)
+      2.times {|i| File.write(File.join(".", path, "#{i+1}.json"), {state: 'noodles'})}
+    end
+
+    after do
+      FileUtils.remove_entry(local_path, true)
+    end
+
+    it 'returns a 201 on success' do
+      response = connection.post path, data
+      response.code.must_equal '201'
+    end
+
+    it 'creates the required directory if it does not exist' do
+      FileUtils.remove_entry(local_path, true)
+      connection.post path, data
+      Dir.exists?(local_path).must_equal true
+    end
+
+    it 'writes to the correct path' do
+      connection.post path, data
+      File.file?(File.join(local_path, '3.json')).must_equal true
+    end
+
+    it 'responds with json' do
+      response = connection.post path, data
+      response.content_type.must_equal 'application/json'
+    end
+
+    it 'returns the id of the file created' do
+      response = connection.post path, data
+      response.body.must_equal ({id: 3})
+    end
+  end
+
+  describe 'error handling' do
+    before do
+      def $knod.do_HEAD
+        raise 'boom!'
+      end
+    end
+
+    after do
+      def $knod.do_HEAD
+        do_GET(head=true)
+      end
+    end
+
+    it 'responds to server errors with a 500' do
+      response = connection.head '/index.html'
+      response.code.must_equal '500'
+    end
+  end
+end
+
+
+

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: knod
+version: !ruby/object:Gem::Version
+  version: 0.4.3
+platform: ruby
+authors:
+- Ryan Moser
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-05-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10'
+description: An http server built using Ruby's standard library
+email: ryanpmoser@gmail.com
+executables:
+- knod
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- Rakefile
+- Readme.md
+- bin/knod
+- knod.gemspec
+- lib/knod.rb
+- lib/knod/request.rb
+- lib/knod/server.rb
+- lib/knod/version.rb
+- test/connection.rb
+- test/test_knod.rb
+homepage: https://github.com/moserrya/knod
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: A tiny RESTful http server
+test_files:
+- test/connection.rb
+- test/test_knod.rb