rad_core 0.0.13 → 0.0.14

data/lib/rad/environment/config.rb

@@ -1,111 +1 @@
-module Rad
-  class Config < SafeHash
-    inherit ::OpenConstructor
-    
-    DEFAULTS = {}
-    RUNTIME = {}
-
-    def initialize
-      super
-
-      DEFAULTS.each{|k, v| self[k] = v}
-      RUNTIME.each{|k, v| self[k] = v}
-    end    
-    
-    # trying to load both file_path and file_path.environment files if they are exists
-    def merge_config! file_path      
-      # unless ::Micon.include? :config
-      #   raise("this method should be called only after config already initialized (use app.after :config do ... end)!")
-      # end
-      raise("config file must have .yml extension (#{file_path})!") unless file_path.end_with? '.yml'
-      default_file_path = file_path.sub(/yml$/, "default.yml")
-      file_path_for_current_environment = file_path.sub(/yml$/, "#{environment!}.yml")
-      [
-        default_file_path,
-        file_path,
-        file_path_for_current_environment
-      ].each do |cfile|
-        if ::File.exist? cfile 
-          data = ::YAML.load_file cfile
-          if data
-            data.must_be.a ::Hash
-            self.deep_merge! data            
-          end
-        end
-      end
-    end
-    
-    # 
-    # runtime_dir
-    # 
-    def runtime_dir= runtime_dir
-      if runtime_dir
-        self[:runtime_dir] = ::File.expand_path(runtime_dir)
-      else
-        self.delete 'runtime_dir'
-      end
-    end
-    
-    
-    #
-    # public_dir
-    #
-    def public_dir 
-      runtime_dir? ? "#{runtime_dir}/public" : self[:public_dir] 
-    end
-    def public_dir?; runtime_dir? end
-    def public_dir!
-      "#{runtime_dir!}/public"
-    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    
-    
-    def development &block; block.call if development? end
-    def production &block; block.call if production? end
-    def test &block; block.call if test? end
-    
-    # 
-    # log_path
-    # 
-    attr_writer :log_path
-    def log_path
-      @log_path ||= runtime_dir? ? "#{runtime_dir}/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 defered_configs; @defered_configs ||= [] end
-    # end
-  end
-end
+rad.environment

data/lib/rad/environment.rb

@@ -1,55 +1 @@
-# Environment prepares and assembles your app ($LOAD_PATH, plugins and config files)
-
-# 
-# Support
-# 
-require 'rad/support'
-
-# config
-[  
-  'config',
-].each{|f| require "rad/environment/#{f}"}
-
-module Rad
-  VERSION = '0.0.1'
-end
-
-# environment
-[  
-  'logger',
-  'environment',
-  'files_helper'
-].each{|f| require "rad/environment/#{f}"}
-Rad::Environment.inherit Rad::FilesHelper
-
-
-# 
-# Runtime initialization
-# 
-rad do
-  register :config do
-    Rad::Config.new
-  end
-  
-  register :environment, depends_on: :config do
-    environment = Rad::Environment.new
-    logger.info "  Rad #{Rad::VERSION} started in :#{config.environment!} mode (at #{Time.now.to_s})\n\n" unless config.test?
-    environment
-  end
-end
-
-# 
-# Handy mehtods 
-# 
-module Rad
-  class << self
-    inject(
-      config: :config,
-      environment: :environment,
-      logger: :logger,
-      workspace: :workspace
-    )
-    
-    # delegate :initialize_runtime, :initialize_plugin, to: Environment
-  end
-end
+rad.environment

data/lib/{rad_core → rad}/gems.rb

@@ -5,7 +5,7 @@ gem 'polyglot', '0.3.1'
 gem 'mime-types', '1.16'
 
 # core gems
-gem 'activesupport', '3.0.3'
+gem 'activesupport', '3.0.7'
 gem 'builder', '2.1.2'
 
 gem 'haml', '3.0.25'
@@ -14,11 +14,10 @@ gem 'tilt', '1.2.1'
 gem 'json', '1.4.6'
 gem 'addressable', '2.2.2'
 gem 'nokogiri', '1.4.4'
-gem 'rack', '1.2.1'
 
 gem 'dictionary', '1.0.0'  
 
-gem 'rack', '1.2.1'
+gem 'rack', '1.3.0'
 gem 'thin', '1.2.7'
 
 gem 'mail', '2.2.14'

data/lib/rad/html/_flash.rb

