crystal 0.0.10 → 0.0.12

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

@@ -0,0 +1,104 @@
+module Crystal  
+  module FormHelper
+    # 
+    # Form
+    #     
+    def form_for *args, &block
+      model_helper, options = build_form_model_helper_and_form_options *args
+      
+      form_tag options do
+        block.call model_helper if block
+      end
+    end
+    
+    def build_form_model_helper_and_form_options model_name, model, options = {}
+      return ModelHelper.new(self, self, model_name, model, options), options
+    end
+    
+    def form_tag options = {}, &block      
+      tag :form, options, &block
+    end
+    
+    
+    # 
+    # Errors
+    # 
+    # delegate :error_messages, :field_with_errors, :to => :form_builder
+    def error_messages *errors 
+      errors = errors.first if errors.size == 1 and errors.first.is_a? Array
+      html = errors.join("<br/>")
+      tag :div, html, :class => :error_messages
+    end
+    
+    def field_with_errors name, errors, options, field_html
+      html = tag :div, errors.join("<br/>"), :class => :field_error_messages
+      html << tag(:span, field_html, :class => :field_with_errors)
+      html
+    end
+    
+    
+    # 
+    # Form fields
+    # 
+    def check_box_tag name, checked = false, options = {}      
+      options = {"type" => "checkbox", "name" => name, "value" => '1'}.update(options)
+      options["checked"] = "checked" if checked
+      tag_with_style :input, '', options
+    end
+        
+    def field_set_tag legend = nil, options = {}, &block
+      content = ""
+      content << tag(:legend, legend) unless legend.blank?
+      content << capture(&block)
+      tag_with_style :fieldset, content, options
+    end
+    
+    def file_field_tag name, options = {}
+      text_field_tag name, nil, options.update("type" => "file")
+    end
+    
+    def hidden_field_tag name, value = '', options = {}
+      text_field_tag(name, value, options.update("type" => "hidden"))
+    end
+    
+    def password_field_tag name, value = nil, options = {}
+      text_field_tag(name, value, options.update("type" => "password"))
+    end
+    
+    def radio_button_tag name, checked = false, options = {}
+      options = {"type" => "radio", "name" => name, "value" => '1'}.update(options)
+      options["checked"] = "checked" if checked
+      tag_with_style :input, '', options
+    end
+    
+    def select_tag name, options = {}, &block
+      tag_with_style :select, capture(&block), {"name" => name}.update(options)
+    end
+    
+    def text_field_tag name, value = '', options = {}
+      tag_with_style :input, '', {"type" => "text", "name" => name, "value" => value}.update(options)
+    end
+    
+    def text_area_tag name, value = '', options = {}
+      tag_with_style :textarea, value, {"name" => name}.update(options)
+    end
+    
+    
+    # 
+    # Other
+    # 
+    def submit_tag value, options = {}
+      tag_with_style :input, '', {"type" => "submit", "value" => value}.update(options)
+    end
+    
+    protected
+      def tag_with_style name, value, options, &block
+        # add special class to fix with CSS some problems with fields display
+        klass = options.delete(:class) || options.delete('class') || ""
+        klass << " #{options[:type] || options['type'] || name}_input"
+        options['class'] = klass
+        
+        tag name, value, options, &block
+      end
+  end
+end

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

@@ -0,0 +1,18 @@
+module Crystal
+  module JavascriptHelper
+    def javascript_include_tag *scripts
+      Array(scripts).collect{|script|
+        tag :script, '', :src => "#{config && config.url_root!}#{script}", :type => "text/javascript"
+      }.join("\n")      
+    end
+    
+    def javascript_tag value = nil, &block
+      args = [{:type => "text/javascript"}]
+      args.unshift value if value
+      tag :script, *args, &block
+    end
+    
+    # Escape
+    def js obj; obj.to_s.js_escape end
+  end
+end

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

@@ -0,0 +1,119 @@
+module Crystal  
+  class ModelHelper
+    attr_accessor :template, :model_name, :model, :options, :form_helper
+    
+    def initialize template, form_helper, model_name, model, options
+      self.template, self.form_helper, self.model_name, self.model, self.options = template, form_helper, model_name, model, options
+    end
+
+      
+    # 
+    # Helpers
+    # 
+    def check_box name, options = {}      
+      render_attribute name, options do |fname, value, o|
+        form_helper.check_box_tag fname, !!value, o
+      end
+    end
+        
+    def file_field name, options = {}
+      render_attribute name, options do |fname, value, o|
+        form_helper.file_field_tag fname, o
+      end
+    end
+    
+    def hidden_field name, options = {}
+      render_attribute name, options do |fname, value, o|
+        form_helper.hidden_field_tag fname, value, o
+      end
+    end
+    
+    def password_field name, options = {}
+      render_attribute name, options do |fname, value, o|
+        form_helper.password_field_tag fname, nil, o
+      end
+    end
+    
+    def radio_button name, options = {}
+      render_attribute name, options do |fname, value, o|
+        form_helper.radio_button_tag fname, !!value, o
+      end
+    end
+    
+    def submit value, options = {}
+      form_helper.submit_tag value, options
+    end
+    
+    def text_field name, options = {}
+      render_attribute name, options do |fname, value, o|
+        form_helper.text_field_tag fname, value, o
+      end
+    end
+    
+    def text_area name, options = {}
+      render_attribute name, options do |fname, value, o|
+        form_helper.text_area_tag fname, value, o
+      end
+    end
+    
+    def error_messages
+      merrors = errors['base']      
+      form_helper.error_messages merrors.to_a unless merrors.blank?
+    end
+    
+    
+    protected
+      def method_missing m, *args, &b
+        form_helper.send m, *args, &b
+      end
+    
+      def render_attribute name, options, &block
+        name = name.to_s
+        ferrors = errors_for(name)
+        
+        if form_helper.respond_to? :field_with_errors
+          field_html = block.call field_name_for(name), value_of(name), options
+          unless ferrors.blank?
+            form_helper.field_with_errors name, ferrors, options, field_html
+          else
+            field_html
+          end
+        else
+          options['errors'] = ferrors          
+          block.call field_name_for(name), value_of(name), options
+        end
+      end
+    
+      def errors
+        unless @errors
+          @errors = {}
+          (
+            (model.respond_to?(:errors) && model.errors) || 
+            (model.respond_to?(:[]) && (model['errors'] || model[:errors])) || 
+            {}
+          ).each do |k, v|
+            @errors[k.to_s] = v
+          end          
+        end
+        @errors
+      end
+    
+      def errors_for name
+        errors[name].to_a
+      end
+    
+      def field_name_for name
+        "#{model_name}[#{name}]"
+      end
+    
+      def value_of name      
+        if model.respond_to? name 
+          model.send name
+        elsif model.respond_to? :[]
+          model[name.to_s] || model[name.to_sym]
+        else
+          raise "Model not respond to :#{name} nor to :[]!"
+        end
+      end
+  end
+end

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

@@ -0,0 +1,66 @@
+module Crystal
+  module ViewUrlHelper
+    # 
+    # links
+    # 
+    def link_to *args, &block
+      # parse args
+      content = if block
+        capture(&block)
+      else
+        args.shift
+      end
+      
+      special = nil
+      html_options = if args.last.is_a?(Hash)
+        if args[-2].is_a?(Hash)
+          args.pop.stringify_keys!
+        else
+          {}
+        end          
+      else        
+        args << {}
+        {}
+      end            
+      
+      # build url
+      url = special_url(*args) || url_for(*args)
+      
+      # add javascript
+      add_js_link_options! url, html_options
+      
+      tag :a, content, html_options.merge('href' => url)
+    end
+    
+    # TODO3 refactor to use data-remote, data-method, data-confirm
+    def add_js_link_options! url, html_options
+      confirm, remote, method = html_options.delete("confirm"), html_options.delete('remote'), 
+        html_options.delete("method")
+        
+      remote ||= config.remote_link_formats!.include? url.marks.format.to_s
+
+      onclick = if remote
+        method ||= :get
+        %{$(this).link_to({method: '#{method}', ajax: true}); return false;}
+      elsif method
+        %{$(this).link_to({method: '#{method}'}); return false;}
+      else
+        nil
+      end
+
+      # if onclick and ActionController::Base.defer_static_scripts?
+      #   html_options['class'] ||= ""
+      # end
+
+      if confirm 
+        onclick = if onclick
+          "if(confirm(#{confirm.js_escape})){#{onclick}}; return false;"
+        else
+          "return confirm(#{confirm.js_escape});"
+        end
+      end
+
+      html_options["onclick"] = onclick if onclick        
+    end
+  end    
+end

data/lib/crystal/html.rb

@@ -0,0 +1,28 @@
+require 'crystal/http'
+require 'crystal/template'
+
+[
+  'flash',
+  
+  'view_helpers/basic_html_helper',  
+  'view_helpers/form_helper',
+  'view_helpers/model_helper',
+  'view_helpers/javascript_helper',
+  'view_helpers/view_url_helper',
+  
+  'controller_helpers/flash_helper',
+  'controller_helpers/controller_url_helper',
+  
+  'processors/scoped_params',
+  'processors/prepare_flash'
+].each{|f| require "crystal/html/#{f}"}
+
+# Flash
+crystal.register :flash, :scope => :cycle, :depends_on => :environment do
+  workspace = crystal[:workspace]
+  workspace.params.must_be.defined  
+  Crystal::Flash.new workspace.params.format
+end
+
+# Initialization
+Crystal::Config::DEFAULTS['remote_link_formats'] = ['js', 'json']

