kenji 0.3.0

data/.gitignore

@@ -0,0 +1,2 @@
+pkg
+Gemfile.lock

data/Gemfile

@@ -0,0 +1,5 @@
+gem 'inifile'
+gem 'json'
+gem 'rack'
+
+source :rubygems

data/LICENSE

@@ -0,0 +1,15 @@
+The Azure License
+
+Copyright (c) 2011 Kenneth Ballenegger
+
+Attribute to Kenneth Ballenegger - http://kswizz.com/
+
+You (the licensee) are hereby granted permission, free of charge, to deal in this software or source code (this "Software") without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, and/or sublicense this Software, subject to the following conditions:
+
+You must give attribution to the party mentioned above, by name and by hyperlink, in the about box, credits document and/or documentation of any derivative work using a substantial portion of this Software.
+
+You may not use the name of the copyright holder(s) to endorse or promote products derived from this Software without specific prior written permission.
+
+THIS 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 THIS SOFTWARE OR THE USE OR OTHER DEALINGS IN THIS SOFTWARE.
+
+http://license.azuretalon.com/

data/README.md

@@ -0,0 +1,84 @@
+*Project is still actively in development.*
+
+
+# Kenji
+
+Kenji is a lightweight backend framework for Ruby.
+
+
+## Rationale
+
+Kenji believes that a traditional web application should be divided into two parts: an client application running in the browser (HTML/JS/CSS), and a backend API with which it communicates. Kenji is the backend side of the equation, while the front-end architecture is left up to the user. (Popular options are [backbone][] and [spine][].)
+
+[backbone]: http://documentcloud.github.com/backbone/
+[spine]: http://spinejs.com/
+
+Kenji believes that in order to keep clean and organized code, routes should be defined inline with their code.
+
+Kenji believes that an app should be usable as a library from scripts or from the command line. An app should be automatable and testable.
+
+Lastly, Kenji is opinionated, but only about things that directly pertain to routing and code architecture. Kenji believes in being a ligthweight module that only solves the problem it focuses on. Everything else is left up to the user. (ORM, data store, web server, message queue, front-end framework, deployment process, etc.)
+
+
+### Routing
+
+Kenji wants you to organize your code into logical units of code, aka. controllers. The controllers will automatically be selected based on the url requested, and the rest of the route is defined inline in the controller, with a domain-specific-language.
+
+The canonical Hello World example for the URL `/hello/world` in Kenji would look like this, in `controller/hello.rb`:
+
+````ruby
+class HelloController < Kenji::Controller
+    get '/world' do
+        {hello: :world}
+    end
+end
+````
+
+A more representative example might be:
+
+````ruby
+class UserController < Kenji::Controller
+
+    # ...
+
+    get '/:id/friends' do |id|
+        # list friends for id
+    end
+
+    post '/:id/friend/:id' do |id, friend_id|
+        # add connection from user id to friend_id
+    end
+
+    delete '/:id/friend/:id' do |id, friend_id|
+        # delete connection from user id to friend_id
+    end
+end
+````
+
+
+### Data Transport
+
+JSON is used as the singular data transport for Kenji. Requests are assumed to have:
+
+    Content-Type: application/json; charset=utf-8
+    Accept: application/json; charset=utf-8
+
+
+## Usage
+
+Getting started with Kenji could not be any easier. All it takes is a few lines and a terminal:
+
+    $ gem install kenji         # (once kenji is on the rubygems main source)
+    $ kenji-init app_name; cd app_name
+    $ rackup                    # launch the webserver
+
+And already, your app is ready to go:
+
+    $ curl http://localhost:9292/hello/world
+    {"hello":"world"}
+
+
+## Requirements & Assumptions
+
+- Requires rubygems and bundler.
+- Requires Ruby 1.9.

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/bin/kenji-init

