fastr 0.0.1

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Chris Moos
+
+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.rdoc

@@ -0,0 +1,17 @@
+= fastr
+
+Description goes here.
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2010 Chris Moos. See LICENSE for details.

data/bin/fastr

@@ -0,0 +1,96 @@
+#!/usr/bin/env ruby
+
+require 'fileutils'
+
+if ARGV.size == 0
+  Fastr.usage
+  exit(0)
+end
+
+module Fastr
+  def self.init_app(app_name)
+    if File.directory? app_name
+      puts "directory already exists"
+      exit(0)
+    end
+    
+    # Directory Structre
+
+    dirs = ['app/config', 'app/controllers', 'app/views', 'app/models', 'lib', 'test']
+    dirs.each do |dir| 
+      FileUtils.mkdir_p("#{app_name}/#{dir}")
+    end 
+
+    # Default Routes
+    File.open("#{app_name}/app/config/routes.rb", "w") do |f|
+      f.write("router.draw do |route|\n")
+      f.write("\troute.for '/:controller/:action'\n")
+      f.write("\t#route.for '/home/:action', :action => '[A-Za-z]+'\n")
+      f.write("\t#route.for '/test', :to => 'home#index'\n")
+      f.write("end")
+      f.close
+    end
+
+    # Rack file
+    File.open("#{app_name}/config.ru", "w") do |f|
+      f.puts("require 'fastr'")
+      f.puts("EM.kqueue = true # OS X")
+      f.puts("fastrApp = Fastr::Application.new(File.expand_path(File.dirname(__FILE__)))")
+      f.puts("app = lambda { |env|")
+      f.puts("\tfastrApp.dispatch(env)")
+      f.puts("}")
+      f.puts("run app")
+      f.close
+    end
+    
+    # Gemfile
+    File.open("#{app_name}/Gemfile", 'a') do |f|
+      f.puts "source :gemcutter"
+
+      f.puts "gem 'jeweler'"
+      f.puts "gem 'eventmachine'"
+      f.puts "gem 'haml'"
+      f.puts "\ngem 'fastr'"
+      f.close
+    end
+    
+    puts "#{app_name} initialized!"
+  end
+  
+  def self.usage
+    puts "Initialize a fastr application."
+    puts "Usage: fastr [init name] [generate controller name]"
+  end
+end
+
+command = ARGV[0]
+
+if command == 'init' and ARGV.length == 2
+  Fastr.init_app(ARGV[1])
+elsif command == 'generate' and ARGV.length > 2
+  what = ARGV[1]
+  if what == 'controller' and ARGV.length == 3
+    name = ARGV[2]
+    path = "app/controllers/#{name}_controller.rb"
+    if File.exists? path
+      puts "Controller already exists."
+      exit(0)
+    end
+    
+    puts "Creating controller: #{path}"
+    File.open(path, "w") do |f|
+      f.puts("class #{name.capitalize}Controller < Fastr::Controller")
+      f.puts("end")
+      f.close
+    end
+  else
+    puts "unknown generator: #{what}"
+    Fastr usage
+  end
+else
+  puts "Unknown command: #{command}"
+  Fastr.usage
+end
+
+
+

data/lib/fastr/application.rb

