silicon 0.2.0

data/lib/silicon/request.rb

@@ -0,0 +1,65 @@
+require 'silicon/chain_factory'
+require 'silicon/view_factory'
+
+module Silicon
+  class Request
+    include Hypo::Scope
+
+    def initialize(route_matcher, container, chain_factory, view_factory)
+      @container = container
+      @route_matcher = route_matcher
+      @chain_factory = chain_factory
+      @view_factory = view_factory
+    end
+
+    def handle(rack_env)
+      create_scope
+
+      path = rack_env['PATH_INFO']
+      request_method = rack_env['REQUEST_METHOD']
+      match = @route_matcher.match(path, request_method)
+      content_type = rack_env['CONTENT_TYPE'] || 'application/json'
+
+      if match.nil?
+        result = [404, { 'Content-Type' => content_type }, []]
+      else
+        query = Rack::Utils.parse_nested_query(rack_env['QUERY_STRING']).symbolize_keys
+        register_params(query, :silicon_query)
+
+        data = rack_env['rack.parser.result']
+        register_params(data, :silicon_data)
+
+        chain = @chain_factory.create(match)
+        chain.execute
+
+        body = ''
+        if match.route.view
+          body = @view_factory.create(match.route.view, content_type)
+        end
+
+        status = @container.resolve(:silicon_status)
+        result = [status, { 'Content-Type' => content_type }, [body]]
+      end
+
+      release
+
+      result
+    end
+
+    private
+    def create_scope
+      @container
+        .register_instance(self, :silicon_request)
+        .using_lifetime(:scope)
+        .bound_to(self)
+    end
+
+    def register_params(params, name)
+      unless params.nil?
+        @container.register_instance(params, name)
+          .using_lifetime(:scope)
+          .bound_to(:silicon_request)
+      end
+    end
+  end
+end

data/lib/silicon/routing/builder.rb

@@ -0,0 +1,96 @@
+require 'silicon/routing/route'
+
+module Silicon
+  module Routing
+    class Builder
+      def initialize
+        @parsed_items = []
+        @route_params = []
+        @current_parent = nil
+        @prev_route = nil
+      end
+
+      def build(sections)
+        result = []
+
+        node = sections.node
+        restore_hierarchy(node, nil,node.to_hash)
+
+        @route_params.each do |route|
+          if route[:actions]
+            route[:actions].each do |action|
+              result << Route.new({
+                path: restore_path(route).gsub('$', '/$'),
+                params: restore_params(route).map{|p| p.sub('$', '')},
+                http_verb: action[:http_verb],
+                view: action[:view],
+                http_status: action[:http_status],
+                catch: sections.catch.command,
+                commands: restore_callbacks(route, :before) + action[:commands] + restore_callbacks(route, :after)
+              })
+            end
+          end
+        end
+
+        result
+      end
+
+      private
+
+      def restore_hierarchy(node, prev_route, current_parent)
+        route = node.to_hash
+
+        if route[:level] == current_parent[:level]
+          route[:parent] = current_parent[:parent]
+          parent = route
+        elsif route[:level] > prev_route[:level]
+          route[:parent] = prev_route
+          parent = prev_route
+        else
+          route[:parent] = current_parent
+          parent = current_parent
+        end
+
+        @route_params << route
+        @prev_route = route
+
+        if node.my_nodes
+          node.my_nodes.each {|n| restore_hierarchy(n, route, parent)}
+        end
+      end
+
+      def restore_path(route)
+        path = (route[:route][:path] || route[:route][:parameter] || '')
+        if route[:parent]
+          restore_path(route[:parent]) + path
+        else
+          path
+        end
+      end
+
+      def restore_params(route)
+        if route[:route][:parameter]
+          param = [route[:route][:parameter]]
+        else
+          param = []
+        end
+
+        if route[:parent]
+          restore_params(route[:parent]) + param
+        else
+          param
+        end
+      end
+
+      def restore_callbacks(route, type)
+        before = route[type]
+
+        if route[:parent]
+          restore_callbacks(route[:parent], type) + before
+        else
+          before
+        end
+      end
+    end
+  end
+end

