ground 0.0.1 → 0.0.2

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    NDU5YmZhOTU0YTdjMzIxOGNlNWY0MDliZDJiZTliNTE0YTQ5NDdkMA==
+    MjIwZmFhYTk5YWI3NTk3ZGMyMjExNTczMzAyOTJhZWE5MjVjZjNjYg==
   data.tar.gz: !binary |-
-    MzczMGFkMGZmYTY5YzgxYWNmOTU2M2E2MzMxYTgzMmUzNDBiZjc5NQ==
+    ZWI0NzM1OTY3YjFhN2NiNmMyMzRlOTk3NzljM2YwYmM3MjY3NjJiZg==
 SHA512:
   metadata.gz: !binary |-
-    NzgwZTg4YjE0ZDg1ODhhMzNkNGEzYzcyNDZmOGVhOTQwNjI4MmRiMTdkMDg1
-    MDUwNDk0ZGNmMWZhZTNiYTUzODVhYmI4OWNlMTE1ZjkxZmZkNTU5ODMyMzUw
-    NTUyODg5ZjMyMzM4MTc2YjRhMDdiOGRjNTU4MTUwNGQ5YTIwZTg=
+    ZDIzODkyN2ZjMmJiNTMzZTEzMjI2MDVmYWQ1MTVlODhkOTY3OTYxNzliMTUz
+    NTJlMDBkNGQzNmIyYmU3NGQ4YmQzZjg0MjA5MGI4YzNmNDhiOWQ5YTVjMTc3
+    NzQ1MjQyM2Y0ZmY3MjVkMGJjYmJhMmVkYzFhMDM4NWExMTQ5ODE=
   data.tar.gz: !binary |-
-    ZWQwZWYyZDBiN2RmZjBiNWMyZmE3ODc2NDQ3NmNkNGNkNDMwZGUwMzc1NWVh
-    YmM4MmFlMWYwMTJmYWYyMmJiMDgxNDBiMGQ5OWU0MjZjZDlkNzNiNTUyMmYy
-    NDNiMzVhZTk3ODgxNWQ2MmVlNWJmMGE2MGViNjg2NDNhNjIzOTE=
+    MWQ0MmRkNTQ0NGJjNmViY2NmNmQ5YWFiZTNmYWE5YzU0OWIzMmQ5ZGQ0ZDg1
+    MjM1NjI0Yzk4ZTk1Y2YyZWVjNGNmNTQ0NGE1NjY0MWFjNGUyNmMzNmRiODNj
+    NzM2M2Q1ZGUwM2Q2NjZiMWM3NTJkNzY3MDZiMzdlNWQ0N2QyMzY=

data/lib/ground.rb

@@ -0,0 +1,53 @@
+require 'dun'
+require 'rack'
+require 'logger'
+require 'ground/activity'
+require 'ground/mime_type'
+require 'ground/protocol/render'
+require 'ground/protocol/render/template'
+require 'ground/activity/ridge'
+require 'ground/protocol/verb'
+require 'ground/protocol/helper'
+require 'ground/activity/log'
+require 'ground/activity/locate'
+require 'ground/activity/state'
+require 'ground/activity/validate'
+require 'ground/rack/url_suffix'
+require 'ground/rack/base_rack'
+require 'ground/activity/hash_with_double_access'
+require 'ground/activity/create_application'
+
+
+module Ground
+  extend Protocol::Verb
+  extend Protocol::Helper
+
+  class << self
+
+    MetaG = self
+    
+    def set(attr, value)
+      MetaG.class_eval { attr_reader attr }
+      instance_variable_set "@#{attr}", value
+    end
+    
+  end
+  
+end
+
+if not Kernel.method_defined?('Ground')
+  Kernel.class_eval do
+    def Ground(app_name = nil, &p)
+      if app_name
+        Ground::CreateApplication(name: app_name, &p)
+      else
+        Ground.instance_eval &p
+      end
+    end
+  end
+end
+
+Ground do
+  set :logger, ::Logger.new(STDOUT)
+end
+

data/lib/ground/activity.rb

@@ -0,0 +1,3 @@
+module Ground
+  Activity = ::Dun::Activity
+end

data/lib/ground/activity/create_application.rb

