rad_core 0.0.13

data/lib/rad/html/helpers/javascript_helper.rb

@@ -0,0 +1,18 @@
+module Rad
+  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/rad/html/helpers/model_helper.rb

@@ -0,0 +1,135 @@
+module Rad  
+  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 select name, values, options = {}
+      render_attribute name, options do |fname, value, o|
+        form_helper.select_tag fname, value, values, 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.must_be.a Symbol
+        ferrors = errors_for(name)
+
+        options = insert_human_readable_label name, options        
+
+        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_sym] = Array.wrap(v)
+          end          
+        end
+        @errors
+      end
+    
+      def errors_for name        
+        name.must_be.a Symbol
+        errors[name]
+      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_sym] || model[name.to_s]
+        else
+          raise "Model not respond to :#{name} nor to :[]!"
+        end
+      end
+      
+      def insert_human_readable_label name, options
+        unless options.include?(:label) or options.include?(:label)
+          options[:label] = model.t(name) if model.respond_to? :t
+        end
+        options
+      end
+  end
+end

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

@@ -0,0 +1,26 @@
+module Rad
+  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
+          rad[:flash] = Rad::Flash.new workspace.params.format, previous_messages
+        end
+        
+        next_processor.call
+        
+        if rad.include? :flash
+          flash = rad[: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/rad/html/processors/scoped_params.rb

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

data/lib/rad/html.rb

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

data/lib/rad/http/http.rb

@@ -0,0 +1,21 @@
+module Rad
+  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.public_dir!}/#{symlink_name}"
+          unless File.exist?(symlink_path) # and File.symlink?(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/rad/http/http_adapter.rb

@@ -0,0 +1,36 @@
+module Rad
+  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: Rad::Response.new}.merge(workspace),
+          &block
+        )
+        
+        response = workspace.response.must_be.defined
+        result = response.finish
+                
+        result
+      end
+      # synchronize_method :call
+      
+      # def mock_call env = {}, workspace = {}, &block
+      #   env['PATH_INFO'] ||= '/'
+      #   env['rack.input'] ||= StringIO.new        
+      #   
+      #   call env, workspace, &block
+      # end
+      
+      def mock_environment
+        {
+          'rack.url_scheme' => 'http',
+          'PATH_INFO' => '/',
+          'rack.input' => StringIO.new
+        }
+      end
+    end        
+  end
+end

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

@@ -0,0 +1,21 @@
+module Rad
+  class StaticFiles
+
+    def initialize(app, dir, filter = nil)
+      @app = app
+      @dir = File.expand_path(dir)
+      @file_server = Rack::File.new(@dir)
+      @filter = filter
+    end
+
+    def call(env)
+      path = env["PATH_INFO"]
+
+      if (!@filter or (@filter and @filter =~ path)) and File.exist?("#{@dir}#{path}")
+        @file_server.call(env)
+      else
+        @app.call(env)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module Rad
+  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/rad/http/processors/http_logger.rb

@@ -0,0 +1,15 @@
+module Rad
+  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/rad/http/processors/http_writer.rb

@@ -0,0 +1,30 @@
+module Rad
+  module Processors    
+    class HttpWriter < Processor      
+      def call
+        response = workspace.response.must_be.defined
+        
+        begin
+          next_processor.call
+
+          response.body = workspace.content if response.body.blank? and workspace.content?
+          response.content_type ||= Mime[(workspace.params.format if workspace.params?) || config.default_format]
+        rescue StandardError => e       
+          raise e if config.test?
+          
+          response.clear          
+          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
+      end
+    end 
+  end
+end

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

@@ -0,0 +1,22 @@
+module Rad
+  module Processors    
+    class PrepareParams < Processor
+      def call
+        workspace.env.must_be.defined
+        workspace.request = Rad::Request.new(workspace.env)
+        workspace.path = workspace.request.path
+        params = workspace.params = Rad::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/rad/http/support/rack/fixes.rb

@@ -0,0 +1,36 @@
+#
+# Rack doesn't works well with ruby 1.9.2
+# there's no :each method in String anymore
+# 
+class Rack::Response
+  def each(&callback)
+    if @body.is_a? String
+      @body.each_char(&callback)
+    else
+      @body.each(&callback)
+    end
+    @writer = callback
+    @block.call(self)  if @block
+  end
+end
+
+class Rack::Request
+  alias_method :params_with_wrong_encoding, :params
+  def params
+    @params ||= encode_in_utf8(params_with_wrong_encoding)
+  end
+
+  protected
+    def encode_in_utf8 hash
+      r = {}
+      hash.each do |k, v|
+        r[k] = if v.is_a? String
+          v.force_encoding("UTF-8")
+        elsif v.is_a? Hash
+          encode_in_utf8(v)
+        else
+          v
+        end
+      end
+    end
+end

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

