RubyGems - goofy - Versions diffs - 1.0.2 - Mend

goofy 1.0.2

Files changed (85) hide show

checksums.yaml +7 -0
data/.gems +4 -0
data/.gitignore +2 -0
data/CHANGELOG +47 -0
data/CONTRIBUTING +19 -0
data/Gemfile +4 -0
data/LICENSE +23 -0
data/README.md +67 -0
data/app/.rspec +2 -0
data/app/Gemfile +13 -0
data/app/app/controllers/application_controller.rb +3 -0
data/app/app/services/.keep +0 -0
data/app/config.ru +4 -0
data/app/config/environment.rb +9 -0
data/app/config/initializers/.keep +0 -0
data/app/config/routes.rb +7 -0
data/app/config/settings.rb +0 -0
data/app/spec/helpers.rb +2 -0
data/app/spec/helpers/goofy.rb +11 -0
data/app/spec/spec_helper.rb +107 -0
data/benchmark/measure.rb +35 -0
data/bin/check_its_goofy.rb +15 -0
data/bin/goofy +61 -0
data/bin/goofy_generator.rb +357 -0
data/bin/goofy_instance_creator.rb +40 -0
data/examples/config.ru +18 -0
data/examples/measure.rb +17 -0
data/examples/rack-response.ru +21 -0
data/examples/views/home.mote +7 -0
data/examples/views/layout.mote +11 -0
data/goofy.gemspec +26 -0
data/lib/goofy.rb +405 -0
data/lib/goofy/capybara.rb +13 -0
data/lib/goofy/controller.rb +14 -0
data/lib/goofy/controller/base.rb +21 -0
data/lib/goofy/controller/callbacks.rb +19 -0
data/lib/goofy/render.rb +63 -0
data/lib/goofy/router.rb +9 -0
data/lib/goofy/safe.rb +23 -0
data/lib/goofy/safe/csrf.rb +47 -0
data/lib/goofy/safe/secure_headers.rb +40 -0
data/lib/goofy/test.rb +11 -0
data/makefile +4 -0
data/test/accept.rb +32 -0
data/test/captures.rb +162 -0
data/test/composition.rb +69 -0
data/test/controller.rb +29 -0
data/test/cookie.rb +34 -0
data/test/csrf.rb +139 -0
data/test/extension.rb +21 -0
data/test/helper.rb +11 -0
data/test/host.rb +29 -0
data/test/integration.rb +114 -0
data/test/match.rb +86 -0
data/test/middleware.rb +46 -0
data/test/number.rb +36 -0
data/test/on.rb +157 -0
data/test/param.rb +66 -0
data/test/path.rb +86 -0
data/test/plugin.rb +68 -0
data/test/rack.rb +22 -0
data/test/redirect.rb +21 -0
data/test/render.rb +128 -0
data/test/root.rb +83 -0
data/test/run.rb +23 -0
data/test/safe.rb +74 -0
data/test/segment.rb +45 -0
data/test/session.rb +21 -0
data/test/settings.rb +52 -0
data/test/views/about.erb +1 -0
data/test/views/about.str +1 -0
data/test/views/content-yield.erb +1 -0
data/test/views/custom/abs_path.mote +1 -0
data/test/views/frag.mote +1 -0
data/test/views/home.erb +2 -0
data/test/views/home.mote +1 -0
data/test/views/home.str +2 -0
data/test/views/layout-alternative.erb +2 -0
data/test/views/layout-yield.erb +3 -0
data/test/views/layout.erb +2 -0
data/test/views/layout.mote +2 -0
data/test/views/layout.str +2 -0
data/test/views/test.erb +1 -0
data/test/with.rb +42 -0
metadata +271 -0

@@ -0,0 +1,7 @@
+This is the body
+<ul>
+  % list.each do |e|
+    <li>{{ e }}</li>
+  % end
+</ul>

data/examples/views/layout.mote ADDED

@@ -0,0 +1,11 @@
+<html>
+  <head>
+    <meta charset="utf-8">
+    <title>Home</title>
+  </head>
+  <body>
+    {{ content }}
+  </body>
+</html>

data/goofy.gemspec ADDED

@@ -0,0 +1,26 @@
+Gem::Specification.new do |s|
+  s.name              = "goofy"
+  s.version           = "1.0.2"
+  s.summary           = "Microframework for web applications"
+  s.description       = "Goofy is a microframework for web applications(heavily based on Cuba)."
+  s.authors           = ["Ehsan Yousefi"]
+  s.email             = ["ehsan.yousefi@live.com"]
+  s.homepage          = "https://github.com/EhsanYousefi/goofy"
+  s.license           = "MIT"
+  s.files = `git ls-files`.split("\n")
+  s.require_paths = ["lib"]
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.add_dependency "rack", "~> 1.6.0"
+  s.add_dependency "prong", '~> 1.0'
+  s.add_dependency "require_all"
+  s.add_dependency "psych"
+  s.add_dependency "wisper"
+  s.add_dependency "racksh"
+  s.add_dependency "shotgun"
+  s.add_development_dependency "cutest"
+  s.add_development_dependency "rack-test"
+  s.add_development_dependency "tilt"
+end

data/lib/goofy.rb ADDED

@@ -0,0 +1,405 @@
+require "rack"
+require "time"
+class Goofy
+  SLASH   = "/".freeze
+  EMPTY   = "".freeze
+  SEGMENT = "([^\\/]+)".freeze
+  DEFAULT = "text/html; charset=utf-8".freeze
+  class Response
+    LOCATION = "Location".freeze
+    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
+    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, &block)
+    app.use(middleware, *args, &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 Goofy.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(/\A\/(#{pattern})(\/|\z)/)
+    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[key] || 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 delete; req.delete? end
+  # If you want to halt the processing of an existing handler
+  # and continue it via a different handler.
+  #
+  # @example
+  #   def redirect(*args)
+  #     run Goofy.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 Goofy 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 < Goofy
+  #     define do
+  #       platform = vars[:platform]
+  #
+  #       on default do
+  #         res.write(platform) # => "heroku" or "salesforce"
+  #       end
+  #     end
+  #   end
+  #
+  #   Goofy.define do
+  #     on "(heroku|salesforce)" do |platform|
+  #       with(platform: platform) do
+  #         run(Platforms)
+  #       end
+  #     end
+  #   end
+  #
+  def with(dict = {})
+    old, env["Goofy.vars"] = vars, vars.merge(dict)
+    yield
+  ensure
+    env["Goofy.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["Goofy.vars"] ||= {}
+  end
+  def not_found
+    res.status = 404
+  end
+end
+Goofy.settings[:req] = Rack::Request
+Goofy.settings[:res] = Goofy::Response
+Goofy.settings[:default_headers] = {}