webink 1.1.4

data/bin/rfcgi

@@ -0,0 +1,112 @@
+require "fcgi"
+require "mmap"
+require "webink/beauty"
+
+def getBinding(cgi,env,params)
+  return binding
+end
+
+script = nil
+fhandle = nil
+control = nil
+pram = nil
+FCGI.each_cgi do |cgi|
+  time = Time.now
+  script = cgi.env_table['SCRIPT_FILENAME']
+  begin
+    pram = CGI::parse(cgi.env_table['QUERY_STRING'].gsub(/\?/, "&"))
+    control = pram['controller'][0]
+    routes = Ink::Beauty.load_routes script
+    fhandle = Mmap.new(routes, "r")
+    Dir.chdir( File.dirname(routes) )
+    control = eval fhandle, getBinding(cgi,cgi.env_table,control) if fhandle
+    fhandle.munmap
+    raise StandardError.new("Routes not matched.") if control.keys.length <= 1
+    
+    control[:get] = pram
+    control[:config] = Ink::Beauty.load_config script
+    control[:time] = time
+    control[:cgi] = cgi
+    if cgi.env_table['REQUEST_METHOD'] == 'POST'
+      control[:post] = Hash.new
+      cgi.params.each do |k,v|
+        if v.is_a? Array
+          control[:post][k] = Array.new
+          v.each do |a|
+            control[:post][k].push (control[:config]["escape_post_data"]) ? CGI::escapeHTML(a) : a
+          end
+          control[:post][k] = control[:post][k].to_s
+        else
+          control[:post][k] = (control[:config]["escape_post_data"]) ? CGI::escapeHTML(v) : v
+        end
+      end
+      pram.each do |k,v|
+        cgi.params[k] = v if not cgi.params.has_key? k
+      end
+    else
+      cgi.params = pram
+    end
+    
+    script = Ink::Beauty.load_init script
+    fhandle = Mmap.new(script, "r")
+    Dir.chdir( File.dirname(script) )
+    eval fhandle, getBinding(cgi,cgi.env_table,control) if fhandle
+    fhandle.munmap
+    
+    
+  rescue LoadError => bang
+    if control and control[:config] and not control[:config]["production"]
+      puts cgi.header({"Location" => "/status-404.html"});
+    else
+      puts cgi.header
+      puts "<hr><b>LoadError:</b>", "<em><pre>", CGI::escapeHTML("#{bang}"), "</pre></em>\n", "<pre>", bang.backtrace.join("\n"), "</pre>"
+    end
+    
+  rescue NotImplementedError => bang
+    if control and control[:config] and not control[:config]["production"]
+      puts cgi.header({"Location" => "/status-500.html"});
+    else
+      puts cgi.header
+      puts "<hr><b>NotImplementedError:</b>", "<em><pre>", CGI::escapeHTML("#{bang}"), "</pre></em>\n", "<pre>", bang.backtrace.join("\n"), "</pre>"
+    end
+    
+  rescue ArgumentError => bang
+    if control and control[:config] and not control[:config]["production"]
+      puts cgi.header({"Location" => "/status-500.html"});
+    else
+      puts cgi.header
+      puts "<hr><b>ArgumentError:</b>", "<em><pre>", CGI::escapeHTML("#{bang}"), "</pre></em>\n", "<pre>", bang.backtrace.join("\n"), "</pre>"
+    end
+    
+  rescue RuntimeError => bang
+    if control and control[:config] and not control[:config]["production"]
+      puts cgi.header({"Location" => "/status-500.html"});
+    else
+      puts cgi.header
+      puts "<hr><b>RuntimeError:</b>", "<em><pre>", CGI::escapeHTML("#{bang}"), "</pre></em>\n", "<pre>", bang.backtrace.join("\n"), "</pre>"
+    end
+  
+  rescue NameError => bang
+    if control and control[:config] and not control[:config]["production"]
+      puts cgi.header({"Location" => "/status-500.html"});
+    else
+      puts cgi.header
+      puts "<hr><b>NameError:</b>", "<em><pre>", CGI::escapeHTML("#{bang}"), "</pre></em>\n", "<pre>", bang.backtrace.join("\n"), "</pre>"
+    end
+    
+  rescue Exception, StandardError => bang
+    if control and control[:config] and not control[:config]["production"]
+      puts cgi.header({"Location" => "/status-500.html"});
+    else
+      puts cgi.header
+      puts "<hr><b>Exception:</b>", "<em><pre>", CGI::escapeHTML("#{bang}"), "</pre></em>\n", "<pre>", bang.backtrace.join("\n"), "</pre>"
+    end
+  end
+  
+  script = nil
+  fhandle = nil
+  control = nil
+  pram = nil
+  GC.start
+end
+