@@ -0,0 +1,34 @@
+# -*- coding: utf-8 -*-
+module Ground
+
+  class CreateApplication < Activity
+    data_reader :name
+
+    def initialize(data)
+      super
+      @middlewares = []
+    end
+
+    def call(&p)
+      app = Class.new(Ground::BaseRack)
+      instance_eval &p
+      app_with_middlewares = pack_middlewares_to_app app
+    end
+
+    private
+
+    def use(middleware, *args, &p)
+      @middlewares << lambda {|app| middleware.new(app, *args, &p)}
+    end
+
+    def pack_middlewares_to_app(app)
+      app_with_middlewares = app.new
+      @middlewares.reverse.each {|middleware|
+        app_with_middlewares = middleware.call(app_with_middlewares)
+      }
+      app_with_middlewares
+    end
+    
+  end
+
+end

data/lib/ground/activity/hash_with_double_access.rb

@@ -0,0 +1,28 @@
+class HashWithDoubleAccess < Ground::Activity
+
+  def call
+    str_h = access_with(data, :to_s)
+    sym_h = access_with(data, :to_sym)
+    sym_h.merge str_h
+  end
+
+
+  private
+
+  def access_with(d, m)
+    tmp_h = {}
+    d.each {|k, v|
+      if v.is_a? Hash
+        tmp_h[k.send(m)] = access_with(v, m)
+      elsif v.is_a? Array
+        v_dup = v.dup
+        v_dup.each_with_index {|item, index| v_dup[index] = access_with(item, m) if item.is_a? Hash}
+        tmp_h[k.send(m)] = v_dup
+      else
+        tmp_h[k.send(m)] = v
+      end
+    }
+    tmp_h
+  end
+  
+end

data/lib/ground/activity/locate.rb

@@ -0,0 +1,41 @@
+module Ground
+  
+  class Locate < Activity
+    data_reader :verb, :path
+
+    def initialize(data)
+      super
+      @verb = verb.upcase
+    end
+
+    def call
+      path_segs = split_to_segs(path)
+      
+      length_match_routes = Ridge.routes[verb].select {|route|
+        route_segs = split_to_segs(route[0])
+        route_segs.size == path_segs.size
+      }
+
+      length_match_routes.detect {|route|
+        match = true
+        route_segs = split_to_segs(route[0])
+        route_segs.each_with_index {|route_seg, index|
+          match = (path_segs[index] == route_seg)  if not route_seg =~ /^:\w+/
+          break if not match
+        }
+        match
+      }
+
+    end
+
+    private
+
+    def split_to_segs(path)
+      segs = path.split('/')
+      segs[0] = '/'
+      segs
+    end
+
+  end
+  
+end

data/lib/ground/activity/log.rb

@@ -0,0 +1,28 @@
+module Ground
+  class Log < Activity
+    set :format, %{(%0.4fs) %s %s %s %s %s %s\n}
+    
+    data_reader :time
+    data_reader :request_method, :path_info
+    data_reader :state
+    data_reader :response
+    data_reader :params
+
+    def call
+      logger.info format % [time,
+                            request_method,
+                            path_info,
+                            state,
+                            response[0],
+                            response[1],
+                            "Parameters: #{params.select{|k, _| k.is_a? Symbol}}"]
+    end
+
+    private
+
+    def logger
+      Ground.logger
+    end
+    
+  end
+end

data/lib/ground/activity/ridge.rb

@@ -0,0 +1,42 @@
+# -*- coding: utf-8 -*-
+module Ground
+  
+  class Ridge < Activity
+
+    data_reader :path, :verb, :state
+
+    class << self
+
+      attr_reader :routes, :states
+
+      # 路由节点的结构 [path, state]
+      def route(verb, path, state)
+
+        @routes ||= {'GET' => [], 'POST' => []}
+        @states ||= []
+        
+        @routes[verb] << [path, state]
+        @states << state if not @states.include?(state)
+        
+      end
+
+    end
+
+    def initialize(data)
+      super
+      @verb = verb.upcase
+    end
+
+    def call
+      route(state)
+    end
+
+    private
+
+    def route(state)
+      self.class.route(verb, path, state)
+    end
+
+  end
+
+end

data/lib/ground/activity/state.rb

