rad_core 0.0.13 → 0.0.14

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

@@ -1,26 +1,23 @@
+rad.html
+
 # 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}
+class ScopedParams < Rad::Conveyors::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 "RAD 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
-                
-        next_processor.call
       end
+      workspace.params.merge! to_add
+      to_delete.each{|n| workspace.params.delete n}
     end
+            
+    next_processor.call
   end
-end
-      
+end

data/lib/rad/html.rb

@@ -1,26 +1 @@
-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']
+rad.html

data/lib/rad/http/_http.rb

@@ -0,0 +1,11 @@
+class Rad::Http  
+  inject environment: :environment
+  attr_reader :rack_adapter, :http_adapter    
+  
+  def initialize
+    @rack_adapter, @http_adapter = Rad::Http::RackAdapter.new, Rad::Http::HttpAdapter.new
+  end    
+  
+  delegate :initialize_rack, :run, to: :rack_adapter
+  delegate :call, :mock_environment, to: :http_adapter
+end

data/lib/rad/http/_http_adapter.rb

@@ -0,0 +1,44 @@
+class Rad::Http::HttpAdapter
+  inject conveyors: :conveyors
+
+  def call env, workspace = {}, &block
+    # result, opt = nil, opt.to_openobject
+    workspace = conveyors.web.call(
+      {env: env, response: Rad::Http::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 url = nil
+    env = {
+      'rack.url_scheme' => 'http',
+      'PATH_INFO' => '/',
+      'HTTP_HOST' => 'spec',
+      'rack.input' => StringIO.new
+    }
+    if url
+      uri = Uri.parse url
+      env.merge!(
+        'HTTP_HOST'    => %(#{uri.host}#{":#{uri.port}" if uri.port.present?}),
+        # 'REQUEST_PATH' => uri.path,
+        'PATH_INFO'    => uri.path,
+        # 'REQUEST_URI'  => uri.path,
+        'QUERY_STRING' => uri.query            
+      )
+    end
+    env
+  end
+end

data/lib/rad/http/_request.rb

@@ -0,0 +1,50 @@
+class Rad::Http::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
+  
+  def normalized_domain
+    return nil unless named_host?(host)
+    host.sub('www.', '').downcase
+    # subdomains = request.subdomains.select{|n| n != 'www'}
+    # subdomain = subdomains.last
+    # pure_domain = request.domain.sub(/\A#{subdomains.join(".")}\./, "")
+    # 
+    # domain = subdomain.blank? ? pure_domain : "#{subdomain}.#{pure_domain}"
+  end
+
+  protected    
+    def named_host?(host)
+      !(host.nil? || /\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.match(host))
+    end
+end

data/lib/rad/http/_require.rb

@@ -0,0 +1,33 @@
+# 
+# Dependencies
+# 
+require 'rack'
+require 'rack/builder'
+
+class Rad::Http
+  attr_accessor :host, :port, :static, :url_root, :default_format, :session
+  require_attr :host, :port, :url_root, :default_format
+  def static?; !!@static end  
+  
+  attr_writer :public_path
+  def public_path
+    @public_path || "#{rad.runtime_path}/public"
+  end
+  def public_path?; !!public_path end
+end
+
+%w(  
+  rack_adapter
+  fixes
+).each{|f| require "rad/http/_support/rack/#{f}"}
+
+
+# 
+# Libraries
+# 
+%w(
+  _request
+  _response
+  _http_adapter
+  _http  
+).each{|f| require "rad/http/#{f}"}

data/lib/rad/http/_response.rb

@@ -0,0 +1,84 @@
+class Rad::Http::Response < Rack::Response
+  include ::OpenConstructor
+
+  STATUS_MESSAGES = {
+    ok: 200,
+    not_found: 404,
+    failed: 500,
+    error: 500,
+    redirect: 302
+  }
+
+  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

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

@@ -0,0 +1,57 @@
+class Rad::Http::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
+  
+  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 run app, host, port
+    handler = detect_rack_handler
+    handler_name = handler.name.gsub(/.*::/, '')
+    logger.info "RAD http server started on #{host}:#{port}" unless rad.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 "RAD 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

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

@@ -1,22 +1,19 @@
-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
+rad.http
+
+class EvaluateFormat < Rad::Conveyors::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 "RAD two :format parameters!" if params.include?(:format) 
+      workspace.params = params.clone
+      workspace.params.format = format
+    else
+      params.format ||= rad.http.default_format
     end
+    
+    next_processor.call
   end
 end

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

@@ -1,15 +1,13 @@
-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
+rad.http
+
+class HttpLogger < Rad::Conveyors::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 "RAD started '#{path}' as '#{format}' (for #{ip} at #{time.to_s} with #{method})"
     end
+    
+    next_processor.call
   end
 end

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

@@ -1,30 +1,28 @@
-module Rad
-  module Processors    
-    class HttpWriter < Processor      
-      def call
-        response = workspace.response.must_be.defined
-        
-        begin
-          next_processor.call
+rad.http
 
-          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
+class HttpWriter < Rad::Conveyors::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?) || rad.http.default_format]          
+    rescue StandardError => e       
+      raise e if rad.test?
+      
+      response.clear          
+      if workspace.params.format? and workspace.params.format == 'json'
+        response.body = {error: (rad.production? ? "Internal error!" : e.message)}.to_json
+        response.content_type = Mime.json
+      else
+        response.body = (rad.production? ? "Internal error!" : e.message)
+        response.content_type = Mime.text
       end
-    end 
+      
+      logger.error e
+      logger.info "\n"
+    end
   end
 end

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

@@ -1,22 +1,23 @@
-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)
+rad.http
 
