ki 0.3.3 → 0.4.1

data/lib/ki.rb

@@ -1,28 +1,28 @@
-require 'rack'
+require 'yaml'
+require 'uri'
 
+require 'rack'
+require 'rack/parser'
 require 'haml'
 require 'sass'
 require 'coffee-script'
+require 'mongo'
+
 
-require 'conf'
-require 'db'
-require 'model'
-require 'helpers'
-require 'util'
-require 'req'
-require 'resp'
-require 'static_file'
-require 'mockreq'
+require 'ki/api_error'
 
-Dir['public/**/**'].each do |s|
-  Ki::StaticFile.compile_css(s)
-  Ki::StaticFile.compile_js(s)
-end
+require 'ki/modules/query_interface'
+require 'ki/modules/restrictions'
+require 'ki/modules/callbacks'
+require 'ki/modules/model_helpers'
+require 'ki/modules/view_helper'
+require 'ki/modules/format_of'
+require 'ki/modules/public_file_helper'
 
-module Ki
-  class Ki
-    def call env
-      Req.new(env).serve
-    end
-  end
-end
+require 'ki/ki_config'
+require 'ki/helpers'
+require 'ki/orm'
+require 'ki/ki'
+require 'ki/model'
+require 'ki/middleware'
+require 'ki/base_request'

data/lib/ki/api_error.rb

@@ -0,0 +1,28 @@
+module Ki
+  class ApiError < StandardError
+    attr_reader :status
+
+    def initialize body, status=400
+      super body
+      @status = status
+    end
+
+    def result
+      { 'error' => to_s }
+    end
+  end
+
+  class InvalidUrlError < ApiError; end
+  class RequiredAttributeMissing < ApiError; end
+  class AttributeNotUnique < ApiError; end
+  class ForbiddenAction < ApiError
+    def initialize
+      super 'action forbidden', 400
+    end
+  end
+  class PartialNotFoundError < ApiError
+    def initialize s
+      super "partial #{s} not found", 404
+    end
+  end
+end

data/lib/ki/base_request.rb

@@ -0,0 +1,34 @@
+module Ki
+  class BaseRequest < Rack::Request
+    include FormatOf
+
+    def root?
+      path == '/'
+    end
+
+    def json?
+      content_type == 'application/json' || format_of(path) == 'json'
+    end
+
+    def to_ki_model_class
+      self.path.to_s.gsub('/','').gsub(format_of(path), '').gsub('.', '').to_class
+    end
+
+    def to_action
+      case request_method
+      when 'GET'
+        :find
+      when 'POST'
+        :create
+      when 'PUT'
+        :update
+      when 'DELETE'
+        :delete
+      when 'SEARCH'
+        :find
+      else
+        raise 'unkown action'
+      end
+    end
+  end
+end

data/lib/ki/helpers.rb

@@ -0,0 +1,55 @@
+class String
+  def to_class
+    chain = self.split "::"
+    klass = Kernel
+    chain.each do |klass_string|
+      klass = klass.const_get klass_string.capitalize
+    end
+    klass.is_a?(Class) ? klass : nil
+  rescue NameError
+    nil
+  end
+end
+
+class Array
+  def stringify_ids
+    self.collect do |e|
+      if e['_id']
+        e['id'] = e['_id'].to_s
+        e.delete('_id')
+      end
+      if e[:_id]
+        e['id'] = e[:_id].to_s
+        e.delete(:_id)
+      end
+      e
+    end
+  end
+end
+
+module Ki
+  module Helpers
+    include ViewHelper
+
+    def css url
+      render_haml "%link{:href => '#{url}', :rel => 'stylesheet'}"
+    end
+
+    def js url
+      render_haml "%script{:src => '#{url}'}"
+    end
+
+    def render_haml s
+      Haml::Engine.new(s).render
+    end
+
+    def partial s
+      path = view_path(s)
+      if File.file?(path)
+        render_haml(File.read(path))
+      else
+        raise PartialNotFoundError.new path
+      end
+    end
+  end
+end

data/lib/ki/ki.rb