data/lib/crystal/http/http.rb

@@ -0,0 +1,21 @@
+module Crystal
+  module HTTP
+    class << self
+      inject :environment => :environment, :config => :config
+      
+      def ensure_public_symlink symlink_name, plugin_public_folder        
+        plugin_public_folder = File.expand_path(plugin_public_folder)
+        File.must.exist(plugin_public_folder)
+                
+        environment.must_be.defined                
+        if environment.config.static? and !environment.config.test?        
+          symlink_path = "#{config.root!}/public/#{symlink_name}"
+          unless File.symlink?(symlink_path) and File.exist?(symlink_path)
+            File.delete(symlink_path) if File.symlink?(symlink_path)
+            File.symlink(plugin_public_folder, symlink_path)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/crystal/http/http_adapter.rb

@@ -0,0 +1,30 @@
+module Crystal
+  module HTTPAdapter
+    class << self    
+      inject :conveyors => :conveyors,
+        :config => :config
+      
+      def call env, workspace = {}, &block
+        # result, opt = nil, opt.to_openobject
+        workspace = conveyors.web.call(
+          {:env => env, :response => Crystal::Response.new}.merge(workspace.symbolize_keys),
+          &block
+        )
+        
+        workspace.response.must_be.defined
+        workspace.response.content_type ||= Mime.send(config.default_format)
+        result = workspace.response.to_a
+        
+        result
+      end
+      # synchronize_method :call
+      
+      def mock_call env = {}, workspace = {}, &block
+        env['PATH_INFO'] ||= '/'
+        env['rack.input'] ||= StringIO.new
+        
+        call env, workspace, &block
+      end
+    end        
+  end
+end

data/lib/crystal/http/middleware/static_files.rb

@@ -0,0 +1,20 @@
+module Crystal
+  class StaticFiles
+
+    def initialize(app, root)
+      @app = app
+      @root = File.expand_path(root)
+      @file_server = Rack::File.new(@root)
+    end
+
+    def call(env)
+      path = env["PATH_INFO"]
+
+      if File.exist? "#{@root}#{path}"
+        @file_server.call(env)
+      else
+        @app.call(env)
+      end
+    end
+  end
+end

data/lib/crystal/http/processors/evaluate_format.rb

@@ -0,0 +1,22 @@
+module Crystal
+  module Processors
+    class EvaluateFormat < Processor
+      def call
+        path = workspace.path.must_be.defined
+        params = workspace.params.must_be.defined
+        
+        parts = path.split('.')        
+        if parts.size > 1
+          format = parts.last
+          logger.warn "Two :format parameters!" if params.include?(:format) 
+          workspace.params = params.clone
+          workspace.params.format = format
+        else
+          params.format ||= config.default_format!
+        end
+        
+        next_processor.call
+      end
+    end
+  end
+end

data/lib/crystal/http/processors/http_logger.rb

@@ -0,0 +1,15 @@
+module Crystal
+  module Processors
+    class HTTPLogger < Processor
+      def call
+        if workspace.request? and workspace.params?        
+          method, path, ip, time, format = workspace.request.request_method, workspace.path, 
+            workspace.request.ip, (workspace.start_time || Time.now), workspace.params.format
+          logger.info "Started '#{path}' as '#{format}' (for #{ip} at #{time.to_s} with #{method})"
+        end
+        
+        next_processor.call
+      end
+    end
+  end
+end

data/lib/crystal/http/processors/http_writer.rb

@@ -0,0 +1,48 @@
+module Crystal
+  module Processors    
+    class HttpWriter < Processor
+      attr_accessor :result_variable
+      
+      def initialize next_processor, result_variable = 'content'
+        super(next_processor)
+        @result_variable = result_variable
+      end
+      
+      def call
+        response = workspace.response.must_be.defined
+        
+        begin
+          next_processor.call
+          
+          result = workspace[result_variable]
+          response.body = result if response.body.blank? and result.present?
+          response.content_type ||= Mime[workspace.params.format]
+        rescue StandardError => e            
+          raise e if config.test?
+          
+          # if workspace.error_processed?
+          #   result = workspace[@result_variable]
+          # 
+          #   response.body << result if result
+          #   response.content_type = Mime[workspace.params.format]
+          # else
+          
+          if workspace.params.format? and workspace.params.format.json?
+            response.body << {:error => (config.production? ? "Internal error!" : e.message)}.to_json
+            response.content_type = Mime.json
+          else
+            response.body << (config.production? ? "Internal error!" : e.message)
+            response.content_type = Mime.text
+          end
+          
+          logger.error e
+          logger.info "\n"
+          
+          # end
+          
+          # response.error = e # for RSpec helpers
+        end
+      end
+    end 
+  end
+end

data/lib/crystal/http/processors/prepare_params.rb

