webink 2.1.1 → 3.0.0

data/bin/webink_database

@@ -1,28 +1,26 @@
 #!/usr/bin/env ruby
 
-require 'simple_mmap'
-require 'webink/beauty'
+require 'webink'
 
 config = nil
 model_classes = Array.new
 
 begin
-  config = Ink::Beauty.load_config "./"
+  config = Ink::Beauty.new.load_config
 rescue Exception => bang
   puts "Error while loading config: #{bang}."
 end
 
-require "#{config["db_type"]}"
-require 'webink'
+require "#{config[:db_type]}"
 
 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$/
+  model_classes << Ink::Model.classname($1) if model =~ /^(.*)\.rb$/
 end
 
 begin
-  Ink::Database.create config
+  Ink::Database.create(config)
   db = Ink::Database.database
   db_tables = db.tables
 

data/bin/webink_init

@@ -0,0 +1,47 @@
+#!/usr/bin/env ruby
+
+config_ru = <<CFG_RU
+require 'erb'
+require 'webink'
+
+run Ink::Beauty.new
+CFG_RU
+
+config_rb = <<CFG_RB
+Ink::Beauty.config = {
+  #sqlite3 config
+  :db_type => "sqlite3",
+  :db_server => "./db.sqlite",
+
+  #mysql config
+  #:db_type => "mysql"
+  #:db_user => "db_username"
+  #:db_pass => "db_password"
+  #:db_database => "db_database_name"
+  #:db_server => "localhost"
+}
+CFG_RB
+
+routes_rb = <<RT_RB
+Ink::Beauty.root = ""
+
+Ink::Beauty.routes = [
+  [ /^\\/([^\\/]+)\\/([^\\/]+)\\/?$/, {:controller => "$1", :module => "$2"} ],
+  [ /^\\/([^\\/]+)\\/?$/, {:controller => "$1", :module => "index"} ],
+  [ /^\\/?$/, {:controller => "admin", :module => "index"} ],
+]
+RT_RB
+
+if File.exist?("config") or File.exist?("config.rb")
+  puts "Directory already initialized. Exiting."
+  exit(0)
+end
+
+File.open("config.ru", "w"){ |f| f.puts config_ru }
+File.open("config.rb", "w"){ |f| f.puts config_rb }
+File.open("routes.rb", "w"){ |f| f.puts routes_rb }
+Dir.mkdir("controllers", 0775)
+Dir.mkdir("models", 0775)
+Dir.mkdir("views", 0775)
+Dir.mkdir("files", 0775)
+File.chmod(0775, "config.ru", "config.rb", "routes.rb")

data/lib/webink.rb

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

data/lib/webink/beauty.rb

@@ -3,78 +3,193 @@ 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.
-  # 
-  # 
+  # as well as the route-matching. Formerly it made the dispatcher code
+  # much more beautiful, hence the name.
+  # Since 3.0.0 it handles the dispatching for rack and serves static files
+  # from ./files/*
+  #
+  #
   #
   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
+
+    # Class accessor definitions
+    #
+    class << self
+      attr_accessor :routes, :config, :root
+    end
+
+    # Constructor
+    #
+    def initialize
+      @params = {}
+    end
+
+    # Instance method
+    #
+    # Rackup call
+    # Initializes the webink environment
+    # Rescues all kinds of errors and responds with error codes
+    # [param env:] rack environment
+    # [returns:] Rack-compatible array
+    def call(env)
+      @params = {} #reset
+      @env = env
+      controller = self.init
+      if controller and not @params[:file]
+        Ink::Database.create(@params[:config])
+        response = controller.verify(@params[:module]).call
+        Ink::Database.database.close
+        response || [404, {}, self.error_mapping(404)]
+      elsif File.exist?("."+@params[:file])
+        [ 200, {}, File.open("."+@params[:file], File::RDONLY) ]
+      else
+        [ 404, {}, self.error_mapping(404) ]
+      end
+    rescue LoadError => bang
+      render_error(404, "LoadError", bang)
+    rescue NotImplementedError => bang
+      render_error(500, "NotImplementedError", bang)
+    rescue ArgumentError => bang
+      render_error(500, "ArgumentError", bang)
+    rescue RuntimeError => bang
+      render_error(500, "RuntimeError", bang)
+    rescue NameError => bang
+      render_error(500, "NameError", bang)
+    rescue Exception, Error => bang
+      render_error(500, "Exception", bang)
+    end
+
+    # Instance method
+    #
+    # Loads models and the controller. Requires the database type.
+    # [returns:] Controller class
+    def load_env
+      require "#{@params[:config][:db_type]}"
+      Dir.new("./models").each{ |m| load "./models/#{m}" if m =~ /\.rb$/ }
+      load "./controllers/#{@params[:controller]}.rb"
+      Ink::Controller.verify(@params[:controller]).new(@params)
+    end
+
+    # Instance method
+    #
+    # Generates a param hash including the config, route and get/post
+    # parameters.
+    # [returns:] Controller class
+    def init
+      req = Rack::Request.new(@env)
+      @params.merge!({:header => {}, :cookie => req.cookies})
+      @params[:get] = Rack::Utils.parse_query(@env["QUERY_STRING"], '&;') || {}
+      @params[:post] = {}
+      if @env['rack.input'].is_a?(StringIO)
+        @params[:post] =
+          Rack::Utils.parse_query(@env['rack.input'].read, "&;\n")
+      end
+      self.load_config
+      self.load_routes
+      @params[:file] ? nil : self.load_env #static file requests are nil
     end
