nano-sharp-gem 0.0.1

data/cuba-4.0.3/lib/cuba.rb

@@ -0,0 +1,436 @@
+require "delegate"
+require "rack"
+require "rack/session"
+
+class Cuba
+  SLASH   = "/".freeze
+  EMPTY   = "".freeze
+  SEGMENT = "([^\\/]+)".freeze
+  DEFAULT = "text/html; charset=utf-8".freeze
+  REGEXES = Hash.new { |h, pattern| h[pattern] = /\A\/(#{pattern})(\/|\z)/ }
+
+  class Response
+    LOCATION = "location".freeze
+
+    module ContentType
+      HTML = "text/html".freeze        # :nodoc:
+      TEXT = "text/plain".freeze       # :nodoc:
+      JSON = "application/json".freeze # :nodoc:
+    end
+
+    attr_accessor :status
+
+    attr :body
+    attr :headers
+
+    def initialize(headers = {})
+      @status  = nil
+      @headers = headers
+      @body    = []
+      @length  = 0
+    end
+
+    def [](key)
+      @headers[key]
+    end
+
+    def []=(key, value)
+      @headers[key] = value
+    end
+
+    def write(str)
+      s = str.to_s
+
+      @length += s.bytesize
+      @headers[Rack::CONTENT_LENGTH] = @length.to_s
+      @body << s
+    end
+
+    # Write response body as text/plain
+    def text(str)
+      @headers[Rack::CONTENT_TYPE] = ContentType::TEXT
+      write(str)
+    end
+
+    # Write response body as text/html
+    def html(str)
+      @headers[Rack::CONTENT_TYPE] = ContentType::HTML
+      write(str)
+    end
+
+    # Write response body as application/json
+    def json(str)
+      @headers[Rack::CONTENT_TYPE] = ContentType::JSON
+      write(str)
+    end
+
+    def redirect(path, status = 302)
+      @headers[LOCATION] = path
+      @status  = status
+    end
+
+    def finish
+      [@status, @headers, @body]
+    end
+
+    def set_cookie(key, value)
+      Rack::Utils.set_cookie_header!(@headers, key, value)
+    end
+
+    def delete_cookie(key, value = {})
+      Rack::Utils.delete_cookie_header!(@headers, key, value)
+    end
+  end
+
+  def self.reset!
+    @app = nil
+    @prototype = nil
+  end
+
+  def self.app
+    @app ||= Rack::Builder.new
+  end
+
+  def self.use(middleware, *args, **kwargs, &block)
+    app.use(middleware, *args, **kwargs, &block)
+  end
+
+  def self.define(&block)
+    app.run new(&block)
+  end
+
+  def self.prototype
+    @prototype ||= app.to_app
+  end
+
+  def self.call(env)
+    prototype.call(env)
+  end
+
+  def self.plugin(mixin)
+    include mixin
+    extend  mixin::ClassMethods if defined?(mixin::ClassMethods)
+
+    mixin.setup(self) if mixin.respond_to?(:setup)
+  end
+
+  def self.settings
+    @settings ||= {}
+  end
+
+  def self.deepclone(obj)
+    Marshal.load(Marshal.dump(obj))
+  end
+
+  def self.inherited(child)
+    child.settings.replace(deepclone(settings))
+  end
+
+  attr :env
+  attr :req
+  attr :res
+  attr :captures
+
+  def initialize(&blk)
+    @blk = blk
+    @captures = []
+  end
+
+  def settings
+    self.class.settings
+  end
+
+  def call(env)
+    dup.call!(env)
+  end
+
+  def call!(env)
+    @env = env
+    @req = settings[:req].new(env)
+    @res = settings[:res].new(settings[:default_headers].dup)
+
+    # This `catch` statement will either receive a
+    # rack response tuple via a `halt`, or will
+    # fall back to issuing a 404.
+    #
+    # When it `catch`es a throw, the return value
+    # of this whole `call!` method will be the
+    # rack response tuple, which is exactly what we want.
+    catch(:halt) do
+      instance_eval(&@blk)
+
+      not_found
+      res.finish
+    end
+  end
+
+  def session
+    env["rack.session"] || raise(RuntimeError,
+      "You're missing a session handler. You can get started " +
+      "by adding Cuba.use Rack::Session::Cookie")
+  end
+
+  # The heart of the path / verb / any condition matching.
+  #
+  # @example
+  #
+  #   on get do
+  #     res.write "GET"
+  #   end
+  #
+  #   on get, "signup" do
+  #     res.write "Signup"
+  #   end
+  #
+  #   on "user/:id" do |uid|
+  #     res.write "User: #{uid}"
+  #   end
+  #
+  #   on "styles", extension("css") do |file|
+  #     res.write render("styles/#{file}.sass")
+  #   end
+  #
+  def on(*args, &block)
+    try do
+      # For every block, we make sure to reset captures so that
+      # nesting matchers won't mess with each other's captures.
+      @captures = []
+
+      # We stop evaluation of this entire matcher unless
+      # each and every `arg` defined for this matcher evaluates
+      # to a non-false value.
+      #
+      # Short circuit examples:
+      #    on true, false do
+      #
+      #    # PATH_INFO=/user
+      #    on true, "signup"
+      return unless args.all? { |arg| match(arg) }
+
+      # The captures we yield here were generated and assembled
+      # by evaluating each of the `arg`s above. Most of these
+      # are carried out by #consume.
+      yield(*captures)
+
+      if res.status.nil?
+        if res.body.empty?
+          not_found
+        else
+          res.headers[Rack::CONTENT_TYPE] ||= DEFAULT
+          res.status = 200
+        end
+      end
+
+      halt(res.finish)
+    end
+  end
+
+  # @private Used internally by #on to ensure that SCRIPT_NAME and
+  #          PATH_INFO are reset to their proper values.
+  def try
+    script, path = env[Rack::SCRIPT_NAME], env[Rack::PATH_INFO]
+
+    yield
+
+  ensure
+    env[Rack::SCRIPT_NAME], env[Rack::PATH_INFO] = script, path
+  end
+  private :try
+
+  def consume(pattern)
+    matchdata = env[Rack::PATH_INFO].match(REGEXES[pattern])
+
+    return false unless matchdata
+
+    path, *vars = matchdata.captures
+
+    env[Rack::SCRIPT_NAME] += "/#{path}"
+    env[Rack::PATH_INFO] = "#{vars.pop}#{matchdata.post_match}"
+
+    captures.push(*vars)
+  end
+  private :consume
+
+  def match(matcher, segment = SEGMENT)
+    case matcher
+    when String then consume(matcher.gsub(/:\w+/, segment))
+    when Regexp then consume(matcher)
+    when Symbol then consume(segment)
+    when Proc   then matcher.call
+    else
+      matcher
+    end
+  end
+
+  # A matcher for files with a certain extension.
+  #
+  # @example
+  #   # PATH_INFO=/style/app.css
+  #   on "style", extension("css") do |file|
+  #     res.write file # writes app
+  #   end
+  def extension(ext = "\\w+")
+    lambda { consume("([^\\/]+?)\.#{ext}\\z") }
+  end
+
+  # Ensures that certain request parameters are present. Acts like a
+  # precondition / assertion for your route. A default value can be
+  # provided as a second argument. In that case, it always matches
+  # and the result is either the parameter or the default value.
+  #
+  # @example
+  #   # POST with data like user[fname]=John&user[lname]=Doe
+  #   on "signup", param("user") do |atts|
+  #     User.create(atts)
+  #   end
+  #
+  #   on "login", param("username", "guest") do |username|
+  #     # If not provided, username == "guest"
+  #   end
+  def param(key, default = nil)
+    value = req.params[key.to_s] || default
+
+    lambda { captures << value unless value.to_s.empty? }
+  end
+
+  # Useful for matching against the request host (i.e. HTTP_HOST).
+  #
+  # @example
+  #   on host("account1.example.com"), "api" do
+  #     res.write "You have reached the API of account1."
+  #   end
+  def host(hostname)
+    hostname === req.host
+  end
+
+  # If you want to match against the HTTP_ACCEPT value.
+  #
+  # @example
+  #   # HTTP_ACCEPT=application/xml
+  #   on accept("application/xml") do
+  #     # automatically set to application/xml.
+  #     res.write res["Content-Type"]
+  #   end
+  def accept(mimetype)
+    lambda do
+      accept = String(env["HTTP_ACCEPT"]).split(",")
+
+      if accept.any? { |s| s.strip == mimetype }
+        res[Rack::CONTENT_TYPE] = mimetype
+      end
+    end
+  end
+
+  # Syntactic sugar for providing catch-all matches.
+  #
+  # @example
+  #   on default do
+  #     res.write "404"
+  #   end
+  def default
+    true
+  end
+
+  # Access the root of the application.
+  #
+  # @example
+  #
+  #   # GET /
+  #   on root do
+  #     res.write "Home"
+  #   end
+  def root
+    env[Rack::PATH_INFO] == SLASH || env[Rack::PATH_INFO] == EMPTY
+  end
+
+  # Syntatic sugar for providing HTTP Verb matching.
+  #
+  # @example
+  #   on get, "signup" do
+  #   end
+  #
+  #   on post, "signup" do
+  #   end
+  def get;     req.get?     end
+  def post;    req.post?    end
+  def put;     req.put?     end
+  def patch;   req.patch?   end
+  def delete;  req.delete?  end
+  def head;    req.head?    end
+  def options; req.options? end
+  def link;    req.link?    end
+  def unlink;  req.unlink?  end
+  def trace;   req.trace?   end
+
+  # If you want to halt the processing of an existing handler
+  # and continue it via a different handler.
+  #
+  # @example
+  #   def redirect(*args)
+  #     run Cuba.new { on(default) { res.redirect(*args) }}
+  #   end
+  #
+  #   on "account" do
+  #     redirect "/login" unless session["uid"]
+  #
+  #     res.write "Super secure account info."
+  #   end
+  def run(app)
+    halt app.call(req.env)
+  end
+
+  def halt(response)
+    throw :halt, response
+  end
+
+  # Adds ability to pass information to a nested Cuba application.
+  # It receives two parameters: a hash that represents the passed
+  # information and a block. The #vars method is used to retrieve
+  # a hash with the passed information.
+  #
+  #   class Platforms < Cuba
+  #     define do
+  #       platform = vars[:platform]
+  #
+  #       on default do
+  #         res.write(platform) # => "heroku" or "salesforce"
+  #       end
+  #     end
+  #   end
+  #
+  #   Cuba.define do
+  #     on "(heroku|salesforce)" do |platform|
+  #       with(platform: platform) do
+  #         run(Platforms)
+  #       end
+  #     end
+  #   end
+  #
+  def with(dict = {})
+    old, env["cuba.vars"] = vars, vars.merge(dict)
+    yield
+  ensure
+    env["cuba.vars"] = old
+  end
+
+  # Returns a hash with the information set by the #with method.
+  #
+  #   with(role: "admin", site: "main") do
+  #     on default do
+  #       res.write(vars.inspect)
+  #     end
+  #   end
+  #   # => '{:role=>"admin", :site=>"main"}'
+  #
+  def vars
+    env["cuba.vars"] ||= {}
+  end
+
+  def not_found
+    res.status = 404
+  end
+end
+
+Cuba.settings[:req] = Rack::Request
+Cuba.settings[:res] = Cuba::Response
+Cuba.settings[:default_headers] = {}

data/cuba-4.0.3/makefile

@@ -0,0 +1,4 @@
+.PHONY: test
+
+test:
+	cutest ./test/*.rb

data/cuba-4.0.3/test/accept.rb

@@ -0,0 +1,77 @@
+require File.expand_path("helper", File.dirname(__FILE__))
+
+test "accept mimetypes" do
+  Cuba.define do
+    on accept("application/xml") do
+      res.write res["content-type"]
+    end
+  end
+
+  env = { "HTTP_ACCEPT" => "application/xml",
+          "SCRIPT_NAME" => "/", "PATH_INFO" => "/post" }
+
+   _, _, body = Cuba.call(env)
+
+  assert_response body, ["application/xml"]
+end
+
+test "tests don't fail when you don't specify an accept type" do
+  Cuba.define do
+    on accept("application/xml") do
+      res.write res["Content-Type"]
+    end
+
+    on default do
+      res.write "Default action"
+    end
+  end
+
+  _, _, body = Cuba.call({})
+
+  assert_response body, ["Default action"]
+end
+
+test "accept HTML mimetype" do
+  Cuba.define do
+    on accept("text/html") do
+      res.write Cuba::Response::ContentType::HTML
+    end
+  end
+
+  env = { "HTTP_ACCEPT" => "text/html",
+          "SCRIPT_NAME" => "/", "PATH_INFO" => "/post" }
+
+   _, _, body = Cuba.call(env)
+
+  assert_response body, ["text/html"]
+end
+
+test "accept TEXT mimetype" do
+  Cuba.define do
+    on accept("text/plain") do
+      res.write Cuba::Response::ContentType::TEXT
+    end
+  end
+
+  env = { "HTTP_ACCEPT" => "text/plain",
+          "SCRIPT_NAME" => "/", "PATH_INFO" => "/post" }
+
+   _, _, body = Cuba.call(env)
+
+  assert_response body, ["text/plain"]
+end
+
+test "accept JSON mimetype" do
+  Cuba.define do
+    on accept("application/json") do
+      res.write Cuba::Response::ContentType::JSON
+    end
+  end
+
+  env = { "HTTP_ACCEPT" => "application/json",
+          "SCRIPT_NAME" => "/", "PATH_INFO" => "/get" }
+
+   _, _, body = Cuba.call(env)
+
+  assert_response body, ["application/json"]
+end

data/cuba-4.0.3/test/captures.rb

@@ -0,0 +1,162 @@
+require File.expand_path("helper", File.dirname(__FILE__))
+
+test "doesn't yield HOST" do
+  Cuba.define do
+    on host("example.com") do |*args|
+      res.write args.size
+    end
+  end
+
+  env = { "HTTP_HOST" => "example.com" }
+
+  _, _, resp = Cuba.call(env)
+
+  assert_response resp, ["0"]
+end
+
+test "doesn't yield the verb" do
+  Cuba.define do
+    on get do |*args|
+      res.write args.size
+    end
+  end
+
+  env = { "REQUEST_METHOD" => "GET" }
+
+  _, _, resp = Cuba.call(env)
+
+  assert_response resp, ["0"]
+end
+
+test "doesn't yield the path" do
+  Cuba.define do
+    on get, "home" do |*args|
+      res.write args.size
+    end
+  end
+
+  env = { "REQUEST_METHOD" => "GET", "PATH_INFO" => "/home",
+          "SCRIPT_NAME" => "/" }
+
+  _, _, resp = Cuba.call(env)
+
+  assert_response resp, ["0"]
+end
+
+test "yields the segment" do
+  Cuba.define do
+    on get, "user", :id do |id|
+      res.write id
+    end
+  end
+
+  env = { "REQUEST_METHOD" => "GET", "PATH_INFO" => "/user/johndoe",
+          "SCRIPT_NAME" => "/" }
+
+  _, _, resp = Cuba.call(env)
+
+  assert_response resp, ["johndoe"]
+end
+
+test "yields a number" do
+  Cuba.define do
+    on get, "user", :id do |id|
+      res.write id
+    end
+  end
+
+  env = { "REQUEST_METHOD" => "GET", "PATH_INFO" => "/user/101",
+          "SCRIPT_NAME" => "/" }
+
+  _, _, resp = Cuba.call(env)
+
+  assert_response resp, ["101"]
+end
+
+test "yield a file name with a matching extension" do
+  Cuba.define do
+    on get, "css", extension("css") do |file|
+      res.write file
+    end
+  end
+
+  env = { "REQUEST_METHOD" => "GET", "PATH_INFO" => "/css/app.css",
+          "SCRIPT_NAME" => "/" }
+
+  _, _, resp = Cuba.call(env)
+
+  assert_response resp, ["app"]
+end
+
+test "yields a segment per nested block" do
+  Cuba.define do
+    on :one do |one|
+      on :two do |two|
+        on :three do |three|
+          res.write one
+          res.write two
+          res.write three
+        end
+      end
+    end
+  end
+
+  env = { "REQUEST_METHOD" => "GET", "PATH_INFO" => "/one/two/three",
+          "SCRIPT_NAME" => "/" }
+
+  _, _, resp = Cuba.call(env)
+
+  assert_response resp, ["one", "two", "three"]
+end
+
+test "consumes a slash if needed" do
+  Cuba.define do
+    on get, "(.+\\.css)" do |file|
+      res.write file
+    end
+  end
+
+  env = { "REQUEST_METHOD" => "GET", "PATH_INFO" => "/foo/bar.css",
+          "SCRIPT_NAME" => "/" }
+
+  _, _, resp = Cuba.call(env)
+
+  assert_response resp, ["foo/bar.css"]
+end
+
+test "regex captures in string format" do
+  Cuba.define do
+    on get, "posts/(\\d+)-(.*)" do |id, slug|
+      res.write id
+      res.write slug
+    end
+  end
+
+
+  env = { "REQUEST_METHOD" => "GET",
+          "PATH_INFO" => "/posts/123-postal-service",
+          "SCRIPT_NAME" => "/" }
+
+  _, _, resp = Cuba.call(env)
+
+
+  assert_response resp, ["123", "postal-service"]
+end
+
+test "regex captures in regex format" do
+  Cuba.define do
+    on get, %r{posts/(\d+)-(.*)} do |id, slug|
+      res.write id
+      res.write slug
+    end
+  end
+
+  env = { "REQUEST_METHOD" => "GET",
+          "PATH_INFO" => "/posts/123-postal-service",
+          "SCRIPT_NAME" => "/" }
+
+  _, _, resp = Cuba.call(env)
+
+
+  assert_response resp, ["123", "postal-service"]
+end