silicon 0.2.0

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/exe/silicon

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'silicon/generators/cli'
+
+Silicon::CLI.start ARGV

data/lib/silicon.rb

@@ -0,0 +1,6 @@
+require 'silicon/version'
+require 'silicon/app'
+require 'silicon/base/handle_errors'
+
+module Silicon
+end

data/lib/silicon/app.rb

@@ -0,0 +1,90 @@
+require 'hypo'
+require 'json'
+require 'rack/parser'
+require 'silicon/loaders/type_loader'
+require 'silicon/loaders/dependency_loader'
+require 'silicon/loaders/template_loader'
+require 'silicon/config'
+require 'silicon/request'
+require 'silicon/template_registry'
+require 'silicon/view_builder_registry'
+require 'silicon/view_factory'
+require 'silicon/chain_factory'
+require 'silicon/view_builders/json'
+require 'silicon/routing/routing'
+
+module Silicon
+  class App
+    def initialize(container = Hypo::Container.new)
+      @container = container
+
+      register_dependencies
+      load_basic_dependencies
+      parse_routes
+      add_view_builders
+    end
+
+    def call(env)
+      request = Request.new(@route_matcher, @container, @chain_factory, @view_factory)
+      request.handle(env)
+    end
+
+    protected
+
+    def add_view_builder(view_builder, format)
+      @view_builder_registry.add(view_builder, format)
+    end
+
+    private
+
+    def add_view_builders
+      add_view_builder(ViewBuilders::Json, 'json')
+    end
+
+    def register_dependencies
+      instances = {
+        config_file_path: 'silicon.yaml'
+      }
+
+      instances.keys.each do |name|
+        @container.register_instance(instances[name], name)
+      end
+
+      singletons = {
+        silicon_config: Config,
+        type_loader: TypeLoader,
+        dependency_loader: DependencyLoader,
+        template_loader: TemplateLoader,
+        template_registry: TemplateRegistry,
+        view_builder_registry: ViewBuilderRegistry,
+        view_factory: ViewFactory,
+        chain_factory: ChainFactory,
+        file_reader: Routing::FileReader,
+        syntax_parser: SyntaxParser,
+        syntax_error_interpreter: Routing::SyntaxErrorInterpreter,
+        routes_builder: Routing::Builder,
+        route_parser: Routing::Parser
+      }
+
+      singletons.keys.each do |name|
+        @container.register(singletons[name], name)
+          .using_lifetime(:singleton)
+      end
+    end
+
+    def load_basic_dependencies
+      @chain_factory = @container.resolve(:chain_factory)
+      @view_factory = @container.resolve(:view_factory)
+      @dependency_loader = @container.resolve(:dependency_loader)
+      @view_builder_registry = @container.resolve(:view_builder_registry)
+      @route_parser = @container.resolve(:route_parser)
+
+      @dependency_loader.load_components
+    end
+
+    def parse_routes
+      routes = @route_parser.parse
+      @route_matcher = Routing::Matcher.new(routes)
+    end
+  end
+end

data/lib/silicon/base/handle_errors.rb

@@ -0,0 +1,16 @@
+module Silicon
+  class HandleErrors
+    def initialize(container, silicon_error)
+      @container = container
+      @silicon_error = silicon_error
+    end
+
+    protected
+    def set_http_status(status_code)
+      @container
+        .register_instance(status_code, :silicon_status)
+        .using_lifetime(:scope)
+        .bound_to(:silicon_request)
+    end
+  end
+end

data/lib/silicon/chain.rb

