culpa 1.0.0.2 → 1.1.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    OTczMmI3N2FkYTQ5NDhhNGU1ZTE1YTZiYjFhNzk4YTNlYWY1NDQxZA==
+    YmFjM2ViYTZiMTdlNDM0OTI2Mjg5YzUyN2VkOWIwMTMyMDc3YTgxMg==
   data.tar.gz: !binary |-
-    MzY0NTE3NGYyOWY0OGYyYzE2NTc0NmUyYTE2OTA2ZWQ1MTFjOTYxMA==
+    Y2VkODYxZGUwNWI2MzU3Yjg5OGZmOTI5NmI3NzljNGE3OWZjYThhNg==
 SHA512:
   metadata.gz: !binary |-
-    ZGJkYzlkZmIxYTEzYmYyZWVhY2E1ZDc0YjljOGU2NjRlZjU0YWQ3NmQ5ODU2
-    N2JjMDIxZGMxOTBhNjk5NDcxYzM1MGVmNDE4M2MyZjA5YzhmODRlMjk3OTdm
-    NmJjMTljZjdiZDVjZDljYjhlNTdkOWQzNzVkNWQ5YzA2NzAzNzQ=
+    MTRhNDdhNWVmMTBjOTY1ZDJmOTViYTRkYTVhZDRjZmY1YjQ2ODNmZTNiOTAw
+    M2YzNTM3ZjE2ZmMyZTk1Y2Y0YjVhOTljMWE0NzFiNTljMjVkMzMxYWMwNDVk
+    YjM3OGQxMGI5ODk1YzljYjc3NWU2YjNjYjVjNmE4YjA1ZmEwM2Q=
   data.tar.gz: !binary |-
-    N2JjNzc2Nzg2NTlmNTBmNjNmYjRkNWRjODgzNjkyZjdlZWMyYWYzZDg4MDcx
-    YWRkMzA5ODY3NWE4MzE1NjM5NjEyYzRmZmYwZTIwMjMzYjg1MWU0YzgzMjVm
-    NjI2NzY5ZjYwYmVjNDQzYzUwZDg4NTc4NjU3Yzc1ZGM4ODJlZGI=
+    NDUxYmQ5ZjllODdhMDU1NGFjN2I0NWZlYTBmNmMzOWI2YmQ4MDlkN2ZmOTA3
+    ZDc4M2I3MmNjY2IzYjVkZTFiYmQyYTRlYzZjM2Q1ZjljYTI4MDkwMDk1ZWJi
+    MTM3YmM1MTUxMTg3OTBlZGVlODQ5MzkzZDc0YmZkYTRjYTMyNTQ=

data/bin/culpa

@@ -18,9 +18,10 @@ def create_project(project_path)
   FileUtils.touch "#{project_path}/actions/.keep"
   FileUtils.mkdir "#{project_path}/models"
   FileUtils.touch "#{project_path}/models/.keep"
+  FileUtils.mkdir "#{project_path}/public"
+  FileUtils.touch "#{project_path}/public/.keep"
   FileUtils.mkdir "#{project_path}/config"
-  FileUtils.mkdir "#{project_path}/config/brickchains"
-  FileUtils.touch "#{project_path}/config/brickchains/.keep"
+  FileUtils.touch "#{project_path}/config/brickchains.rb"
   FileUtils.mkdir "#{project_path}/config/initializers"
   FileUtils.touch "#{project_path}/config/initializers/.keep"
 
@@ -36,6 +37,12 @@ def create_project(project_path)
   dockerfile_rackup_path = File.join( File.dirname(__FILE__), '../templates/culpa/Dockerfile' )
   FileUtils.cp dockerfile_rackup_path, "#{project_path}/Dockerfile"
 
+  puts '==> Copying default public folder content'
+  index_html_rackup_path = File.join( File.dirname(__FILE__), '../templates/culpa/index.html' )
+  FileUtils.cp index_html_rackup_path, "#{project_path}/public/index.html"
+  logo_png_rackup_path = File.join( File.dirname(__FILE__), '../templates/culpa/logo.png' )
+  FileUtils.cp logo_png_rackup_path, "#{project_path}/public/logo.png"
+
   puts '==> Switching to project directory'
   FileUtils.cd project_path
 