data/bin/webink_database

@@ -0,0 +1,50 @@
+require 'mmap'
+require 'webink/beauty'
+
+config = nil
+model_classes = Array.new
+
+begin
+  config = Ink::Beauty.load_config "./"
+rescue Exception => bang
+  puts "Error while loading config: #{bang}."
+end
+
+require "#{config["db_type"]}"
+require 'webink'
+
+models = Dir.new "./models"
+models.each do |model|
+  load "#{models.path}/#{model}" if model =~ /\.rb$/
+  model_classes.push Ink::Model.classname($1) if model =~ /^(.*)\.rb$/
+end
+
+begin
+  Ink::Database.create config
+  db = Ink::Database.database
+  db_tables = db.tables
+  
+  if ARGV[0] == "drop"
+    puts "Dropping old tables..."
+    db_tables.each do |t|
+      puts "...#{t}"
+      db.query "DROP TABLE #{t};"
+    end
+  end
+  
+  puts "Creating new tables..."
+  model_classes.each do |m|
+    puts "...for class: #{m.name}:"
+    c = m.create
+    puts c
+    c.each do |exec|
+      begin
+        db.query exec
+      rescue => ex
+        puts ex
+      end
+    end
+  end
+rescue Exception => bang
+  puts "SQLError: #{bang}."
+end

data/lib/webink.rb

@@ -0,0 +1,4 @@
+require 'webink/model'
+require 'webink/controller'
+require 'webink/database'
+

data/lib/webink/beauty.rb

@@ -0,0 +1,80 @@
+module Ink
+
+  # = Beauty class
+  #
+  # This class provides a set of tools for loading config and init scripts
+  # as well as the route-matching. It makes the dispatcher code much more
+  # beautiful, hence the name.
+  # 
+  # 
+  #
+  class Beauty
+    
+    # Class method
+    # 
+    # Attempts to load the init file of the project or raises a LoadError.
+    # [param script:] Project folder path
+    # [returns:] valid init file path
+    def self.load_init(script)
+      script = "#{File.dirname(script)}/init"
+      script = "#{script}.rb" if not File.exist? script
+      raise LoadError.new("Init not found.") if not File.exist? script
+      script
+    end
+    
+    # Class method
+    # 
+    # Attempts to load the config file of the project or raises a LoadError.
+    # Once loaded, the config is evaluated and can raise a RuntimeError, or
+    # it is returned
+    # [param script:] Project folder path
+    # [returns:] a valid config
+    def self.load_config(script)
+      config = "#{File.dirname(script)}/config"
+      config = "#{config}.rb" if not File.exist? config
+      raise LoadError.new("Config not found.") if not File.exist? config
+      fhandle = Mmap.new(config, "r")
+      config = eval fhandle
+      fhandle.munmap
+      raise RuntimeError.new("Config error.") if not config.instance_of? Hash
+      config
+    end
+    
+    # Class method
+    # 
+    # Attempts to load the routes file of the project or raises a LoadError
+    # [param script:] Project folder path
+    # [returns:] valid routes file path
+    def self.load_routes(script)
+      routes = "#{File.dirname(script)}/routes"
+      routes = "#{routes}.rb" if not File.exist? routes
+      raise LoadError.new("Routes not found.") if not File.exist? routes
+      routes
+    end
+    
+    # Class method
+    # 
+    # Attempts to match the params onto the routes and return the results in
+    # form of a Hash.
+    # [param root:] Relative project folder path to the server document path
+    # [param routes:] Array of Arrays: regex, Hash(Symbol => String)
+    # [param params:] Requested string
+    # [returns:] Hash of Symbol => String
+    def self.routing(root, routes, params)
+      match = { :root => root }
+      routes.each do |entry|
+        k = entry[0]
+        v = entry[1]
+        if params =~ k
+          v.each do |sys,e|
+            match[sys] = (e =~ /^\$\d+$/ and params =~ k and eval e) ? (eval e) : e
+          end
+          break
+        end
+      end
+      match
+    end
+    
+  end
+  
+end

data/lib/webink/controller.rb

