casual-api 3.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1f562aeb27eaed4448ca125d26b257e9c0cf51c6
+  data.tar.gz: 08a14d0ba57999138e843de5e5e567c33ffa50b0
+SHA512:
+  metadata.gz: 194ac34b57ddec0727cfe72c415cb66266b589c0477e9c8784869e9a534a089c302c825b143cc718d669f312e95995f6e46c6673fea540fd2388acf9d591a55a
+  data.tar.gz: eb1f02762637aeef75ed68d48786d35a36a097d8b846ddb401e17cae5334e0abe6bae542c9faa62ac88b476cb7b2061978298147cc6063f4767b066bb92c8e7f

data/bin/casual-api

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+require 'open3'
+lib = File.expand_path('../../lib', __FILE__)
+command = "thin -R #{lib}/config.ru start"
+puts "casual-api is running, CTRL+C to stop"
+_, out, err, th = Open3.popen3(command)
+th.join

data/lib/casual.rb

@@ -0,0 +1,94 @@
+require 'rack'
+require_relative './dsl.rb'
+
+class ChildProcess
+  def initialize(action, parameters, session)
+    @file_descriptors = []
+    @action = action
+    @params = parameters
+    @session = session
+  end
+
+  def execute
+    obj = Action.fire @action, @params, @session
+    {
+      session: obj.session,
+      status_code: obj.status_code,
+      content_type: obj.content_type,
+      body: obj.body,
+    }
+  end
+end
+
+
+# RackApp
+class Casual
+  def initialize(prefix, file, mode)
+    @prefix = prefix
+    @file = file
+    @mode = mode
+  end
+
+  def call(env)
+    @env = env
+    @req = Rack::Request.new(env) 
+    fire_action
+  end
+
+  private
+  def fire_action
+    actions = parse_actions
+    action = detect_action actions
+    if action
+      cp = ChildProcess.new(action, parameters, session)
+      result = cp.execute
+      @req.session['casual.session'] = result[:session]
+      res = Rack::Response.new(){|r|
+        r.status = result[:status_code]
+        r.write result[:body]
+        r['Content-Type'] = map_content_type(result[:content_type])
+      }
+      res.finish
+    else
+      [404, {}, []]
+    end
+  end
+
+  def map_content_type(c)
+    {
+     txt: "text/plain;charset=utf-8",
+     html: "text/html;charset=utf-8",
+    }[c.to_sym] || c
+  end
+
+  def parse_actions
+    if @mode == "development" || !@actions
+      @actions = DSL.parse @file
+    else
+      @actions
+    end
+  end
+
+  def detect_action actions
+    path = request_path
+    _method = request_method
+    actions.detect{|act|
+      act[:method] == _method && make_path(act) == path
+    }
+  end
+  def make_path action
+    @prefix + (action[:domain] + [action[:name]]).compact.map{|p|p.to_s}.join('/')
+  end
+  def parameters
+    @req.params.map{|k,v| {k.to_sym => v} }.inject({}, :merge)
+  end
+  def session
+    @req.session['casual.session'] || {}
+  end
+  def request_method
+    @req.request_method.downcase.to_sym
+  end
+  def request_path
+    @req.path
+  end
+end

data/lib/config.ru

@@ -0,0 +1,34 @@
+require 'rack'
+require 'yaml'
+
+require_relative './casual.rb'
+
+config = open("config.yaml"){|f|
+  YAML.load f.read
+}
+
+use Rack::Session::Pool,
+    :key => config["session"]["key"],
+    :domain => config["session"]["domain"],
+    :path => config["session"]["path"],
+    :expire_after => config["session"]["expire"],
+    :secret => config["session"]["secret"]
+
+(config["routes"] || {}).each{|k,v|
+  map(k)do
+    run Rack::Cascade.new [
+      Casual.new(k, v, config["mode"])
+    ]
+  end
+}
+
+(config["static_web"] || {}).each{|k,v|
+  use Rack::Static, urls: [""],
+                    root: v["directory"],
+                    index: v["index"]
+  map(k)do
+    run Rack::Cascade.new [
+      Rack::Directory.new(v["directory"]),
+    ]
+  end
+}

data/lib/dsl.rb