-    
-    # Class method
-    # 
+
+    # Instance 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
+    # Once loaded, the config is returned
     # [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 = SimpleMmap::MappedFile.new(config)
-      config = eval fhandle.read_window_data(0,fhandle.size)
-      fhandle.close
-      raise RuntimeError.new("Config error.") if not config.instance_of? Hash
-      config
+    def load_config
+      config = "./config"
+      config = "#{config}.rb" unless File.exist?(config)
+      raise LoadError.new("Config not found.") unless File.exist?(config)
+      load config
+      if Beauty.config.nil?
+        raise LoadError.new("Config extension error on Beauty")
+      end
+      @params[:config] = Beauty.config
+      Beauty.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
+
+    # Instance method
+    #
+    # Attempts to load the routes file of the project or raises a LoadError.
+    # Determines and stores the current route in the @params
+    def load_routes
+      routes = "./routes"
+      routes = "#{routes}.rb" unless File.exist?(routes)
+      raise LoadError.new("Routes not found.") unless File.exist?(routes)
+      load routes
+      if Beauty.routes.nil?
+        raise LoadError.new("Route extension error on Beauty")
+      elsif Beauty.root.nil?
+        raise LoadError.new("Root extension error on Beuaty")
+      end
+      @params.merge!(self.routing(@env["REQUEST_PATH"])) if @env["REQUEST_PATH"]
     end
-    
-    # Class method
-    # 
+
+    # Instance 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
+    # Possible root route is extracted and routes matching to /files/* will
+    # be stored in the match.
+    # [param str:] Requested string
     # [returns:] Hash of Symbol => String
-    def self.routing(root, routes, params)
+    def routing(str)
+      root = Beauty.root
+      root = $1 if root =~ /(.*)\/$/
       match = { :root => root }
-      routes.each do |entry|
+      if str =~ /^#{root}(.*)\/?$/
+        str = $1
+      else
+        raise LoadError.new("No matching route found")
+      end
+      # match file route:
+      if str =~ /^(\/files\/.+)$/
+        return match.merge({ :file => $1 })
+      end
+      Beauty.routes.each do |entry|
         k = entry[0]
         v = entry[1]
-        if params =~ k
+        if str =~ k
           v.each do |sys,e|
-            match[sys] = (e =~ /^\$\d+$/ and params =~ k and eval e) ? (eval e) : e
+            match[sys] =
+              (e =~ /^\$\d+$/ and str =~ k and eval e) ? (eval e) : e
           end
           break
         end
       end
+      raise LoadError.new("No matching route found") if match.keys.length <= 1
       match
     end
-    
+
+    # Instance method
+    #
+    # Renders error stacktraces or errors back to the
+    # user
+    # [param code:] Error code integer
+    # [param type:] Exception type string
+    # [param bang:] Exception instance
+    # [returns:] Rack-compatible array
+    def render_error(code, type, bang)
+      if Beauty.config and Beauty.config[:production]
+        [code, {}, self.error_mapping(code)]
+      else
+        [200, {}, [
+          "<b>#{type}</b>",
+          "<em><pre>#{bang}</pre></em>",
+          "<pre>#{bang.backtrace.join("\n")}</pre>"
+        ]]
+      end
+    end
+
+    # Instance method
+    #
+    # Maps error code integers to error strings
+    # [param code:] Error code integer
+    # [returns:] Error string
+    def error_mapping(code)
+      {
+        404 => "404 Page not found",
+        500 => "500 Internal error",
+      }[code]
+    end
+
   end
-  
 end

data/lib/webink/controller.rb

@@ -12,7 +12,8 @@ module Ink
   #   class App < Ink::Controller
   #
   #     def index
-  #       redirect_to :controller => "my_app", :module => "feed", :id => 29382374
+  #       redirect_to :controller => "my_app", :module => "feed",
+  #         :id => 29382374
   #     end
   #
   #     def feed
@@ -29,9 +30,11 @@ module Ink
   #   end
   #
   # A controller named App should have the filename app.rb and be
-  # placed inside the project controller folder. It can have
+  # placed inside the project controllers 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.
+  # Note that controller filenames are not camelized when they are
+  # being searched for by the dispatcher.
   #
   # In the sample above there are three modules, index redirects
   # to feed, feed renders a template and partial renders a partial.
@@ -72,10 +75,11 @@ module Ink
   # The routes being evaluated by the dispatcher are simple regular expressions.
   # This example fits the controller from earlier.
   #
-  #   root = "/folder"
+  #   Beauty.root = "/folder"
   #
-  #   routes = [
-  #     [ /^\/([^\/]+)\/([^\/]+)(\/([0-9]+))?$/, {:controller => "$1", :module => "$2", :id => "$4"} ],
+  #   Beauty.routes = [
+  #     [ /^\/([^\/]+)\/([^\/]+)(\/([0-9]+))?$/,
+  #       {:controller => "$1", :module => "$2", :id => "$4"} ],
   #     [ /^\/([^\/]+)\/?$/, {:controller => "$1", :module => "index"} ],
   #     [ /^\/?$/, {:controller => "app", :module => "index"} ],
   #   ]
@@ -94,7 +98,8 @@ module Ink
   # 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"}
+  #   link_to "name", "controller", "module", "param1", "param2",
+  #     {:class => "h1", :id => "14"}
   #
   # The link above will produce this:
   #