@@ -0,0 +1,36 @@
+#!/usr/bin/env ruby
+
+path = '.' << '/' << (ARGV.first || '.')
+app_name =  File.basename(path)
+
+Dir.mkdir(path) unless File.directory?(path)
+path = File.realpath(path)
+
+init_source = File.realpath(File.dirname(File.dirname(__FILE__))) << '/inited'
+
+for_earch_item = lambda do |item, base|
+    next if item == '.' || item == '..'
+    item_to_create = item.gsub('__APP_NAME__', app_name)
+
+    
+    if File.directory?("#{init_source}/#{base}/#{item}")
+        Dir.mkdir("#{path}/#{base}/#{item_to_create}") unless File.directory?("#{path}/#{base}/#{item}")
+        puts "Initializing directory #{base}/#{item_to_create}"
+        Dir.foreach("#{init_source}/#{base}/#{item}") { |i| for_earch_item.call(i, "#{base}/#{item}") }
+    else
+        puts "Generating content for file #{base}/#{item_to_create}"
+        data = ''
+        f = File.open("#{init_source}/#{base}/#{item}", 'r')
+        while line = f.gets
+            data += (line.gsub('__APP_NAME__', app_name))
+        end
+        f.close
+        f = File.open("#{path}/#{base}/#{item_to_create}", 'w')
+        f.puts data
+        f.close
+    end
+end
+
+Dir.foreach(init_source) { |i| for_earch_item.call(i, '.') }
+
+system("cd #{path}; bundle install")

data/inited/.gitignore

@@ -0,0 +1,2 @@
+tmp
+Gemfile.lock

data/inited/Gemfile

@@ -0,0 +1,4 @@
+gem 'rack'
+gem 'kenji'
+
+source :rubygems

data/inited/README.md

@@ -0,0 +1,3 @@
+# Hello, world!
+
+This is the readme for __APP_NAME__, an awesome new app.

data/inited/__APP_NAME__

@@ -0,0 +1,52 @@
+#!/usr/bin/ruby
+
+class Main
+
+  def self.init
+    require 'rubygems'
+    require 'bundler/setup'
+    require $root+'/lib/kenji/kenji'
+    @@k = Kenji::Kenji.new({}, $root)
+  end
+
+  def self.main args
+    verb = args.first.to_sym unless args.empty?
+
+    # case verb
+    # when :import
+    #   puts "Calling import script..."
+    #   @@k.controller_for(:import)._caffeine @@k
+    # when :process
+    #   puts "Processing values..."
+    #   @@k.controller_for(:processing)._value @@k
+    # when :configure
+    #   require $root + '/lib/configure'
+    #   skip_update = (args[1] =~ /-?-?skip[-_]update/)
+    #   AnalyticsModule.configure __FILE__, skip_update
+    # else
+    #   puts <<-EOO
+    #   No verb defined. Usage: ./main [verb]
+    # 
+    #   configure [--skip-update]:
+    #       process the value of users
+    #       optionally, skip the self-update process
+    #   import:
+    #       import install from caffeine.io
+    #   process:
+    #       process the value of users
+    #   EOO
+    # end
+  end
+
+  def kenji
+    @@k
+  end
+end
+
+require 'pathname'
+$root = File.dirname Pathname.new(__FILE__).realpath.to_s
+
+Main.init unless ARGV.first == 'configure'
+if __FILE__ == $0
+  Main.main ARGV
+end

data/inited/config.ru

@@ -0,0 +1,11 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'rack'
+require 'kenji'
+
+# use Rack::ShowExceptions
+
+app = proc do |env|
+  Kenji::Kenji.new(env, File.dirname(__FILE__)).call
+end
+run app

data/inited/configuration/README

@@ -0,0 +1 @@
+This is where configuration goes.

data/inited/controllers/main.rb

@@ -0,0 +1,6 @@
+
+class MainController
+  get '/index' do
+    {hello: :world}
+  end
+end

data/inited/models/README

@@ -0,0 +1 @@
+This is where models go.

data/inited/public/humans.txt

@@ -0,0 +1 @@
+Handcrafted with love by Kenneth Ballenegger

data/inited/public/index.html

@@ -0,0 +1,19 @@
+<html>
+<head>
+    <title>Hello, world!</title>
+
+    <script src="http://ajax.googleapis.com/ajax/libs/jquery/1.7.1/jquery.min.js" type="text/javascript" charset="utf-8"></script>
+    <script type="text/javascript" charset="utf-8">
+        $(document).ready(function() {
+            $.ajax('/main/index.json', {
+                success: function(data) {
+                    $('#name').html(data.hello);
+                }
+            });
+        });
+    </script>
+</head>
+<body>
+    Hello, <span id="name">User</span>!
+</body>
+</html>

data/inited/scripts/README

@@ -0,0 +1 @@
+This is where scripts go.

data/inited/tmp/README

@@ -0,0 +1 @@
+This folder is for Rack & Passenger to use.

data/kenji.gemspec