@@ -0,0 +1,40 @@
+module Ki
+  class KiApp
+    # should never reach this
+    # middleware should catch all the requests
+    def call env
+      s = 'misplaced in space'
+      Rack::Response.new(s).finish
+    end
+  end
+
+  class Ki
+    PUBLIC_PATH = 'public'
+    VIEWS_PATH = 'views'
+
+    def initialize
+      KiConfig.instance.read environment
+      Orm::Db.instance.establish_connection
+
+      @app = Rack::Builder.new do
+        use Middleware::InitMiddleware
+        # TODO what happens with invalid json?
+        use Rack::Parser, :content_types => { 'application/json'  => Proc.new { |body| ::MultiJson.decode body } }
+        use Middleware::ApiHandler
+        use Middleware::CoffeeCompiler
+        use Middleware::SassCompiler
+        use Middleware::HamlCompiler
+        use Middleware::PublicFileServer
+        run KiApp.new
+      end
+    end
+
+    def environment
+      ENV['RACK_ENV']
+    end
+
+    def call env
+      @app.call env
+    end
+  end
+end

data/lib/ki/ki_cli.rb

@@ -0,0 +1,46 @@
+require 'thor'
+
+class KiGenerator < Thor::Group
+  include Thor::Actions
+
+  def self.source_root
+    File.join(File.dirname(__FILE__), '..', '..')
+  end
+end
+
+class AppGenerator < KiGenerator
+
+  argument :app_name
+
+  def prepare_dir
+    unless app_name =~ /^[a-zA-Z0-9-]*$/
+      say "App name must contain only alphanumeric characters and -"
+      exit 1
+    end
+
+    if Dir.exists? app_name
+      say "#{app_name} already exists"
+      exit 2
+    end
+
+    Dir.mkdir app_name
+  end
+
+  def create_app
+    directory("spec/examples/base", app_name)
+
+    # Set database names
+    config_file = File.read("#{app_name}/config.yml")
+    config_file.gsub!("name: np_development", "name: #{app_name}_development")
+    config_file.gsub!("name: np_test", "name: #{app_name}_test")
+    config_file.gsub!("name: np", "name: #{app_name}")
+    File.open("#{app_name}/config.yml", "w") {|file| file.puts config_file}
+
+    # Set rvm gemset name
+    `echo #{app_name} > #{app_name}/.ruby-gemset`
+  end
+end
+
+class KiCli < Thor
+  register AppGenerator, :new, 'new [APP_NAME]', 'generate a new app'
+end

data/lib/ki/ki_config.rb

@@ -0,0 +1,20 @@
+require 'singleton'
+
+module Ki
+  class KiConfig
+    include Singleton
+
+    CONFIG_FILE_PATH = 'config.yml'
+
+    attr_reader :config, :environment
+
+    def read environment
+      @environment = environment
+      @config = YAML.load_file(CONFIG_FILE_PATH)[environment]
+    end
+
+    def database
+      @config['database']
+    end
+  end
+end

data/lib/ki/middleware.rb