@@ -0,0 +1,112 @@
+require 'logger'
+
+module Fastr  
+  class Application
+    include Fastr::Log
+
+    attr_accessor :router, :app_path
+    
+    def initialize(path)
+      self.app_path = path
+      
+      @booting = true
+      boot
+    end
+    
+    def dispatch(env)
+      return [500, {}, "Server Not Ready"] if @booting
+      
+      begin 
+        do_dispatch(env)
+      rescue Exception => e
+        bt = e.backtrace.join("\n")
+        [500, {}, "Exception: #{e}\n\n#{bt}"]
+      end
+    end
+    
+    def do_dispatch(env)
+      path = env['PATH_INFO']
+      
+      log.debug "Checking for routes that match: #{path}"
+      route = router.match(env)
+
+      if route.has_key? :ok
+        vars = route[:ok]        
+        controller = vars[:controller]
+        action = vars[:action]
+        
+        raise Fastr::Error.new("Controller and action not present in route") if controller.nil? or action.nil?
+        
+        
+        klass = "#{controller.capitalize}Controller"
+        
+        log.info "Routing to controller: #{klass}, action: #{action}"
+        
+        obj = Module.const_get(klass).new
+        
+        ret = obj.send(action)
+        
+        #[200, {}, "ok"]
+        ret
+      else
+        [404, {"Content-Type" => "text/plain"}, "404 Not Found: #{path}"]
+      end
+    end
+    
+    private
+    
+    #
+    # This is used to initialize the application.
+    # It runs in a thread because startup depends on EventMachine running
+    #
+    def boot
+      Thread.new do
+        sleep 1 until EM.reactor_running?
+        
+        begin
+          load_app_classes
+          setup_router
+          setup_watcher
+          
+          @booting = false
+        rescue Exception => e
+          log.error "#{e}"
+          puts e.backtrace
+          log.fatal "Exiting due to previous errors..."
+          exit(1)
+        end
+      end
+    end
+    
+    def setup_router
+      self.router = Fastr::Router.new(self)
+      self.router.load
+    end
+  
+    def load_app_classes
+      log.debug "Loading application classes..."
+      Dir["#{self.app_path}/app/controllers/*.rb"].each do |f|
+        log.debug "Loading: #{f}"
+        load(f)
+      end
+    end
+    
+    def setup_watcher
+      this = self
+      Handler.send(:define_method, :app) do 
+        this
+      end
+      
+      Dir["#{self.app_path}/app/controllers/*.rb"].each do |f|
+        EM.watch_file(f, Handler)
+      end
+    end
+    
+    module Handler
+      def file_modified
+        app.log.info "Reloading file: #{path}"
+        load(path)
+      end
+    end
+  end
+end

data/lib/fastr/controller.rb

@@ -0,0 +1,6 @@
+module Fastr
+  class Controller
+    include Fastr::Template
+    
+  end
+end

data/lib/fastr/exception.rb

@@ -0,0 +1,3 @@
+module Fastr
+  class Error < Exception; end
+end

data/lib/fastr/logger.rb

@@ -0,0 +1,27 @@
+require 'logger'
+
+module Fastr
+  module Log    
+    def self.included(kls)
+      logger = Logger.new(STDOUT)
+      logger.level = Logger::DEBUG
+      logger.formatter = Fastr::Log::Formatter.new(kls)
+      define_method :log do
+        logger
+      end
+    end
+        
+    class Formatter < Logger::Formatter
+      attr_accessor :progname
+      
+      def initialize(name)
+        self.progname = name
+      end
+      
+      
+      def call(severity, time, progname, msg)
+        puts "[#{severity}] [#{self.progname}]: #{msg}"
+      end
+    end
+  end
+end

data/lib/fastr/router.rb

