ki 0.0.2 → 0.1.0

data/lib/db.rb

@@ -6,44 +6,74 @@ module Ki
   class Db
     include Singleton
 
-    attr_accessor :db
+    attr_reader :db
 
-    def all name
-      items = []
-      @db[name].find.each { |row| items << row }
-      items
+    def collection_names
+      @db.collection_names.delete_if{|name| name =~ /^system/}
+    end
+
+    def remove_collections
+      collection_names.each{|c| @db[c].drop}
+    end
+
+    def find_all name
+      @db[name].find.collect{ |row| row }
     end
 
     def find name, id
-      item = @db[name].find(:_id => BSON::ObjectId(id))
-      item.to_a.first
+      @db[name].find( { '_id' => BSON::ObjectId(id) }).first
+    end
+
+    def find_by name, hash
+      @db[name].find(hash).to_a
     end
 
-    def insert name, hash
-      @db[name].insert(hash)
+    def create name, hash
+      @db[name].insert(hash).to_s
     end
 
-    # document doesn't update if id is in the hash
+    # document doesn't update if :_id is in the hash
+    # all prev object data is deleted
     def update name, hash
       id = hash['_id']
       hash.delete('_id')
       @db[name].update({:_id => BSON::ObjectId(id)}, hash)
+      id
     end
 
-    def remove name, id
+    def delete name, id
       @db[name].remove(:_id => BSON::ObjectId(id))
     end
     
-    def clear_model_subclasses
-      @db['ki_model_subclasses'].remove
+    def config_db
+      yaml = read_yaml
+      config yaml['host'], yaml['port'], yaml['db_name']
     end
 
     def config host, port, db_name
+      # puts "Using #{db_name} at #{host}:#{port}"
       @con = Mongo::Connection.new(host, port)
       @db = @con.db(db_name)
     rescue Mongo::ConnectionFailure
       puts "Could not connect to MongoDB"
       exit 1
     end
+
+    private
+
+    def read_yaml
+      config_path = File.join(Dir.pwd, 'config.yml')
+      yaml = {}
+      if File.exists? config_path
+        YAML.load_file(config_path)
+      else
+        {
+          'host' => '127.0.0.1',
+          'port' => 27017,
+          'db_name' => Util.app_name
+        }
+      end
+    end
   end
 end
+

data/lib/extensions/mail.rb

@@ -0,0 +1,41 @@
+require 'net/smtp'
+
+module Ki
+  # Extension module which helps with sending emails.
+  # Include it in a Ki::Model to load its send_mail method
+  #
+  # === Example
+  #   class Article < Ki::Model
+  #     include Ki::Mail
+  #   end
+  module Mail
+    def send_mail *params
+      params = params[0] if params.class == Array
+
+      if params.length != 4
+        raise 'params missing'
+      end
+      
+      params.each do |elem|
+        if !self.class.required_attributes.include? elem
+          raise "invalid attribute #{elem.to_s}" 
+        end
+      end
+
+      from = @req[params[0].to_s]
+      to = @req[params[1].to_s]
+      subject = @req[params[2].to_s]
+      body = @req[params[3].to_s]
+
+      really_send "#{subject}\n\n#{body}", from, to
+    end
+
+    private
+
+    def really_send message, from, to
+      Net::SMTP.start('localhost') do |smtp|
+        smtp.send_message message, from, to
+      end
+    end
+  end
+end

data/lib/helpers.rb

@@ -0,0 +1,16 @@
+module Ki
+  module Helpers
+    def haml contents
+      Haml::Engine.new(contents)
+    end
+
+    def partial s, hash={}
+      path = Util.root_view_path s
+      unless File.exists? path
+        path = File.join(Util.src_path, 'views', s) + '.haml'
+      end
+      contents = File.read(path)
+      haml(contents).render(Object.new(), hash)
+    end
+  end
+end

data/lib/ki.rb

@@ -1,39 +1,20 @@
 require 'rack'
 require 'haml'
 
-require 'util'
 require 'db'
-require 'request'
-require 'modules'
 require 'model'
-require 'controller'
-require 'response'
+require 'helpers'
+require 'util'
+require 'req'
+require 'resp'
+require 'static_file'
 
-Ki::Util.config_db
-Ki::Db.instance.clear_model_subclasses
+Ki::Db.instance.config_db
 
 module Ki
   class Ki
-    def self.new
-      Rack::Builder.new do
-        Util.static_files.each do |sf|
-          map "/public/#{File.basename(sf)}" do
-            run Rack::File.new(sf)
-          end
-        end
-
-        map '/' do
-          run Controller.new
-        end
-      end
-    end
-
-    def self.root
-      File.join(File.expand_path(File.join(File.dirname(__FILE__), '..')))
-    end
-
-    def self.app_name
-      File.basename(Dir.getwd)
+    def call env
+      Req.new(env).serve
     end
   end
 end

data/lib/ki_cli.rb