data/lib/silicon/routing/file_reader.rb

@@ -0,0 +1,27 @@
+module Silicon
+  module Routing
+    class FileReader
+      def initialize(silicon_config)
+        @config = silicon_config
+      end
+
+      def read
+        path = File.join('./', @config[:path][:routes])
+        content = File.read(path)
+
+        # use '^' instead spaces and tabs
+        raw_content = content.gsub(/\t/, '  ')
+                        .gsub('  ', '^')
+                        .gsub(' ', '')
+
+        ###Hack:
+        # grammar problem - can't simply match '-' character in route path when '->' present.
+        # Will be resolved later. Replace '->', '<-' with '*>', '<*' for a while for syntax parser.
+        ###
+        raw_content = raw_content.gsub('->', '*>').gsub('<-', '<*')
+
+        raw_content.gsub!("\n", ';') + ';'
+      end
+    end
+  end
+end

data/lib/silicon/routing/match.rb

@@ -0,0 +1,12 @@
+module Silicon
+  module Routing
+    class Match
+      attr_reader :route, :params
+
+      def initialize(route, params)
+        @route = route
+        @params = params
+      end
+    end
+  end
+end

data/lib/silicon/routing/matcher.rb

@@ -0,0 +1,40 @@
+require 'silicon/routing/match'
+
+module Silicon
+  module Routing
+    class Matcher
+      def initialize(routes)
+        @routes = routes
+      end
+
+      def match(path, http_method)
+        segments = path.split('/')
+        params = {}
+        matched = nil
+
+        @routes.each do |route|
+          if route.segments.length == segments.length
+            for i in 0..segments.length - 1 do
+              template = route.segments[i]
+              value = segments[i]
+
+              if value == template
+              elsif template.index('$') == 0
+                name = template.sub('$', '')
+                params[name] = value
+              else
+                break
+              end
+
+              if i == segments.length - 1 && route.http_verb == http_method
+                matched = route
+              end
+            end
+          end
+        end
+
+        matched.nil? ? nil : Match.new(matched, params)
+      end
+    end
+  end
+end

data/lib/silicon/routing/parser.rb

@@ -0,0 +1,25 @@
+module Silicon
+  module Routing
+    class Parser
+      def initialize(file_reader, routes_builder,
+                     syntax_parser, syntax_error_interpreter)
+        @file_reader = file_reader
+        @routes_builder = routes_builder
+        @syntax_parser = syntax_parser
+        @syntax_error_interpreter = syntax_error_interpreter
+      end
+
+      def parse
+        content = @file_reader.read
+        tree = @syntax_parser.parse(content)
+
+        if tree.nil?
+          error_message = @syntax_error_interpreter.interpret
+          raise Silicon::SyntaxError, error_message
+        end
+
+        @routes_builder.build(tree.parse)
+      end
+    end
+  end
+end

data/lib/silicon/routing/route.rb

@@ -0,0 +1,19 @@
+module Silicon
+  module Routing
+    class Route
+      attr_reader :http_verb, :path, :params, :catch,
+                  :commands, :segments, :view, :http_status
+
+      def initialize(hash)
+        @http_verb = hash[:http_verb]
+        @path = hash[:path].sub('.', '')
+        @params = hash[:params]
+        @commands = hash[:commands]
+        @view = hash[:view]
+        @http_status = hash[:http_status]
+        @segments = @path.split('/')
+        @catch = hash[:catch]
+      end
+    end
+  end
+end

data/lib/silicon/routing/routing.rb

@@ -0,0 +1,11 @@
+require 'treetop'
+require 'silicon/routing/builder'
+require 'silicon/routing/parser'
+require 'silicon/routing/matcher'
+require 'silicon/routing/file_reader'
+require 'silicon/routing/syntax_error_interpreter'
+require 'silicon/routing/syntax_grammar'
+require 'silicon/routing/syntax'
+
+module Routing
+end

data/lib/silicon/routing/syntax.rb

