crystal 0.0.10 → 0.0.12

data/lib/crystal/conveyor/workspace.rb

@@ -0,0 +1,36 @@
+module Crystal
+  class Workspace < OpenObject
+    def params
+      self[:params] || Params.new
+    end
+    
+    def params?
+      !!params
+    end
+            
+    alias_method :set_without_params, :[]=
+    def []= k, v      
+      if k.to_s == 'params'
+        self.params = v
+      else
+        set_without_params k, v
+      end
+    end  
+    
+    def params= v
+      if v.is_a? Params
+        set_without_params :params, v
+      else
+        set_without_params :params, Params.new(v)
+      end
+    end
+        
+    def inspect
+      h = {}
+      each{|k, v| h[k.to_s] = v}
+      h['env'] = "..." if h.include? 'env'      
+      h['request'] = "..." if h.include? 'request'
+      h.inspect
+    end
+  end  
+end

data/lib/crystal/conveyor.rb

@@ -0,0 +1,29 @@
+# Conveyor is the heart of Crystal, it allows for Processors to process request and build responce.
+
+require 'crystal/environment'
+
+[
+  # 'config',
+  'params',
+  'workspace',
+  'processor',
+  'conveyor',
+  'conveyors',
+  'processors/conveyor_logger',
+].each{|f| require "crystal/conveyor/#{f}"}
+
+Crystal.metaclass_eval do
+  inject :conveyors => :conveyors
+end
+
+# 
+# Initializations
+# 
+crystal do
+  register :workspace, :scope => :cycle, :depends_on => :environment
+  register :conveyors, :depends_on => :environment do
+    Crystal::Conveyors.new
+  end
+end
+
+Crystal::Config::DEFAULTS['show_exceptions'] = false

data/lib/crystal/environment/config.rb

@@ -0,0 +1,118 @@
+module Crystal
+  class Config < SafeHash
+    inherit OpenConstructor
+    
+    DEFAULTS = {
+      :environment => 'development',
+    }.stringify_keys
+
+    def initialize
+      super
+      
+      config = DEFAULTS.clone
+      config.merge! Config.command_line_config if Config.command_line_config
+      config.each{|k, v| self.send "#{k}=", v}            
+    end    
+    
+    def load_app_config!
+      return unless root?
+      
+      # loading app_root/config/config.yml
+      cfile = "#{root!}/config/config.yml"
+      if File.exist? cfile
+        data = YAML.load_file cfile
+        if data
+          data.must_be.a Hash
+          data.each{|k, v| self[k] = v}
+        end
+      end
+      
+      # loading app_root/config/config.<environment>.yml
+      env_cfile = "#{root!}/config/config.#{environment!}.yml"
+      if File.exist? env_cfile
+        data = YAML.load_file env_cfile
+        if data
+          data.must_be.a Hash
+          data.each{|k, v| self[k] = v}
+        end
+      end
+    end
+    
+    # 
+    # root
+    # 
+    def root= root 
+      if root
+        self['root'] = File.expand_path(root)
+      else
+        self.delete 'root'
+      end
+    end
+    
+    
+    # 
+    # environment
+    # 
+    def environment= env
+      env = env.to_s
+      env.must_be.in %w{production development test}
+      self['environment'] = env
+    end
+  
+    def development?; environment == 'development' end
+    def production?; environment == 'production' end
+    def test?; environment == 'test' end    
+    
+    
+    # 
+    # log_path
+    # 
+    attr_writer :log_path
+    def log_path
+      @log_path ||= root? ? "#{root}/log/#{environment}.log" : ""
+    end
+    
+    
+    # 
+    # log_level
+    # 
+    attr_writer :log_level
+    def log_level
+      @log_level ||= production? ? :info : :debug
+    end
+    
+    
+    # 
+    # session
+    # 
+    # :key => 'rack.session', :domain => 'foo.com', :path => '/', :expire_after => 2592000, :secret => 'change_me'
+    # attr_accessor :session
+    # def session?; !!session end
+      
+      
+    class << self
+      attr_accessor :command_line_config
+      
+      def apply_command_line_arguments!
+        require 'optparse'      
+      
+        config = {}
+        case ARGV.first
+          when "p" then config['environment'] = "production"
+          when "d" then config['environment'] = "development"
+          when "t" then config['environment'] = "test"
+        end
+      
+        OptionParser.new{|op|
+          op.on('-e env'){|val| config['environment'] = val}
+          op.on('-s server'){|val| config['server'] = val}
+          op.on('-p port'){|val| config['port'] = val.to_i}
+        }.parse!(ARGV.dup)      
+        
+        self.command_line_config = config
+      end
+      
+      def defered_configs; @defered_configs ||= [] end
+    end
+  end
+end

data/lib/crystal/environment/dependency_resolver.rb

