rad_core 0.0.13

data/lib/rad/conveyor/workspace.rb

@@ -0,0 +1,36 @@
+module Rad
+  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] = v}
+      h['env'] = "..." if h.include? 'env'      
+      h['request'] = "..." if h.include? 'request'
+      h.inspect
+    end
+  end  
+end

data/lib/rad/conveyor.rb

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

data/lib/rad/environment/config.rb

@@ -0,0 +1,111 @@
+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

data/lib/rad/environment/dependency_resolver.rb

@@ -0,0 +1,107 @@
+# module Rad
+#   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/rad/environment/environment.rb

@@ -0,0 +1,29 @@
+module Rad
+  class Environment
+    inject logger: :logger, config: :config
+    
+    class << self      
+      inject logger: :logger, config: :config
+      
+      # def initialize_runtime runtime_dir, environment = nil
+      #   init_file_path = "#{runtime_dir}/init.rb"                                
+      #   load init_file_path if File.exist? init_file_path
+      #     
+      #   Micon.after :config do |config|
+      #     config.runtime_dir = runtime_dir
+      #     
+      #     config.merge_config! "#{runtime_dir}/config/config.yml"
+      #   end
+      # end
+      # 
+      # def initialize_plugin plugin_dir
+      #   init_file_path = "#{plugin_dir}/init.rb"                                
+      #   load init_file_path if File.exist? init_file_path
+      #     
+      #   Micon.after :config do |config|          
+      #     config.merge_config! "#{plugin_dir}/config/config.yml" 
+      #   end
+      # end      
+    end    
+  end
+end

data/lib/rad/environment/files_helper.rb

@@ -0,0 +1,55 @@
+module Rad
+  module FilesHelper    
+    def directories
+      $LOAD_PATH
+    end
+    
+    def file_exist? path, directories = nil
+      find_files(path).size > 0
+    end
+
+    def find_files fname, directories = nil
+      directories ||= self.directories
+      FilesHelper.find_files fname, directories
+    end
+    
+    def find_files_without_cache fname, directories = nil
+      # directories ||= self.directories
+      FilesHelper.find_files_without_cache fname, directories
+    end
+    
+    def find_file fname, directories = nil
+      files = find_files(fname, directories)
+      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
+    
+    class << self
+      # don't move this class method to module, because there will be then 
+      # multiple cache for every object that includes it.      
+      def find_files fname, directories = nil
+        fname.must =~ /\//
+        directories.must_be.present # || raise('directories ')= self.directories
+        files = directories.collect{|dir| "#{dir}#{fname}"}
+        files.select{|f| File.exist? f}
+      end
+      cache_method_with_params_in_production :find_files
+    end
+  end
+end
+  

data/lib/rad/environment/logger.rb

@@ -0,0 +1,21 @@
+rad.register :logger do
+  if defined?(SILENCE_LOGGER)
+    logger = Logger.new nil
+  else
+    config = rad[:config]
+    if config and config.runtime_dir? and File.exist?("#{config.runtime_dir}/log")
+      logger = ActiveSupport::BufferedLogger.new rad.config.log_path
+      logger.level = ActiveSupport::BufferedLogger.const_get config.log_level.to_s.upcase      
+      # logger.auto_flushing = false if config.production? and !config.stdout_logger(false)
+    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/rad/environment.rb

@@ -0,0 +1,55 @@
+# 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

data/lib/rad/html/flash.rb

@@ -0,0 +1,42 @@
+module Rad
+  class 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
+end

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

@@ -0,0 +1,83 @@
+module Rad
+  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

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

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

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

@@ -0,0 +1,115 @@
+module Rad  
+  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 = {}            
+      model_name.must_be.a String, Symbol
+      return 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, 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, 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
+end

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

@@ -0,0 +1,5 @@
+module Rad
+  module HtmlHelper
+    inherit BasicHtmlHelper, FormHelper, JavascriptHelper, FlashHelper
+  end
+end