@@ -0,0 +1,52 @@
+module Ground
+  
+  class State < Activity
+
+    include Ground::Protocol::Render
+    include Ground::Protocol::Render::Template
+    
+    data_reader :request, :params
+
+    class << self
+      
+      def path(*args)
+        paths = []
+        route = detect_route('GET') || detect_route('POST')
+        
+        route[0].split('/').each_with_index {|route_seg, index|
+          paths[index] = (route_seg =~ /^:\w+/ ? args.shift : route_seg)
+        }
+        paths << '/' if paths.size == 0
+        paths.join('/')
+        
+      end
+
+      def detect_route(verb)
+        Ridge.routes[verb.to_s.upcase].detect {|route| route[1] == self}
+      end
+      
+    end
+
+
+    private
+
+    def response
+      @response ||= ::Rack::Response.new
+    end
+
+    def session
+      @session ||= request.session
+    end
+
+    # check Ground::MimeType for all mime type abb defined in ground
+    def request_accept?(mime_type_abb)
+      Ground::MimeType[request_accepts.first] == mime_type_abb
+    end
+
+    def request_accepts
+      @request_accepts ||= request.env['HTTP_ACCEPT'].split(', ')
+    end
+
+  end
+  
+end

data/lib/ground/activity/validate.rb

@@ -0,0 +1,37 @@
+module Ground
+  class Validate < Activity
+
+    attr_reader :errors, :validations
+
+    def initialize(data)
+      super
+      @errors = {}
+      @validations = []
+    end
+
+    def call
+      execute_validations
+    end
+    
+    private
+
+    def validates(attr, error_msg, &p)
+      validation = validations.detect {|validation|
+        validation[0] == attr and validation[1] == error_msg
+      } || [attr, error_msg, p]
+      validations << validation
+    end
+
+    def execute_validations
+      validations.each {|validation|
+        attr, error_msg, p = validation
+        if !p.call
+          errors[attr] ||= []
+          errors[attr] << error_msg if !errors[attr].include?(error_msg)
+        end
+      }
+      errors
+    end
+
+  end
+end

data/lib/ground/mime_type.rb

@@ -0,0 +1,23 @@
+module Ground
+  MimeType = {
+    "*/*"                      => :all,
+    "text/plain"               => :text,
+    "text/html"                => :html,
+    "application/xhtml+xml"    => :html,
+    "text/javascript"          => :js, 
+    "application/javascript"   => :js, 
+    "application/x-javascript" => :js, 
+    "text/calendar"            => :ics,   
+    "text/csv"                 => :csv,   
+    "application/xml"          => :xml,
+    "text/xml"                 => :xml, 
+    "application/x-xml"        => :xml, 
+    "text/yaml"                => :yaml, 
+    "application/x-yaml"       => :yaml, 
+    "application/rss+xml"      => :rss,   
+    "application/atom+xml"     => :atom,  
+    "application/json"         => :json, 
+    "text/x-json"              => :json,
+    "text/markdown"            => :md
+  }
+end

data/lib/ground/protocol/helper.rb

@@ -0,0 +1,19 @@
+module Ground::Protocol
+  
+  module Helper
+
+    Ridge = Ground::Ridge
+
+    def help(*args, &p)
+      if args.first == :all_states
+        help Ground::State, &p
+      else
+        args.each {|obj|
+          obj.class_eval &p if block_given?
+        }
+      end
+    end
+
+  end
+  
+end

data/lib/ground/protocol/render.rb

@@ -0,0 +1,59 @@
+module Ground::Protocol
+  module Render
+
+    include ::Rack::Utils
+
+    def json(content, status = 200)
+      response_with(content, status, 'application/json; charset=UTF-8')
+    end
+
+    def xml(content, status = 200)
+      response_with(content, status, 'application/xml; charset=UTF-8')
+    end
+
+    def html(content, status = 200)
+      response_with(content, status, 'text/html; charset=UTF-8')
+    end
+
+    def text(content, status = 200)
+      response_with(content, status, 'text/plain; charset=UTF-8')
+    end
+
+    def non_found(content)
+      response_as 404, content
+    end
+
+    def forbid(content = nil)
+      response_as 403, content
+    end
+
+    def not_accept(content = nil)
+      response_as 406, content
+    end
+
+    def unauthorized(content = nil)
+      response_as 401, content
+    end
+
+    def redirect(target, status = 302)
+      response.status = status
+      response['Location'] = target
+      response.finish
+    end
+
+    private
+
+    def response_as(status, content=nil)
+      content ||= HTTP_STATUS_CODES[status]
+      text content, status
+    end
+    
+    def response_with(content, status, content_type)
+      response['Content-Type'] = content_type
+      response.status = status
+      response.write(content)
+      response.finish
+    end
+
+  end
+end