@@ -0,0 +1,107 @@
+# module Crystal
+#   class DependencyResolver    
+#     class Dependency
+#       attr_accessor :name, :block, :before, :after
+#       
+#       def initialize name, block
+#         @name, @block = name, block
+#         @before, @after = [], []
+#       end
+#       
+#       def inspect
+#         "#<#{name} #{before.inspect}, #{after.inspect}>"
+#       end
+#     end
+#     
+#     def dependencies; @dependencies ||= {} end
+#       
+#     # 
+#     # Define dependency
+#     #       
+#     def run name, options = {}, &block
+#       options = options.to_openobject
+#       # raise "Invalid usage, you must specify :after or :before!" unless options.before? or options.after?
+#       d = Dependency.new name, block
+#       
+#       if options.before?
+#         add_dependency d, :before, options.before.must_be.present
+#       elsif options.after?
+#         add_dependency d, :after, options.after.must_be.present
+#       else
+#         add_dependency d, nil, nil
+#       end
+#     end
+#     
+#     
+#     # 
+#     # Call dependencies
+#     # 
+#     def call name, &block
+#       return unless dep = dependencies[name]
+#         
+#       # before
+#       callees = []
+#       dep_lists = [dep.before]
+#       while !dep_lists.empty?
+#         dep_lists.each do |list|
+#           callees << list
+#         end
+# 
+#         dep_lists = next_level dep_lists, :before
+#       end
+#       call_all callees.reverse
+#       
+#       # call
+#       dep.block.call if dep.block
+#       
+#       # after
+#       dep_lists = [dep.after]
+#       while !dep_lists.empty?
+#         call_all dep_lists
+#         
+#         dep_lists = next_level dep_lists, :after
+#       end
+#     end  
+#     
+#     protected
+#       def add_dependency dep, type, ref
+#         raise "Dependency '#{dep.name}' already defined!" if dependencies.include? dep.name        
+#         dependencies[dep.name] = dep
+#         
+#         # add back reference
+#         if type
+#           catch :found do          
+#             dep_lists = [dependencies.values]
+#             while !dep_lists.empty?
+#               dep_lists.each do |list|
+#                 list.each do |d|
+#                   if d.name == ref
+#                     d.send(type) << dep
+#                     throw :found
+#                   end
+#                 end
+#               end
+#             
+#               dep_lists = next_level dep_lists, type
+#             end          
+#             
+#             raise "Dependency '#{ref}' referenced from '#{dep.name}' not found!"
+#           end                    
+#         end
+#       end
+#       
+#       def next_level dep_lists, type
+#         r = []
+#         dep_lists.each do |list|          
+#           list.each do |d|
+#             r << d.send(type)
+#           end
+#         end
+#         r
+#       end
+#       
+#       def call_all list_of_lists
+#         list_of_lists.each{|list| list.each{|d| d.block.call if d.block}}
+#       end
+#   end
+# end

data/lib/crystal/environment/environment.rb

@@ -0,0 +1,5 @@
+module Crystal
+  class Environment
+    inject :logger => :logger, :config => :config
+  end
+end

data/lib/crystal/environment/files_helper.rb

@@ -0,0 +1,42 @@
+module Crystal
+  module FilesHelper
+    def directories
+      $LOAD_PATH
+    end
+    
+    def file_exist? path
+      find_files(path).size > 0
+    end
+            
+    # find_files    
+    def find_files_without_cache fname, directories = nil
+      fname.must =~ /\//
+      directories ||= self.directories
+      files = directories.collect{|dir| "#{dir}#{fname}"}
+      files.select{|f| File.exist? f}
+    end
+    cache_method_with_params_in_production :find_files    
+    
+    def find_file fname
+      files = find_files(fname)
+      raise "File '#{fname}' not found!" if files.size == 0
+      raise "Found multiple files for '#{fname}'" if files.size > 1
+      files.first
+    end
+    
+    def find_files_by_pattern_without_cache pattern, directories = nil
+      directories ||= self.directories
+      patterns = directories.to_a.collect{|d| "#{d}#{pattern}"}
+      Dir.glob patterns
+    end
+    alias_method :find_files_by_pattern, :find_files_by_pattern_without_cache
+    
+    def find_file_by_pattern pattern
+      files = find_files_by_pattern(pattern)
+      raise "File '#{pattern}' not found!" if files.size == 0
+      raise "Found multiple files for '#{pattern}'" if files.size > 1
+      files.first
+    end
+  end
+end
+  

data/lib/crystal/environment/logger.rb

