crystal 0.0.10 → 0.0.12

data/lib/crystal/support/rson.rb

@@ -0,0 +1,53 @@
+class Object
+  def rson?
+    false
+  end
+end
+
+[
+  FalseClass,
+  TrueClass,
+  Numeric,
+  String,
+  Symbol,
+  NilClass,
+].each do |klass|
+  klass.class_eval do
+    def to_rson options = {}
+      self
+    end
+    
+    def rson?
+      true
+    end
+  end
+end
+
+Array.class_eval do
+  def to_rson options = {}
+    collect{|v| v.to_rson(options)}
+  end
+  
+  def rson?
+    all?{|v| v.rson?}
+  end
+end
+  
+[Hash, OpenObject].each do |klass|
+  klass.class_eval do
+    def to_rson options = {}
+      r = self.class.new
+      each do |k, v|
+        r[k.to_rson(options)] = v.to_rson(options)
+      end
+      r
+    end
+  
+    def rson?
+      each do |k, v|
+        return false unless k.rson? and v.rson?
+      end
+      true
+    end
+  end
+end

data/lib/crystal/support/ruby_ext_with_active_support.rb

@@ -0,0 +1,4 @@
+OpenObject.class_eval do
+  # support :extract_options for OpenObject
+  def extractable_options?; true end
+end

data/lib/crystal/support/safe_hash.rb

@@ -0,0 +1,135 @@
+require 'singleton'
+
+class SafeHash < BasicObject
+  attr_reader :hash
+  
+  def initialize hash = {}
+    reinitialize hash
+  end
+  
+  def []= key, value
+    value = SafeHash.new value if value.is_a? Hash
+    @hash[key.to_s] = value
+  end
+  
+  def include? key
+    @hash.include? key.to_s
+  end
+  
+  def [] key, *args     
+    key = key.to_s
+    if key.last == '!'
+      key = key[0..-2]
+      if @hash.include? key
+        @hash[key]
+      else
+        raise "No key #{key}"
+      end
+    elsif key.last == '?'
+      key = key[0..-2]
+      @hash.include? key
+    else
+      if @hash.include? key
+        @hash[key]
+      elsif args.empty?
+        SafeNil.instance
+      else
+        return *args
+      end
+    end
+  end
+  
+  def reinitialize hash
+    @hash = {}
+    hash.each do |k, v|
+      v = SafeHash.new v if v.is_a? Hash 
+      @hash[k.to_s] = v
+    end
+    # @hash.freeze
+  end
+  
+  def method_missing m, *args
+    m = m.to_s
+    if m.last == '='
+      self[m[0..-2]] = *args
+    else
+      self[m, *args]
+    end
+  end
+  
+  def to_yaml *args
+    @hash.to_yaml *args
+  end
+  
+  def inspect
+    @hash.inspect
+  end
+  
+  def delete key
+    @hash.delete key.to_s
+  end
+  
+  # deep conversion, check and converts nested SafeHashes to Hashes
+  def to_hash    
+    r = {}
+    @hash.each do |k, v|
+      r[k] = if v.respond_to :is_a_safe_hash?
+        v.to_hash
+      else
+        v
+      end
+    end
+    r
+  end
+  alias_method :to_h, :to_hash
+  
+  def is_a_safe_hash?
+    true
+  end
+  
+  class SafeNil < BasicObject
+    include Singleton
+
+    def [] key, *args
+      key = key.to_s
+      if key.last == '!'
+        raise "No key #{key}"
+      elsif key.last == '?'
+        false
+      elsif args.empty?
+        SafeNil.instance
+      else
+        return *args
+      end
+    end
+
+    def method_missing m, *args
+      m = m.to_s
+      if m.last == '='
+        raise "No such key!"
+      else
+        self[m, *args]
+      end
+    end
+    
+    def include? key
+      false
+    end
+    
+    def to_b
+      false
+    end
+    
+    def to_yaml *args
+      nil.to_yaml *args
+    end
+    
+    def to_h
+      {}
+    end
+    
+    def inspect
+      nil.inspect
+    end
+  end
+end

data/lib/crystal/support/string.rb