@@ -0,0 +1,109 @@
+module Fastr
+  class Router
+    include Fastr::Log
+    
+    attr_accessor :routes, :route_file
+    
+    def initialize(app)
+      @app = app
+      self.routes = []
+      self.route_file = "#{@app.app_path}/app/config/routes.rb"
+      setup_watcher
+    end
+    
+    def match(env)
+      self.routes.each do |info|
+        match = env['PATH_INFO'].match(info[:regex])
+
+        # See if a route matches
+        if not match.nil?
+
+          # Map any parameters in our matched string
+          vars = {}
+          
+          info[:vars].each_index do |i|
+            var = info[:vars][i]
+            vars[var] = match[i+1]
+          end
+
+          return {:ok => vars.merge!(info[:hash]) }
+        end
+      end
+      
+      {:error => :not_found}
+    end
+    
+    def load
+      log.debug "Loading routes from: #{self.route_file}"
+      self.routes = []
+      
+      file = File.open(self.route_file)
+      @app.instance_eval(file.read)
+    end
+    
+    def for(path, *args)
+      arg = args[0]
+      log.debug "Adding route, path: #{path}, args: #{args.inspect}"
+
+      match = get_regex_for_route(path, arg)
+      hash = get_to_hash(arg)
+      
+      self.routes.push({:regex => match[:regex], :args => arg, :vars => match[:vars], :hash => hash})
+    end
+    
+    def draw(&block)
+      block.call(self)
+    end
+    
+    def file_modified
+      puts "changed!"
+    end
+    
+    private 
+    
+    def get_to_hash(args)
+      hash = {}
+      return hash if args.nil?
+      if args.has_key? :to
+        match = args[:to].match(/(\w+)#(\w+)/)
+        hash.merge!(:controller => match[1], :action => match[2]) if not match.nil?
+      end
+      hash
+    end
+    
+    def get_regex_for_route(path, args)
+      vars = []
+      regexRoute = path
+      
+      args = {} if args.nil?
+      
+      path.scan(/:(\w+)/).each do |var|
+        match = '\w+'
+        varName = var[0]
+        
+        if args.has_key? varName.to_sym
+          match = args[varName.to_sym]
+        end
+          regexRoute.gsub!(":#{var}", "(#{match.to_s})")
+        vars.push(varName.to_sym)
+      end
+      {:regex => "^#{regexRoute}$", :vars => vars}
+    end
+    
+    def setup_watcher
+      this = self
+      Handler.send(:define_method, :router) do 
+        this
+      end
+      
+      EM.watch_file(self.route_file, Handler)
+    end
+    
+    module Handler
+      def file_modified
+        router.log.info "Routes changed, reloading."
+        router.load
+      end
+    end
+  end
+end

data/lib/fastr/template.rb

@@ -0,0 +1,46 @@
+require 'haml'
+
+module Fastr
+  module Template
+    @@tpl_cache = {}
+    
+    
+    def self.included(kls)
+      kls.extend(ClassMethods)
+    end
+    
+    module ClassMethods
+      
+    end
+    
+    def render(type, *args)
+      method = "render_#{type}".to_sym
+      if self.respond_to? method
+        self.send(method, args)
+      else  
+        raise Exception.new("No render found for: #{type}")
+      end
+    end
+    
+    def render_text(txt)
+      [200, {"Content-Type" => 'text/plain'}, txt]
+    end
+    
+    def render_haml(args)
+      tpl = args[0][:template]
+      
+      if @@tpl_cache.has_key? tpl
+        haml_engine = @@tpl_cache[tpl]
+      else
+        tpl_data = File.read("app/views/#{tpl}.haml")
+        haml_engine = Haml::Engine.new(tpl_data)
+        @@tpl_cache[tpl] = haml_engine
+      end
+      
+      
+      resp = haml_engine.render
+      
+      [200, {"Content-Type" => "text/html"}, resp]
+    end
+  end
+end

data/lib/fastr.rb

@@ -0,0 +1,10 @@
+module Fastr
+  ROOT = File.expand_path(File.dirname(__FILE__))
+  
+  autoload :Application,      "#{ROOT}/fastr/application"
+  autoload :Log,              "#{ROOT}/fastr/logger"
+  autoload :Router,           "#{ROOT}/fastr/router"
+  autoload :Error,            "#{ROOT}/fastr/exception"
+  autoload :Controller,       "#{ROOT}/fastr/controller"
+  autoload :Template,         "#{ROOT}/fastr/template"
+end

data/test/helper.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'fastr'
+
+class Test::Unit::TestCase
+end

data/test/test_fastr.rb

@@ -0,0 +1,7 @@
+require 'helper'
+
+class TestFastr < Test::Unit::TestCase
+  should "probably rename this file and start testing for real" do
+    flunk "hey buddy, you should probably rename this file and start testing for real"
+  end
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification 
+name: fastr
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Chris Moos
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-05-19 00:00:00 -07:00
+default_executable: fastr
+dependencies: []
+
+description: A fast, micro-framework for Ruby that should be run under EventMachine servers (thin)
+email: chris@tech9computers.com
+executables: 
+- fastr
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- lib/fastr.rb
+- lib/fastr/application.rb
+- lib/fastr/controller.rb
+- lib/fastr/exception.rb
+- lib/fastr/logger.rb
+- lib/fastr/router.rb
+- lib/fastr/template.rb
+- LICENSE
+- README.rdoc
+has_rdoc: true
+homepage: http://github.com/chrismoos/fastr
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Another rack web framework for Ruby.
+test_files: 
+- test/helper.rb
+- test/test_fastr.rb