@@ -0,0 +1,69 @@
+require 'timeout'
+
+module Silicon
+  class Chain
+    def initialize(container, silicon_config, commands, catch_command = nil)
+      @commands = commands
+      @container = container
+      @catch_command = catch_command
+      @async_timeout = silicon_config[:action][:async_timeout]
+    end
+
+    def execute
+      if @catch_command.nil?
+        run_actions
+      else
+        begin
+          run_actions
+        rescue Exception => error
+          @container
+            .register_instance(error, :silicon_error)
+            .using_lifetime(:scope)
+            .bound_to(:silicon_request)
+
+          action = @container.resolve(@catch_command.name.to_sym)
+          action.call
+        end
+      end
+    end
+
+    private
+
+    def run_actions
+      threads = []
+      Thread.abort_on_exception = true
+      @commands.each_with_index do |command, index|
+        if command.sequential?
+          # all previous parallel commands should be done before the current sequential
+          threads.each {|t| t.join}
+          threads = []
+
+          run_action(command.name)
+        else
+          thread = Thread.new {
+            Timeout::timeout(@async_timeout) {
+              run_action(command.name)
+            }
+          }
+          threads << thread if command.parallel?
+        end
+
+        # if it's last item in chain then wait until parallel commands are done
+        if index == @commands.length - 1
+          threads.each {|t| t.join}
+        end
+      end
+    end
+
+    def run_action(name)
+      action = @container.resolve(name.to_sym)
+      result = action.call
+      result_name = action.respond_to?(:result_name) ? action.result_name : "#{name}_result"
+
+      @container
+        .register_instance(result, result_name.to_sym)
+        .using_lifetime(:scope)
+        .bound_to(:silicon_request)
+    end
+  end
+end

data/lib/silicon/chain_factory.rb

@@ -0,0 +1,39 @@
+require 'silicon/chain'
+
+module Silicon
+  class ChainFactory
+    def initialize(container, silicon_config)
+      @container = container
+      @silicon_config = silicon_config
+    end
+
+    def create(match)
+      status = match.route.http_status || default_http_status(match.route.http_verb)
+      register_params(match.params)
+      register_status(status)
+      Chain.new(@container, @silicon_config, match.route.commands, match.route.catch)
+    end
+
+    private
+
+    def register_params(params)
+      params.keys.each do |key|
+        @container
+          .register_instance(params[key], key.to_sym)
+          .using_lifetime(:scope)
+          .bound_to(:silicon_request)
+      end
+    end
+
+    def register_status(status)
+      @container
+        .register_instance(status, :silicon_status)
+        .using_lifetime(:scope)
+        .bound_to(:silicon_request)
+    end
+
+    def default_http_status(http_verb)
+      http_verb == 'POST' ? 201 : 200
+    end
+  end
+end

data/lib/silicon/config.rb

@@ -0,0 +1,15 @@
+require 'yaml'
+require 'silicon/extensions/hash'
+
+module Silicon
+  class Config
+    def initialize(config_file_path)
+      path = File.join(Dir.pwd, config_file_path)
+      @params = YAML.load_file(path).deep_symbolize_keys!
+    end
+
+    def [](key)
+      @params[key]
+    end
+  end
+end

data/lib/silicon/errors/silicon_error.rb

@@ -0,0 +1,4 @@
+module Silicon
+  class SiliconError < StandardError
+  end
+end

data/lib/silicon/errors/syntax_error.rb

@@ -0,0 +1,6 @@
+require 'silicon/errors/silicon_error'
+
+module Silicon
+  class SyntaxError < SiliconError
+  end
+end

data/lib/silicon/errors/view_engine_error.rb

@@ -0,0 +1,6 @@
+require 'silicon/errors/silicon_error'
+
+module Silicon
+  class ViewEngineError < SiliconError
+  end
+end

data/lib/silicon/extensions/hash.rb

@@ -0,0 +1,18 @@
+class Hash
+  # simplecov incorrectly covers activesupport variants of these overloads.
+  # Actually both methods are covered by unit tests.
+
+  # :nocov:
+  def symbolize_keys
+    Hash[map{|(k,v)| [k.to_sym,v]}]
+  end
+
+  def deep_symbolize_keys!
+    keys.each do |key|
+      val = delete(key)
+      self[(key.to_sym rescue key)] = val.is_a?(Hash) || val.is_a?(Array) ? val.deep_symbolize_keys! : val
+    end
+    self
+  end
+  # :nocov:
+end

data/lib/silicon/generators/cli.rb