@@ -0,0 +1,21 @@
+crystal.register :logger do
+  if defined?(SILENCE_LOGGER)
+    logger = Logger.new nil
+  else
+    config = crystal[:config]
+    if config and config.root? and File.exist?("#{config.root}/log")
+      logger = ActiveSupport::BufferedLogger.new crystal.config.log_path
+      logger.level = ActiveSupport::BufferedLogger.const_get config.log_level.to_s.upcase
+      logger.auto_flushing = false if crystal.config.production?        
+    elsif config and config.test?
+      logger = Logger.new nil
+    elsif config
+      logger = Logger.new STDOUT
+      logger.warn "No log folder!"
+    else
+      logger = Logger.new STDOUT
+      logger.warn "Config not initialized!"
+    end    
+  end  
+  logger
+end

data/lib/crystal/environment.rb

@@ -0,0 +1,52 @@
+# Environment prepares and assembles your app ($LOAD_PATH, plugins and config files)
+
+# 
+# Support
+# 
+require 'crystal/support'
+
+# config
+[  
+  'config',
+].each{|f| require "crystal/environment/#{f}"}
+
+module Crystal
+  VERSION = '0.0.1'
+end
+
+# environment
+[  
+  'logger',
+  'environment',
+  'files_helper'
+].each{|f| require "crystal/environment/#{f}"}
+Crystal::Environment.inherit Crystal::FilesHelper
+
+
+# 
+# Runtime initialization
+# 
+crystal do
+  register :config do
+    config = Crystal::Config.new.set!(:root => $APP_DIR)
+    config.load_app_config!    
+    config
+  end
+
+  register :environment do
+    Crystal::Environment.new  
+  end
+end
+
+# 
+# Handy mehtods 
+# 
+module Crystal
+  class << self
+    inject(
+      :config => :config,
+      :environment => :environment,
+      :logger => :logger
+    )
+  end
+end

data/lib/crystal/html/controller_helpers/controller_url_helper.rb

@@ -0,0 +1,52 @@
+module Crystal
+  module ControllerUrlHelper
+    # 
+    # redirect_to
+    # 
+    def redirect_to *args
+      params, response = workspace.params, workspace.response
+      params.format.must_be.in 'html', 'js'                
+      
+      url = special_url(*args) || url_for(*args)
+      
+      if params.format == 'js'
+        response.body << "window.location = '#{url}';"
+      else
+        response.status = 301
+        response.headers['Location'] = url        
+        response.body = %(<html><body>You are being <a href="#{h(url)}">redirected</a>.</body></html>)
+      end
+      
+      # Flash need to know if we using redirect
+      force_keeping_mode_for_flash!
+      
+      nil
+    end    
+    
+    def reload_page
+      workspace.params.format.must == 'js'
+      
+      force_keeping_mode_for_flash!
+      workspace.response.body << "window.location.reload();"
+    end
+    
+    def special_url *args
+      return nil unless args.last.empty?
+              
+      case args.first.to_s
+      when 'back'
+        workspace.request.env["HTTP_REFERER"] || 'javascript:history.back()'
+      when '#' then
+        '#'
+      else
+        nil
+      end
+    end
+    
+    protected            
+      
+      def force_keeping_mode_for_flash!
+        crystal[:flash].force_keeping_mode! if crystal.include? :flash
+      end
+  end
+end

data/lib/crystal/html/controller_helpers/flash_helper.rb

@@ -0,0 +1,5 @@
+module Crystal
+  module FlashHelper
+    inject :flash => :flash
+  end
+end

data/lib/crystal/html/flash.rb

@@ -0,0 +1,40 @@
+module Crystal
+  class Flash < OpenObject
+    attr_accessor :previous_messages, :current_messages
+    
+    attr_accessor :ajax_mode, :force_keeping_mode
+    
+    def initialize format, previous_messages = {}
+      self.current_messages, self.previous_messages = {}, previous_messages
+      self.ajax_mode = format == 'js'
+      self.force_keeping_mode = false
+    end
+    
+    def [] key
+      key = key.to_s
+      
+      if ajax_mode and !force_keeping_mode
+        current_messages[key] || previous_messages[key]
+      else
+        previous_messages[key]
+      end
+    end
+    
+    def []= key, value
+      current_messages[key.to_s] = value.to_s
+    end
+    
+    def force_keeping_mode!
+      self.force_keeping_mode = true
+    end
+
+    def messages_for_next_request
+      if ajax_mode and !force_keeping_mode
+        {}
+      else
+        current_messages
+      end
+    end
+      
+  end
+end

data/lib/crystal/html/include_into_controller.rb

@@ -0,0 +1,24 @@
+require 'crystal/html'
+require 'crystal/router'
+
+module Crystal
+  # View helpers
+  [BasicHtmlHelper, FormHelper, JavascriptHelper, ViewUrlHelper].each do |helper|
+    ControllerContext.inherit helper
+  end  
+    
+  # Controller helpers  
+  [RoutingHelper, FlashHelper, ControllerUrlHelper].each do |helper|
+    AbstractController.inherit helper
+  end  
+  
+  # TODO2 refactor it!
+  [
+    :special_url, :url_for, :persist_params, :dont_persist_params, 
+    :default_path, :return_to_path,
+    :flash,
+    :redirect_to, :reload_page
+  ].each do |m|
+    ControllerContext.delegate m, :to => :controller
+  end
+end