@@ -0,0 +1,40 @@
+class Rad::Html::Flash < OpenObject
+  attr_accessor :previous_messages, :current_messages
+    
+  def initialize format, previous_messages = {}
+    self.current_messages, self.previous_messages = {}, previous_messages
+    @keep = false
+  end
+
+  def [] key
+    key = key.to_s
+  
+    if keep?
+      previous_messages[key]        
+    else
+      current_messages[key] || previous_messages[key]
+    end
+  end
+
+  def []= key, value
+    current_messages[key.to_s] = value.to_s
+  end
+
+  def keep!
+    @keep = true
+    self
+  end
+
+  def keep?
+    !!@keep
+  end
+
+  def messages_for_next_request
+    if keep?
+      current_messages
+    else        
+      {}
+    end
+  end
+  
+end

data/lib/rad/html/_helpers/basic_html_helper.rb

@@ -0,0 +1,72 @@
+module Rad::Html::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 })
+
+
+  # 
+  # JavaScript & StyleSheets
+  #     
+  def stylesheet_link_tag *stylesheets
+    stylesheets.collect{|ssheet|
+      tag :link, '', href: "#{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
+
+  # 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|
+          next if key == :content # used in common_interface don't delete it
+          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

data/lib/rad/html/_helpers/flash_helper.rb

@@ -0,0 +1,3 @@
+module Rad::Html::FlashHelper
+  inject flash: :flash
+end

data/lib/rad/html/_helpers/form_helper.rb

@@ -0,0 +1,114 @@
+module Rad::Html::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 = {}            
+    model_name.must_be.a String, Symbol
+    return Rad::Html::ModelHelper.new(self, self, model_name, model, options), options
+  end
+
+  def form_tag options = {}, &block      
+    options['method'] ||= options[:method] || 'post'
+    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, value = '1', options = {}
+    options = {type: "radio", name: name, value: value, checked: false}.update(options)
+    checked = options.delete :checked
+    options["checked"] = "checked" if checked
+    tag_with_style :input, '', options
+  end
+
+  def select_tag name, selected, values, options = {}      
+    buff = "\n"
+    values.each do |n, v|        
+      o = {}
+      o[:value] = v if v
+      o[:selected] = 'selected' if (v || n) == selected        
+      buff << tag(:option, n, o)
+      buff << "\n"
+    end
+  
+    tag_with_style :select, buff, {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

data/lib/rad/html/_helpers/html_helper.rb

@@ -0,0 +1,3 @@
+module Rad::Html::HtmlHelper
+  inherit Rad::Html::BasicHtmlHelper, Rad::Html::FormHelper, Rad::Html::JavascriptHelper, Rad::Html::FlashHelper
+end

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

@@ -0,0 +1,27 @@
+module Rad::Html::JavascriptHelper      
+  def javascript_include_tag *scripts
+    scripts.collect{|script|
+      tag :script, '', src: "#{script}", type: "text/javascript"
+    }.join("\n")      
+  end
+
+  def javascript_tag script = nil, options = {}, &block
+    script = capture &block if block
+    if options[:defer] or (!options.include?(:defer) and Rad::Html::JavascriptHelper.defer)
+      script = "rad.defer(function(){#{script}});"
+    end
+    html = tag :script, script, {type: "text/javascript"}
+    block ? concat(html) : html
+  end
+  
+  def call_deferred_js
+    javascript_tag 'rad.callDeferred();', defer: false
+  end
+
+  # Escape
+  def js obj; obj.to_s.js_escape end
+  
+  
+  def self.defer; @defer ||= true end
+  def self.defer= value; @defer = value end        
+end

data/lib/rad/html/_helpers/model_helper.rb

@@ -0,0 +1,143 @@
+class Rad::Html::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|
+      html = form_helper.hidden_field_tag(fname, '0') + "\n"
+      html += form_helper.check_box_tag fname, !!value, o
+      html
+    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, value = 1, options = {}
+    render_attribute name, options do |fname, v, o|
+      o[:checked] = value == v
+      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        
+
+      value = value_of name
+      field_name = field_name_for name, value
+      
+      if form_helper.respond_to? :field_with_errors
+        field_html = block.call field_name, value, 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, value, 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, value
+      if value.is_a? Array
+        "#{model_name}[#{name}][]"
+      else
+        "#{model_name}[#{name}]"
+      end
+    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)
+        options[:label] = model.t(name) if model.respond_to? :t
+      end
+      options
+    end
+end

data/lib/rad/html/_require.rb

@@ -0,0 +1,15 @@
+class Rad::Html
+  attr_accessor :remote_link_formats
+  require_attr :remote_link_formats
+end
+
+%w(
+  _flash
+  
+  _helpers/basic_html_helper
+  _helpers/form_helper
+  _helpers/model_helper
+  _helpers/javascript_helper
+  _helpers/flash_helper
+  _helpers/html_helper
+).each{|f| require "rad/html/#{f}"}

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

@@ -1,26 +1,25 @@
-module Rad
-  module Processors
-    class PrepareFlash < Processor
+rad.html
 
-      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
+
+class PrepareFlash < Rad::Conveyors::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::Html::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