slick 0.16.3 → 0.17.0

data/lib/slick/project.rb

@@ -0,0 +1,53 @@
+
+
+class Slick::Project
+
+    attr_reader :root_path, :load_paths, :name, :lib_names
+
+    def initialize
+        @root_path = find_root_path(Dir.pwd)
+        @load_paths = $LOAD_PATH.map{|load_path| find_root_path(load_path) }.compact
+        if @root_path
+            @name = gem_name(@root_path)
+            @load_paths.unshift(@root_path) unless @load_paths.include?(@root_path)
+        end
+        
+        @lib_names = @load_paths.map{|load_path| gem_name(load_path) }
+    end
+
+    def exist?
+        !@name.nil?
+    end
+
+    private
+
+    def find_file_path(path, pattern)
+        current_path = path
+        while true
+            Dir.open(current_path).each do |item|
+                candidate_file_path = "#{current_path}/#{item}"
+                return candidate_file_path if File.file?(candidate_file_path) && item.match(pattern)
+            end
+            if matches = current_path.match(/\A(.*)\/([^\/]+)\z/)
+                current_path = matches[1]
+                current_path = '/' if current_path == ''
+            else
+                break
+            end
+        end
+        nil
+    end
+
+    def find_root_path(path)
+        out = find_file_path(path, /\A\.slick\z/)
+        out.sub!(/\.slick\z/, '').sub!(/\A(.+)\/\z/, '\1') if out
+        out
+    end
+
+    def gem_name(path)
+        out = find_file_path(path, /\A[^\/]+\.gemspec\z/)
+        out.sub!(/\A.*\//, '').sub!(/\.gemspec\z/, '\1') if out
+        out
+    end
+
+end

data/lib/slick/project_watcher.rb

@@ -0,0 +1,36 @@
+
+require "slick/helpers"
+
+class Slick::ProjectWatcher
+
+    def self.watch
+        self.new.watch
+    end
+
+    include Slick::Helpers
+
+    def watch
+        last_modified_times = {}
+
+        while true
+            is_change = false
+
+            Dir.glob("#{project.root_path}/**/*").each do |file|
+                last_modified_time = File.mtime(file)
+                if last_modified_times[file] != last_modified_time
+                    is_change = true
+                end
+                last_modified_times[file] = last_modified_time
+            end
+
+            if is_change
+                Process.kill('KILL', @child_process_pid) if @child_process_pid
+                @child_process_pid = Process.fork
+                break if !@child_process_pid
+                
+            end
+        end
+    end
+
+
+end

data/lib/slick/registry.rb

@@ -0,0 +1,39 @@
+
+module Slick::Registry
+
+    attr_reader :name
+
+    def registered?
+        registered_classes.values.include? self
+    end
+
+    def registered_classes
+        @registered_classes ||= superclass.respond_to?(:registered_classes) ? superclass.registered_classes : {}
+    end
+
+    def register(name, *args, &block)
+        raise "Class has already been registered" if registered?
+        name = name.to_s
+        instance_eval{ @name = name }
+        registered_classes[name] = self
+        self
+    end
+
+    def for(name, options = {})
+        name = name.to_s
+        registered_classes[name] || begin
+            klass = Class.new(self)
+            if options.paramify.register_if_not_exists == 'true'
+                klass.register(name, options)
+            else
+                klass.instance_eval{ @name = name }
+            end
+            klass
+        end
+    end
+
+    def create(name, *args, &block)
+        self.for(name).new(*args, &block)
+    end
+
+end

data/lib/slick/request.rb

@@ -0,0 +1,6 @@
+
+require "rack"
+
+class Slick::Request < Rack::Request
+    
+end

data/lib/slick/resource_factories/config.rb

@@ -0,0 +1,14 @@
+
+require "slick/resource_factory"
+
+Class.new(Slick::ResourceFactory){ register "config", :shared => true }.define_method "create" do
+    if project.exist?
+        config_file_path = "#{project.root_path}/config.rb"
+        Slick::Workspace.new.instance_eval(
+            File.read(config_file_path),
+            config_file_path
+        ).paramify
+    else
+        {}.paramify
+    end
+end

data/lib/slick/resource_factories/database.rb

@@ -0,0 +1,6 @@
+
+require "slick/resource_factory"
+
+Class.new(Slick::ResourceFactory){ register "database" }.define_method "create" do
+    Slick::Database.new(config.database)
+end

data/lib/slick/resource_factories/database_schema_cache.rb

@@ -0,0 +1,6 @@
+
+require "slick/resource_factory"
+
+Class.new(Slick::ResourceFactory){ register "database_schema_cache", :shared => true }.define_method "create" do
+    {}
+end

data/lib/slick/resource_factories/database_session_cache.rb

@@ -0,0 +1,6 @@
+
+require "slick/resource_factory"
+
+Class.new(Slick::ResourceFactory){ register "database_session_cache" }.define_method "create" do
+    {}
+end

data/lib/slick/resource_factories/env.rb

@@ -0,0 +1,14 @@
+
+require "slick/resource_factory"
+
+Class.new(Slick::ResourceFactory){ register "env" }.define_method "create" do
+    {
+        "REQUEST_METHOD" => "GET",
+        "SCRIPT_NAME" => "",
+        "PATH_INFO" => "/",
+        "QUERY_STRING" => "",
+        "SERVER_NAME" => "localhost",
+        "SERVER_PORT" => "80",
+        "rack.input" => ""
+    }
+end

data/lib/slick/resource_factories/environment.rb

@@ -0,0 +1,6 @@
+
+require "slick/resource_factory"
+
+Class.new(Slick::ResourceFactory){ register "environment", :shared => true }.define_method "create" do
+    ENV["RACK_ENV"] || "development"
+end

data/lib/slick/resource_factories/file.rb

@@ -0,0 +1,6 @@
+
+require "slick/resource_factory"
+
+Class.new(Slick::ResourceFactory){ register "file" }.define_method "create" do
+    web.find_file("/")
+end

data/lib/slick/resource_factories/params.rb

@@ -0,0 +1,6 @@
+
+require "slick/resource_factory"
+
+Class.new(Slick::ResourceFactory){ register "params" }.define_method "create" do
+    request.params.paramify
+end

data/lib/slick/resource_factories/project.rb

@@ -0,0 +1,6 @@
+
+require "slick/resource_factory"
+
+Class.new(Slick::ResourceFactory){ register "project", :shared => true }.define_method "create" do
+    Slick::Project.new
+end

data/lib/slick/resource_factories/request.rb

@@ -0,0 +1,6 @@
+
+require "slick/resource_factory"
+
+Class.new(Slick::ResourceFactory){ register "request" }.define_method "create" do
+    Slick::Request.new(env)
+end

data/lib/slick/resource_factories/response.rb

@@ -0,0 +1,6 @@
+
+require "slick/resource_factory"
+
+Class.new(Slick::ResourceFactory){ register "response" }.define_method "create" do
+    Slick::Response[200, {"Content-Type" => "text/html"}, []]
+end

data/lib/slick/resource_factories/web.rb

@@ -0,0 +1,11 @@
+
+require "slick/resource_factory"
+
+Class.new(Slick::ResourceFactory){ register "web", :shared => true }.define_method "create" do
+    out = Slick::Web::Dir.new
+    project.load_paths.reverse.each do |load_path|
+        web_dir_path = "#{load_path}/web"
+        out.merge_dir(web_dir_path) if File.directory?(web_dir_path)
+    end
+    out
+end

data/lib/slick/resource_factory.rb

@@ -0,0 +1,35 @@
+
+require "slick/registry"
+require "slick/helper"
+require "slick/helpers"
+
+
+class Slick::ResourceFactory
+
+    class << self
+
+        include Slick::Registry
+
+        def register(name, options = {})
+            super(name)
+
+            @shared = options.paramify.shared == "true"
+
+            Class.new(Slick::Helper){ register name }.define_method "call" do
+                ::Slick.resource_provider[self.class.name]
+            end
+        end
+
+        def shared?
+            @shared
+        end
+
+    end
+
+    include Slick::Helpers
+
+    def create
+
+    end
+
+end

data/lib/slick/resource_provider.rb

@@ -0,0 +1,51 @@
+
+
+class Slick::ResourceProvider
+
+    attr_reader :shared_resources
+
+    def initialize
+        @shared_resources = {}
+        @mutex = Mutex.new
+    end
+
+    def thread_resources
+        Thread.current["SLICK_RESOURCES"] ||= {}
+    end
+
+    def [](name)
+        name = name.to_s
+
+        return thread_resources[name] if !thread_resources[name].nil?
+        return shared_resources[name] if !shared_resources[name].nil?
+
+        resource_factory = Slick::ResourceFactory.create(name)
+
+        if resource_factory.class.shared?
+            @mutex.synchronize { shared_resources[name] ||= resource_factory.create }
+            shared_resources[name]
+        else
+            thread_resources[name] = resource_factory.create
+            thread_resources[name]
+        end
+    end
+
+    def []=(name, value)
+        thread_resources[name.to_s] = value
+        self
+    end
+
+    def reset(shared = false, thread = true, &block)
+        previous_shared_resources = shared_resources
+        previous_thread_resources = thread_resources
+        @mutex.syncronize { @shared_resources = {} } if shared
+        Thread.current["SLICK_RESOURCES"] = {} if thread
+        if block
+            out = block.call
+            @mutex.synchronize { @shared_resources = previous_shared_resources } if shared
+            Thread.current["SLICK_RESOURCES"] = previous_thread_resources if thread
+            out
+        end
+    end
+
+end

data/lib/slick/response.rb

@@ -0,0 +1,14 @@
+
+require "rack"
+
+class Slick::Response < Rack::Response
+    
+    def to_s
+        body.join
+    end
+
+    def inspect
+        to_s
+    end
+
+end

data/lib/slick/util.rb

@@ -0,0 +1,72 @@
+
+require 'cgi'
+
+module Slick::Util
+
+    class << self
+
+        def pluralize(word)
+            word = word.to_s
+            Inflections.pluralize_rules.each do |rule|
+                pattern, replacement = rule
+                return word.sub(pattern, replacement) if word.match?(pattern)
+            end
+        end
+
+        def singularize(word)
+            word = word.to_s
+            Inflections.singularize_rules.each do |rule|
+                pattern, replacement = rule
+                return word.sub(pattern, replacement) if word.match?(pattern)
+            end
+        end
+
+        def html_escape(stringable)
+            CGI::escapeHTML(stringable.to_s)
+        end
+
+        def html_unescape(stringable)
+            CGI::unescapeHTML(stringable.to_s)
+        end
+
+        def url_escape(stringable)
+            CGI::escape(stringable.to_s)
+        end
+
+        def url_unescape(stringable)
+            CGI::unescape(stringable.to_s)
+        end
+
+        def paramify(hashable)
+            if hashable.kind_of?(Hash)
+                out = ParamsHash.new
+                hashable.each{|name, value| out[name] = paramify(value)}
+                out
+            elsif hashable.kind_of?(Array)
+                out = ParamsHash.new
+                hashable.each_with_index{|value, index| out[index] = paramify(value)}
+                out
+            else
+                return hashable
+            end
+        end
+
+        def url_encode(hashable, path = [], out = [])
+            hashable = paramify(hashable) if !hashable.kind_of?(ParamsHash)
+            if hashable.kind_of?(ParamsHash)
+                hashable.each do |name, value|
+                    path.push(name)
+                    url_encode(value, path, out)
+                    path.pop
+                end
+                return out.join('&') if path.count == 0
+            elsif path.count == 0
+                return url_escape(hashable)
+            else 
+                out << "#{url_escape(path.first)}#{path[1..path.length].map{|name| "[#{url_escape(name)}]"}.join}=#{url_escape(hashable)}"
+            end
+        end
+
+    end
+
+end

data/lib/slick/util/inflections.rb

@@ -0,0 +1,122 @@
+
+module Slick::Util::Inflections
+
+    instance_eval do
+        @pluralize_rules = []
+        @singularize_rules = []
+    end
+
+    class << self
+
+        attr_accessor :pluralize_rules
+        attr_accessor :singularize_rules
+
+        def plural(*args)
+            pluralize_rules.prepend(args)
+        end
+
+        def singular(*args)
+            singularize_rules.prepend(args)
+        end
+
+        def irregular(singular, plural)
+            s0 = singular[0]
+            srest = singular[1..-1]
+
+            p0 = plural[0]
+            prest = plural[1..-1]
+
+            if s0.upcase == p0.upcase
+                plural(/(#{s0})#{srest}$/i, '\1' + prest)
+                plural(/(#{p0})#{prest}$/i, '\1' + prest)
+
+                singular(/(#{s0})#{srest}$/i, '\1' + srest)
+                singular(/(#{p0})#{prest}$/i, '\1' + srest)
+            else
+                plural(/#{s0.upcase}(?i)#{srest}$/,   p0.upcase   + prest)
+                plural(/#{s0.downcase}(?i)#{srest}$/, p0.downcase + prest)
+                plural(/#{p0.upcase}(?i)#{prest}$/,   p0.upcase   + prest)
+                plural(/#{p0.downcase}(?i)#{prest}$/, p0.downcase + prest)
+
+                singular(/#{s0.upcase}(?i)#{srest}$/,   s0.upcase   + srest)
+                singular(/#{s0.downcase}(?i)#{srest}$/, s0.downcase + srest)
+                singular(/#{p0.upcase}(?i)#{prest}$/,   s0.upcase   + srest)
+                singular(/#{p0.downcase}(?i)#{prest}$/, s0.downcase + srest)
+            end
+        end
+
+        def uncountable(singular_and_plural)
+            irregular(singular_and_plural, singular_and_plural)
+        end
+
+    end
+
+    plural(/$/, "s")
+    plural(/s$/i, "s")
+    plural(/^(ax|test)is$/i, '\1es')
+    plural(/(octop|vir)us$/i, '\1i')
+    plural(/(octop|vir)i$/i, '\1i')
+    plural(/(alias|status)$/i, '\1es')
+    plural(/(bu)s$/i, '\1ses')
+    plural(/(buffal|tomat)o$/i, '\1oes')
+    plural(/([ti])um$/i, '\1a')
+    plural(/([ti])a$/i, '\1a')
+    plural(/sis$/i, "ses")
+    plural(/(?:([^f])fe|([lr])f)$/i, '\1\2ves')
+    plural(/(hive)$/i, '\1s')
+    plural(/([^aeiouy]|qu)y$/i, '\1ies')
+    plural(/(x|ch|ss|sh)$/i, '\1es')
+    plural(/(matr|vert|ind)(?:ix|ex)$/i, '\1ices')
+    plural(/^(m|l)ouse$/i, '\1ice')
+    plural(/^(m|l)ice$/i, '\1ice')
+    plural(/^(ox)$/i, '\1en')
+    plural(/^(oxen)$/i, '\1')
+    plural(/(quiz)$/i, '\1zes')
+
+    singular(/s$/i, "")
+    singular(/(ss)$/i, '\1')
+    singular(/(n)ews$/i, '\1ews')
+    singular(/([ti])a$/i, '\1um')
+    singular(/((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)(sis|ses)$/i, '\1sis')
+    singular(/(^analy)(sis|ses)$/i, '\1sis')
+    singular(/([^f])ves$/i, '\1fe')
+    singular(/(hive)s$/i, '\1')
+    singular(/(tive)s$/i, '\1')
+    singular(/([lr])ves$/i, '\1f')
+    singular(/([^aeiouy]|qu)ies$/i, '\1y')
+    singular(/(s)eries$/i, '\1eries')
+    singular(/(m)ovies$/i, '\1ovie')
+    singular(/(x|ch|ss|sh)es$/i, '\1')
+    singular(/^(m|l)ice$/i, '\1ouse')
+    singular(/(bus)(es)?$/i, '\1')
+    singular(/(o)es$/i, '\1')
+    singular(/(shoe)s$/i, '\1')
+    singular(/(cris|test)(is|es)$/i, '\1is')
+    singular(/^(a)x[ie]s$/i, '\1xis')
+    singular(/(octop|vir)(us|i)$/i, '\1us')
+    singular(/(alias|status)(es)?$/i, '\1')
+    singular(/^(ox)en/i, '\1')
+    singular(/(vert|ind)ices$/i, '\1ex')
+    singular(/(matr)ices$/i, '\1ix')
+    singular(/(quiz)zes$/i, '\1')
+    singular(/(database)s$/i, '\1')
+
+    irregular("person", "people")
+    irregular("man", "men")
+    irregular("child", "children")
+    irregular("sex", "sexes")
+    irregular("move", "moves")
+    irregular("zombie", "zombies")
+
+    uncountable "equipment"
+    uncountable "information"
+    uncountable "rice"
+    uncountable "money"
+    uncountable "species"
+    uncountable "series"
+    uncountable "fish"
+    uncountable "sheep"
+    uncountable "jeans"
+    uncountable "police"
+
+end