data/lib/crystal/html/processors/prepare_flash.rb

@@ -0,0 +1,26 @@
+module Crystal
+  module Processors
+    class PrepareFlash < Processor
+
+      def call
+        workspace.request.must_be.present
+        workspace.params.must_be.defined
+        
+        previous_messages = workspace.request.session.delete 'flash'
+        if previous_messages.present?
+          previous_messages = JSON.load previous_messages
+          crystal[:flash] = Crystal::Flash.new workspace.params.format, previous_messages
+        end
+        
+        next_processor.call
+        
+        if crystal.include? :flash
+          flash = crystal[:flash]
+          messages = flash.messages_for_next_request
+          workspace.request.must_be.present
+          workspace.request.session['flash'] = messages.to_json unless messages.empty?
+        end
+      end
+    end
+  end
+end

data/lib/crystal/html/processors/scoped_params.rb

@@ -0,0 +1,30 @@
+# Converts {'model[attribute]' => value} into {'model' => {'attribute' => value}}
+module Crystal
+  module Processors
+    class ScopedParams < Processor      
+      def call
+        if workspace.params?
+          to_delete = []
+          workspace.params.each do |name, value|
+            name.scan /(.+)\[(.+)\]/ do |scope_name, name_in_scope|
+              scope = workspace.params[scope_name] ||= {}
+            
+              unless scope.is_a? Hash
+                logger.warn "Owerriding :#{scope} param!"
+                scope = {}
+                workspace.params[scope_name] = scope
+              end
+            
+              scope[name_in_scope] = value
+              to_delete << name
+            end
+          end
+          to_delete.each{|n| workspace.params.delete n}
+        end
+                
+        next_processor.call
+      end
+    end
+  end
+end
+      

data/lib/crystal/html/view_helpers/basic_html_helper.rb

@@ -0,0 +1,83 @@
+module Crystal
+  module BasicHtmlHelper
+    BOOLEAN_ATTRIBUTES = %w(disabled readonly multiple checked autobuffer
+                         autoplay controls loop selected hidden scoped async
+                         defer reversed ismap seemless muted required
+                         autofocus novalidate formnovalidate open).to_set
+    BOOLEAN_ATTRIBUTES.merge(BOOLEAN_ATTRIBUTES.map {|attr| attr.to_sym })
+    
+    
+    # 
+    # authenticity_token
+    # 
+    def authenticity_token; workspace.request.session['authenticity_token'] end    
+    
+    
+    # 
+    # JavaScript & StyleSheets
+    #     
+    def stylesheet_link_tag *stylesheets
+      Array(stylesheets).collect{|ssheet|
+        tag :link, '', :href => "#{config && config.url_root!}#{ssheet}", :media => "screen", :rel => "stylesheet", :type => "text/css"
+      }.join("\n")
+    end
+    
+    
+    # 
+    # Assets
+    # 
+    def image_tag src, opt = {}
+      opt[:src] = src
+      tag :img, '', opt
+    end
+            
+    
+    # 
+    # Common HTML tags
+    # 
+    def label_tag name, text, options = {}
+      tag :label, text, options.merge(:for => name)
+    end
+    
+    
+    # 
+    # Special
+    # 
+    def tag name, content_or_options_with_block = nil, options = nil, escape = true, &block      
+      if block_given?
+        options = content_or_options_with_block if content_or_options_with_block.is_a?(Hash)
+        content = capture(&block)
+        concat "<#{name}#{tag_options(options)}>#{content}</#{name}>"
+      else
+        content = content_or_options_with_block
+        "<#{name}#{tag_options(options)}>#{content}</#{name}>"
+      end      
+    end
+    
+    # instance_methods(false).each do |m|
+    #   alias_method "html_#{m}", m
+    # end
+    
+    # Escape
+    def h obj; obj.to_s.html_escape end    
+    
+    protected
+    
+      def tag_options options
+        return "" unless options
+        options.must_be.a Hash
+        unless options.blank?
+          attrs = []
+          options.each_pair do |key, value|
+            if BOOLEAN_ATTRIBUTES.include?(key)
+              attrs << %(#{key}="#{key}") if value
+            elsif !value.nil?
+              final_value = value.is_a?(Array) ? value.join(" ") : value
+              attrs << %(#{key}="#{final_value}")
+            end
+          end
+          " #{attrs.sort * ' '}" unless attrs.empty?
+        end
+      end
+  end
+end