xenon 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 278d552255e77d646a1670ab310a3dd786991efc
-  data.tar.gz: f1924cc643df82774d2fdda50432919bd012b24f
+  metadata.gz: f05aa3e37aef60ceb5222b097b411a15d3c38874
+  data.tar.gz: 2b1c1226260313cc76c9a2768c3c761038adeedb
 SHA512:
-  metadata.gz: dfd9fb60f55c963b10d6e8c7e7d5155ceb848555ae7a045c965dd672b0106d12bea485de077c39e4f6cadbd4b915040e89898eedbd3345de86ede6fda91592fa
-  data.tar.gz: 6211e6a63cccd8e2a6832e7dfc18e39e18370bcd1c70b21f8d0fa0aad7111d3e8261d2349e818a8c3c40289eeeda5070ae69761c2e3990c0f333e512166d4e46
+  metadata.gz: b19aaf5f2e92fe435ed3ca6723af7484aa410578684a0fb0b6ba908ad442d9d866159912afc087eb03ddfd112a02013bca5a73c99c9d7549dfc3ad9203fb737a
+  data.tar.gz: 74594a32ddfce37b50224584a2b5a13dc869a8a5a7ffa87c50e20a0af79c1ea38cafa9b8f332e2c55e3971e752d7e62b7ddade445990e8b8340e72fd36e23c19

data/.gitignore

@@ -1,22 +1,23 @@
 *.gem
 *.rbc
-.bundle
-.config
-.yardoc
+.ruby-version
+.ruby-gemset
 Gemfile.lock
-InstalledFiles
-_yardoc
-coverage
-doc/
-lib/bundler/man
-pkg
-rdoc
-spec/reports
-test/tmp
-test/version_tmp
-tmp
-*.bundle
-*.so
-*.o
-*.a
-mkmf.log
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalisation:
+/.bundle/
+/lib/bundler/man/

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--require spec_helper
+--format documentation

data/Guardfile

@@ -0,0 +1,48 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+## Uncomment and set this to only include directories you want to watch
+# directories %w(app lib config test spec features)
+
+## Uncomment to clear the screen before every task
+clearing :on
+
+## Guard internally checks for changes in the Guardfile and exits.
+## If you want Guard to automatically start up again, run guard in a
+## shell loop, e.g.:
+##
+##  $ while bundle exec guard; do echo "Restarting Guard..."; done
+##
+## Note: if you are using the `directories` clause above and you are not
+## watching the project directory ('.'), then you will want to move
+## the Guardfile to a watched dir and symlink it back, e.g.
+#
+#  $ mkdir config
+#  $ mv Guardfile config/
+#  $ ln -s config/Guardfile .
+#
+# and, you'll have to watch "config/Guardfile" instead of "Guardfile"
+
+# Note: The cmd option is now required due to the increasing number of ways
+#       rspec may be run, below are examples of the most common uses.
+#  * bundler: 'bundle exec rspec'
+#  * bundler binstubs: 'bin/rspec'
+#  * spring: 'bin/rspec' (This will use spring if running and you have
+#                          installed the spring binstubs per the docs)
+#  * zeus: 'zeus rspec' (requires the server to be started separately)
+#  * 'just' rspec: 'rspec'
+
+guard :rspec, cmd: "bundle exec rspec" do
+  require "guard/rspec/dsl"
+  dsl = Guard::RSpec::Dsl.new(self)
+
+  # RSpec files
+  rspec = dsl.rspec
+  watch(rspec.spec_helper) { rspec.spec_dir }
+  watch(rspec.spec_support) { rspec.spec_dir }
+  watch(rspec.spec_files)
+
+  # Ruby files
+  ruby = dsl.ruby
+  dsl.watch_spec_files_for(ruby.lib_files)
+end

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Greg Beech
+
+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/README.md

@@ -1,6 +1,6 @@
 # Xenon
 
-An HTTP framework for building RESTful APIs, inspired by [Spray](http://spray.io).
+An HTTP framework for building RESTful APIs, inspired by [Spray][spray].
 
 ## Installation
 
@@ -27,3 +27,6 @@ At the moment I probably wouldn't use this gem for anything you actually depend
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)
 5. Create a new Pull Request
+
+
+[spray]: http://spray.io/ "spray"

data/lib/xenon.rb

