dandy 0.6.0

data/lib/dandy/chain_factory.rb

@@ -0,0 +1,39 @@
+require 'dandy/chain'
+
+module Dandy
+  class ChainFactory
+    def initialize(container, dandy_config)
+      @container = container
+      @dandy_config = dandy_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, @dandy_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(:dandy_request)
+      end
+    end
+
+    def register_status(status)
+      @container
+        .register_instance(status, :dandy_status)
+        .using_lifetime(:scope)
+        .bound_to(:dandy_request)
+    end
+
+    def default_http_status(http_verb)
+      http_verb == 'POST' ? 201 : 200
+    end
+  end
+end

data/lib/dandy/config.rb

@@ -0,0 +1,15 @@
+require 'yaml'
+require 'dandy/extensions/hash'
+
+module Dandy
+  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/dandy/errors/dandy_error.rb

@@ -0,0 +1,4 @@
+module Dandy
+  class DandyError < StandardError
+  end
+end

data/lib/dandy/errors/syntax_error.rb

@@ -0,0 +1,6 @@
+require 'dandy/errors/dandy_error'
+
+module Dandy
+  class SyntaxError < DandyError
+  end
+end

data/lib/dandy/errors/view_engine_error.rb

@@ -0,0 +1,6 @@
+require 'dandy/errors/dandy_error'
+
+module Dandy
+  class ViewEngineError < DandyError
+  end
+end

data/lib/dandy/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/dandy/generators/cli.rb

@@ -0,0 +1,58 @@
+require 'thor'
+require 'terminal-table'
+
+module Dandy
+  class CLI < Thor
+    include Thor::Actions
+
+    def self.source_root
+      File.dirname(__FILE__)
+    end
+
+    desc 'new NAME', 'Create new Dandy application'
+    def new(name)
+      copy_file 'templates/app/app.rb', "#{name}/app/app.rb"
+      copy_file 'templates/app/app.routes', "#{name}/app/app.routes"
+      copy_file 'templates/dandy.yml', "#{name}/dandy.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"
+      copy_file 'templates/Gemfile', "#{name}/Gemfile"
+      template 'templates/actions/welcome.tt', "#{name}/app/actions/welcome.rb", {app_name: name}
+
+      inside name do
+        run 'bundle'
+      end
+    end
+
+    desc 'routes', 'Show Dandy application routes'
+    def routes
+      require './app/app'
+      app = App.new
+
+      headings = ['HTTP Verb', 'Path', 'Action Chain']
+      rows = app.routes.map do |route|
+        indent = ''
+        commands = []
+        route.commands.each_with_index do |c, index|
+          indent += '  ' if c.sequential? && index > 0
+
+          prefix = '->' if c.sequential?
+          prefix = '=>' if c.parallel?
+          prefix = '=*' if c.async?
+
+          commands << "#{indent} #{prefix} #{c.name}"
+        end
+
+
+        commands = commands.join("\n")
+        [route.http_verb, route.path, commands]
+      end
+
+      table = Terminal::Table.new(headings: headings, rows: rows)
+      table.style = {all_separators: true}
+      puts table
+    end
+  end
+end
+

data/lib/dandy/generators/templates/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+gem 'rack-cors'
+gem 'dandy'

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

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

data/lib/dandy/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/dandy/generators/templates/app/app.rb

@@ -0,0 +1,4 @@
+require 'dandy'
+
+class App < Dandy::App
+end

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

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

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

@@ -0,0 +1,17 @@
+require 'rack'
+require 'rack/cors'
+require './app/app'
+
+use Rack::Parser, :content_types => {
+  'application/json'  => Proc.new { |body| ::MultiJson.decode body }
+}
+
+use Rack::Cors do
+  # Setup your CORS policy
+end
+
+if ENV['DANDY_ENV'] == 'development' || ENV['DANDY_ENV'] == ''
+  use Rack::Reloader
+end
+
+run App.new

data/lib/dandy/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/dandy/generators/templates/views/show_welcome.json.jbuilder

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

data/lib/dandy/loaders/dependency_loader.rb

@@ -0,0 +1,21 @@
+module Dandy
+  class DependencyLoader
+    def initialize(container, type_loader, dandy_env)
+      @container = container
+      @type_loader = type_loader
+      @types = type_loader.load_types
+      @dandy_env = dandy_env
+    end
+
+    def load_components
+      if @dandy_env == 'development'
+        # every time reload types in development mode
+        @types = @type_loader.load_types
+      end
+
+      @types.each do |type|
+        @container.register(type).using_lifetime(:scope).bound_to(:dandy_request)
+      end
+    end
+  end
+end

data/lib/dandy/loaders/template_loader.rb

@@ -0,0 +1,20 @@
+module Dandy
+  class TemplateLoader
+    def initialize(dandy_config)
+      @directory = File.join(dandy_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/dandy/loaders/type_loader.rb

@@ -0,0 +1,25 @@
+module Dandy
+  class TypeLoader
+    def initialize(dandy_config)
+      @directories = dandy_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

data/lib/dandy/request.rb

@@ -0,0 +1,65 @@
+require 'dandy/chain_factory'
+require 'dandy/view_factory'
+
+module Dandy
+  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, :dandy_query)
+
+        data = rack_env['rack.parser.result']
+        register_params(data, :dandy_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(:dandy_status)
+        result = [status, { 'Content-Type' => content_type }, [body]]
+      end
+
+      release
+
+      result
+    end
+
+    private
+    def create_scope
+      @container
+        .register_instance(self, :dandy_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(:dandy_request)
+      end
+    end
+  end
+end

data/lib/dandy/routing/builder.rb

@@ -0,0 +1,96 @@
+  require 'dandy/routing/route'
+
+module Dandy
+  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