data/lib/ground/protocol/render/template.rb

@@ -0,0 +1,26 @@
+module Ground::Protocol
+  module Render
+    module Template
+
+      def haml(path, &p)
+        template = Tilt::HamlTemplate.new(File.join(Ground.views, "#{path}.haml"))
+        template.render self, &p
+      end
+
+      def slim(path, &p)
+        template = Slim::Template.new(File.join(Ground.views, "#{path}.slim"))
+        template.render self, &p
+      end
+
+      def erb(file, &p)
+        template = ERB.new(File.read(File.join(Ground.root, file)))
+        template.result(binding)
+      end
+
+      def plain(file, &p)
+        File.read(File.join(Ground.root, file))
+      end
+
+    end
+  end
+end

data/lib/ground/protocol/verb.rb

@@ -0,0 +1,17 @@
+module Ground::Protocol
+  module Verb
+    
+    def get(path, state)
+      ridge path: path, verb: 'get', state: state  
+    end
+
+    def post(path, state)
+      ridge path: path, verb: 'post', state: state
+    end
+
+    def ridge(data)
+      Ground::Ridge data
+    end
+    
+  end  
+end

data/lib/ground/rack/base_rack.rb

@@ -0,0 +1,57 @@
+module Ground
+  class BaseRack
+    
+    attr_reader :env
+    attr_reader :request
+
+    def call(env)
+      start_time = Time.now
+      set_request Rack::Request.new(env)
+
+      route, state = Ground::Locate(verb: request_method, path: path_info)
+      return non_exist_route if state.nil?
+
+      params = get_params route
+      response = state << {request: request, params: params}
+      time = Time.now - start_time
+      Ground::Log({
+                    time:           time,
+                    request_method: request_method,
+                    path_info:      request.env['REQUEST_PATH'],
+                    state:          state,
+                    response:       response,
+                    params:         params
+                  })
+      
+      response
+    end
+
+    private
+
+    def set_request request
+      @request = request
+    end
+
+    def request_method
+      request.request_method
+    end
+
+    def path_info
+      request.path_info
+    end
+
+    def get_params(route)
+      p = {}
+      path_segs = request.path_info.split('/')
+      route.split('/').each_with_index {|route_seg, index|
+        p[route_seg.sub(':', '')] = path_segs[index] if route_seg =~ /^:\w+/
+      }
+      HashWithDoubleAccess p.merge(request.params)
+    end
+
+    def non_exist_route
+      Rack::Response.new(["Non Exist Route: #{request_method} #{path_info}"], 500)
+    end
+    
+  end
+end

data/lib/ground/rack/url_suffix.rb

@@ -0,0 +1,42 @@
+module Ground
+
+  # When request's path contains a suffix like json, xml etc,
+  # it will git rid of the suffix and set the accept header
+  # by the suffix
+  # 
+  # Example:
+  #   get '/book/:id.json'
+  # 
+  # the request path '/book/2.json' will become '/book/2', and
+  # the request accept header will be added a 'application/json'
+  # mime type
+  class UrlSuffix
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      suffix = /\.(\w+)$/
+      if env['PATH_INFO'].match(suffix)
+        accept_type = suffix_to_accept_type $1
+        if accept_type
+          env['HTTP_ACCEPT'] = "#{accept_type}, #{env['HTTP_ACCEPT']}"
+          env['PATH_INFO'] = env['PATH_INFO'].sub(suffix, '')
+        end
+      end
+
+      @app.call(env)
+
+    end
+
+    private
+    
+    def suffix_to_accept_type(suffix)
+      accept = Ground::MimeType.detect {|_, v| v == suffix.to_sym}
+      accept[0] if accept
+    end
+    
+  end
+  
+end

data/test/ground_set_test.rb

@@ -0,0 +1,13 @@
+require 'test_helper'
+
+Ground do
+  set :env, (ENV['RACK_ENV'] || :development).to_sym
+end
+
+class GroundSetTest < Test::Unit::TestCase
+
+  def test_set_attribute
+    assert_equal Ground.env, :development
+  end
+
+end