@@ -0,0 +1,285 @@
+module Ink
+
+  # = Controller class
+  # 
+  # == Usage
+  # 
+  # Controllers handle incoming requests and decide what to do
+  # with them. A controller has access to all incoming data, like
+  # POST and GET as well as the config.
+  #
+  #   class App < Ink::Controller
+  #     
+  #     def index
+  #       redirect_to :controller => "app", :module => "feed", :id => 29382374
+  #     end
+  #     
+  #     def feed
+  #       @arg = @params[:id]
+  #       @users = []
+  #       render :template => "index"
+  #     end
+  #
+  #     def partial
+  #       @arg = "foo bar"
+  #       render :partial => "part", :standalone => true
+  #     end
+  #     
+  #   end
+  #
+  # A controller named App should have the filename app.rb and be
+  # placed inside the project controller folder. It can have instance
+  # methods that are usually refered to as modules.
+  # So a route should contain at least a :controller and a :module.
+  #
+  # In the sample above there are three modules, index redirects
+  # to feed, feed renders a template and partial renders a partial.
+  # When using a partial inside a template, you do not need the
+  # standalone argument, but when you plan to return just the partial,
+  # you should add it to the argument string. Rendering returns an
+  # interpreted erb instance, which is returned to the calling part of
+  # the script, which runs the erb instance. Redirecting forwards
+  # an erb instance and passes on the existing @params, after overwriting
+  # and setting its hash arguments, so multiple redirecting works.
+  #
+  # The template is called inside the binding on the controller, which
+  # means that all instance variables and methods are available as such.
+  #
+  # == Templates
+  #
+  # All templates are to be put into the project views folder, and are
+  # to be named name.html.erb, while partials are to be named _anothername.html.erb.
+  # It is possible to create subfolders and call the templates via
+  # :template => "subfolder/template.html.erb".
+  #
+  # The index.html.erb template in the controller above looks like this:
+  #
+  #   <%= render :partial => "part" %>
+  #
+  # And the _part.html.erb, that is called from the index, is this:
+  #
+  #   WTF <%= @arg %>!!
+  #   <br>
+  #
+  # When the index module is requested, it will set :id to 29382374.
+  # However requesting the feed module, it requires :id to be set as
+  # a parameter through the routes.
+  #
+  # == Routing
+  #
+  # The routes being evaluated by the dispatcher are simple regular expressions.
+  # This example fits the controller from earlier.
+  #
+  #   root = "/folder"
+  #
+  #   routes = [
+  #     [ /^\/([^\/]+)\/([^\/]+)(\/([0-9]+))?$/, {:controller => "$1", :module => "$2", :id => "$4"} ],
+  #     [ /^\/([^\/]+)\/?$/, {:controller => "$1", :module => "index"} ],
+  #     [ /^\/?$/, {:controller => "app", :module => "index"} ],
+  #   ]
+  #
+  # Routes are built as a priority list, the first match will be the route taken. All
+  # route configurations must include a variable named root, as it will help to create
+  # dynamic links within websites. Root is relative to the webserver root. Assume your
+  # webserver points to public_html, then routes can be "" for the public_html folder,
+  # or "/anysubfolder" which points to anysubfolder. Deeper structures work too.
+  #
+  # == Linking
+  #
+  # A controller has the ability to create hyperlinks for you, that will dynamically match
+  # the project path etc. (and is also using the root variable from the routes.rb)
+  #
+  #   link_to "name", "controller", "module", "param1", "param2", {:class => "h1", :id => "14"}
+  #
+  # The link above will produce this:
+  #
+  #   <a class="h1" id="14" href="/controller/module/param1/param2/">name</a>
+  #
+  # So the first entry of the argument array is the hyperlink name, then all
+  # following entries are connected as the href string, prefixed by the root variable
+  # that is set in the routes.rb. The hash includes the attributes for the <a>-tag.
+  #
+  # == Pathing
+  #
+  # A controller also constructs paths for you (and is also using the root variable
+  # from the routes.rb), which you can use to dynamically reroute forms, just to
+  # mention one example.
+  #
+  #   @my = "no"
+  #   path_to "this", "is", @my, "path"
+  #
+  # The constructed path will look like this:
+  #
+  #   /this/is/no/path
+  #
+  # It just puts together the arguments given to it.
+  #
+  # == Sessions
+  #
+  # Usually very important in the development of websites are sessions. There is some
+  # basic support for it in webink, that will make certain bits easier. For more information
+  # have a look at the blog-demo.
+  #
+  # Each controller usually expects cookies to work, if you handle sessions via cgi.
+  # Whenever cookies do not work, or you do not intend to use them in the first place,
+  # path_to and link_to watch out for the instance variables @session_key and @session_id
+  # which are added via GET to the path/hyperlink, that they construct. Therefore the
+  # tools should not be used for external linking. The dispatcher automatically filters
+  # the GET session_id when using POST and adds it to the cgi.params, so sessions can
+  # be used confortably.
+  #
+  # Per default, the @session_key should be "_session_id" as specified in the cgi/session
+  # library from ruby core, but the controller offers some freedom, in case you may want
+  # a different key name for some reason.
+  #
+  # 
+  #
+  class Controller
+    
+    # Constructor
+    # 
+    # Creates a new controller of the derived class. params are the globals set
+    # by the dispatcher, and include keys like: :get, :post and :config. Also the
+    # matched routes are put there, :controller, :module and any parameters like
+    # :id or :page that were retrieved from the routes.
+    # [param params:] Hash of Symbol => Objects
+    def initialize(params)
+      @params = params
+    end
+    
+    # Instance method
+    # 
+    # Render a template or a partial that is located in the ./views/ folder of the
+    # project. Subfolders are allowed to be specified. All instance variables are
+    # accessible from within the template, as are any instance methods.
+    # [param args:] Hash of arguments
+    # [returns:] interpreted erb instance or nil
+    def render(args)
+      args[:locals] = Array.new if not args[:locals]
+      template = nil
+      if args[:template]
+        template = File.open "./views/#{args[:template]}.html.erb", "r"
+        erb = ERB.new template.readlines * "\n"
+        puts @params[:cgi].header
+        erb.run self.getBinding(args[:locals])
+      elsif args[:partial]
+        template = File.open "./views/#{(File.dirname(args[:partial]) != ".") ? "#{File.dirname(args[:partial])}/" : ""}_#{File.basename(args[:partial])}.html.erb", "r"
+        erb = ERB.new template.readlines * "\n"
+        if not args[:standalone]
+          erb.result self.getBinding(args[:locals])
+        else
+          puts @params[:cgi].header
+          erb.run self.getBinding(args[:locals])
+        end
+      else
+        nil
+      end
+    end
+    
+    # Instance method
+    # 
+    # Redirect to a controller and module. The new controller will
+    # be instanciated with a copy of the current params.
+    # [param args:] Hash of arguments
+    # [returns:] interpreted erb instance or nil
+    def redirect_to(args)
+      p = Hash.new
+      @params.each do |k,v|
+        p[k] = v
+      end
+      args.each do |k,v|
+        p[k] = v
+      end
+      if p[:controller] and p[:module]
+        controller = (Ink::Controller.verify p[:controller]).new p
+        (controller.verify p[:module]).call
+      else
+        nil
+      end
+    end
+    
+    # Instance method
+    #
+    # Creates a dynamic hyperlink
+    # First argument is the name, then follow the pieces that are imploded by
+    # a /, followed by hashes, that become attributes. It adds the @session_key
+    # and @session_id if they are set.
+    # Convenience method
+    # [param args:] Array of Strings and Hashes
+    # [returns:] Hyperlink
+    def link_to(*args)
+      raise ArgumentError.new("Expects an array.") if not args.instance_of? Array and args.length < 2
+      href = "#{@params[:root]}#{(@params[:root][@params[:root].length-1].chr == "/") ? "" : "/"}" if @params[:root].length > 0
+      href = "/" if @params[:root].length == 0
+      a = "<a "
+      name = args[0]
+      for i in 1...args.length
+        arg = args[i]
+        if not arg.instance_of? Hash
+          href += "#{arg}/"
+        else
+          arg.each do |k,v|
+            a += "#{k}=\"#{v}\" "
+          end
+        end
+      end
+      href += "?#{@session_key}=#{@session_id}" if @session_id and @session_key
+      "#{a}href=\"#{href}\">#{name}</a>"
+    end
+    
+    # Instance method
+    #
+    # Creates a dynamic path
+    # The array pieces are imploded by a /. It adds the @session_key
+    # and @session_id if they are set.
+    # Convenience method
+    # [param args:] Array of Strings or String
+    # [returns:] path
+    def path_to(*args)
+      href = "#{@params[:root]}#{(@params[:root][@params[:root].length-1].chr == "/") ? "" : "/"}" if @params[:root].length > 0
+      href = "/" if @params[:root].length == 0
+      
+      if args.is_a? Array
+        for i in 0...args.length
+          arg = args[i]
+          href += "#{arg}/"
+        end
+      else
+        href += "#{args}/"
+      end
+      href += "?#{@session_key}=#{@session_id}" if @session_id and @session_key
+      href
+    end
+    
+    # Instance method
+    # 
+    # Retrieve the current binding of the instance.
+    # [param locals:] an Array of data for the template
+    # [returns:] current binding
+    def getBinding(*locals)
+      binding
+    end
+    
+    # Class method
+    # 
+    # Retrieve the class of the name controller, that can be instanciated
+    # by using new. Raises a NameError.
+    # [param controller:] Controller name string
+    # [returns:] class or nil
+    def self.verify(controller)
+      ((Module.const_get controller.capitalize).is_a? Class) ? (Module.const_get controller.capitalize) : (raise NameError.new("Controller not found."))
+    end
+    
+    # Instance method
+    # 
+    # Retrieve the method of name mod, that can be called by using the
+    # call method. Raises a NameError.
+    # [param mod:] Method name string
+    # [returns:] method or nil
+    def verify(mod)
+      self.method(mod)
+    end
+    
+  end
+  
+end