@@ -0,0 +1,24 @@
+$:.push File.expand_path('../lib', __FILE__)
+require 'kenji/version'
+
+Gem::Specification.new do |s|
+    s.name        = 'kenji'
+    s.version     = Kenji::VERSION
+    s.platform    = Gem::Platform::RUBY
+    s.date        = '2012-04-05'
+    s.summary     = 'Kenji'
+    s.description = 'A lightweight Ruby web framework.'
+    s.authors     = ['Kenneth Ballenegger']
+    s.email       = ['kenneth@ballenegger.com']
+    s.homepage    =
+        'https://github.com/kballenegger/kenji'
+
+    s.add_dependency 'json'
+    s.add_dependency 'rack'
+        
+    s.files         = `git ls-files`.split("\n")
+    s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+    s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+    s.require_paths = ['lib']
+
+end

data/lib/kenji/controller.rb

@@ -0,0 +1,108 @@
+
+module Kenji
+  class Controller
+
+    # use the reader freely to grab the kenji object
+    attr_accessor :kenji
+  
+    # Routes below will accept routes in the format, eg.:
+    #     /hello/:id/children
+    # Can contain any number of :id, but must be in their own url segment.
+    # Colon-prefixed segments become variables, passed onto the given block as arguments.
+    # The name given to the variable is irrelevant, and is thrown away: /hello/:/children is equivalent to the example above. 
+    # Given block must have correct arity.
+    
+    # Route GET
+    def self.get(path, &block)
+      route(:get, path, &block)
+    end
+
+    # Route POST
+    def self.post(path, &block)
+      route(:post, path, &block)
+    end
+
+    # Route PUT
+    def self.put(path, &block)
+      route(:put, path, &block)
+    end
+
+    # Route DELETE
+    def self.delete(path, &block)
+      route(:delete, path, &block)
+    end
+
+    # TODO: figure out whether I want PATCH, OPTIONS, HEAD
+
+    # Route all methods for given path
+    def self.all(path, &block)
+      route(:get, :post, :put, :delete, path, &block)
+    end
+
+    def self.fallback(&block)
+      define_method(:fallback, &block)
+      nil # void method
+    end
+
+    # Route a given path to the correct block, for any given methods
+    #
+    # Note: this works by building a tree for the path,
+    # each node being a path segment or variable segment, and the leaf @action being the block
+    
+    def self.route(*methods, path, &block)
+      # bind the block to self as an instance method, so its context is correct
+      define_method(:_tmp_route_action, &block)
+      block = instance_method(:_tmp_route_action)
+      remove_method(:_tmp_route_action)
+      # store the block for each method
+      methods.each do |method|
+        node = ((@routes ||= {})[method] ||= {})
+        segments = path.split('/')
+        segments = segments.drop(1) if segments.first == ''     # discard leading /'s empty segment
+        segments.each do |segment|                              # lazily create tree
+          segment = ':' if segment =~ /^:/                      # discard :variable name
+          node = (node[segment.to_sym] ||= {})
+        end
+        node[:@action] = block                                  # store block as leaf in @action
+      end
+      nil # void method
+    end
+
+    
+    # Most likely only used by Kenji itself.
+    # Override to implement your own routing, if you'd like.
+    def call(method, path)
+      segments = path.split('/')
+      segments = segments.drop(1) if segments.first == ''     # discard leading /'s empty segment
+      node = self.class.routes[method]
+      variables = []
+      segments.each do |segment|                              # traverse tree to find 
+        if node[segment.to_sym]
+          node = node[segment.to_sym]                         # attempt to move down to the plain text segment
+        else
+          node = node[:':']                                   # attempt to find a variable segment
+          variables << segment                                # either we've found a variable, or the `unless` below will trigger
+        end
+        break unless node                                     # break if as an instance method nil, fallback below
+      end
+      if node && action = node[:@action]                      # the block is stored in the @action leaf
+        return action.bind(self).call(*variables)
+      else                                                    # or, fallback if necessary store the block for each method
+        if respond_to? :fallback
+          if self.class.instance_method(:fallback).arity == 1
+            return fallback(path)
+          else
+            return fallback
+          end
+        end
+      end
+    end
+
+    private
+    # Accessor for @routes
+    def self.routes
+      @routes || {}
+    end
+  end
+end
+

data/lib/kenji/string_extensions.rb

@@ -0,0 +1,16 @@
+# Kenji string extensions
+
+class String
+    def to_underscore!
+        self.gsub!(/(.)([A-Z])/,'\1_\2').downcase!
+    end
+    def to_underscore
+        self.clone.to_underscore!
+    end
+    def to_camelcase!
+        self.replace self.split('_').each{ |s| s.capitalize! }.join('')
+    end
+    def to_camelcase
+        self.clone.to_camelcase!
+    end
+end