@@ -0,0 +1,28 @@
+require_relative 'syntax/primitives/arrow'
+require_relative 'syntax/primitives/back_arrow'
+require_relative 'syntax/primitives/eol'
+require_relative 'syntax/primitives/indent'
+require_relative 'syntax/primitives/http_verb'
+require_relative 'syntax/primitives/http_status'
+require_relative 'syntax/primitives/parameter'
+require_relative 'syntax/primitives/path'
+
+require_relative 'syntax/action'
+require_relative 'syntax/actions'
+require_relative 'syntax/command'
+require_relative 'syntax/commands'
+require_relative 'syntax/view'
+require_relative 'syntax/node'
+require_relative 'syntax/nodes'
+require_relative 'syntax/route'
+require_relative 'syntax/respond'
+
+
+require_relative 'syntax/sections'
+require_relative 'syntax/before_section'
+require_relative 'syntax/tree_section'
+require_relative 'syntax/after_section'
+require_relative 'syntax/catch_section'
+
+module Syntax
+end

data/lib/silicon/routing/syntax/action.rb

@@ -0,0 +1,30 @@
+module Syntax
+  class Action < Treetop::Runtime::SyntaxNode
+    attr_reader :http_verb, :commands, :node, :respond
+
+    def parse(node)
+      @node = node
+      @commands = []
+
+      elements.each do |element|
+        if element.is_a? HttpVerb
+          @http_verb = element.text_value
+        end
+
+        if element.is_a? Commands
+          @commands = element.parse
+        end
+
+        if element.is_a? Respond
+          @respond = element.parse
+        end
+      end
+
+      self
+    end
+
+    def to_hash
+      {http_verb: @http_verb, commands: @commands, view: @respond.view, http_status: @respond.http_status}
+    end
+  end
+end

data/lib/silicon/routing/syntax/actions.rb

@@ -0,0 +1,15 @@
+module Syntax
+  class Actions < Treetop::Runtime::SyntaxNode
+    attr_reader :actions
+
+    def parse(node)
+      @actions = []
+
+      elements.each do |element|
+        @actions << element.parse(node).to_hash
+      end
+
+      @actions
+    end
+  end
+end

data/lib/silicon/routing/syntax/after_section.rb

@@ -0,0 +1,19 @@
+module Syntax
+  class AfterSection < Treetop::Runtime::SyntaxNode
+    attr_reader :commands
+
+    def parse
+      @commands = []
+
+      if elements.length > 0
+        elements[0].elements.each do |element|
+          if element.is_a? Commands
+            @commands = element.parse
+          end
+        end
+      end
+
+      self
+    end
+  end
+end

data/lib/silicon/routing/syntax/before_section.rb

@@ -0,0 +1,18 @@
+module Syntax
+  class BeforeSection < Treetop::Runtime::SyntaxNode
+    attr_reader :commands
+
+    def parse
+      @commands = []
+      if elements.length > 0
+        elements[0].elements.each do |element|
+          if element.is_a? Commands
+            @commands = element.parse
+          end
+        end
+      end
+
+      self
+    end
+  end
+end

data/lib/silicon/routing/syntax/catch_section.rb

@@ -0,0 +1,15 @@
+module Syntax
+  class CatchSection < Treetop::Runtime::SyntaxNode
+    attr_reader :command
+
+    def parse
+      elements[0].elements.each do |element|
+        if element.is_a? Command
+          @command = element.parse
+        end
+      end
+
+      self
+    end
+  end
+end

data/lib/silicon/routing/syntax/command.rb

@@ -0,0 +1,27 @@
+module Syntax
+  class Command < Treetop::Runtime::SyntaxNode
+    attr_reader :name
+
+    def parse
+      @is_async = text_value.start_with? '=*'
+      @is_parallel = text_value.start_with? '=>'
+      @is_sequential = text_value.start_with? '*>'
+
+      @name = text_value.sub('*>', '').sub('=*', '').sub('=>', '')
+
+      self
+    end
+
+    def async?
+      @is_async
+    end
+
+    def parallel?
+      @is_parallel
+    end
+
+    def sequential?
+      @is_sequential
+    end
+  end
+end