@@ -1,5 +1,240 @@
-require "xenon/version"
+require 'json'
+require 'rack'
+require 'active_support/core_ext/string'
+require 'xenon/headers'
+require 'xenon/routing'
+require 'xenon/version'
 
 module Xenon
-  # Your code goes here...
+
+  class Rejection
+    ACCEPT = 'ACCEPT'
+    HEADER = 'HEADER'
+    METHOD = 'METHOD'
+
+    attr_reader :reason, :info
+
+    def initialize(reason, info = {})
+      @reason = reason
+      @info = info
+    end
+
+    def [](name)
+      @info[name]
+    end
+  end
+
+  class Request
+    attr_accessor :unmatched_path
+
+    def initialize(rack_req)
+      @rack_req = rack_req
+      @unmatched_path = rack_req.path
+      freeze
+    end
+
+    def request_method
+      @rack_req.request_method.downcase.to_sym
+    end
+
+    def form_hash
+      @rack_req.POST
+    end
+
+    def query_hash
+      @rack_req.GET
+    end
+
+    def header(name)
+      snake_name = name.to_s.tr('-', '_')
+      value = @rack_req.env['HTTP_' + snake_name.upcase]
+      return nil if value.nil?
+
+      klass = Xenon::Headers.header_class(name)
+      klass ? klass.parse(value) : Xenon::Headers::Raw.new(name, value)
+    end
+
+    def copy(changes = {})
+      r = dup
+      changes.each { |k, v| r.instance_variable_set("@#{k}", v) }
+      r.freeze
+    end
+
+    def freeze
+      @unmatched_path.freeze
+      super
+    end
+  end
+
+  class Response
+    attr_reader :status, :headers, :body
+
+    def initialize
+      @headers = Headers.new
+      @complete = false
+      freeze
+    end
+
+    def complete?
+      @complete
+    end
+
+    def copy(changes = {})
+      r = dup
+      changes.each { |k, v| r.instance_variable_set("@#{k}", v) }
+      r.freeze
+    end
+
+    def freeze
+      @headers.freeze
+      @body.freeze
+      super
+    end
+
+    def self.error(status, developer_message = nil)
+      body = { 
+        status: status, 
+        developer_message: developer_message || Rack::Utils::HTTP_STATUS_CODES[status]
+      }
+      Response.new.copy(complete: true, status: status, body: body)
+    end
+  end
+
+  class Context
+    attr_accessor :request, :response, :rejections
+
+    def initialize(request, response)
+      @request = request
+      @response = response
+      @rejections = []
+    end
+
+    def branch
+      original_request = @request
+      original_response = @response
+      yield
+    ensure
+      @request = original_request
+      @response = original_response unless @response.complete?
+    end
+  end
+
+  class JsonMarshaller
+    def media_type
+      MediaType::JSON
+    end
+
+    def content_type
+      media_type.with_charset(Encoding::UTF_8)
+    end
+
+    def marshal_to?(media_range)
+      media_range =~ media_type
+    end
+
+    def marshal(obj)
+      [obj.to_json]
+    end
+  end
+
+  class XmlMarshaller
+    def media_type
+      MediaType::XML
+    end
+
+    def content_type
+      media_type.with_charset(Encoding::UTF_8)
+    end
+
+    def marshal_to?(media_range)
+      media_range =~ media_type
+    end
+
+    def marshal(obj)
+      raise "#{obj.class} does not support #to_xml" unless obj.respond_to?(:to_xml)
+      [obj.to_xml]
+    end
+  end
+
+  class Api
+    include Xenon::Routing::Directives
+
+    DEFAULT_MARSHALLERS = [JsonMarshaller.new]
+
+    class << self
+      def marshallers(*marshallers)
+        @marshallers = marshallers unless marshallers.nil? || marshallers.empty?
+        (@marshallers.nil? || @marshallers.empty?) ? DEFAULT_MARSHALLERS : @marshallers
+      end
+
+      def select_marshaller(media_ranges)
+        weighted = marshallers.sort_by do |m|
+          media_range = media_ranges.find { |mr| m.marshal_to?(mr) }
+          media_range ? media_range.q : 0.0
+        end
+        weighted.last
+      end
+    end
+
+    attr_reader :context
+
+    def route
+      raise NotImplementedError.new
+    end
+
+    def call(env)
+      dup.call!(env)
+    end
+
+    def call!(env)
+      @context = Context.new(Request.new(Rack::Request.new(env)), Response.new)
+
+      accept = @context.request.header('Accept')
+      marshaller = accept ? self.class.select_marshaller(accept.media_ranges) : self.class.marshallers.first
+      begin
+        if marshaller.nil?
+          @context.rejections << Rejection.new(Rejection::ACCEPT, { supported: self.class.marshallers.map(&:media_type) })
+        else
+          catch (:complete) { route }
+        end
+        @context.response = handle_rejections(@context.rejections) unless @context.response.complete?
+      rescue => e
+        @context.response = handle_error(e)
+      end
+      @context.response = Response.error(501, 'The response was not completed') unless @context.response.complete?
+
+      marshaller ||= self.class.marshallers.first
+      resp = @context.response.copy(
+        headers: @context.response.headers.set(Headers::ContentType.new(marshaller.content_type)),
+        body: marshaller.marshal(@context.response.body))
+      [resp.status, resp.headers.map { |h| [h.name, h.to_s] }.to_h, resp.body]
+    end
+
+    def handle_error(e)
+      puts "handle_error: #{e}"
+      @context.response = Response.error(500)
+    end
+
+    def handle_rejections(rejections)
+      puts "handle_rejections: #{rejections}"
+      if rejections.empty?
+        Response.error(404)
+      else
+        rejection = rejections.first
+        case rejection.reason
+        when Rejection::ACCEPT
+          Response.error(406, "Supported media types: #{rejection[:supported].join(", ")}")
+        when Rejection::HEADER
+          Response.error(400, "Missing required header: #{rejection[:required]}")
+        when Rejection::METHOD
+          supported = rejections.take_while { |r| r.reason == Rejection::METHOD }.map { |r| r[:supported].upcase }
+          Response.error(405, "Supported methods: #{supported.join(", ")}")
+        else 
+          Response.error(500)
+        end
+      end
+    end
+
+  end
+
 end