@@ -0,0 +1,185 @@
+require 'pp'
+require 'securerandom'
+
+module BodyWriter
+  def self.extended obj
+    obj.instance_variable_set(:@body, "")
+  end
+  def write str
+    @body << str.to_s
+  end
+  def print str
+    @body << str.to_s
+  end
+  def puts str
+    @body << str.to_s << "\n"
+  end
+  def printf *p
+    @body << (sprintf *p)
+  end
+  def command cmd
+    write `#{cmd.to_s}`
+  end
+  def body
+    @body
+  end
+  def body=(value)
+    @body = value
+  end
+end
+
+module Action
+  def self.extended obj
+    obj.instance_variable_set(:@session, {})
+    obj.instance_variable_set(:@content_type, nil)
+    obj.instance_variable_set(:@status_code, 200)
+    obj.instance_variable_set(:@tempfiles, [])
+  end
+
+  def file? file
+    file.is_a? Hash
+  end
+
+  def tempfile file
+    if file.is_a? Hash
+      file[:tempfile].path
+    else
+      f = Tempfile.open(SecureRandom.hex(4))
+      f.write file
+      f.flush
+      @tempfiles.push f
+      f.path
+    end
+  end
+
+  def session_clear
+    session.clear
+    session = nil
+  end
+
+  def session; @session; end
+  def session=(value); @session = value; end
+  def content_type; @content_type; end
+  def tempfiles; @tempfiles; end
+  def status_code; @status_code; end
+  def content_type=(type); @content_type = type; end
+  def status_code=(code); @status_code = code; end
+
+
+  def self.fire(action, params, session)
+    obj = Object
+    obj.extend Action
+    obj.extend BodyWriter
+    obj.content_type = action[:content_type] || :txt
+    obj.session = session
+    ps = action[:action].parameters.map{|_, name|
+      {name => params[name]}
+    }.inject({}, :merge)
+    result = execute(obj, ps, action[:action])
+    unless result[:executed]
+      obj.status_code = 400
+      obj.body = "Not given enough parameter"
+      obj.content_type = :txt
+    end
+    obj.tempfiles.each{|f| f.close }
+    obj
+  end
+
+  private
+  def self.execute(obj, ps, block)
+    vs = block.parameters.map{|_,n|ps[n]}.inject([[],true]){|(acc,b),v|
+      (b && v) ? [acc+[v],b] : [acc,false]
+    }[0]
+    if block.arity <= vs.length
+      result = obj.instance_exec(*vs, &block)
+      { executed: true, result: result }
+    else
+      { executed: false }
+    end
+  end
+
+end
+
+module Annotation
+  def file *files
+    @context_stack.last[:files] ||= []
+    @context_stack.last[:files].push(*files)
+  end
+  def description(param1, param2=nil)
+    @context_stack.last[:description] ||= {}
+    if param2
+      @context_stack.last[:description][:params] ||= {}
+      @context_stack.last[:description][:params][param1] = param2
+    else
+      @context_stack.last[:description][:path] = param1
+    end
+  end
+  def clear_annotaion
+    @context_stack.last.delete(:files)
+    @context_stack.last.delete(:description)
+  end
+end
+
+module ExtExpression
+  def content_type type
+    @context_stack.last[:content_type] = type
+  end
+end
+
+module SyntaxSugar
+  def get(path, &block); path(:get, path, caller, &block); end
+  def post(path, &block); path(:post, path, caller, &block); end
+  
+  def command(path, cmd)
+    get path do
+      write `#{cmd}`
+    end
+  end
+end
+
+
+module DSL
+  def self.extended obj
+    # add stacks and a context to an extended object.
+    obj.instance_variable_set(:@action_stack, [])
+    obj.instance_variable_set(:@domain_stack, [])
+    obj.instance_variable_set(:@context_stack, [{}])
+    obj.extend Action
+    obj.extend Annotation
+    obj.extend ExtExpression
+    obj.extend SyntaxSugar
+  end
+  def action_stack
+    @action_stack
+  end
+
+  def domain(*path , &block)
+    # annotations don't effect over domain
+    clear_annotaion
+    @domain_stack.push *path
+    @context_stack.push(@context_stack.last.clone)
+    block.call
+    @context_stack.pop
+    @domain_stack.pop path.length
+    # annotations don't effect over domain
+    clear_annotaion
+  end
+
+  def path(method, name, c=nil, &block)
+    meta = @context_stack.last.clone
+    meta[:method] = method
+    meta[:name] = name
+    meta[:domain] = @domain_stack.clone
+    meta[:action] = block
+    clear_annotaion    # annotations effect only a path.
+    @action_stack.push meta
+  end
+  
+  def self.parse(file)
+    obj = Object.new
+    obj.extend DSL
+    obj.instance_eval(open(file){|f|f.read})
+    obj.action_stack
+  end
+
+end

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification
+name: casual-api
+version: !ruby/object:Gem::Version
+  version: 3.0.0
+platform: ruby
+authors:
+- Takeshi Kojima
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-09-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thin
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.6.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.6.2
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.5.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.5.2
+description: A simple web server
+email: tatkeshi@gmail.com
+executables:
+- casual-api
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/casual-api
+- lib/casual.rb
+- lib/config.ru
+- lib/dsl.rb
+homepage: https://github.com/tatkeshi/casual-api
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: casual-api
+test_files: []