data/test/hash_with_double_access_test.rb

@@ -0,0 +1,31 @@
+# -*- coding: utf-8 -*-
+require 'test_helper'
+
+class HashWithDoubleAccessTest < Test::Unit::TestCase
+
+  def test_double_access
+    h = {:a => 1, 'b' => 2, 'c' => {'d' => 4, :e => 5}, 'g' => [1,2,3], 'h' => [{'a' => 1, 'cc' => [{'b' => 2}, {'c' => 3}]}, {'b' => 5}]}
+
+    hd = HashWithDoubleAccess h
+
+    assert_equal hd[:a], 1
+    assert_equal hd['a'], 1
+    assert_equal hd['c']['d'], 4
+    assert_equal hd[:c][:d], 4
+    assert_equal hd['c']['e'], 5
+    assert_equal hd[:c][:e], 5
+
+    assert_equal hd[:c]['d'], nil
+    assert_equal hd[:c]['e'], nil
+    assert_equal hd['c'][:e], nil
+    assert_equal hd['c'][:d], nil
+
+    assert_equal hd[:h].size, 2
+    assert_equal hd[:h][0][:a], 1
+    assert_equal hd[:h][1][:b], 5
+    assert_equal hd['h'][0][:a], nil
+    assert_equal hd['h'][1][:b], nil
+
+  end
+
+end

data/test/locate_test.rb

@@ -0,0 +1,23 @@
+require 'test_helper'
+require 'routes'
+
+class LocateTest < Test::Unit::TestCase
+
+  def test_locate
+    location = Ground::Locate(verb: 'get', path: '/')
+    assert_equal location, ['/', SiteIndex]
+    
+    location = Ground::Locate(verb: 'get', path: '/books')
+    assert_equal location, ['/books', BooksIndex]
+
+    location = Ground::Locate(verb: 'get', path: '/book/2')
+    assert_equal location, ['/book/:id', BookShow]
+
+    location = Ground::Locate(verb: 'post', path: '/book/3/comments')
+    assert_equal location, ['/book/:id/comments', BookComments]
+
+    location = Ground::Locate(verb: 'get', path: '/jim/notes')
+    assert_equal location, ['/:username/notes', UserNotes]
+  end
+
+end

data/test/ridge_test.rb

@@ -0,0 +1,15 @@
+# -*- coding: utf-8 -*-
+require 'test_helper'
+require 'routes'
+
+class RidgeTest < Test::Unit::TestCase
+
+  def test_state_path
+    assert_equal SiteIndex.path, '/'
+    assert_equal BookShow.path(1), '/book/1'
+    assert_equal BooksIndex.path, '/books'
+    assert_equal BookComments.path(1), '/book/1/comments'
+    assert_equal UserNotes.path('jim'), '/jim/notes'
+  end
+  
+end

data/test/routes.rb

@@ -0,0 +1,13 @@
+SiteIndex = Class.new(Ground::State)
+BooksIndex = Class.new(Ground::State)
+BookShow = Class.new(Ground::State)
+BookComments = Class.new(Ground::State)
+UserNotes = Class.new(Ground::State)
+
+Ground::Ridge(verb: 'get', path: '/', state: SiteIndex)
+Ground::Ridge(verb: 'get', path: '/book/:id', state: BookShow)
+Ground::Ridge(verb: 'get', path: '/books', state: BooksIndex)
+Ground::Ridge(verb: 'post', path: '/book/:id/comments', state: BookComments)
+Ground::Ridge(verb: 'get', path: '/:username/notes', state: UserNotes)
+
+

data/test/test_helper.rb

@@ -0,0 +1,11 @@
+require 'test/unit'
+
+testdir = File.dirname(__FILE__)
+$LOAD_PATH.unshift testdir unless $LOAD_PATH.include?(testdir)
+
+libdir = File.dirname(File.dirname(__FILE__)) + '/lib'
+$LOAD_PATH.unshift libdir unless $LOAD_PATH.include?(libdir)
+
+require 'ground'
+
+

data/test/validate_test.rb

@@ -0,0 +1,10 @@
+require 'test_helper'
+
+class ValidateTest < Test::Unit::TestCase
+
+  def test_validate
+    errors = Ground::Validate()
+    assert_equal errors, {}
+  end
+
+end