@@ -0,0 +1,23 @@
+require 'thor'
+
+module Silicon
+  class CLI < Thor
+    include Thor::Actions
+
+    def self.source_root
+      File.dirname(__FILE__)
+    end
+
+    desc 'new NAME', 'create new Silicon application'
+    def new(name)
+      copy_file 'templates/app.rb', "#{name}/app/app.rb"
+      copy_file 'templates/app.routes', "#{name}/app/app.routes"
+      copy_file 'templates/silicon.yml', "#{name}/silicon.yml"
+      copy_file 'templates/config.ru', "#{name}/config.ru"
+      copy_file 'templates/views/show_welcome.json.jbuilder', "#{name}/app/views/show_welcome.json.jbuilder"
+      copy_file 'templates/actions/common/handle_errors.rb', "#{name}/app/actions/common/handle_errors.rb"
+      template 'templates/actions/welcome.tt', "#{name}/app/actions/welcome.rb", {app_name: name}
+    end
+  end
+end
+

data/lib/silicon/generators/templates/actions/common/handle_errors.rb

@@ -0,0 +1,2 @@
+class HandleErrors < Silicon::HandleErrors
+end

data/lib/silicon/generators/templates/actions/welcome.tt

@@ -0,0 +1,9 @@
+class Welcome
+  def call
+    "Welcome to <%= config[:app_name] %>!"
+  end
+
+  def result_name
+    'message'
+  end
+end

data/lib/silicon/generators/templates/app.rb

@@ -0,0 +1,4 @@
+require 'silicon'
+
+class App < Silicon::App
+end

data/lib/silicon/generators/templates/app.routes

@@ -0,0 +1,4 @@
+:receive
+    .->
+        GET -> welcome -> :respond <- show_welcome
+:catch -> handle_errors

data/lib/silicon/generators/templates/config.ru

@@ -0,0 +1,8 @@
+require 'rack'
+require './app'
+
+use Rack::Parser, :content_types => {
+  'application/json'  => Proc.new { |body| ::MultiJson.decode body }
+}
+
+run App.new

data/lib/silicon/generators/templates/silicon.yml

@@ -0,0 +1,7 @@
+path:
+  dependencies:
+    - app/actions
+  views: app/views
+  routes: app/app.routes
+action:
+  async_timeout: 10 # in seconds

data/lib/silicon/generators/templates/views/show_welcome.json.jbuilder

@@ -0,0 +1 @@
+json.message @message

data/lib/silicon/loaders/dependency_loader.rb

@@ -0,0 +1,14 @@
+module Silicon
+  class DependencyLoader
+    def initialize(container, type_loader)
+      @container = container
+      @types = type_loader.load_types
+    end
+
+    def load_components
+      @types.each do |type|
+        @container.register(type).using_lifetime(:scope).bound_to(:silicon_request)
+      end
+    end
+  end
+end

data/lib/silicon/loaders/template_loader.rb

@@ -0,0 +1,20 @@
+module Silicon
+  class TemplateLoader
+    def initialize(silicon_config)
+      @directory = File.join(silicon_config[:path][:views], '**/*')
+    end
+
+    def load_templates
+      result = {}
+
+      files = Dir.glob(@directory).reject {|file_path| File.directory? file_path}
+      files.each do |file|
+        path = File.join Dir.pwd, file
+        content = File.read(path)
+        result[file] = content
+      end
+
+      result
+    end
+  end
+end

data/lib/silicon/loaders/type_loader.rb

@@ -0,0 +1,25 @@
+module Silicon
+  class TypeLoader
+    def initialize(silicon_config)
+      @directories = silicon_config[:path][:dependencies]
+    end
+
+    def load_types
+      types = []
+      @directories.each do |directory|
+        dir = File.join(directory, '**/*')
+        files = Dir.glob(dir).reject {|file_path| File.directory? file_path}
+
+        files.each do |file|
+          path = File.join Dir.pwd, file
+          require path
+          file_name = File.basename(file).gsub(File.extname(file), '')
+          class_name = file_name.split('_').each(&:capitalize!).join('')
+          types << Object.const_get(class_name)
+        end
+      end
+
+      types
+    end
+  end
+end