-        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
+# 
+# Outdated, Rack does this by themself, keeping it just in case.
+# 
+class PrepareParams < Rad::Conveyors::Processor
+  def call    
+    workspace.env.must_be.defined    
+    workspace.request = Rad::Http::Request.new(workspace.env)
+    workspace.path = workspace.request.path
+    params = workspace.params = Rad::Conveyors::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 "RAD parameter :#{k} will be overwriden from JSON!" if params.include?(k)
       end
-    end 
+      params.merge! json_params
+    end
+    next_processor.call
   end
 end

data/lib/rad/http/request.rb

@@ -0,0 +1 @@
+rad.http

data/lib/rad/http/response.rb

@@ -0,0 +1 @@
+rad.http

data/lib/rad/http.rb

@@ -1,48 +1 @@
-# 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',
-)
+rad.http

data/lib/rad/mailer/_letter.rb

@@ -0,0 +1,28 @@
+class Rad::Mailer::Letter
+  inject mailer: :mailer
+
+  attr_accessor :from, :to, :subject, :body
+
+  def initialize properties
+    properties.each do |k, v|
+      send "#{k}=", v
+    end
+  end
+
+  def validate!
+    from || raise("letter :from not specified!")
+    to || raise("letter :to not specified!")
+    subject || raise("letter :subject not specified!")
+    body || raise("letter :body not specified!") 
+  end
+
+  def deliver
+    validate!
+    mailer.deliver self
+  end
+
+  def to_hash
+    {from: from, to: to, subject: subject, body: body}
+  end
+  alias_method :to_h, :to_hash
+end

data/lib/rad/mailer/_mailer.rb

@@ -0,0 +1,13 @@
+class Rad::Mailer
+  inject logger: :logger
+  
+  def deliver letter
+    mail = Mail.new letter.to_h
+    if rad.development?
+      logger.info "RAD delivering mail #{letter.to_h.inspect}"
+    else
+      logger.info "RAD delivering mail '#{letter.subject}'"
+    end
+    mail.deliver!
+  end
+end

data/lib/rad/mailer/_mailer_controller.rb

@@ -0,0 +1,38 @@
+module Rad::Mailer::MailerController
+  inherit Rad::Controller::Abstract
+
+  attr_accessor :from, :to, :subject, :body
+
+  module ClassMethods
+    protected      
+      inject conveyors: :conveyors
+  
+      def method_missing m, *args, &block
+        mail_controller = self.new
+        if mail_controller.respond_to? m
+          build_letter mail_controller, m, *args
+        else
+          super
+        end
+      end        
+    
+      def build_letter mail_controller, m, *args
+        conveyors.mail.must_be.present
+        
+        # copying parameter from current workspace if any
+        # mail_workspace = rad.workspace? ? rad.workspace.clone : {}            
+        # mail_workspace.merge!(
+        #   controller: mail_controller,
+        #   method_name: m,
+        #   arguments: args
+        # )
+
+        workspace = conveyors.mail.call(
+          controller: mail_controller,
+          method_name: m,
+          arguments: args
+        )
+        workspace.letter.must_be.present
+      end
+  end
+end

data/lib/rad/mailer/_require.rb

@@ -0,0 +1,7 @@
+require 'mail'
+
+%w(
+  _mailer
+  _letter  
+  _mailer_controller
+).each{|f| require "rad/mailer/#{f}"}

data/lib/rad/mailer/mailer_controller.rb

@@ -0,0 +1 @@
+rad.mailer