@@ -126,18 +131,18 @@ module Ink
   # 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.
+  # Each controller usually expects cookies to work. 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.
+  # Per default, the @session_key should be "_session_id", but the
+  # controller offers some freedom, in case you may want a different
+  # key name for some reason.
   #
   #
   #
@@ -169,17 +174,18 @@ module Ink
         template = File.open "./views/#{args[:template]}.html.erb", "r"
         erb = ERB.new template.readlines * "\n"
         template.close
-        puts @params[:cgi].header
-        erb.run self.getBinding(args[:locals])
+        [200, @params[:header], erb.result(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"
+        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"
         template.close
         if not args[:standalone]
-          erb.result self.getBinding(args[:locals])
+          erb.result(self.getBinding(args[:locals]))
         else
-          puts @params[:cgi].header
-          erb.run self.getBinding(args[:locals])
+          [200, @params[:header], erb.result(self.getBinding(args[:locals]))]
         end
       else
         nil
@@ -201,8 +207,8 @@ module Ink
         p[k] = v
       end
       if p[:controller] and p[:module]
-        controller = (Ink::Controller.verify p[:controller]).new p
-        (controller.verify p[:module]).call
+        controller = Ink::Controller.verify(p[:controller]).new(p)
+        controller.verify(p[:module]).call
       else
         nil
       end
@@ -218,8 +224,10 @@ module Ink
     # [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].length == 0) ? "/" : "#{@params[:root]}#{(@params[:root][@params[:root].length-1].chr == "/") ? "" : "/"}"
+      if not args.instance_of? Array and args.length < 2
+        raise ArgumentError.new("Expects an array.")
+      end
+      href = "#{@params[:root]}/"
       a = "<a "
       name = args[0]
       for i in 1...args.length
@@ -245,7 +253,7 @@ module Ink
     # [param args:] Array of Strings or String
     # [returns:] path
     def path_to(*args)
-      href = (@params[:root].length == 0) ? "/" : "#{@params[:root]}#{(@params[:root][@params[:root].length-1].chr == "/") ? "" : "/"}"
+      href = "#{@params[:root]}/"
 
       if args.is_a? Array
         for i in 0...args.length
@@ -275,14 +283,15 @@ module Ink
     # [param controller:] Controller name string
     # [returns:] class or nil
     def self.verify(controller)
-      if not Module.const_defined? controller.capitalize
-        if File.exists? "./controllers/#{controller}.rb"
+      if not Module.const_defined?(controller.capitalize)
+        if File.exists? "./controllers/#{controller}.rb" and
+            Module.const_get(controller.capitalize).is_a?(Class)
           load "./controllers/#{controller}.rb"
         else
           raise NameError.new("Controller not found.")
         end
       end
-      ((Module.const_get controller.capitalize).is_a? Class) ? (Module.const_get controller.capitalize) : (raise NameError.new("Controller not found."))
+      Module.const_get(controller.capitalize)
     end
 
     # Instance method

data/lib/webink/database.rb

@@ -10,21 +10,19 @@ module Ink
   #
   # Sample config for MySQL:
   #   config = {
-  #     "escape_post_data"  => false,
-  #     "production"        => true,
-  #     "db_type"           => "mysql",
-  #     "db_user"           => "yourusername",
-  #     "db_pass"           => "yourpassword",
-  #     "db_database"       => "yourdatabase",
-  #     "db_server"         => "localhost",
+  #     :production        => true,
+  #     :db_type           => "mysql",
+  #     :db_user           => "yourusername",
+  #     :db_pass           => "yourpassword",
+  #     :db_database       => "yourdatabase",
+  #     :db_server         => "localhost",
   #   }
   #
   # Sample config for SQLite3:
   #   config = {
-  #     "escape_post_data"  => false,
-  #     "production"        => true,
-  #     "db_type"           => "sqlite3",
-  #     "db_server"         => "/full/path/to/database.sqlite",
+  #     :production        => true,
+  #     :db_type           => "sqlite3",
+  #     :db_server         => "/full/path/to/database.sqlite",
   #   }
   #
   # == Usage
@@ -109,12 +107,13 @@ module Ink
     # possible.
     # [param config:] Hash of config parameters
     def initialize(config)
-      @type = config["db_type"]
+      @type = config[:db_type]
       if @type == "mysql"
-        @db = Mysql.real_connect(config["db_server"],config["db_user"],config["db_pass"],config["db_database"])
+        @db = Mysql.real_connect(config[:db_server],config[:db_user],
+          config[:db_pass],config[:db_database])
         @db.reconnect = true
       elsif @type == "sqlite3"
-        @db = SQLite3::Database.new(config["db_server"])
+        @db = SQLite3::Database.new(config[:db_server])
       else
         raise ArgumentError.new("Database undefined.")
       end
@@ -140,7 +139,11 @@ module Ink
     # Returns the Database instance or raises a Runtime Error
     # [returns:] Database instance
     def self.database
-      (@@database) ? @@database : (raise RuntimeError.new("No Database found. Create one first"))
+      if @@database
+        @@database
+      else
+        raise RuntimeError.new("No Database found. Create one first")
+      end
     end
 
     # Instance method
@@ -158,7 +161,9 @@ module Ink
           end
         end
       elsif @type == "sqlite3"
-        re = @db.query "SELECT name FROM sqlite_master WHERE type='table' ORDER BY name;"
+        re = @db.query <<QUERY
+SELECT name FROM sqlite_master WHERE type='table' ORDER BY name;
+QUERY
         re.each do |row|
           row.each do |t|
             result.push t
@@ -273,7 +278,9 @@ module Ink
     # [param class_name:] Defines the __table__ name or class
     # [returns:] primary key or nil
     def last_inserted_pk(class_name)
-      class_name = Ink::Model.classname(class_name) unless class_name.is_a? Class
+      unless class_name.is_a?(Class)
+        class_name = Ink::Model.classname(class_name)
+      end
       table_name = class_name.table_name
       pk_name = class_name.primary_key
       return if table_name.nil? or pk_name.nil?
@@ -302,7 +309,8 @@ module Ink
     # [param class_name:] Defines the class name or class
     # [param params:] Additional SQL syntax like WHERE conditions (optional)
     def remove(class_name, params="")
-      table_name = (class_name.is_a? Class) ? class_name.table_name : Ink::Model.str_to_tablename(class_name)
+      table_name = (class_name.is_a? Class) ? class_name.table_name :
+        Ink::Model.str_to_tablename(class_name)
       return if table_name.nil?
       self.query("DELETE FROM #{table_name} #{params};")
     end
@@ -310,11 +318,14 @@ module Ink
     # Instance method
     #
     # Retrieve class instances, that are loaded with the database result set.
-    # [param class_name:] Defines the class name or class which should be queried
+    # [param class_name:] Defines the class name or class which should be
+    #                     queried
     # [param params:] Additional SQL syntax like WHERE conditions (optional)
     # [returns:] Array of class_name instances from the SQL result set
     def find(class_name, params="")
-      class_name = Ink::Model.classname(class_name) unless class_name.is_a? Class
+      unless class_name.is_a?(Class)
+        class_name = Ink::Model.classname(class_name)
+      end
       result = Array.new
       table_name = class_name.table_name
       return result if table_name.nil?
@@ -354,7 +365,11 @@ module Ink
       union_class = ((class1.class_name <=> class2.class_name) < 0) ?
         "#{tablename1}_#{tablename2}" :
         "#{tablename2}_#{tablename1}"
-      re = self.query("SELECT #{tablename2}.* FROM #{union_class}, #{tablename2} WHERE #{union_class}.#{fk1} = #{class1_id} AND #{union_class}.#{fk2} = #{tablename2}.#{pk2} #{params};")
+      re = self.query <<QUERY
+SELECT #{tablename2}.* FROM #{union_class}, #{tablename2}
+WHERE #{union_class}.#{fk1} = #{class1_id}
+AND #{union_class}.#{fk2} = #{tablename2}.#{pk2} #{params};
+QUERY
       re.each do |entry|
         instance = class2.new entry
         result.push instance
@@ -384,10 +399,19 @@ module Ink
       fk1 = class1.foreign_key
       tablename1 = class1.table_name
       tablename2 = class2.table_name
-      if ((class1.class_name <=> class2.class_name) < 0 and relationship == "one_one") or relationship == "one_many"
-        re = self.query "SELECT * FROM #{tablename2} WHERE #{class2.primary_key}=(SELECT #{class2.foreign_key} FROM #{tablename1} WHERE #{class1.primary_key}=#{class1_id});"
+      if ((class1.class_name <=> class2.class_name) < 0 and
+          relationship == "one_one") or relationship == "one_many"
+        re = self.query <<QUERY
+SELECT * FROM #{tablename2}
+WHERE #{class2.primary_key}=(
+  SELECT #{class2.foreign_key} FROM #{tablename1}
+  WHERE #{class1.primary_key}=#{class1_id}
+);
+QUERY
       else
-        re = self.query "SELECT * FROM #{tablename2} WHERE #{fk1} = #{class1_id} #{params};"
+        re = self.query <<QUERY
+SELECT * FROM #{tablename2} WHERE #{fk1} = #{class1_id} #{params};
+QUERY
       end
 
       re.each do |entry|
@@ -400,7 +424,8 @@ module Ink
     # Instance method
     #
     # Retrieve one class2 instance, that is related to the class1 instance with
-    # primary key class1_id. Only relevant for one_one and one_many relationships
+    # primary key class1_id. Only relevant for one_one and one_many
+    # relationships
     # [param class1:] Reference classname or class
     # [param class1_id:] Primary key value of the reference classname
     # [param class2:] Match classname or class
@@ -426,23 +451,42 @@ module Ink
     # [param type:] relationship type
     def delete_all_links(instance, link, type)
       if type == "one_one"
-        firstclass = ((instance.class.name.downcase <=> link.name.downcase) < 0) ? instance.class : link
-        secondclass = ((instance.class.name.downcase <=> link.name.downcase) < 0) ? link : instance.class
-        key = ((instance.class.name.downcase <=> link.name.downcase) < 0) ? instance.class.primary_key : instance.class.foreign_key
+        firstclass =
+          ((instance.class.name.downcase <=> link.name.downcase) < 0) ?
+          instance.class : link
+        secondclass =
+          ((instance.class.name.downcase <=> link.name.downcase) < 0) ?
+          link : instance.class
+        key =
+          ((instance.class.name.downcase <=> link.name.downcase) < 0) ?
+          instance.class.primary_key : instance.class.foreign_key
         value = instance.method(instance.class.primary_key).call
-        @db.query "UPDATE #{firstclass.table_name} SET #{secondclass.foreign_key}=NULL WHERE #{key}=#{value};"
+        @db.query <<QUERY
+UPDATE #{firstclass.table_name}
+SET #{secondclass.foreign_key}=NULL
+WHERE #{key}=#{value};
+QUERY
       elsif type == "one_many" or type == "many_one"
         firstclass = (type == "one_many") ? instance.class : link
         secondclass = (type == "one_many") ? link : instance.class
-        key = (type == "one_many") ? instance.class.primary_key : instance.class.foreign_key
+        key = (type == "one_many") ? instance.class.primary_key :
+          instance.class.foreign_key
         value = instance.method(instance.class.primary_key).call
-        @db.query "UPDATE #{firstclass.table_name} SET #{secondclass.foreign_key}=NULL WHERE #{key}=#{value};"
+        @db.query <<QUERY
+UPDATE #{firstclass.table_name}
+SET #{secondclass.foreign_key}=NULL
+WHERE #{key}=#{value};
+QUERY
       elsif type == "many_many"
         tablename1 = instance.class.table_name
         tablename2 = link.table_name
-        union_class = ((instance.class.name.downcase <=> link.name.downcase) < 0) ? "#{tablename1}_#{tablename2}" : "#{tablename2}_#{tablename1}"
+        union_class =
+          ((instance.class.name.downcase <=> link.name.downcase) < 0) ?
+          "#{tablename1}_#{tablename2}" : "#{tablename2}_#{tablename1}"
         value = instance.method(instance.class.primary_key).call
-        @db.query "DELETE FROM #{union_class} WHERE #{instance.class.foreign_key}=#{value};"
+        @db.query <<QUERY
+DELETE FROM #{union_class} WHERE #{instance.class.foreign_key}=#{value};
+QUERY
       end
     end
 
@@ -452,10 +496,12 @@ module Ink
     # link is the class of the related data, and type refers to the
     # relationship type of the two. When one tries to insert an array
     # for a x_one relationship, the last entry will be set.
-    # [param instance:] Instance of a class that refers to an existing database entry
+    # [param instance:] Instance of a class that refers to an existing
+    #                   database entry
     # [param link:] the related class (not a String, but class reference)
     # [param type:] relationship type
-    # [param value:] relationship data that was set, either a primary key value, or an instance, or an array of both
+    # [param value:] relationship data that was set, either a primary key value,
+    #                or an instance, or an array of both
     def create_all_links(instance, link, type, value)
       to_add = Array.new
       if value.is_a? Array
@@ -482,7 +528,8 @@ module Ink
     # The relationship between the two is defined by type. one_one
     # relationships are placing an additional call to delete_all_links
     # that will remove conflicts.
-    # [param instance:] Instance of a class that refers to an existing database entry
+    # [param instance:] Instance of a class that refers to an existing database
+    #                   entry
     # [param link:] the related class (not a String, but class reference)
     # [param type:] relationship type
     # [param value:] primary key of the relationship, that is to be created
@@ -492,27 +539,49 @@ module Ink
           re = self.find(link.name, "WHERE #{link.primary_key}=#{fk};").first
           self.delete_all_links re, instance.class, type
         end
-        firstclass = ((instance.class.name.downcase <=> link.name.downcase) < 0) ? instance.class : link
-        secondclass = ((instance.class.name.downcase <=> link.name.downcase) < 0) ? link : instance.class
-        key = ((instance.class.name.downcase <=> link.name.downcase) < 0) ? instance.class.primary_key : link.primary_key
+        firstclass =
+          ((instance.class.name.downcase <=> link.name.downcase) < 0) ?
+          instance.class : link
+        secondclass =
+          ((instance.class.name.downcase <=> link.name.downcase) < 0) ?
+          link : instance.class
+        key =
+          ((instance.class.name.downcase <=> link.name.downcase) < 0) ?
+          instance.class.primary_key : link.primary_key
         value = instance.method(instance.class.primary_key).call
-        fk_set = ((instance.class.name.downcase <=> link.name.downcase) < 0) ? fk : value
-        value_set = ((instance.class.name.downcase <=> link.name.downcase) < 0) ? value : fk
-        @db.query "UPDATE #{firstclass.table_name} SET #{secondclass.foreign_key}=#{fk} WHERE #{key}=#{value};"
+        fk_set =
+          ((instance.class.name.downcase <=> link.name.downcase) < 0) ?
+          fk : value
+        value_set =
+          ((instance.class.name.downcase <=> link.name.downcase) < 0) ?
+          value : fk
+        @db.query <<QUERY
+UPDATE #{firstclass.table_name} SET #{secondclass.foreign_key}=#{fk}
+WHERE #{key}=#{value};
+QUERY
       elsif type == "one_many" or type == "many_one"
         firstclass = (type == "one_many") ? instance.class : link
         secondclass = (type == "one_many") ? link : instance.class
-        key = (type == "one_many") ? instance.class.primary_key : link.primary_key
+        key = (type == "one_many") ? instance.class.primary_key :
+          link.primary_key
         value = instance.method(instance.class.primary_key).call
         fk_set = (type == "one_many") ? fk : value
         value_set = (type == "one_many") ? value : fk
-        @db.query "UPDATE #{firstclass.table_name} SET #{secondclass.foreign_key}=#{fk_set} WHERE #{key}=#{value_set};"
+        @db.query <<QUERY
+UPDATE #{firstclass.table_name} SET #{secondclass.foreign_key}=#{fk_set}
+WHERE #{key}=#{value_set};
+QUERY
       elsif type == "many_many"
         tablename1 = instance.class.table_name
         tablename2 = link.table_name
-        union_class = ((instance.class.name.downcase <=> link.name.downcase) < 0) ? "#{tablename1}_#{tablename2}" : "#{tablename2}_#{tablename1}"
+        union_class =
+          ((instance.class.name.downcase <=> link.name.downcase) < 0) ?
+          "#{tablename1}_#{tablename2}" : "#{tablename2}_#{tablename1}"
         value = instance.method(instance.class.primary_key).call
-        @db.query "INSERT INTO #{union_class} (#{instance.class.foreign_key}, #{link.foreign_key}) VALUES (#{value}, #{fk});"
+        @db.query <<QUERY
+INSERT INTO #{union_class}
+(#{instance.class.foreign_key}, #{link.foreign_key}) VALUES (#{value}, #{fk});
+QUERY
       end
     end
 

data/lib/webink/model.rb

@@ -139,15 +139,26 @@ module Ink
         i = 0
         self.class.fields.each do |k,v|
           if data.is_a? Array
-            raise LoadError.new("Model cannot be loaded, wrong number or arguments #{data.length} expected #{self.class.fields.length} or #{self.class.fields.length - 1}") if data.length < self.class.fields.length - 1 or data.length > self.class.fields.length
-            if self.class.primary_key != k or data.length == self.class.fields.length
+            if data.length < self.class.fields.length - 1 or
+                data.length > self.class.fields.length
+              raise LoadError.new(<<ERR)
+Model cannot be loaded, wrong number or arguments #{data.length} expected
+#{self.class.fields.length} or #{self.class.fields.length - 1}
+ERR
+            end
+            if self.class.primary_key != k or
+                data.length == self.class.fields.length
               init_field k, data[i]
               i += 1
             else
               init_field self.class.primary_key, nil
             end
           else
-            raise LoadError.new("Model cannot be loaded, argument missing: #{key}") if not data.key?(k.to_s) and self.class.primary_key != k
+            if not data.key?(k.to_s) and self.class.primary_key != k
+              raise LoadError.new(<<ERR)
+Model cannot be loaded, argument missing: #{key}
+ERR
+            end
             init_field k, data[k.to_s]
           end
         end
@@ -188,7 +199,11 @@ module Ink
     # [key:] String
     # [value:] Object
     def init_field(key, value)
-      raise NameError.new("Model cannot use #{key} as field, it is blocked by primary key") if key.to_s.downcase == "pk"
+      if key.to_s.downcase == "pk"
+        raise NameError.new(<<ERR)
+Model cannot use #{key} as field, it is blocked by primary key
+ERR
+      end
       entry = self.class.make_safe(value)
       instance_variable_set("@#{key}", entry)
 
@@ -231,7 +246,11 @@ module Ink
     # [key:] String
     def init_foreign(key)
       k_table = self.class.str_to_tablename(key)
-      raise NameError.new("Model cannot use #{k_table} as foreign, it already exists") if k_table == "pk"
+      if k_table == "pk"
+        raise NameError.new(<<ERR)
+Model cannot use #{k_table} as foreign, it already exists
+ERR
+      end
       if not self.respond_to?(k_table)
         instance_variable_set("@#{k_table}", nil)
         self.class.send(:define_method, k_table) do
@@ -250,7 +269,11 @@ module Ink
     # nil if you do not want to change them. Old references are
     # automatically removed.
     def save
-      raise NotImplementedError.new("Cannot save to Database without field definitions") if not self.class.respond_to? :fields
+      if not self.class.respond_to?(:fields)
+      raise NotImplementedError.new(<<ERR)
+Cannot save to Database without field definitions
+ERR
+      end
       string = Array.new
       keystring = Array.new
       valuestring = Array.new
@@ -259,21 +282,33 @@ module Ink
         value = instance_variable_get "@#{k}"
         value = "NULL" if value.nil?
         if k != self.class.primary_key
-          string.push "`#{k}`=#{(value.is_a?(Numeric)) ? value : "\'#{value}\'"}"
+          string.push "`#{k}`=#{(value.is_a?(Numeric)) ? value :
+            "\'#{value}\'"}"
           keystring.push "`#{k}`"
           valuestring.push "#{(value.is_a?(Numeric)) ? value : "\'#{value}\'"}"
         else
-          pkvalue = "WHERE `#{self.class.primary_key}`=#{(value.is_a?(Numeric)) ? value : "\'#{value}\'"}"
+          pkvalue = "WHERE `#{self.class.primary_key}`=#{
+            (value.is_a?(Numeric)) ? value : "\'#{value}\'"
+            }"
         end
       end
       if pkvalue
         response = Ink::Database.database.find self.class, pkvalue
         if response.empty?
