casual-api 3.0.2 → 3.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b1552be82e1bda4452edefb02d6aa9bcf80a3acc
-  data.tar.gz: 72e38979a147b0433d378a5c2a622af96e1624ca
+  metadata.gz: 45222dcf0822e0dd2a5435627f91147a2bc4a78e
+  data.tar.gz: 8ee0ef74b92e226dec8e3a307ffd23a9bc297e01
 SHA512:
-  metadata.gz: abfc8346e7c6caba58546df5d88fc242cd3ff37d7768c215d975ecc1f3bf3c0f4cdc5f2fcd17c8f2d630ec3c1df14e1a3b427eed17e1de2d8b21ed556809c0a9
-  data.tar.gz: 1f4471ba83ee2893bae942cee31911ca86452c93cb317f432a187f844066e8e6b6351a1afdb84e43a5ecf203fbd972fe9ef1e711cad4dc19dbf4a2a85f376186
+  metadata.gz: 09d85af70129a29def81eb53d2a16dd106ede9e2470b7b84aca70effc69747bfb22f45012ffb95c7868d6c7476581821cd46ec3046c74554f1d6564903c785c2
+  data.tar.gz: 8a25f7ee7cf1a01882557418dcc3259b21a8aefe1582fb59dc481246e57cff7908fa29ef4cb2c6d53a000c771732678e9dda39a372384f5c24b8babda5ffb6b7

data/lib/casual-api.rb

@@ -0,0 +1 @@
+require_relative './dsl.rb'

data/lib/casual.rb

@@ -1,102 +1,125 @@
 require 'rack'
+require 'tempfile'
 require_relative './dsl.rb'
 
-class ChildProcess
-  def initialize(action, parameters, session)
-    @file_descriptors = []
-    @action = action
-    @params = parameters
-    @session = session
-  end
+module CasualAPI
+  class ChildProcess
+    def initialize(action, parameters, session)
+      @action = action
+      @params = parameters
+      @session = session
+    end
+
+    def execute
+      check_parameter
+      obj = Action.fire @action, @params, @session
+      {
+       session: obj.session,
+       status_code: obj.status_code,
+       content_type: obj.content_type,
+       body: obj.body,
+      }
+    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,
-    }
+    private
+    def check_parameter
+      check_satisfy_required_parameters
+      check_upload_file
+    end
+    def check_satisfy_required_parameters
+      unless @action[:parameters].all?{|k,v|@params[k] || !v[:required]}
+        raise InvalidParameterError, "Invalid parameter(s)"
+      end
+    end
+    def check_upload_file
+      unless @action[:parameters].all?{|k,v|
+          next false if v[:is_file] ^ @params[k].is_a?(Hash)
+          next false if v[:as_file] && @params[k].is_a?(Hash)
+          true
+        }
+        raise InvalidParameterError, "Invalid parameter(s)"
+      end
+    end
   end
-end
 
 
-# RackApp
-class Casual
-  def initialize(prefix, file, mode)
-    @prefix = prefix
-    @file = file
-    @mode = mode
-  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
+    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
-      begin
-        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
-      rescue CommandError => ex
-        return [ex.status_code,
-                { 'Content-Type' => map_content_type(ex.content_type) },
-                [ex.message]]
-      rescue => ex
-        [500, {}, ["Server Error"]]
+    private
+    def fire_action
+      actions = parse_actions
+      action = detect_action actions
+      if action
+        begin
+          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
+        rescue CommandError => ex
+          return [ex.status_code,
+                  { 'Content-Type' => map_content_type(ex.content_type) },
+                  [ex.message]]
+        rescue => ex
+          [500, {}, ["Server Error"]]
+        end
+      else
+        [404, {}, []]
       end
-    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 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
+    def parse_actions
+      if @mode == "development" || !@actions
+        @actions = DSL.parse @file
+      else
+        @actions
+      end
     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[:names]).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
+    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[:names]).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
 end

data/lib/config.ru

@@ -1,6 +1,5 @@
 require 'rack'
 require 'yaml'