@@ -0,0 +1,24 @@
+module Crystal
+  module Processors    
+    class PrepareParams < Processor
+      def call
+        workspace.env.must_be.defined
+
+        workspace.request = Crystal::Request.new(workspace.env)
+        workspace.path = workspace.request.path
+        params = workspace.params = Crystal::Params.new(workspace.request.params)
+
+        if params.json?
+          json_params = JSON.load params['json']
+          json_params.must_be.a Hash
+          json_params.keys.each do |k|
+            logger.warn "Parameter :#{k} will be overwriden from JSON!" if params.include?(k)
+          end
+          params.merge! json_params
+        end
+        
+        next_processor.call
+      end
+    end 
+  end
+end

data/lib/crystal/http/rack_config.rb

@@ -0,0 +1,15 @@
+# module Crystal
+#   module RackConfig
+#     def run_common_app rack_config_file_path
+#       $APP_DIR = File.expand_path(File.dirname(rack_config_file_path))
+# 
+#       require "#{$APP_DIR}/config/init"
+# 
+#       Crystal::Config::DEFAULTS['environment'] = $CENV || 'production'
+#       Micon[:environment]
+# 
+#       Crystal.build_common_app self
+#       run Crystal
+#     end
+#   end
+# end

data/lib/crystal/http/support/rack/rack_adapter.rb

@@ -0,0 +1,65 @@
+module Crystal
+  class RackAdapter
+    SERVERS = %w{mongrel thin webrick}
+    
+    # class Callback
+    #   def initialize app; end
+    #   def self.call env; Crystal::Adapter.call env end
+    # end
+    
+    class << self
+      inject(
+        :logger => :logger,
+        :config => :config
+      )
+      
+      def build_common_app builder = nil, &block
+        if block
+          @build_common_app = block
+        else
+          unless @build_common_app
+            raise "Common App not defined! Use profiles (like crystal/profiles/web), define it by yourself or use your own configuration!"
+          end
+          @build_common_app.call builder
+        end
+      end
+      
+      def parse_config
+        app, options = Rack::Builder.parse_file 'config.ru'
+        app
+      end
+      
+      def run app
+        handler = detect_rack_handler
+        handler_name = handler.name.gsub(/.*::/, '')
+        # unless handler_name =~/cgi/i
+        logger.info "Crystal #{Crystal::VERSION} started on #{config.port!} in :#{config.environment!} mode (at #{Time.now.to_s})\n\n"
+        handler.run app, :Host => config.host!, :Port => config.port! do |server|
+          [:INT, :TERM].each {|sig| trap(sig){quit!(server, handler_name)}}
+        end
+      rescue Errno::EADDRINUSE => e
+        logger.error "Port #{config.port!} taken!"
+      end
+      
+      def quit!(server, handler_name)
+        ## Use thins' hard #stop! if available, otherwise just #stop
+        server.respond_to?(:stop!) ? server.stop! : server.stop
+        puts "\nCrystal stopped" unless handler_name =~/cgi/i        
+      end
+      
+      protected        
+        def detect_rack_handler
+          return Rack::Handler.get('mongrel')
+          SERVERS.each do |server_name|
+            begin
+              return Rack::Handler.get(server_name.downcase)
+            rescue LoadError
+            rescue NameError
+            end
+          end
+          fail "  Server handler (#{SERVERS.join(', ')}) not found."
+        end
+        
+    end
+  end
+end

data/lib/crystal/http/support/rack/request.rb

@@ -0,0 +1,12 @@
+module Crystal
+  class Request < Rack::Request
+    # Returns an array of acceptable media types for the response
+    # def accept
+    #   @env['HTTP_ACCEPT'].to_s.split(',').map { |a| a.split(';')[0].strip }
+    # end
+    # 
+    # def secure?
+    #   (@env['HTTP_X_FORWARDED_PROTO'] || @env['rack.url_scheme']) == 'https'
+    # end
+  end
+end

data/lib/crystal/http/support/rack/response.rb

@@ -0,0 +1,39 @@
+module Crystal
+  class Response
+    attr_accessor :status, :headers, :body
+    # attr_accessor :error # for specs
+    
+    def initialize
+      @status, @headers, @body = 200, {}, ""
+    end
+    
+    def write str
+      body << str
+    end      
+
+    def content_type= type; headers["Content-Type"] = type end
+    def content_type; headers["Content-Type"] end
+    def content_type?; !!content_type end
+    
+    def location; headers['Location'] end
+    def location= location; headers['Location'] = location end
+    
+    def to_a
+      [status, headers, body]
+    end 
+    
+    def inspect
+      to_a.inspect
+    end
+    
+    def == other
+      super(other) || to_a == other
+    end
+    
+    def empty?
+      body.empty?
+    end
+    alias_method :blank?, :empty?
+    
+  end
+end