@@ -92,6 +99,7 @@ end
 
 def start_server
   require 'rack'
+  ENV['RACK_ENV'] ||= 'development'
   Rack::Handler.default.run(Culpa::Application.new, Port: 4748)
 end
 

data/lib/culpa/action.rb

@@ -55,7 +55,7 @@ class Action
       unknown_error: 520
   }
 
-  attr_reader :e, :r, :logger
+  attr_reader :e, :r
 
   class RenderNow < StandardError
     attr_reader :to_render
@@ -64,24 +64,35 @@ class Action
     end
   end
 
-  def initialize(envelope, request, logger)
+  def initialize(envelope, request)
     @e = envelope
     @r = request
-    @logger = logger
     @to_render = nil
   end
 
+  def method_missing(sym)
+    @r.send(sym)
+  end
+
   def render(options={})
     options[:headers] ||= {}
     if options.has_key? :json
-      @to_render = {
-         format: :json,
-         status: RETURN_CODES[options[:status]] || 200,
-         headers: { 'Content-Type' => 'application/json' }.merge(options[:headers]),
-         object: options[:json]
+      if options[:json]
+        to_render = {
+           format: :json,
+           status: RETURN_CODES[options[:status]] || 200,
+           headers: { 'Content-Type' => 'application/json' }.merge(options[:headers]),
+           object: options[:json]
+        }
+      else
+      to_render = {
+         format: :status,
+         headers: options[:headers],
+         status: RETURN_CODES[options[:or_status]]
       }
+      end
     elsif options.has_key? :file
-      @to_render = {
+      to_render = {
          format: :file_from_path,
          headers: {
              'Content-Type' => options[:content_type] || 'application/octet-stream',
@@ -90,9 +101,9 @@ class Action
          status: RETURN_CODES[options[:status]] || 200,
          object: Culpa::FileStreamer.new(options[:file])
       }
-      @to_render[:headers]['Content-Length'] = options[:size] if options.has_key? :size
+      to_render[:headers]['Content-Length'] = options[:size] if options.has_key? :size
     elsif options.has_key? :status
-      @to_render = {
+      to_render = {
          format: :status,
          headers: options[:headers],
          status: RETURN_CODES[options[:status]]
@@ -100,7 +111,7 @@ class Action
     else
      raise Culpa::UnknownRenderCall.new
     end
-    raise RenderNow.new(@to_render)
+    raise RenderNow.new(to_render)
   end
 
 end

data/lib/culpa/brickchain_helpers.rb

@@ -0,0 +1,74 @@
+module Culpa
+
+  class BrickchainExecutor
+
+    attr_reader :envelope
+
+    def initialize(envelope, request)
+      @envelope = envelope
+      @request = request
+    end
+
+    def async(&blk)
+      asb = AsyncBrickchain.new(@envelope, @request)
+      asb.instance_eval(&blk)
+      asb.chs.each { |call_holder| call_holder.thread.join }
+    end
+
+    def method_missing(sym)
+      return CallHolder.new(sym.to_s, @envelope, @request)
+    end
+
+  end
+
+  class AsyncBrickchain
+
+    attr_reader :envelope
+    attr_reader :chs
+
+    def initialize(envelope, request)
+      @envelope = envelope
+      @request = request
+      @chs = []
+    end
+
+    def method_missing(sym)
+      @chs << CallHolder.new(sym.to_s, @envelope, @request, true)
+      @chs.last
+    end
+
+  end
+
+  class CallHolder
+
+    attr_reader :thread
+
+    def initialize(brickname, envelope, request, async=false)
+      @brickname = brickname
+      @envelope = envelope
+      @request = request
+      @async = async
+    end
+
+    def from(action_name)
+      if @async
+        @thread = Thread.new { sub_from(action_name) }
+      else
+        sub_from(action_name)
+      end
+    end
+
+    def sub_from(action_name)
+      action = get_action(action_name.to_s)
+      action.send @brickname
+      return false
+    end
+
+    def get_action(name)
+      action_name = name.split('_').map{|w| w.capitalize}.join
+      return Actions.const_get(action_name).new(@envelope, @request)
+    end
+
+  end
+
+end

data/lib/culpa/envelope.rb

@@ -39,11 +39,9 @@ module Culpa
   class EnvelopeRequest
 
     attr_accessor :verb
+    attr_accessor :path
     attr_accessor :input
     attr_accessor :params
-    attr_accessor :res_name
-    attr_accessor :id
-    attr_accessor :sub_call
 
     def initialize(attributes)
       attributes.each do |name, value|

data/lib/culpa/path_parser.rb

@@ -2,40 +2,89 @@ module Culpa
 
   class PathParser
 
-    ROUTE_PATTERNS = {
-        '/:res_name' => {
-            regex: Regexp.new('^/(\w+)$'),
-            id_to_sym: {
-                1 => :res_name
-            }
-        },
-        '/:res_name/:id' => {
-            regex: Regexp.new('^/(\w+)/(\w+)$'),
-            id_to_sym: {
-                1 => :res_name,
-                2 => :id
-            }
-        },
-        '/:res_name/:id/:sub_call' => {
-            regex: Regexp.new('^/(\w+)/(\w+)/(\w+)$'),
-            id_to_sym: {
-                1 => :res_name,
-                2 => :id,
-                3 => :sub_call
-            }
-        }
-    }
+    def self.route_patterns
+      @@route_patterns
+    end
 
     # Parsing a path
     def self.parse(pattern, path)
-      current_pattern = ROUTE_PATTERNS[pattern]
-      result = path.match(current_pattern[:regex])
+      result = path.match(pattern[:regex])
       return unless result
-      returned = {}
-      current_pattern[:id_to_sym].each do |id, sym|
-        returned[sym] = result[id]
+      return Hash[result.names.map{ |name| name }.zip(result.captures)]
+    end
+
+    # Use the brickchains to build the cache of route
+    def self.create_route_cache(brickchains, global_prefix)
+      custom_routes = []
+      brickchains.each do |name,data|
+        next unless data.has_key?(:options) and data[:options] and data[:options].has_key?(:url)
+        item = {
+          regex: self.compose_regex(global_prefix + data[:options][:url]),
+          router_method_name: name
+        }
+        item[:verb] = data[:options][:verb] if data[:options].has_key? :verb
+        custom_routes << item
       end
-      returned
+      fixed_routes = [
+        {
+          infer: {
+            get: 'list',
+            post: 'create'
+          },
+          regex: self.compose_regex(global_prefix + '/:res_name')
+        }, {
+          infer: {
+            get: 'get',
+            put: 'update',
+            patch: 'update',
+            delete: 'delete'
+          },
+          regex: self.compose_regex(global_prefix + '/:res_name/:id')
+        }, {
+          regex: self.compose_regex(global_prefix + '/:res_name/:id/:sub_call')
+        }
+      ]
+      @@route_patterns = custom_routes + fixed_routes
+    end
+
+    # Transforms a string to its equivalent for the compose_regex
+    def self.dir_to_regex(dir)
+      return dir unless dir.start_with? ':'
+      "(?<#{dir[1..dir.length-1]}>\\w+)"
+    end
+
+    # Composing a regex from a human-readable http path pattern
+    def self.compose_regex(url)
+      regex = url.split('/').map{ |dir| self.dir_to_regex(dir) }.join('/')
+      Regexp.new("^#{regex}$")
+    end
+
+    # Search for the routes, extracts informations and returns
+    # the router method name and the request informations
+    def self.extract_vars(path, call_options)
+      @@route_patterns.each do |data|
+        next unless params = self.parse(data, path)
+        call_options[:params].merge!(params)
+        if data.has_key?(:router_method_name)
+          raise RouteNotFoundError.new if data.has_key?(:verb) and call_options[:verb] != data[:verb]
+          return data[:router_method_name], call_options
+        else
+          return self.infer_method_name(data, call_options[:params], call_options[:verb]), call_options
+        end
+      end
+    end
+
+    # Try to return the router method name or infer it automatically
+    def self.infer_method_name(pattern, params, verb)
+      if params.has_key?('sub_call')
+        return "#{params['sub_call']}_#{params['res_name']}".to_sym
+      end
+
+      unless pattern[:infer].is_a?(Hash) and pattern[:infer].has_key?(verb)
+        raise UnpredictableSubCallError.new
+      end
+
+      return "#{pattern[:infer][verb]}_#{params['res_name']}".to_sym
     end
 
   end

data/lib/culpa/routes_builder.rb

@@ -0,0 +1,68 @@
+module Culpa
+
+  class RoutesBuilder
+
+    attr_reader :result
+    attr_reader :prefix
+    attr_reader :public_folder
+
+    def initialize(to_eval)
+      @result = {}
+      if to_eval.is_a? String
+        instance_eval(to_eval)
+      else
+        instance_eval(&to_eval)
+      end
+    end
+
+    def global_prefix(prefix)
+      @prefix = prefix
+    end
+
+    def set_public_folder(folder)
+      @public_folder = folder
+    end
+
+    def brickchain(name,*opts,&blk)
+      @result[name] = {
+        options: opts[0],
+        block: blk
+      }
+      @result[name][:before] = @before if @before
+    end
+
+    def before(&blk)
+      @before=[] unless @before
+      @before << blk
+    end
+
+    def brickchain_context(name, &blk)
+      @result.merge!(RoutesBuilder.new(blk).result)
+    end
+
+    def infer(name, &blk)
+      bta = BlockToArray.new
+      bta.instance_eval(&blk)
+      bta.culpa_bta_result.each do |item|
+        route_name = "#{item}_#{name}".to_sym
+        @result[route_name] = {
+          class_name: name,
+          brick_name: item
+        }
+          @result["#{item}_#{name}".to_sym][:before] = @before if @before
+      end
+    end
+
+  end
+
+  class BlockToArray
+    attr_reader :culpa_bta_result
+    def initialize
+      @culpa_bta_result = []
+    end
+    def method_missing(sym)
+      @culpa_bta_result << sym.to_s
+    end
+  end
+
+end

data/lib/culpa/test_helpers.rb

@@ -14,41 +14,34 @@ module CulpaHelpers
 
   class BrickCall
 
+    attr_reader :from_done
+
     def initialize(brick_name)
       @brick_name = brick_name.to_s
+      @from_done = false
     end
 
     def from(action_const)
+      @from_done = true
       @action_const = action_const
-      @envelope = Culpa::Envelope.new()
-      @params = Culpa::EnvelopeRequest.new({})
-      self
-    end
-
-    # :nocov:
-    def and_with_envelope(envelope)
-      with_envelope(envelope)
-    end
-
-    def and_with_params(params)
-      with_params(params)
-    end
-    # :nocov:
-
-    def with_envelope(envelope)
-      @envelope = Culpa::Envelope.new(envelope)
       self
     end
 
-    def with_params(params)
-      @params = Culpa::EnvelopeRequest.new(params)
+    def with(opts)
+      opts[:envelope] ||= {}
+      @envelope = Culpa::Envelope.new(opts[:envelope])
+      opts.delete(:envelope)
+      @params = Culpa::EnvelopeRequest.new(opts)
       self
     end
 
     def call
+      return unless @from_done
       return @call_cache if @call_done
+      @envelope ||= Culpa::Envelope.new({})
+      @params ||= Culpa::EnvelopeRequest.new({})
+      @action_const.new(@envelope, @params).send(@brick_name)
       @call_done = true
-      @action_const.new(@envelope, @params, Logger.new(STDOUT)).send(@brick_name)
       return @call_cache = { to_render: nil, envelope: @envelope }
     rescue Action::RenderNow => renderer
       return @call_cache = { to_render: renderer.to_render, envelope: @envelope }
@@ -58,6 +51,7 @@ module CulpaHelpers
 
   RSpec::Matchers.define :have_status do |expected|
     match do |actual|
+      actual.from(described_class) unless actual.from_done or described_class.nil?
       bc = actual.call
       bc[:to_render][:status] == Action::RETURN_CODES[expected]
     end
@@ -66,6 +60,7 @@ module CulpaHelpers
   RSpec::Matchers.define :have_headers do |expected|
     match do |actual|
       expected.each do |k,v|
+        actual.from(described_class) unless actual.from_done or described_class.nil?
         bc = actual.call
         return false unless bc[:to_render][:headers].has_key?(k) and
                             bc[:to_render][:headers][k] == expected[k]
@@ -76,6 +71,7 @@ module CulpaHelpers
 
   RSpec::Matchers.define :have_body do |expected|
     match do |actual|
+      actual.from(described_class) unless actual.from_done or described_class.nil?
       bc = actual.call
       bc[:to_render][:object] == expected
     end
@@ -83,6 +79,7 @@ module CulpaHelpers
 
   RSpec::Matchers.define :have_envelope do |expected|
     match do |actual|
+      actual.from(described_class) unless actual.from_done or described_class.nil?
       bc = actual.call
       bc[:envelope] == Culpa::Envelope.new(expected)
     end

data/lib/culpa.rb

@@ -7,8 +7,10 @@ require 'logger'
 require_relative 'culpa/envelope'
 require_relative 'culpa/path_parser'
 require_relative 'culpa/file_streamer'
+require_relative 'culpa/routes_builder'
+require_relative 'culpa/brickchain_helpers'
 
-CULPA_VERSION='1.0.0.2'
+CULPA_VERSION='1.1.0'
 
 ACTIONS_PATH ||= './actions/*.rb'
 MODELS_PATH ||= './models/*.rb'
@@ -30,6 +32,7 @@ module Culpa
   class UnpredictableSubCallError < StandardError; end
   class NoRenderCalled < StandardError; end
   class UnknownRenderCall < StandardError; end
+  class RouteNotFoundError < StandardError; end
 
   Dir[MODELS_PATH].each do |file|
     require file
@@ -38,13 +41,13 @@ module Culpa
   class Application
 
     def initialize(options = {})
-      @router = {}
-      bc_path = options[:brickchains] || './config/brickchains'
-      Dir["#{bc_path}/*.yml"].map { |bc_file|
-        YAML.load_file(bc_file)
-      }.each{ |bc|
-        @router.merge!(bc)
-      }
+      # Loading brickchains definitions
+      bc_path = options[:brickchains] || './config/brickchains.rb'
+      route_builder = RoutesBuilder.new(File.read(bc_path))
+      @public_folder = options[:public] || route_builder.public_folder || './public'
+      @router = route_builder.result
+      PathParser.create_route_cache(@router, route_builder.prefix || '')
+      # Logging helper
       @logger = Logger.new(options[:log_output] || STDOUT)
       @logger.level = case ENV['RACK_ENV']
                         when 'development', 'test'
@@ -55,102 +58,76 @@ module Culpa
                           # :nocov:
                       end
       @logger.info 'Culpa fully initialized'
+      if %w(development test).include? ENV['RACK_ENV']
+        @rack_file = Rack::File.new(@public_folder)
+      end
     end
 
     ##
     # Rack entrypoint
     def call(env)
-      call_options = {
+      path = env['PATH_INFO']
+      if @rack_file && (File.exists?("#{@public_folder}#{path}") || path == '/')
+        env['PATH_INFO'] = '/index.html' if path == '/'
+        return @rack_file.call(env)
+      end
+      @logger.info "Received request : #{path}"
+      # Request preparation
+      request = {
           verb: env['REQUEST_METHOD'].downcase.to_sym,
           params: Rack::Utils.parse_nested_query(env['QUERY_STRING'])
       }
       # Parse body if in JSON, otherwise pass the rack.input directly
       if env['CONTENT_TYPE'] == 'application/json'
         body = JSON.parse(env['rack.input'].read)
-        call_options[:sub_call] = body['sub_call'] if body.has_key? 'sub_call'
-        call_options[:input] = body['data']
+        request[:input] = if body.has_key?('data')
+                            body['data']
+                          else
+                            body
+                          end
+        request[:params]['sub_call'] = body['sub_call'] if body.has_key? 'sub_call'
       else
-        call_options[:input] = env['rack.input']
+        request[:input] = env['rack.input']
       end
-      # Try the enforced routes
-      if route_params = PathParser.parse('/:res_name', env['PATH_INFO'])
-        call_options[:res_name] = route_params[:res_name]
-        case call_options[:verb]
-          when :get
-            call_options[:sub_call] = 'list'
-          when :post
-            call_options[:sub_call] = 'create'
-          else
-            raise UnpredictableSubCallError.new
-        end unless call_options.has_key? :sub_call
-      elsif route_params = PathParser.parse('/:res_name/:id', env['PATH_INFO'])
-        call_options[:res_name] = route_params[:res_name]
-        call_options[:id] = route_params[:id]
-        case call_options[:verb]
-          when :get
-            call_options[:sub_call] = 'get'
-          when :put
-            call_options[:sub_call] = 'update'
-          when :delete
-            call_options[:sub_call] = 'delete'
-          else
-            raise UnpredictableSubCallError.new
-        end unless call_options.has_key? :sub_call
-      elsif route_params = PathParser.parse('/:res_name/:id/:sub_call', env['PATH_INFO'])
-        call_options[:res_name] = route_params[:res_name]
-        call_options[:id] = route_params[:id]
-        call_options[:sub_call] = route_params[:sub_call]
-      else
-        @logger.info "Refused request, #{env['PATH_INFO']} didn't match enforced routes"
-        return rack_error 400
-      end
-      # Call the brickchain and return the value to Rack
-      @logger.info "Calling brickchain => subcall: #{call_options[:sub_call]}, action: #{call_options[:res_name]}, id: #{call_options[:id]}"
-      call_brickchain call_options
+      # Extract vars from path, take route decision and go !
+      method_name, f_request = PathParser.extract_vars(path, request)
+      call_brickchain method_name, f_request
     rescue UnpredictableSubCallError, JSON::ParserError
       rack_error 400
-    rescue StandardError => error
-      @logger.error "Error ecountered while treating request : #{error.message}, aborting...\n#{error.backtrace.join("\n")}"
+    rescue RouteNotFoundError
+      @logger.info "Route not found : #{env['PATH_INFO']}"
+      rack_error 404
+    rescue StandardError => err
+      if ENV['RACK_ENV'] == 'development'
+        # :nocov:
+        @logger.error "#{err.to_s}\n#{err.backtrace.join("\n")}"
+        # :nocov:
+      end
       rack_error 500
     end
 
-    def call_brickchain(options)
-      router_method_name = "#{options[:sub_call]}_#{options[:res_name]}"
-      envelope =  Envelope.new
+    def call_brickchain(router_method_name, options)
+      raise RouteNotFoundError.new unless @router.has_key? router_method_name
+      @logger.info "Executing brickchain : #{router_method_name}"
+      envelope = Envelope.new
       request = EnvelopeRequest.new(options)
-      return rack_error(404) unless @router.has_key? router_method_name
-      @logger.info "Brickchain determined for #{router_method_name}"
-      @router[router_method_name].each do |brick|
-        # Iterating over the brickchain of this request
-        if brick.is_a? String
-          # This brick is a sychronous call, processing call directly.
-          result = brick_call brick, envelope, request
-          return result if result
-        elsif brick.is_a?(Hash) && brick.has_key?('async')
-          # This brick is a bundle of async bricks, treating it in threads.
-          brick['async'].map { |async_brick|
-            Thread.new { brick_call(async_brick, envelope, request) }
-          }.each { |thread|
-            result = thread.value
-            return result if result
-          }
-        end
+      route = @router[router_method_name]
+      route[:before].each do |before_block|
+        BrickchainExecutor.new(envelope, request).instance_eval(&before_block)
+      end if route.has_key? :before
+
+      if route.has_key? :block
+        BrickchainExecutor.new(envelope, request).instance_eval(&route[:block])
+      else
+        ch = CallHolder.new(route[:brick_name], envelope, request)
+        ch.from(route[:class_name])
       end
-      raise NoRenderCalled.new
-    end
 
-    ##
-    # Call a brick and get the instancied class of the brick's parent action
-    def brick_call(brick, envelope, request)
-      action_class_name, method_name = brick.split('.')
-      action_class = Actions.const_get(action_class_name).new(envelope, request, @logger)
-      action_class.send method_name
-      return false
+      raise NoRenderCalled.new
     rescue Action::RenderNow => renderer
       return do_render(renderer.to_render)
     end
 
-    ##
     # Renders a json or anything else
     def do_render(to_render)
       body = case to_render[:format]
@@ -167,7 +144,7 @@ module Culpa
     ##
     # Rack pre-formatted error
     def rack_error(code)
-      [code.to_s, {'Content-Type' => 'application/json'}, []]
+      [code.to_s, {}, []]
     end
 
   end

data/templates/culpa/Gemfile

@@ -1,6 +1,6 @@
 source 'https://rubygems.org'
 
-gem 'culpa', '~> 1.0'
+gem 'culpa', '~> 1.1'
 
 # Use rspec to test your project.
 gem 'rspec', '~> 3.4'

data/templates/culpa/index.html

@@ -0,0 +1,52 @@
+<!DOCTYPE HTML>
+
+<html>
+
+  <head>
+    <title>Culpa : Welcome</title>
+    <style>
+      body, html {
+        padding: 0;
+        margin: 0;
+        font-family: sans-serif;
+        text-align: center;
+      }
+      .top-bar {
+        line-height: 60px;
+        height: 60px;
+        background-color: #be1735;
+        color: white;
+        font-size: 20px;
+      }
+      img {
+        margin: 40px;
+        width: 400px;
+        margin-left: auto;
+        margin-right: auto;
+      }
+      a {
+        display: block;
+        margin-left: auto;
+        margin-right: auto;
+        width: 300px;
+        padding: 10px 30px;
+        text-decoration: none;
+        border-radius: 30px;
+        border: 2px solid #be1735;
+        color: #be1735;
+        transition: all ease-in-out .4s;
+      }
+      a:hover {
+        color: white;
+        background-color: #be1735;
+      }
+    </style>
+  </head>
+
+  <body>
+    <div class="top-bar">Welcome to your Culpa project !</div>
+    <img src="logo.png" />
+    <a href="http://culpaframework.org/guides.html">Read the guide to get started !</a>
+  </body>
+
+</html>

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: culpa
 version: !ruby/object:Gem::Version
-  version: 1.0.0.2
+  version: 1.1.0
 platform: ruby
 authors:
 - Jérémy SEBAN
@@ -62,14 +62,17 @@ files:
 - bin/culpa
 - lib/culpa.rb
 - lib/culpa/action.rb
+- lib/culpa/brickchain_helpers.rb
 - lib/culpa/envelope.rb
 - lib/culpa/file_streamer.rb
 - lib/culpa/path_parser.rb
+- lib/culpa/routes_builder.rb
 - lib/culpa/test_helpers.rb
 - templates/culpa/Dockerfile
 - templates/culpa/Gemfile
 - templates/culpa/config.ru
 - templates/culpa/generators/action.tmpl
+- templates/culpa/index.html
 - templates/culpa/logo.png
 homepage: http://culpaframework.org/
 licenses:
@@ -81,9 +84,9 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ~>
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ! '>='