data/lib/kenji/version.rb

@@ -0,0 +1,5 @@
+
+module Kenji
+  VERSION = "0.3.0"
+end
+

data/lib/kenji.rb

@@ -0,0 +1,114 @@
+require 'json'
+require 'kenji/controller'
+require 'kenji/string_extensions'
+require 'rack'
+
+module Kenji
+  class Kenji
+
+    attr_reader :env, :root
+
+    def initialize(env, root)
+      @headers = {
+        'Content-Type' => 'application/json'
+      }
+      @status = 200
+      @root = File.expand_path(root) + '/'
+      @env = env
+    end
+
+    def call
+      path = @env['PATH_INFO']
+      
+      # deal with static files
+      static = "#{@root}public#{path}"
+      return Rack::File.new("#{@root}public").call(@env) if File.file?(static)
+
+
+      # new routing code
+      segments = path.split('/')
+      segments = segments.drop(1) if segments.first == ''       # discard leading /'s empty segment
+
+      acc = ''; out = {}
+      while head = segments.shift
+        acc = "#{acc}/#{head}"
+        if controller = controller_for(acc)                    # if we have a valid controller 
+          begin
+            out = controller.call(@env['REQUEST_METHOD'].downcase.to_sym, '/'+segments.join('/')).to_json
+          rescue KenjiRespondControlFlowInterrupt => e
+            out = e.response
+          end
+          break
+        end
+      end
+
+      [@status, @headers, [out]]
+    end
+
+
+
+    # Methods for users!
+
+
+    # Sets one or multiple headers, as named arametres. eg.
+    # 
+    #   kenji.header 'Content-Type' => 'hello/world'
+    def header(hash={})
+      hash.each do |key, value|
+        @headers[key] = value
+      end
+    end
+
+    # Fetch (and cache) the json input to the request
+    # Return a Hash
+    def input_as_json
+      return @json_input if @json_input
+      require 'json'
+      raw = @env['rack.input'].read if @env['rack.input']
+      begin
+        return @json_input = JSON.parse(raw)
+      rescue JSON::ParserError => e
+      end if raw
+      {} # default return value
+    end
+    
+    # Respond to the request
+    def respond code, message, hash={}
+      @status = code
+      response = {            # default structure. TODO: figure out if i really want to keep this 
+        :status => code,
+        :message => message
+      }
+      hash.each { |k,v| response[k]=v }
+      raise KenjiRespondControlFlowInterrupt.new(response.to_json)
+    end
+
+
+
+    # Private methods
+
+    # Will attempt to fetch the controller, and verify that it is a implements call 
+    def controller_for subpath
+      path = "#{@root}controllers#{subpath}.rb"
+      return nil unless File.exists?(path)
+      require path
+      controller_name = subpath.split('/').last
+      controller_class = Object.const_get(controller_name.to_s.to_camelcase+'Controller')
+      return unless controller_class.method_defined?(:call) && controller_class.instance_method(:call).arity == 2 # ensure protocol compliance
+      controller = controller_class.new
+      controller.kenji = self if controller.respond_to?(:kenji=)
+      return controller if controller
+      nil # default return value
+    end
+    
+  end
+  
+
+  class KenjiRespondControlFlowInterrupt < StandardError
+    attr_accessor :response
+    def initialize(response)
+        @response = response
+    end
+  end # early exit containing a response
+end
+

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification
+name: kenji
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+  prerelease: 
+platform: ruby
+authors:
+- Kenneth Ballenegger
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-05 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: &70195188110740 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70195188110740
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: &70195188110000 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70195188110000
+description: A lightweight Ruby web framework.
+email:
+- kenneth@ballenegger.com
+executables:
+- kenji-init
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/kenji-init
+- inited/.gitignore
+- inited/Gemfile
+- inited/README.md
+- inited/__APP_NAME__
+- inited/config.ru
+- inited/configuration/README
+- inited/controllers/main.rb
+- inited/lib/README
+- inited/models/README
+- inited/public/humans.txt
+- inited/public/index.html
+- inited/scripts/README
+- inited/tmp/README
+- inited/tmp/always_restart.txt
+- kenji.gemspec
+- lib/kenji.rb
+- lib/kenji/controller.rb
+- lib/kenji/string_extensions.rb
+- lib/kenji/version.rb
+homepage: https://github.com/kballenegger/kenji
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Kenji
+test_files: []
+has_rdoc: