tau 0.1.0 → 0.1.1

data/lib/tau/builder.rb

@@ -1,34 +1,29 @@
-require 'tau/projecter'
-require 'tau/renderer'
-
-module Tau
-  class Builder
-    class << self
-
-      def build
-        raise "You are not in the project directory" unless Projecter.project_dir?(Dir.pwd)
-
-        FileUtils.rm_rf('build')
-        Dir['code/**/*'].each do |filename|
-          if File.directory?(filename)
-            FileUtils.mkdir_p filename.sub('code/', 'build/')
-          elsif not Renderer.need_render? filename
-            FileUtils.cp filename, destination_for(filename)
-          else
-            Renderer.render_to_file destination_for(filename), filename
-          end
-        end
-      end
-
-    private
-
-      def destination_for(filename)
-        filename.sub('code/', 'build/').sub(/\.sass$/, '.css')
-                                       .sub(/\.scss$/, '.css')
-                                       .sub(/\.haml$/, '.html')
-                                       .sub(/\.coffee$/, '.js')
-      end
-
-    end
-  end
-end
+require 'tau/projecter'
+require 'tau/enginer'
+
+module Tau
+  class Builder
+    def self.build
+      raise "You are not in the project directory" unless Projecter.project_dir?(Dir.pwd)
+
+      FileUtils.rm_rf(BUILD_DIR)
+      Dir["#{CODE_DIR}/**/*"].each do |filename|
+        if File.directory?(filename)
+          FileUtils.mkdir_p destination_for(filename)
+        elsif Enginer.can_render_from? filename
+          engine = Enginer.engine_for_render_from filename
+          File.write destination_for(filename, engine), engine.render_file(filename)
+        else
+          FileUtils.cp filename, destination_for(filename)
+        end
+      end
+    end
+
+  private
+
+    def self.destination_for(filename, engine = nil)
+      filename = engine.dst_for filename if engine != nil
+      filename.sub(CODE_DIR, BUILD_DIR)
+    end
+  end
+end

data/lib/tau/cli.rb

@@ -1,35 +1,35 @@
-require 'thor'
-require 'tau/projecter'
-require 'tau/server'
-require 'tau/version'
-require 'tau/builder'
-
-module Tau
-  class Cli < Thor
-    map '-v' => :version
-
-    desc "new PROJECT_NAME", "Making new project"
-    def new(project_name)
-      begin
-        Tau::Projecter.new_project(Dir.pwd, project_name)
-      rescue Exception => e
-        puts e.message
-      end
-    end
-
-    desc :server, "Starting server for development"
-    def server
-      Tau::Server.start
-    end
-
-    desc :build, "Building project"
-    def build
-      Tau::Builder.build
-    end
-
-    desc :version, "Show tau version"
-    def version
-      puts "Tau #{Tau::VERSION}"
-    end
-  end
-end
+require 'thor'
+require 'tau/projecter'
+require 'tau/server'
+require 'tau/version'
+require 'tau/builder'
+
+module Tau
+  class Cli < Thor
+    map '-v' => :version
+
+    desc "new PROJECT_NAME", "Making new project"
+    def new(project_name)
+      begin
+        Tau::Projecter.new_project(Dir.pwd, project_name)
+      rescue Exception => e
+        puts e.message
+      end
+    end
+
+    desc :server, "Starting server for development"
+    def server
+      Tau::Server.start
+    end
+
+    desc :build, "Building project"
+    def build
+      Tau::Builder.build
+    end
+
+    desc :version, "Show tau version"
+    def version
+      puts "Tau #{Tau::VERSION}"
+    end
+  end
+end

data/lib/tau/config.rb

@@ -0,0 +1,15 @@
+module Tau
+  module Defaults
+    PORT = 15000
+  end
+
+  CODE_DIR = 'code'
+  BUILD_DIR = 'build'
+  CONFIG_FILE = 'tau.yml'
+
+  PROJECT_NAME_EXP = /^[[:word:]\.-]+$/
+
+  SERVER = %w(thin webrick)
+
+  FILE_PATH_EXP = /^([[:word:]\.-\/]+)$/
+end

data/lib/tau/enginer.rb

@@ -0,0 +1,42 @@
+require 'tau/engines/haml'
+require 'tau/engines/sass'
+require 'tau/engines/scss'
+require 'tau/engines/coffee'
+
+module Tau
+  class Enginer
+    ENGINES = [Engines::Haml, Engines::Sass, Engines::Scss, Engines::Coffee]
+
+    def self.can_render_to?(filename)
+      ENGINES.each do |engine|
+        return true if engine.can_render_to? filename
+      end
+      false
+    end
+
+    def self.can_render_from?(filename)
+      ENGINES.each do |engine|
+        return true if engine.can_render_from? filename
+      end
+      false
+    end
+
+    def self.engine_for_render_to(filename)
+      ENGINES.select {|engine| engine.can_render_to? filename}.first
+    end
+
+    def self.engine_for_render_from(filename)
+      ENGINES.select {|engine| engine.can_render_from? filename}.first
+    end
+
+    def self.dst_for(source)
+      engine = engine_for_render_from source
+      engine != nil ? engine.dst_for(source) : source
+    end
+
+    def self.source_for(dst)
+      engine = engine_for_render_to dst
+      engine != nil ? engine.source_for(dst) : dst_for
+    end
+  end
+end

data/lib/tau/engines/abstract_engine.rb

@@ -0,0 +1,71 @@
+module Tau
+  module Engines
+    class AbstractEngine
+      class << self
+
+        def render_file(filename)
+          render File.read(filename)
+        end
+
+        def source_exist?(dst)
+          File.exist? source_for(dst)
+        end
+
+        def source_for(dst)
+          dst.sub(/\.#{render_to}\z/, ".#{render_from}")
+        end
+
+        def dst_exist?(source)
+          File.exist? dst_for(source)
+        end
+
+        def dst_for(source)
+          source.sub(/\.#{render_from}\z/, ".#{render_to}")
+        end
+
+        def can_render_to?(filename)
+          filename.end_with?(render_to) and source_exist?(filename)
+        end
+
+        def can_render_from?(filename)
+          filename.end_with?(render_from) and File.exist?(filename)
+        end
+
+      private
+
+        def render_to(format)
+          self.instance_eval %{
+            def render_to?(format)
+              format == "#{format}"
+            end
+
+            def render_to
+              "#{format}"
+            end
+          }
+        end
+
+        def to(format)
+          render_to format
+        end
+
+        def render_from(format)
+          self.instance_eval %{
+            def render_from?(format)
+              format == "#{format}"
+            end
+
+            def render_from
+              "#{format}"
+            end
+          }
+        end
+
+        def from(format)
+          render_from format
+        end
+
+      end
+    end
+  end
+end

data/lib/tau/engines/coffee.rb

@@ -0,0 +1,15 @@
+require 'tau/engines/abstract_engine'
+require 'coffee-script'
+
+module Tau
+  module Engines
+    class Coffee < AbstractEngine
+      render_to 'js'
+      from 'coffee'
+
+      def self.render(content)
+        CoffeeScript.compile(content)
+      end
+    end
+  end
+end

data/lib/tau/engines/haml.rb

@@ -0,0 +1,15 @@
+require 'tau/engines/abstract_engine'
+require 'haml'
+
+module Tau
+  module Engines
+    class Haml < AbstractEngine
+      render_to 'html'
+      from 'haml'
+
+      def self.render(content)
+        ::Haml::Engine.new(content).render
+      end
+    end
+  end
+end

data/lib/tau/engines/sass.rb

@@ -0,0 +1,15 @@
+require 'tau/engines/abstract_engine'
+require 'sass'
+
+module Tau
+  module Engines
+    class Sass < AbstractEngine
+      render_to 'css'
+      from 'sass'
+
+      def self.render(content)
+        ::Sass::Engine.new(content).render
+      end
+    end
+  end
+end

data/lib/tau/engines/scss.rb

@@ -0,0 +1,15 @@
+require 'tau/engines/abstract_engine'
+require 'sass'
+
+module Tau
+  module Engines
+    class Scss < AbstractEngine
+      render_to 'css'
+      from 'scss'
+
+      def self.render(content)
+        ::Sass::Engine.new(content, syntax: :scss).render
+      end
+    end
+  end
+end

data/lib/tau/projecter.rb

@@ -1,30 +1,43 @@
-module Tau
-  class Projecter
-    def self.new_project(directory, project_name)
-      Dir.chdir(directory)
-
-      raise "This already is the project directory" if project_dir?(directory)
-      raise "Wrong project name" unless project_name =~ /^[[:word:]\.-]+$/
-      raise "Directory exists" if Dir.exist?(project_name)
-
-      Dir.mkdir(project_name)
-      Dir.chdir(project_name) do
-        puts("\tcreate\tcode")
-        Dir.mkdir('code')
-        puts("\tcreate\tcode/js")
-        Dir.mkdir('code/js')
-        puts("\tcreate\tcode/css")
-        Dir.mkdir('code/css')
-        puts("\tcreate\tcode/img")
-        Dir.mkdir('code/img')
-        puts("\tcreate\ttau.yaml")
-        File.new('tau.yml', 'w')
-      end
-    end
-
-    def self.project_dir?(directory)
-      Dir.chdir(directory)
-      Dir.exist?('code') and File.exist?('tau.yml')
-    end
-  end
-end
+require 'tau/config'
+
+module Tau
+  class Projecter
+    def self.new_project(parent_directory, project_name)
+      Dir.chdir(parent_directory)
+
+      raise "This already is the project directory" if project_dir?(parent_directory)
+      raise "Wrong project name" unless project_name =~ PROJECT_NAME_EXP
+      raise "Directory exists" if Dir.exist?(project_name)
+
+      Dir.mkdir(project_name)
+      Dir.chdir(project_name) do
+        create_dir(CODE_DIR)
+        create_dir(CODE_DIR, 'js')
+        create_dir(CODE_DIR, 'css')
+        create_dir(CODE_DIR, 'img')
+        create_file(CONFIG_FILE)
+      end
+    end
+
+    def self.project_dir?(directory)
+      Dir.chdir(directory)
+      Dir.exist?(CODE_DIR) and File.exist?(CONFIG_FILE)
+    end
+
+  private
+
+    def self.create_dir(*directory)
+      directory = File.join directory
+
+      Dir.mkdir(directory)
+      puts("\tcreate\t#{directory}")
+    end
+
+    def self.create_file(*filename)
+      filename = File.join filename
+
+      File.new(filename, 'w')
+      puts("\tcreate\t#{filename}")
+    end
+  end
+end

data/lib/tau/server.rb

@@ -1,52 +1,33 @@
 require 'sinatra/base'
-require 'haml'
-require 'coffee-script'
-require 'sass'
+require 'tau/enginer'
+require 'tau/server/file_listing'
 
 module Tau
   class Server < Sinatra::Base
-    def self.start
-      set :port, 15000 # TODO: it should be changeable
+    helpers Tau::ServerHelpers::FileListing
 
-      # TODO: / route should return list of all files
-      get '/' do
-        "There should be list of all files."
-      end
+    def self.start
+      set :server, SERVER
+      set :port, Defaults::PORT # TODO: it should be changeable
 
-      # html
-      get /([\/\.\w-]+)\.html/ do |filename|
-        filename = "code/#{filename}"
-        return haml File.read("#{filename}.haml") if File.exist?("#{filename}.haml")
-        send_file "#{filename}.html" if File.exist?("#{filename}.html")
-        raise Sinatra::NotFound
-      end
+      get FILE_PATH_EXP do |path|
+        path = File.expand_path File.join(CODE_DIR, path) # we are currently in project dir
 
-      # javascript
-      get /js\/([\/\.\w-]+)\.js/ do |filename|
-        filename = "code/js/#{filename}"
-        return coffee File.read("#{filename}.coffee") if File.exist?("#{filename}.coffee")
-        send_file "#{filename}.js" if File.exist?("#{filename}.js")
-        raise Sinatra::NotFound
-      end
+        show_list_of_files_on path if File.directory? path
 
-      # css
-      get /css\/([\/\.\w-]+)\.css/ do |filename|
-        filename = "code/css/#{filename}"
-        return sass File.read("#{filename}.sass") if File.exist?("#{filename}.sass")
-        return scss File.read("#{filename}.scss") if File.exist?("#{filename}.scss")
-        send_file "#{filename}.css" if File.exist?("#{filename}.css")
-        raise Sinatra::NotFound
-      end
+        send_file path if File.exist? path
 
-      # images
-      get /img\/([\/\.\w-]+)/ do |filename|
-        filename = "code/img/#{filename}"
-        send_file filename if File.exist?(filename)
-        raise Sinatra::NotFound
+        # render file by one of engine if path isn't a directory or real file
+        engine = Enginer.engine_for_render_to path
+        if engine != nil
+          engine.render_file engine.source_for(path)
+        else
+          raise Sinatra::NotFound
+        end
       end
 
       not_found do
-        "No such file or directory"
+        show_list_of_files_on File.expand_path(CODE_DIR), "No such file or directory"
       end
 
       run!