@@ -0,0 +1,63 @@
+require 'thor'
+
+require 'util'
+
+class KiGenerator < Thor::Group
+  include Thor::Actions
+
+  def self.source_root
+    File.join(File.dirname(__FILE__), '..', 'examples', 'base')
+  end
+end
+
+class ConfigGenerator < KiGenerator
+  def generate
+    create_file 'config.yml' do
+      "host: 127.0.0.1\nport: 27017\ndb_name: #{Ki::Util.app_name}\n"
+    end
+  end
+end
+
+class AppGenerator < KiGenerator
+
+  argument :app_name
+
+  def prepare_dir
+    dest_root = File.join(Dir.pwd, app_name)
+
+    if Dir.exists? dest_root
+      unless yes? "#{app_name} already exists. Do you want to overwrite it?"
+        say 'aborted'
+        exit 1
+      end
+    else
+      Dir.mkdir dest_root
+    end
+  end
+
+  def create_app
+    dest_root = File.join(Dir.pwd, app_name)
+
+    ['Gemfile', 'config.ru', 'app.rb'].each do |f|
+      copy_file f, File.join(dest_root, f)
+    end
+  end
+end
+
+class KiCli < Thor
+  register AppGenerator, :new, 'new [APP_NAME]', 'generate a new app'
+  register ConfigGenerator, :config, 'config', 'generate a new config.yml'
+
+  desc 'server', 'starts the app'
+  # method_option :reload, :type => :boolean, :aliases => '-r', :desc => 'Recommended for development'
+  method_option :port, :type => :numeric, :aliases => '-p', :desc => 'port'
+  def server
+    port = options[:port] ? options[:port] : 3000
+    # if options[:reload]
+    #  say 'Starting Ki Reloaded', :yellow
+    #else
+    say 'Starting Ki', :green
+    #end
+    system "bundle exec thin start -p #{port}"
+  end
+end

data/lib/model.rb

@@ -1,128 +1,95 @@
+require 'modules/callbacks'
+require 'modules/restrictions'
+require 'modules/query_interface'
+
+require 'extensions/mail'
+
 module Ki
   class Model
     extend Restrictions
+    extend QueryInterface
+    include InitRestrictions
     include Callbacks
 
+    attr_accessor :hash
     attr_reader :req
 
     def initialize req
-      @req = req
+      @hash = {}
       @db = Db.instance
-    end
+      @req = req
 
-    def forbid_actions
-      []
+      action = to_action(req)
+      raise 'action forbidden' if forbidden_actions.include? action
+      ccall action
     end
 
-    def respond_to
-      [:json, :html]
-    end
+    def find
+      raise 'params missing' unless @req.params
+      raise 'param _id missing' unless @req.params['_id']
 
-    def required_attributes
-      []
+      @hash = @db.find(class_name, @req.params['_id'])
+      raise "#{class_name} not found" if @hash.nil?
     end
 
-    def format_response code, message, error=false
-      if message.class == String
-        message = { :message => message }
-      end
-      unless message.class == Array
-        message = [message]
-      end
+    def create
+      check_for_required_attributes
+      @hash['_id'] = @db.create(class_name, @req.params)
+    end
 
-      # fix this hack
-      @req[:code] = code
+    def update
+      raise 'params missing' unless @req.params
+      raise 'param _id missing' unless @req.params['_id']
 
-      return {
-        :code => code,
-        :message => message,
-        :format => @req.format
-      }
+      check_for_required_attributes
+      @hash['_id'] = @db.update(class_name, @req.params)
     end
 
-    # TODO fix this method
-    def to_response
-      if self.class == Model
-        return format_response(404, 'did you get lost?')
-      end
+    def delete
+      raise 'params missing' unless @req.params
+      raise 'param _id missing' unless @req.params['_id']
 
-      unless respond_to.include? @req.format
-        return format_response(403, 'format not allowed')
-      end
+      @hash = @db.delete(class_name, @req.params['_id'])
+    end
 
-      unless route_allowed?
-        return format_response(403, 'not allowed')
-      end
+    def to_json
+      @hash.to_json
+    end
 
-      case @req.request_method
-      when 'GET'
-        if @req.params['_id']
-          s = @db.find(@req.base, @req.params['_id'])
-        else
-          s = @db.all(@req.base)
-        end
+    def class_name
+      self.class.to_s.downcase
+    end
 
-        return format_response(200, s)
-      when 'POST'
-        before_create
-        required_attributes.each do |ra|
-          unless @req.params.keys.include? ra.to_s
-            return format_response(400, "required attribute #{ra} missing")
-          end
-        end
-        id = @db.insert(@req.base, @req.params)
-        after_create
-        return format_response(200, id)
-      when 'PUT'
-        if @req.params['_id']
-          required_attributes.each do |ra|
-            unless @req.params.keys.include? ra.to_s
-              return format_response(400, "required attribute #{ra} missing")
-            end
-          end
-
-          before_update
-          result = @db.update(@req.base, @req.params)
-          after_update
-          return format_response(200, result)
-        else
-          return format_response(400, 'missing param _id')
-        end
-      when 'DELETE'
-        if @req.params['_id']
-          before_delete
-          result = @db.remove(@req.base, @req.params['_id'])
-          after_delete
-          return format_response(200, result)
-        else
-          return format_response(400, 'missing param _id')
+    private
+
+    def check_for_required_attributes
+      required_attributes.each do |ra|
+        unless @req.params.keys.include? ra.to_s
+          raise "#{ra.to_s} missing"
         end
-      else
-        return format_response(405, 'method not allowed')
       end
-    rescue BSON::InvalidObjectId
-      return format_response(400, "invalid object _id")
     end
 
-    private
-
-    def route_allowed?
-      case @req.request_method
+    def to_action req
+      case req.request_method
       when 'GET'
-        if @req.params['_id']
-          !forbid_actions.include? :find
-        else
-          !forbid_actions.include? :find_all
-        end
+        :find
       when 'POST'
-        !forbid_actions.include? :create
+        :create
       when 'PUT'
-        !forbid_actions.include? :update
+        :update
       when 'DELETE'
-        !forbid_actions.include? :delete
+        :delete
       else
-        false
+        raise 'unkown action'
       end
     end
+
+    # calls method m + before and after methods
+    def ccall m
+      send "before_#{m.to_s}".to_sym
+      send m.to_sym
+      send "after_#{m.to_s}".to_sym
+    end
   end
 end