rad_core 0.0.13 → 0.0.14

data/lib/rad/environment/dependency_resolver.rb

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

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

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

@@ -1,21 +0,0 @@
-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/html/flash.rb

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

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

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

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

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

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

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

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

@@ -1,135 +0,0 @@
-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/http/http.rb

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

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