data/lib/xenon/errors.rb

@@ -0,0 +1,4 @@
+module Xenon
+  class Error < StandardError; end
+  class ParseError < Error; end
+end

data/lib/xenon/headers.rb

@@ -0,0 +1,114 @@
+require 'active_support/core_ext/string'
+
+module Xenon
+  class Headers
+    include Enumerable
+
+    def initialize
+      @hash = {}
+    end
+
+    def initialize_dup(other)
+      super
+      @hash = @hash.dup
+    end
+
+    def freeze
+      @hash.freeze
+      super
+    end
+
+    def each(&block)
+      @hash.values.each(&block)
+    end
+
+    def set!(header)
+      @hash[header.name] = header
+      self
+    end
+
+    def add!(header)
+      existing = @hash[header.name]
+      if existing
+        if existing.respond_to?(:merge)
+          set!(existing.merge(header))
+        else
+          raise "Unmergeable header '#{header.name}' already exists"
+        end
+      else
+        set!(header)
+      end
+      self
+    end
+
+    %i(set add).each do |name|
+      define_method name do |header|
+        dup.send("#{name}!", header)
+      end
+    end
+
+    alias_method :<<, :add!
+
+    class << self
+      def register(klass)
+        (@registered ||= {})[klass.const_get(:NAME)] = klass
+      end
+
+      def header_class(name)
+        (@registered || {})[name]
+      end
+
+      def Header(name)
+        klass = Class.new do
+          def name
+            self.class.const_get(:NAME)
+          end
+
+          def self.inherited(base)
+            Headers.register(base)
+          end
+        end
+        Headers.const_set("#{name.tr('-', '_').classify}Header", klass)
+        klass.const_set(:NAME, name)
+        klass
+      end
+
+      def ListHeader(name)
+        klass = Header(name)
+        klass.class_eval do
+          attr_reader :values
+
+          def initialize(values)
+            @values = values
+          end
+
+          def merge(other)
+            self.class.new(*(@values + other.values))
+          end
+
+          def to_s
+            @values.map(&:to_s).join(', ')
+          end
+        end
+        klass
+      end
+    end
+
+    class Raw
+      attr_reader :name, :value
+
+      def initialize(name, value)
+        @name = name
+        @value = value
+      end
+
+      def to_s
+        @value
+      end
+    end
+
+    [:Accept, :AcceptCharset, :AcceptEncoding, :CacheControl, :ContentType].each do |sym|
+      autoload sym, "xenon/headers/#{sym.to_s.underscore}"
+    end
+  end
+end