-
 require_relative './casual.rb'
 
 config = open("config.yaml"){|f|
@@ -17,7 +16,7 @@ use Rack::Session::Pool,
 (config["routes"] || {}).each{|k,v|
   map(k)do
     run Rack::Cascade.new [
-      Casual.new(k, v, config["mode"])
+      CasualAPI::Casual.new(k, v, config["mode"])
     ]
   end
 }

data/lib/dsl.rb

@@ -1,228 +1,277 @@
 require 'pp'
 require 'securerandom'
+require 'tempfile'
 
-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}`
+module CasualAPI
+  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
-  def body
-    @body
+
+  class CommandError < StandardError
+    def content_type; :txt; end
+    def status_code; 400; end
   end
-  def body=(value)
-    @body = value
+  class InvalidParameterError < CommandError
   end
-end
 
-class CommandError < StandardError
-  def content_type; :txt; end
-  def status_code; 400; end
-end
-class InvalidParameterError < CommandError
-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
 
-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 invalid_parameter *params
+      raise InvalidParameterError, "Invalid parameter(s): #{params.map{|p|p.to_s}.join(',')}"
+    end
 
-  def invalid_parameter *params
-    raise InvalidParameterError, "Invalid parameter(s): #{params.map{|p|p.to_s}.join(',')}"
-  end
+    def file? file
+      file.is_a? Hash
+    end
 
-  def file? file
-    file.is_a? Hash
-  end
+    def tempfile file
+      Action.tempfile self, file
+    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
+    def session_clear
+      session.clear
+      session = nil
     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 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]
-      raise InvalidParameterError, "Not given required parameter(s)"
-    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 }
+    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)
+      execute(obj, ps, action)
+      obj.tempfiles.each{|f| f.close }
+      obj
     end
-  end
 
-end
+    private
+    def self.execute(obj, ps, action)
+      ps = to_as_file(obj, ps, action)
+      ps = to_tempfile(obj, ps, action)
+      vs = action[:parameters].map{|k,v|ps[k]}
+      obj.instance_exec(*vs, &(action[:action]))
+    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
+    def self.to_as_file(obj, ps, action)
+      action[:parameters].select{|_,v|v[:as_file]}.each{|k,_|
+        f = Tempfile.open(k.to_s)
+        f.write ps[k]
+        f.close
+        f.open
+        obj.tempfiles.push f
+        ps[k] = {tempfile: f}
+      }
+      ps
+    end
+    def self.to_tempfile(obj, ps, action)
+      action[:parameters].select{|_,v|v[:tempfile]}.each{|k,_|
+        ps[k] = tempfile obj, ps[k]
+      }
+      ps
+    end
+    def self.tempfile(obj,file)
+      if file.is_a? Hash
+        file[:tempfile].path
+      else
+        f = Tempfile.open(SecureRandom.hex(4))
+        f.write file
+        f.flush
+        f.close
+        f.open
+        obj.tempfiles.push f
+        f.path
+      end
     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 Annotation
+    def is_file *files
+      @context_stack.last[:is_file] ||= []
+      @context_stack.last[:is_file].push(*files)
+    end
+    def as_file *files
+      @context_stack.last[:as_file] ||= []
+      @context_stack.last[:as_file].push(*files)
+    end
+    def tempfile *files
+      @context_stack.last[:tempfile] ||= []
+      @context_stack.last[:tempfile].push(*files)
+    end
 
-module SyntaxSugar
-  def get(*names, &block); path(:get, *names, &block); end
-  def post(*names, &block); path(:post, *names, &block); end
-  
-  def command(*names, cmd)
-    eval(replace :get, names, "write `#{cmd}`")
+    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(:is_file)
+      @context_stack.last.delete(:as_file)
+      @context_stack.last.delete(:tempfile)
+      @context_stack.last.delete(:description)
+    end
   end
 
-  def text(*names, text)
-    eval(replace :get, names, "write \"#{text}\"")
+  module ExtExpression
+    def content_type type
+      @context_stack.last[:content_type] = type
+    end
   end
 