@@ -0,0 +1,26 @@
+class String
+  def json_escape
+    ERB::Util.json_escape self
+  end
+  
+  def html_escape
+    # ERB::Util.html_escape self
+    Rack::Utils.escape_html self
+  end
+  
+  JS_ESCAPE_MAP = {
+    '\\'    => '\\\\',
+    '</'    => '<\/',
+    "\r\n"  => '\n',
+    "\n"    => '\n',
+    "\r"    => '\n',
+    '"'     => '\\"',
+    "'"     => "\\'" 
+  }  
+  def js_escape
+    gsub(/(\\|<\/|\r\n|[\n\r"'])/){JS_ESCAPE_MAP[$1]}
+  end
+  
+  # String marks, like :format, :safe 
+  def marks; @marks ||= OpenObject.new end
+end

data/lib/crystal/support.rb

@@ -0,0 +1,42 @@
+require 'crystal/support/gems'
+
+
+require 'crystal/support/active_support'
+
+
+require 'ruby_ext'
+
+require 'ruby_ext/open_constructor'
+require 'crystal/support/ruby_ext_with_active_support'
+
+require 'class_loader'
+
+require 'micon'
+require 'crystal/support/micon'
+
+require 'dictionary'
+
+require 'thread'
+require 'time'
+require 'uri'
+require 'json'
+
+
+require 'addressable/uri'
+require 'crystal/support/addressable'
+::Uri = Addressable::URI
+
+autoload :Nokogiri, 'nokogiri'
+
+[  
+  'module',
+  'buffered_logger',
+  'callbacks',
+  'filters',
+  'format',
+  'mime',  
+  'string',
+  'rson',
+  'exception',
+  'safe_hash'
+].each{|f| require "crystal/support/#{f}"}

data/lib/crystal/template/support/tilt.rb

@@ -0,0 +1,68 @@
+module Tilt
+  # 
+  # Include it into your template context class for :output, :capture and :concat support
+  # 
+  module ContextExt
+    def output
+      _tilt_template.class.output(self)
+    end
+  
+    def capture *args, &block
+      _tilt_template.class.capture self, &block      
+    end
+  
+    def concat value
+      _tilt_template.class.concat self, value
+    end
+  end  
+  
+  class Template
+    def self.get_output context
+      raise "Output variable for #{self.class} not defined!"
+    end
+    
+    def self.capture context, &block
+      raise "capture not implemented for #{self.class}!"
+    end
+    
+    def self.concat context, value
+      raise "concat not implemented for #{self.class}!"
+    end
+  end
+  
+  class ERBTemplate
+    def self.get_output context
+      context.instance_variable_get "@output"
+    end
+    
+    def self.capture context, &block
+      begin
+        old_output = context.instance_variable_get "@output"
+        old_output.must_be.defined
+        context.instance_variable_set "@output", ""
+        block.call
+        context.instance_variable_get "@output"
+      ensure
+        context.instance_variable_set "@output", old_output
+      end      
+    end
+    
+    def self.concat context, value
+      get_output(context) << value
+    end    
+  end
+  
+  class HamlTemplate
+    def self.get_output context
+      context.haml_buffer.buffer
+    end
+    
+    def self.capture context, &block
+      context.capture_haml &block
+    end
+    
+    def self.concat context, value
+      context.haml_concat value
+    end
+  end
+end

data/lib/crystal/template/template.rb

@@ -0,0 +1,244 @@
+module Crystal
+  module Template
+    DIRECTORY_NAME = "views"
+    
+    class << self
+      inject(
+        :logger => :logger,
+        :config => :config,
+        :environment => :environment
+      )
+      
+      def render *args, &block
+        result, context = basic_render(parse_arguments(*args), &block)
+        result
+      end        
+      
+      # def render_and_return_context *args, &block
+      #   basic_render(*parse_arguments(*args), &block)
+      # end
+      
+      def render_layout *args
+        options = parse_arguments(*args)
+        options = options.stringify_keys!
+        options.must.include :content
+        options.must.include :context
+        
+        result, context = basic_render options do |*args|
+          if args.empty?
+            options.content
+          else
+            args.size.must_be == 1
+            variable_name = args.first.to_s
+            self.context.content_variables[variable_name]
+          end
+        end
+        
+        result
+      end      
+      
+      def exist? tname, options = {}
+        options = options.to_openobject
+        !!find_template(tname, calculate_prefixes(options), options.format, options.current_dir)
+      end
+      
+      def read tname, options = {}
+        options = options.to_openobject
+        file = find_template tname, calculate_prefixes(options), options.format, options.current_dir
+        raise "No template '#{tname}'!" unless file
+        File.read file
+      end
+      
+      def template_name_with_prefix tname, prefix      
+        index = tname.rindex('/')
+        index = index ? index + 1 : 0
+        tname = tname.clone
+        tname.insert index, prefix
+      end
+      
+      def parse_arguments *args
+        options = args.extract_options!.to_openobject
+        if args.size == 1
+          options.template = args.first
+        else 
+          raise "Invalid input" if args.size != 0
+        end     
+        
+        options
+      end
+      
+      def basic_render options, &block        
+        options = options.clone.to_openobject
+        
+        with_context options do |context|        
+          context.content_block ||= block            
+
+          with_scope options, context do |scope|              
+            unless file = options.file                                
+              file = find_template options.template!, calculate_prefixes(options), scope.format, scope.current_dir
+              # p [tname, calculate_prefixes(options), scope.format, scope.current_dir]
+              raise "No template '#{options.template!}'!" unless file
+            end
+            
+            scope.current_dir = dirname(file)
+            
+            template = create_tilt_template file
+            
+            result = with_template context, template do
+              render_template template, options, &context.content_block
+            end
+            
+            return result, context
+          end            
+        end
+      end
+      
+      protected
+        def context          
+          Thread.current[:render_context]
+        end
+        
+        def calculate_prefixes options
+          options.action ? [''] : options.prefixes
+        end
+        
+        def with_context options, &block
+          context = Thread.current[:render_context] || options.context || create_context(options)
+          
+          old = Thread.current[:render_context]
+          begin            
+            Thread.current[:render_context] = context
+            block.call context
+          ensure
+            Thread.current[:render_context] = old
+          end
+        end
+        
+        def with_scope options, context, &block
+          initial = context.scope_variables
+
+          old = context.scope_variables || OpenObject.new
+          begin
+            context.scope_variables = {
+              :current_dir => options.current_dir || old.current_dir,
+              :format => options.format || old.format
+              # :prefixes => options.prefixes || old.prefixes
+            }.to_openobject
+
+            block.call context.scope_variables
+          ensure
+            context.scope_variables = old if initial
+          end
+        end
+        
+        def with_template context, template, &block
+          old = context._tilt_template
+          begin            
+            context._tilt_template = template
+            block.call context
+          ensure
+            context._tilt_template = old
+          end
+        end
+        
+        def create_context options
+          context_class = options.context_class || TemplateContext
+          raise "#{context_class} must inherit from TemplateContext!" unless context_class.is? TemplateContext
+          context = context_class.new
+          
+          context.options = options
+
+          if ivs = options.instance_variables
+            (ivs.is_a?(Array) ? ivs : [ivs]).each do |container|              
+              if container.is_a? Hash
+                container.each do |name, value|
+                  context.instance_variable_set("@#{name}", value)
+                end
+              else
+                container.instance_variables.each do |ivname|
+                  iv = container.instance_variable_get(ivname)
+                  context.instance_variable_set(ivname, iv)
+                end
+              end
+            end
+          end
+          
+          context
+        end
+        
+        def dirname_without_cache path; 
+          File.dirname path
+        end        
+        cache_method_with_params_in_production :dirname                    
+        
+        def find_template tname, prefixes, format, current_dir
+          # splitted into two to optimize cache
+          if tname =~ /^\//
+            find_absolute_template tname, prefixes, format
+          else
+            find_relative_template tname, prefixes, format, current_dir
+          end
+        end
+                
+        def find_absolute_template_without_cache tname, prefixes, format          
+          prefixes = prefixes || config.default_template_prefixes!
+          prefixes.each do |prefix|
+            tname_with_prefix = template_name_with_prefix("/#{DIRECTORY_NAME}#{tname}", prefix)
+            file = find_file(tname_with_prefix, format, environment.directories)
+            return file if file
+          end
+          return nil
+        end
+        cache_method_with_params_in_production :find_absolute_template
+        
+        def find_relative_template_without_cache tname, prefixes, format, current_dir          
+          raise "You can't use relative template path '#{tname}' without :current_dir!" unless current_dir
+          prefixes = prefixes || config.default_template_prefixes!
+          prefixes.each do |prefix|
+            tname_with_prefix = template_name_with_prefix("/#{tname}", prefix)
+            file = find_file(tname_with_prefix, format, current_dir)
+            return file if file
+          end
+          return nil
+        end
+        cache_method_with_params_in_production :find_relative_template
+        
+        def find_file tname, format, directories          
+          if tname.include? '.'
+            _find_file(tname, directories) || _find_file("#{tname}.*", directories)
+          else            
+            if format
+              _find_file("#{tname}.#{format}.*", directories) or
+                _find_file("#{tname}.*", directories, true)              
+            else
+              _find_file("#{tname}.*", directories)
+            end
+          end                    
+        end
+        
+        # with_one_extension - 'tname.*' matches not only 'tname.erb' but also 'tname.html.erb', 
+        # with this option enabled it will not match 'tname.html.erb', only 'tname.erb'
+        def _find_file pattern, directories, with_one_extension = false
+          files = environment.find_files_by_pattern_without_cache pattern, directories
+          files = files.select{|f| f !~ /\.[^\.\/]+\.[^\.\/]+$/} if with_one_extension
+          logger.warn "Multiple templates for '#{pattern}'!" if files.size > 1
+          files.first
+        end
+        
+        def create_tilt_template path
+          template_options = {
+            :ugly => true,
+            :outvar => "@output"
+          }
+          template = Tilt.new(path, nil, template_options)
+        end
+        
+        def render_template template, options, &block
+          locals = options.locals || {}
+          locals[:object] = options.object if options.object?
+
+          template.render context, locals, &block
+        end        
+    end
+  end
+end

data/lib/crystal/template/template_context.rb

@@ -0,0 +1,57 @@
+module Crystal
+  class TemplateContext
+    include Tilt::CompileSite, Tilt::ContextExt
+    
+    # 
+    # System
+    #
+    attr_accessor :options, :_tilt_template     
+       
+    # for saving :format, :current_dir and others
+    # def scope_variables; @scope_variables ||= OpenObject.new end
+    attr_accessor :scope_variables
+    
+    
+    # 
+    # Helpers
+    # 
+    inject(
+      :workspace => :workspace,
+      :router => :router,
+      :config => :config
+    )
+    
+    delegate :render, :to => ::Crystal::Template
+    delegate :url_for, :to => :router        
+    
+    
+    # 
+    # Content Variables
+    # 
+    attr_accessor :content_block
+    def content_variables; @content_variables ||= {} end    
+    def content_for name, content = nil, &block
+      content ||= capture(&block)
+      (content_variables[name.to_s] ||= "") << content
+      nil
+    end        
+    def prepend_to name, content = nil, &block
+      content ||= capture(&block)
+      (content_variables[name.to_s] ||= "").insert 0, content
+      nil
+    end
+    def wrap_content_for name, &block
+      block.must_be.defined
+      content = capture((content_variables[name.to_s] || ""), &block)
+      content_variables[name.to_s] ||= content
+      nil
+    end
+    def has_content_for? name
+      content_variables.include? name.to_s
+    end    
+        
+    def params
+      workspace.params
+    end        
+  end
+end

data/lib/crystal/template.rb

@@ -0,0 +1,21 @@
+gem "haml"
+
+require 'crystal/environment'
+
+require 'erb'
+require 'haml'
+require 'tilt'
+require 'crystal/template/support/tilt'
+
+[  
+  'template',
+  'template_context'
+].each{|f| require "crystal/template/#{f}"}
+
+
+# 
+# Initialization
+# 
+Crystal::Config::DEFAULTS.merge!({
+  :default_template_prefixes => ['', '_']
+}.stringify_keys)

data/lib/views/crystal_default_templates/development/error.html.erb

@@ -0,0 +1,11 @@
+<html>
+<body>
+	<p>
+		<b><font color='red'>ERROR:</font></b>
+		<%= error.message.html_escape %>
+	</p>
+	<pre>
+  <%= error.backtrace && error.backtrace.sfilter(Exception.common_filters).join("\n  ").html_escape %>
+	</pre>
+</body>
+</html>

data/lib/views/crystal_default_templates/development/error.js.erb

@@ -0,0 +1 @@
+console.log("<%= error.message.js_escape %>");

data/readme.md

@@ -1,7 +1,11 @@
-# Crystal - Ruby Web Framework.
+# Crystal - Ruby Web Framework inspired by Rails and Spring.
 
-It's a code extracted from my [http://bom4.com](http://bom4.com) application.
-It's under heavy development now and not ready for use.
+It kinda does the same thing as Rails but in different way. The idea is to provide you with an application framework as opened and extensible as the Ruby itself.
 
-# TODO
-- Use Rack::Utils for escape
+It's the constructor, built from set of low coupled components. You can start quickly using one of predefined 'opinionated' profiles, or tune and extend it as you wish. 
+The same apply for the architecture of your application - instead of to be a monolith it consists of cooperating plugins/gems. 
+
+Web tier looks almost like Rails and overall architecture is slightly borrowed from Java Spring framework.
+Yes, I know that IoC aren't much popular in Ruby community, but it's not quite ordinary IoC, and it's really handy.
+
+*It's under heavy development, and not ready to use.*