metadata

@@ -1,43 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: ground
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
-- guimin jiang
+- jgm
 autorequire: 
 bindir: bin
 cert_chain: []
 date: 2014-06-25 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: dun
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rack
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+dependencies: []
 description: ! '    A simple ruby web framework
 
 '
@@ -46,9 +18,29 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- README.md
-- Rakefile
-- licenses.txt
+- lib/ground.rb
+- lib/ground/activity.rb
+- lib/ground/activity/create_application.rb
+- lib/ground/activity/hash_with_double_access.rb
+- lib/ground/activity/locate.rb
+- lib/ground/activity/log.rb
+- lib/ground/activity/ridge.rb
+- lib/ground/activity/state.rb
+- lib/ground/activity/validate.rb
+- lib/ground/mime_type.rb
+- lib/ground/protocol/helper.rb
+- lib/ground/protocol/render.rb
+- lib/ground/protocol/render/template.rb
+- lib/ground/protocol/verb.rb
+- lib/ground/rack/base_rack.rb
+- lib/ground/rack/url_suffix.rb
+- test/ground_set_test.rb
+- test/hash_with_double_access_test.rb
+- test/locate_test.rb
+- test/ridge_test.rb
+- test/routes.rb
+- test/test_helper.rb
+- test/validate_test.rb
 homepage: https://github.com/baya/ground
 licenses:
 - MIT

data/README.md

@@ -1,114 +0,0 @@
-# Ground
-Ground is a web framework, no controller, no model, no views and no mvc. Most of the ground codes are inherited from
-[Dun::Activity](https://github.com/baya/dun/blob/master/lib/dun.rb). So ground is a high unified web framework.
-
-## states
-
-```ruby
-  class SiteIndex < Ground::State
-    def call
-	  text 'Site Index'
-	end
-  end
-
-  module Book
-    State = Ground::State
-	
-    class Index < State
-	  def call
-	    @books = Book.all
-		html erb('views/book/index.html.erb')
-	  end
-	end
-
-    class Show < State
-	  def call
-	    @book = Book.find(params[:id])
-		html erb('views/book/show.html.erb')
-	  end
-	end
-
-    class Create < State
-	  def call
-	    @book = Book.create(params[:book])
-		rediret '/books'
-	  end
-	end
-	
-  end
-```
-
-## routes
-
-```ruby
-  Ground do
-    get '/', SiteIndex
-	get '/books', Book::Index
-	get '/book/:id', Book::Show
-	post '/book', Book::Create
-  end
-```
-
-## route helpers
-
-```ruby
-  SiteIndex.path     # '/'
-  Book::Index.path   # '/books'
-  Book::Show.path(2) # '/book/2'
-  Book::Create.path  # '/book'
-```
-
-## sets
-
-```ruby
-  Ground do
-    set :env, (ENV['RACK_ENV'] || 'development').to_s
-	set :logger, ::Logger.new(STDOUT)
-  en
-
-  Ground.env #=> development
-  Ground.logger.info("debug+++")
-```
-
-## helpers
-
-```ruby
-  # Book::Index, Book::Show will hava instance method 'hello_ground'
-  Ground do
-    help Book::Index, Book::Show do
-	  
-	  def hello_ground
-	    'hello ground'
-	  end
-	  
-	end
-  end
-```
-
-## create a ground app
-
-```ruby
-  module BookStore
-	App = Ground 'book store' do
-	  use Rack::ShowExceptions
-	  use Rack::Static, urls: ['/js', '/css', '/lib', '/partials'], :root => "lib/app"
-	  ...
-	end
-  end
-```
-
-## config.ru
-
-``` ruby
-  $: << '.'
-  require 'app'
-  run BookStore::App
-```
-
-## Apps using ground
-
-* [SceneMaster](https://github.com/baya/SceneMaster)
-* [Description](https://github.com/baya/description)
-* [Gstar](https://github.com/baya/Gstar)
-
-

data/Rakefile

@@ -1,8 +0,0 @@
-require 'rake/testtask'
-Rake::TestTask.new do |t|
-  t.libs << 'test'
-  t.test_files = FileList['test/*_test.rb']
-end
-
-desc "Run tests"
-task :default => :test

data/licenses.txt

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) <year> <copyright holders>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE 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 THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.