@@ -0,0 +1,67 @@
+module Rad
+  class RackAdapter
+    SERVERS = %w{thin mongrel webrick}
+    
+    # class Callback
+    #   def initialize app; end
+    #   def self.call env; Rad::Adapter.call env end
+    # end
+    
+    class << self
+      inject(
+        logger: :logger,
+        config: :config
+      )
+      
+      def initialize_rack builder = nil, &block
+        @rack_configurations ||= []
+        if block
+          raise "provide configuration block!" unless block
+          @rack_configurations << block
+        else
+          if @rack_configurations.empty?
+            raise "Common App not defined! Use profiles (like rad/profiles/web), define it by yourself or use your own configuration!"
+          end
+          @rack_configurations.each{|conf| conf.call builder}
+        end
+      end
+      
+      def parse_config
+        app, options = Rack::Builder.parse_file 'config.ru'
+        app
+      end
+      
+      def run app, host, port
+        handler = detect_rack_handler
+        handler_name = handler.name.gsub(/.*::/, '')
+        logger.info "  HTTP server started on #{host}:#{port}" unless config.test?
+        # unless handler_name =~/cgi/i
+        handler.run app, Host: host, Port: port do |server|
+          [:INT, :TERM].each {|sig| trap(sig){quit!(server, handler_name)}}
+        end
+      rescue Errno::EADDRINUSE => e
+        logger.error "Port #{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 "\nRad stopped" unless handler_name =~/cgi/i        
+      end
+      
+      protected        
+        def detect_rack_handler
+          return Rack::Handler.get('thin')
+          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/rad/http/support/rack/request.rb

@@ -0,0 +1,42 @@
+module Rad
+  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
+    
+    
+    # Returns all the \subdomains as an array, so <tt>["dev", "www"]</tt> would be
+    # returned for "dev.www.rubyonrails.org". You can specify a different <tt>tld_length</tt>,
+    # such as 2 to catch <tt>["www"]</tt> instead of <tt>["www", "rubyonrails"]</tt>
+    # in "www.rubyonrails.co.uk".
+    def subdomains(tld_length = 1)
+      return [] unless named_host?(host)
+      parts = host.split('.')
+      parts[0..-(tld_length+2)]
+    end
+    
+    
+    # Returns the \domain part of a \host, such as "rubyonrails.org" in "www.rubyonrails.org". You can specify
+    # a different <tt>tld_length</tt>, such as 2 to catch rubyonrails.co.uk in "www.rubyonrails.co.uk".
+    def domain(tld_length = 1)
+      return nil unless named_host?(host)
+
+      host.split('.').last(1 + tld_length).join('.')
+    end
+    
+    def cookies_with_memory
+      @cookies_with_memory ||= cookies_without_memory
+    end
+    alias_method_chain :cookies, :memory
+    
+    protected    
+      def named_host?(host)
+        !(host.nil? || /\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.match(host))
+      end
+  end
+end

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

@@ -0,0 +1,86 @@
+module Rad
+  class Response < Rack::Response
+    include ::OpenConstructor
+    
+    STATUS_MESSAGES = {
+      ok: 200,
+      not_found: 404,
+      failed: 500,
+      error: 500,
+      redirect: 301
+    }
+    
+    def initialize *args
+      super
+      clear
+    end
+    
+    def content_type= type; self["Content-Type"] = type end
+    def content_type; self["Content-Type"] end
+    def content_type?; !!content_type end
+    
+    def location; self['Location'] end
+    def location= location; self['Location'] = location end
+    
+    # def to_a
+    #   [status, headers, body]
+    # end 
+    
+    def body_as_string
+      if @body.is_a? String
+        @body
+      else
+        @body ? @body.join : ""
+      end
+    end
+    
+    def inspect
+      to_a2.inspect
+    end
+    
+    def == other
+      to_a2 == other
+    end
+    
+    def cookies
+      self['Set-Cookie']
+    end
+        
+    def clear
+      @status = 200
+      @header = Rack::Utils::HeaderHash.new("Content-Type" => nil)
+      @length = 0
+      @body = []
+    end    
+    
+    def status= code_or_message
+      @status = if code_or_message.is_a? Numeric
+        code_or_message
+      else
+        self.class.decode_status_message(code_or_message) || raise("unknown http status message '#{code_or_message}'!")
+      end
+    end
+    
+    def self.decode_status_message message
+      STATUS_MESSAGES[message]
+    end
+    
+    
+    #
+    # Status helpers
+    #
+    STATUS_MESSAGES.each do |message, status_code|
+      define_method("#{message}?"){self.status == status_code}
+    end
+    alias_method :success?, :ok?
+    
+    def redirect?
+      super or (body and body.include?('window.location'))
+    end
+    
+    protected
+      def to_a2
+        [status, header, body_as_string]
+      end
+  end
+end

data/lib/rad/http.rb

@@ -0,0 +1,48 @@
+# WServer provides support for Web Servers (via Rack)
+
+require 'rack'
+require 'rack/builder'
+
+require 'rad/conveyor'
+
+# support
+[  
+  'rack/request',
+  'rack/response',
+  'rack/rack_adapter',
+  'rack/fixes'
+].each{|f| require "rad/http/support/#{f}"}
+
+# http
+[
+  # 'config',
+  'http',
+  'http_adapter',
+  'processors/prepare_params',
+  'processors/http_writer',
+  'processors/http_logger',
+  'processors/evaluate_format'
+].each{|f| require "rad/http/#{f}"}
+
+module Rad
+  autoload :StaticFiles, 'rad/http/middleware/static_files'
+end
+
+Rad.metaclass_eval do
+  delegate :initialize_rack, to: Rad::RackAdapter  
+  delegate :call, to: Rad::HTTPAdapter
+  delegate :ensure_public_symlink, to: Rad::HTTP
+end
+
+
+# 
+# Initialization
+# 
+Rad::Config::DEFAULTS.merge!(
+  host: '0.0.0.0',
+  port: 4000,
+  
+  static: true,
+  url_root: '',
+  default_format: 'html',
+)