-          Ink::Database.database.query "INSERT INTO #{self.class.table_name} (#{keystring * ","}) VALUES (#{valuestring * ","});"
+          Ink::Database.database.query <<QUERY
+INSERT INTO #{self.class.table_name}
+(#{keystring * ","}) VALUES
+(#{valuestring * ","});
+QUERY
           pk = Ink::Database.database.last_inserted_pk(self.class)
-          instance_variable_set "@#{self.class.primary_key}", pk.is_a?(Numeric) ? pk : "\'#{pk}\'" if pk
+          if pk
+            instance_variable_set("@#{self.class.primary_key}",
+              pk.is_a?(Numeric) ? pk : "\'#{pk}\'")
+          end
         else
-          Ink::Database.database.query "UPDATE #{self.class.table_name} SET #{string * ","} #{pkvalue};"
+          Ink::Database.database.query <<QUERY
+UPDATE #{self.class.table_name} SET #{string * ","} #{pkvalue};
+QUERY
         end
       end
 
@@ -281,8 +316,10 @@ module Ink
         self.class.foreign.each do |k,v|
           value = instance_variable_get "@#{self.class.str_to_tablename(k)}"
           if value
-            Ink::Database.database.delete_all_links self, Ink::Model.classname(k), v
-            Ink::Database.database.create_all_links self, Ink::Model.classname(k), v, value
+            Ink::Database.database.delete_all_links(self,
+              Ink::Model.classname(k), v)
+            Ink::Database.database.create_all_links(self,
+              Ink::Model.classname(k), v, value)
           end
         end
       end
@@ -294,15 +331,24 @@ module Ink
     # obsolete. Disregard from using the instance anymore.
     # All links between models will be removed also.
     def delete
-      raise NotImplementedError.new("Cannot delete from Database without field definitions") if not self.class.respond_to? :fields
+      if not self.class.respond_to? :fields
+      raise NotImplementedError.new(<<ERR)
+Cannot delete from Database without field definitions
+ERR
+      end
       if self.class.respond_to? :foreign
         self.class.foreign.each do |k,v|
-          Ink::Database.database.delete_all_links self, Ink::Model.classname(k), v
+          Ink::Database.database.delete_all_links(self,
+            Ink::Model.classname(k), v)
         end
       end
 
       pkvalue = instance_variable_get "@#{self.class.primary_key}"
-      Ink::Database.database.remove self.class.name, "WHERE `#{self.class.primary_key}`=#{(pkvalue.is_a?(Numeric)) ? pkvalue : "\'#{pkvalue}\'"}"
+      Ink::Database.database.remove self.class.name, <<QUERY
+WHERE `#{self.class.primary_key}`=#{
+(pkvalue.is_a?(Numeric)) ? pkvalue : "\'#{pkvalue}\'"
+}
+QUERY
     end
 
     # Instance method
@@ -311,11 +357,15 @@ module Ink
     # matching foreign accessor
     # [param foreign_class:] Defines the foreign class name or class
     def find_references(foreign_class)
-      c = (foreign_class.is_a? Class) ? foreign_class : Ink::Model.classname(foreign_class)
+      c = (foreign_class.is_a? Class) ? foreign_class :
+        Ink::Model.classname(foreign_class)
       relationship = self.class.foreign[c.class_name]
       if relationship
-        result_array = (relationship == "many_many") ? Ink::Database.database.find_union(self.class, self.pk, c) : Ink::Database.database.find_references(self.class, self.pk, c)
-        instance_variable_set("@#{c.table_name}", (relationship =~ /^one_/) ? result_array.first : result_array)
+        result_array = (relationship == "many_many") ?
+          Ink::Database.database.find_union(self.class, self.pk, c) :
+          Ink::Database.database.find_references(self.class, self.pk, c)
+        instance_variable_set("@#{c.table_name}",
+          (relationship =~ /^one_/) ? result_array.first : result_array)
         true
       else
         false
@@ -330,7 +380,11 @@ module Ink
     # [returns:] Array of SQL statements
     def self.create
       result = Array.new
-      raise NotImplementedError.new("Cannot create a Database without field definitions") if not self.respond_to? :fields
+      if not self.respond_to?(:fields)
+        raise NotImplementedError.new(<<ERR)
+Cannot create a Database without field definitions
+ERR
+      end
 
       string = "CREATE TABLE #{self.table_name} ("
       mfk = self.foreign_key
@@ -346,7 +400,12 @@ module Ink
          tmp = self.foreign.map do |k,v|
            f_class = Ink::Model::classname(k)
            if v == "many_many" and (self.name <=> k) < 0
-             result.push "CREATE TABLE #{self.table_name}_#{Ink::Model::str_to_tablename(k)} (#{Ink::Database.database.primary_key_autoincrement*" "}, `#{self.foreign_key}` #{self.foreign_key_type}, `#{f_class.foreign_key}` #{f_class.foreign_key_type});"
+             result.push <<QUERY
+CREATE TABLE #{self.table_name}_#{Ink::Model::str_to_tablename(k)}
+(#{Ink::Database.database.primary_key_autoincrement*" "},
+`#{self.foreign_key}` #{self.foreign_key_type},
+`#{f_class.foreign_key}` #{f_class.foreign_key_type});
+QUERY
              nil
            end
            if v == "one_many" or (v == "one_one" and (self.name <=> k) < 0)
@@ -387,9 +446,12 @@ module Ink
     def self.str_to_classname(str)
       res = []
       str.scan(/((^|_)([a-z0-9]+))/) { |s|
-        res.push(s[2][0].upcase + ((s[2].length > 1) ? s[2][1,s[2].length] : "")) if s.length > 0
+        if s.length > 0
+          res.push(s[2][0].upcase +
+            ((s[2].length > 1) ? s[2][1,s[2].length] : ""))
+        end
       }
-      ((Module.const_get res.join).is_a? Class) ? res.join : nil
+      Module.const_get(res.join).is_a?(Class) ? res.join : nil
     end
 
     # Class method
@@ -404,7 +466,7 @@ module Ink
       str.scan(/([A-Z][a-z0-9]*)/) { |s|
         res.push (res.length>0) ? "_" + s.join.downcase : s.join.downcase
       }
-      ((Module.const_get str).is_a? Class) ? res.join : nil
+      Module.const_get(str).is_a?(Class) ? res.join : nil
     end
 
     # Class method
@@ -418,12 +480,15 @@ module Ink
       res = []
       if str[0] =~ /^[a-z]/
         str.scan(/((^|_)([a-z0-9]+))/) { |s|
-          res.push(s[2][0].upcase + ((s[2].length > 1) ? s[2][1,s[2].length] : "")) if s.length > 0
+          if s.length > 0
+            res.push(s[2][0].upcase +
+              ((s[2].length > 1) ? s[2][1,s[2].length] : ""))
+          end
         }
       else
         res.push str
       end
-      ((Module.const_get res.join).is_a? Class) ? (Module.const_get res.join) : nil
+      Module.const_get(res.join).is_a?(Class) ? Module.const_get(res.join) : nil
     end
 
     # Class method

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: webink
 version: !ruby/object:Gem::Version
-  version: 2.1.1
+  version: 3.0.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,16 +9,16 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-16 00:00:00.000000000 Z
+date: 2013-06-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: fcgi
+  name: rack
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 0.8.8
+        version: 1.5.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -26,28 +26,12 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 0.8.8
-- !ruby/object:Gem::Dependency
-  name: simple-mmap
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: 1.1.4
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: 1.1.4
+        version: 1.5.2
 description: 
 email: 
 executables:
 - webink_database
-- rfcgi
+- webink_init
 extensions: []
 extra_rdoc_files: []
 files:
@@ -57,7 +41,7 @@ files:
 - lib/webink/database.rb
 - lib/webink/model.rb
 - bin/webink_database
-- bin/rfcgi
+- bin/webink_init
 - LICENSE.md
 homepage: https://github.com/matthias-geier/WebInk
 licenses: []

data/bin/rfcgi

@@ -1,143 +0,0 @@
-#!/usr/bin/env ruby
-
-require "fcgi"
-require "simple_mmap"
-require "webink/beauty"
-
-def getBinding(cgi,env,params)
-  return binding
-end
-def error(cgi, code)
-  puts cgi.header
-  puts cgi.header("nph" => true, "status" => code, "connection" => "close", "type" => "text/html")
-end
-
-script = nil
-fhandle = nil
-control = nil
-pram = nil
-is_production = nil
-use_errors = nil
-FCGI.each_cgi do |cgi|
-  is_production = ((cgi.env_table["INK_PRODUCTION"] and eval cgi.env_table["INK_PRODUCTION"]) or (ENV["INK_PRODUCTION"] and eval ENV["INK_PRODUCTION"])) ? true : false
-  use_errors = ((cgi.env_table["INK_ERRORS"] and eval cgi.env_table["INK_ERRORS"]) or (ENV["INK_ERRORS"] and eval ENV["INK_ERRORS"])) ? true : false
-  time = Time.now
-  script = cgi.env_table['SCRIPT_FILENAME']
-  begin
-    pram = Hash.new
-    CGI::parse(cgi.env_table['QUERY_STRING'].gsub(/\?/, "&")).each do |k,v|
-      if v.is_a? Array
-        if v.length == 0
-          pram[k] = nil
-        elsif v.length == 1
-          pram[k] = v[0]
-        else
-          pram[k] = v
-        end
-      else
-        pram[k] = v
-      end
-    end
-    control = pram['controller']
-    routes = Ink::Beauty.load_routes script
-    fhandle = SimpleMmap::MappedFile.new(routes)
-    Dir.chdir( File.dirname(routes) )
-    control = eval fhandle.read_window_data(0,fhandle.size), getBinding(cgi,cgi.env_table,control) if fhandle
-    fhandle.close
-    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
-    control[:env] = ENV
-    control[:is_production] = is_production
-    control[:use_errors] = use_errors
-    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][0] if control[:post][k].length <= 1
-        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 = SimpleMmap::MappedFile.new(script)
-    Dir.chdir( File.dirname(script) )
-    eval fhandle.read_window_data(0,fhandle.size), getBinding(cgi,cgi.env_table,control) if fhandle
-    fhandle.close
-
-  rescue LoadError => bang
-    if is_production
-      puts cgi.header({"Location" => "/status-404.html"}) if use_errors
-      error cgi, "NOT_FOUND" if not use_errors
-    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 is_production
-      puts cgi.header({"Location" => "/status-500.html"}) if use_errors
-      error cgi, "SERVER_ERROR" if not use_errors
-    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 is_production
-      puts cgi.header({"Location" => "/status-500.html"}) if use_errors
-      error cgi, "SERVER_ERROR" if not use_errors
-    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 is_production
-      puts cgi.header({"Location" => "/status-500.html"}) if use_errors
-      error cgi, "SERVER_ERROR" if not use_errors
-    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 is_production
-      puts cgi.header({"Location" => "/status-500.html"}) if use_errors
-      error cgi, "SERVER_ERROR" if not use_errors
-    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 is_production
-      puts cgi.header({"Location" => "/status-500.html"}) if use_errors
-      error cgi, "SERVER_ERROR" if not use_errors
-    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
-