-  def get_command(*names, cmd); command(*names, cmd); end
-  def post_command(*names, cmd)
-    eval(replace :post, names, "write `#{cmd}`")
-  end
+  module SyntaxSugar
+    def get(*names, &block); path(:get, *names, &block); end
+    def post(*names, &block); path(:post, *names, &block); end
+    
+    def command(*names, cmd)
+      eval(replace :get, names, "write `#{cmd}`")
+    end
 
-  def get_text(*names, text); text(*names, text); end
-  def post_text(*names, text)
-    eval(replace :post, names, "write \"#{text}\"")
-  end
+    def text(*names, text)
+      eval(replace :get, names, "write \"#{text}\"")
+    end
+
+    def get_command(*names, cmd); command(*names, cmd); end
+    def post_command(*names, cmd)
+      eval(replace :post, names, "write `#{cmd}`")
+    end
 
-  private
-  def replace meth, names, cmd,
-    ps = cmd.scan(/\$\{(?<p>[^\}]*)\}/).flatten
-    fs = cmd.scan(/\$\<(?<p>[^\}]*)\>/).flatten
-    c = ps.inject(cmd){|acc,c|
-      acc.gsub /\$\{#{c}\}/, "\#{#{c}}"
-    }
-    c = fs.inject(c){|acc,c|
-      acc.gsub /\$\<#{c}\>/, "\#{#{c}}"
-    }
-    filecheck = fs.inject(""){|acc,f|
-      acc << "invalid_parameter :#{f} unless file? #{f}\n"
-      acc << "#{f} = tempfile #{f}\n"
-    }
-    args = (ps + fs).join(',')
+    def get_text(*names, text); text(*names, text); end
+    def post_text(*names, text)
+      eval(replace :post, names, "write \"#{text}\"")
+    end
+
+    private
+    def replace meth, names, cmd
+      ps = cmd.scan(/\$\{(?<p>[^:\}]*)\}/).flatten
+      fs = cmd.scan(/\$\{file:(?<p>[^:\}]*)\}/).flatten
+      c = ps.inject(cmd){|acc,c|
+        acc.gsub /\$\{#{c}\}/, "\#{#{c}}"
+      }
+      c = fs.inject(c){|acc,c|
+        acc.gsub /\$\{file:#{c}\}/, "\#{#{c}}"
+      }
+      is_file_annotation = "is_file " + fs.map{|f|":#{f}"}.join(',')
+      tempfile_annotation = "tempfile " + fs.map{|f|":#{f}"}.join(',')
+      args = (ps + fs).join(',')
     <<PROC
+    #{is_file_annotation}
+    #{tempfile_annotation}
     #{meth.to_s}(#{names.map{|n|":#{n.to_s}"}.join(',')}) do | #{args} |
-      #{filecheck}#{c}
+      #{c}
     end
 PROC
+    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
+  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 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, *names, &block)
-    meta = @context_stack.last.clone
-    meta[:method] = method
-    meta[:names] = names
-    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
+    def path(method, *names, &block)
+      meta = @context_stack.last.clone
+      meta[:method] = method
+      meta[:names] = names
+      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.map{|x| normalize x }
+    end
 
+    def self.normalize hs
+      description = hs[:description] || {}
+      description[:params] ||= {}
+      parameters = hs[:action].parameters.map.with_index{|(_,n),i|
+        { n => {
+                required: i < hs[:action].arity,
+                is_file: (hs[:is_file]||[]).include?(n),
+                as_file: (hs[:as_file]||[]).include?(n),
+                tempfile: (hs[:tempfile]||[]).include?(n),
+               }
+        }
+      }.inject({}, :merge)
+      {
+        method: hs[:method],
+          names: hs[:names],
+          description: description,
+          domain: hs[:domain],
+          action: hs[:action],
+          parameters: parameters,
+      }
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: casual-api
 version: !ruby/object:Gem::Version
-  version: 3.0.2
+  version: 3.0.3
 platform: ruby
 authors:
 - Takeshi Kojima
@@ -38,6 +38,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - bin/casual-api
+- lib/casual-api.rb
 - lib/casual.rb
 - lib/config.ru
 - lib/dsl.rb