@@ -0,0 +1,155 @@
+module Ki
+  module Middleware
+    module BaseMiddleware
+      include FormatOf
+      include ViewHelper
+      include PublicFileHelper
+
+      def initialize app
+        @app = app
+      end
+    end
+
+    class PublicFileServer
+      include BaseMiddleware
+
+      def call env
+        req = BaseRequest.new env
+        if public_file_exists? req
+          Rack::File.new(Ki::PUBLIC_PATH).call env
+        else
+          @app.call env
+        end
+      end
+    end
+
+    class InitMiddleware
+      include BaseMiddleware
+
+      def call env
+        req = BaseRequest.new env
+        if req.root?
+          resp = Rack::Response.new
+          resp.redirect('/index')
+          resp.finish
+        else
+          env['CONTENT_TYPE'] = 'application/json' if format_of(req) == 'json'
+          @app.call env
+        end
+      end
+    end
+
+    class HamlCompiler
+      include BaseMiddleware
+
+      def call env
+        req = BaseRequest.new env
+        if view_exists?(req)
+          render_haml view_path(req)
+        else
+          @app.call env
+        end
+      end
+
+      def render_haml file_path
+        file_contents = File.read(file_path)
+
+        if view_exists? 'layout'
+          layout_contents = File.read(view_path('layout'))
+        else
+          layout_contents = "= yield"
+        end
+
+        html = haml(layout_contents).render do
+          haml(file_contents).render
+        end
+
+        Rack::Response.new(html).finish
+      end
+
+      def haml s
+        Haml::Engine.new("- extend Ki::Helpers\n" + s)
+      end
+    end
+
+    class CoffeeCompiler
+      include BaseMiddleware
+
+      def call env
+        req = BaseRequest.new env
+        coffee_path = req.path.to_s[0...-3] + '.coffee'
+        if !public_file_exists?(req) && format_of(req) == 'js' && public_file_exists?(coffee_path)
+          js = CoffeeScript.compile(File.read(public_file_path(coffee_path)))
+          Rack::Response.new(js).finish
+        else
+          @app.call env
+        end
+      end
+    end
+
+    class SassCompiler
+      include BaseMiddleware
+
+      def call env
+        req = BaseRequest.new env
+        sass_path = req.path.to_s[0...-4] + '.sass'
+        # if req ends with css and it does not exist, if a sass file exists instead
+        if !public_file_exists?(req) && format_of(req) == 'css' && public_file_exists?(sass_path)
+          eng = Sass::Engine.new(File.read(public_file_path(sass_path)), :syntax => :sass)
+          Rack::Response.new(eng.render).finish
+        else
+          @app.call env
+        end
+      end
+    end
+
+    # Handles all API calls
+    #
+    # Any json request is considered an api call. A request is considered as json
+    # if the format is .json or Content-Type header is set to 'application/json'
+    #
+    # If the query param 'redirect_to' is given, the response will not contain the
+    # json output from the url, instead it will redirect to the url given
+    class ApiHandler
+      include BaseMiddleware
+
+      def call env
+        req = BaseRequest.new env
+        if req.json?
+          begin
+            klass = req.to_ki_model_class
+            if Model.descendants.include? klass
+              # TODO do not have redirect_to param
+              model = klass.new(req.to_action, req.params)
+              # TODO document this
+              if req.params['redirect_to'].nil?
+                render model
+              else
+                # TODO check for injection
+                redirect_to req.params['redirect_to']
+              end
+            else
+              raise InvalidUrlError.new("invalid url '#{req.path}'", 404)
+            end
+          rescue ApiError => e
+            render e
+          end
+        else
+          @app.call env
+        end
+      end
+
+      def redirect_to s
+        resp = Rack::Response.new
+        resp.redirect(s)
+        resp.finish
+      end
+
+      def render r
+        resp = Rack::Response.new(r.result.to_json, r.status)
+        resp['Content-Type'] = 'application/json'
+        resp.finish
+      end
+    end
+  end
+end

data/lib/ki/model.rb

@@ -0,0 +1,70 @@
+module Ki
+  class Model
+    extend QueryInterface
+    extend Restrictions
+    include Callbacks
+    include ModelHelpers
+
+    attr_accessor :action, :result, :params, :status
+
+    def initialize action, params
+      @action = action
+      @params = params
+      @status = 200
+
+      raise ForbiddenAction.new if forbidden_actions.include? @action
+      ccall
+    end
+
+    def find
+      @result = self.class.find @params
+    end
+
+    def create
+      check_for_required_attributes
+      check_for_unique_attributes
+      @result = self.class.create @params
+    end
+
+    def update
+      check_for_required_attributes
+      check_for_unique_attributes
+      @result = self.class.update @params
+    end
+
+    def delete
+      @result = self.class.delete @params
+    end
+
+    private
+
+    def check_for_required_attributes
+      required_attributes.each do |ra|
+        if !@params.keys.include?(ra.to_s)
+          raise RequiredAttributeMissing.new("#{ra.to_s} missing")
+        end
+      end
+    end
+
+    def check_for_unique_attributes
+      unique_attributes.each do |ua|
+        u = self.class.find({ua.to_s => @params[ua.to_s]})
+        unless u.empty?
+          raise AttributeNotUnique.new("#{ua.to_s} not unique")
+        end
+      end
+    end
+
+    def ccall
+      before_all
+      send "before_#{@action.to_s}".to_sym
+      send @action.to_sym
+      send "after_#{@action.to_s}".to_sym
+      after_all
+    end
+
+    def self.descendants
+      ObjectSpace.each_object(Class).select { |klass| klass < self }
+    end
+  end
+end