adva-core 0.0.2 → 0.0.3

data/lib/adva/generators/install.rb

@@ -1,31 +0,0 @@
-module Adva
-  module Generators
-    class Install
-      include Thor::Shell
-
-      attr_reader :engines
-
-      def initialize(engines)
-        self.engines = engines
-      end
-
-      def invoke
-        engines.each do |engine|
-          engine.copy_migrations.each do |path|
-            say_status('copy migration', File.basename(path), :green)
-          end
-        end
-      end
-
-      protected
-
-        def engines=(engines)
-          engines = Array(engines)
-          engines = Adva.engines if engines.blank? || engines.include?(:all)
-          engines = engines.map { |engine| engine.is_a?(Class) ? engine : Adva.const_get(engine.to_s.classify) }
-          engines.unshift(Adva::Core) unless engines.include?(Adva::Core)
-          @engines = engines.uniq
-        end
-    end
-  end
-end

data/lib/adva/generators/templates/app/app_template.rb

@@ -1,3 +0,0 @@
-copy_file config[:source].join('lib/bundler/repository.rb'), "#{app_path}/lib/bundler/repository.rb"
-copy_file config[:source].join('Gemfile'), "#{app_path}/Gemfile"
-remove_file 'public/index.html'

data/lib/adva/generators/templates/engine/Gemfile.erb

@@ -1,3 +0,0 @@
-source :rubygems
-
-gemspec

data/lib/adva/generators/templates/engine/all.rb

@@ -1 +0,0 @@
-Dir[File.expand_path('../**/*_test.rb', __FILE__)].each { |file| require file }

data/lib/adva/generators/templates/engine/en.yml.erb

@@ -1,2 +0,0 @@
-en:
-  <%= name %>: ""

data/lib/adva/generators/templates/engine/engine.rb.erb

@@ -1,11 +0,0 @@
-require 'adva'
-
-module Adva
-  class <%= class_name %> < ::Rails::Engine
-    include Adva::Engine
-
-    # initializer 'adva-<%= name %>.require_section_types' do
-    #   config.to_prepare { require_dependency 'page' }
-    # end
-  end
-end

data/lib/adva/generators/templates/engine/gemspec.erb

@@ -1,21 +0,0 @@
-# encoding: utf-8
-
-# $: << File.expand_path('../lib', __FILE__)
-# require 'adva/<%= name %>/version'
-
-Gem::Specification.new do |s|
-  s.name         = "adva-<%= name %>"
-  s.version      = '0.0.1'
-  s.authors      = ["Ingo Weiss", "Sven Fuchs"]
-  s.email        = "nobody@adva-cms.org"
-  s.homepage     = "http://github.com/svenfuchs/adva-cms2"
-  s.summary      = "[summary]"
-  s.description  = "[description]"
-
-  s.files        = Dir['{app,config,lib,public}/**/*']
-  s.platform     = Gem::Platform::RUBY
-  s.require_path = 'lib'
-  s.rubyforge_project = '[none]'
-  
-  s.add_dependency 'adva-core'
-end

data/lib/adva/generators/templates/engine/migration.rb.erb

@@ -1,11 +0,0 @@
-class Adva<%= class_name %>CreateTables < ActiveRecord::Migration
-  def self.up
-    # create_table :<%= table_name %> do |t|
-    #   t.timestamps
-    # end
-  end
-
-  def self.down
-    # drop_table :<%= table_name %>
-  end
-end

data/lib/adva/generators/templates/engine/redirects.rb.erb

@@ -1,3 +0,0 @@
-# Adva::Registry.set :redirect, {
-#   'controller#action' => lambda { |controller| controller.show_url }
-# }

data/lib/adva/generators/templates/engine/routes.rb.erb

@@ -1,3 +0,0 @@
-# Rails.application.routes.draw do
-#   resource :<%= name %>
-# end

data/lib/adva/generators/templates/engine/test_helper.rb.erb

@@ -1,3 +0,0 @@
-require File.expand_path('../../../adva-core/test/test_helper', __FILE__)
-
-require 'adva-<%= name %>'

data/lib/adva/i18n.rb

@@ -1,73 +0,0 @@
-require 'i18n/exceptions'
-
-I18n.module_eval do
-  self.exception_handler = :log_missing_translations
-
-  class << self
-    attr_writer :missing_translations
-
-    def missing_translations
-      @missing_translations ||= MemoryLogger.new
-    end
-
-    def log_missing_translations(exception, locale, key, options)
-      missing_translations.log(exception.keys) if I18n::MissingTranslationData === exception
-      default_exception_handler(exception, locale, key, options)
-    end
-  end
-
-  class MemoryLogger < Hash
-    def initialize
-      at_exit { dump } if Rails.env.test?
-    end
-
-    def log(keys)
-      log = self
-      keys.each_with_index do |key, ix|
-        key = key.to_s
-        if ix < keys.size - 1
-          log = log.key?(key) ? log[key] : (log[key] = {})
-        else
-          log[key] = key.to_s.titleize
-        end
-      end
-    end
-
-    def dump
-      require 'yaml'
-      puts YAML.dump(Hash[*to_a.flatten]) unless empty?
-    end
-  end
-end
-
-# TODO move to I18n
-I18n.module_eval do
-  class << self
-    def handle_exception(exception, locale, key, options)
-      case handler = options[:exception_handler] || config.exception_handler
-      when Symbol
-        send(handler, exception, locale, key, options)
-      else
-        handler.call(exception, locale, key, options)
-      end
-    end
-
-    def wrap_exception(exception, locale, key, options)
-      case exception
-      when MissingTranslationData
-        %(<span class="translation_missing">#{exception.keys.join('.')}</span>)
-      else
-        raise exception
-      end
-    end
-  end
-end
-
-I18n::MissingTranslationData.class_eval do
-  def keys
-    options.each { |k, v| options[k] = v.inspect if v.is_a?(Proc) }
-    keys = I18n.normalize_keys(locale, key, options[:scope])
-    keys << 'no key' if keys.size < 2
-    keys
-  end
-end

data/lib/adva/rack.rb

@@ -1,5 +0,0 @@
-module Adva
-  module Rack
-    autoload :Static, 'adva/rack/static'
-  end
-end

data/lib/adva/rack/static.rb

@@ -1,50 +0,0 @@
-require 'active_support/core_ext/string/starts_ends_with'
-
-module Adva
-  module Rack
-    class Static
-      FILE_METHODS = %w(GET HEAD)
-      STATIC_PATHS = %w(/images/adva /javascripts/adva /stylesheets/adva)
-
-      attr_reader :app, :directories
-
-      def initialize(app)
-        @app = app
-        @directories = Adva.engines.map { |engine| ::Rack::File.new(engine.root.join('public')) }
-      end
-
-      def call(env)
-        path   = env['PATH_INFO'].chomp('/')
-        method = env['REQUEST_METHOD']
-
-        if FILE_METHODS.include?(method) && static?(path)
-          if directory = directories.detect { |directory| exist?(directory, path) }
-            return directory.call(env)
-          else
-            return not_found(path)
-          end
-        end
-
-        app.call(env)
-      end
-
-      def static?(path)
-        STATIC_PATHS.detect { |static_path| path.starts_with?(static_path)  }
-      end
-
-      def exist?(directory, path)
-        File.file?(File.join(directory.root, ::Rack::Utils.unescape(path)))
-      end
-
-      def not_found(path)
-        body = "File not found: #{path}\n"
-        headers = {
-          'Content-Type'   => 'text/plain',
-          'Content-Length' => body.size.to_s,
-          'X-Cascade'      => 'pass'
-        }
-        [404, headers, [body]]
-      end
-    end
-  end
-end

data/lib/adva/registry.rb

@@ -1,62 +0,0 @@
-# Global registry for storing common configuration.
-
-module Adva
-  class Registry < Hash
-    class << self
-      def instance
-        @@instance ||= new
-      end
-    
-      def get(*args)
-        instance.get(*args)
-      end
-    
-      def set(*args)
-        instance.set(*args)
-      end
-    
-      def clear
-        instance.clear
-      end
-    end
-
-    def initialize
-      super &lambda { |hash, key| hash[key] = Registry.new }
-    end
-
-    def set(*args)
-      value, last_key = args.pop, args.pop.to_sym
-      target = args.inject(self) { |result, key| result[key.to_sym] }
-
-      case value
-      when Hash
-        target[last_key].merge!(to_registry(value))
-      when Array
-        target[last_key] = Array(target[last_key]) unless target[last_key].is_a?(Array)
-        target[last_key] += value
-      else
-        target.merge!(last_key => value)
-      end
-    end
-
-    def get(*keys)
-      keys.map { |key| key.to_sym }.inject(self) do |result, key| 
-        return nil unless result.has_key?(key)
-        result[key]
-      end
-    end
-  
-    protected
-    
-      def merge!(other)
-        other.each { |key, value| self[key] = value }
-      end
-  
-      def to_registry(hash)
-        hash.inject(Registry.new) do |registry, (key, value)|
-          registry[key.to_sym] = value.is_a?(Hash) ? to_registry(value) : value
-          registry
-        end
-      end
-  end
-end

data/lib/adva/responder.rb

@@ -1,21 +0,0 @@
-require 'action_controller'
-require 'responders'
-
-module Adva
-  class Responder < ActionController::Responder
-    autoload :Redirect, 'adva/responder/redirect'
-
-    module Base
-      include Adva::Responder::Redirect
-      include Responders::FlashResponder
-      include Responders::HttpCacheResponder
-    end
-    include Base
-
-    delegate :params, :controller_path, :resource, :resources, :to => :controller
-
-    def action
-      controller.params[:action]
-    end
-  end
-end

data/lib/adva/responder/redirect.rb

@@ -1,31 +0,0 @@
-# Common redirect responder. Redirects to a :return_to param if present or an
-# entry in the Registry for the current controller/action (e.g. pages#update).
-
-module Adva
-  class Responder
-    module Redirect
-      def to_html
-        return_to_redirect || registry_redirect || super
-      end
-
-      def return_to_redirect
-        redirect_to(params[:return_to]) if !get? && params[:return_to] && !has_errors?
-      end
-
-      def registry_redirect
-        if !has_errors? && target = current_redirect
-          redirect_to(target)
-        end
-      end
-
-      def current_redirect
-        target = Registry.get(:redirect, controller_action_path)
-        target.respond_to?(:call) ? target.call(controller) : target
-      end
-
-      def controller_action_path
-        "#{controller_path}##{params[:action]}"
-      end
-    end
-  end
-end

data/lib/adva/routing_filters/section_path.rb

@@ -1,72 +0,0 @@
-require 'routing_filter'
-
-# If the path is, aside from a slash and an optional locale, the leftmost part
-# of the path, replace it by "sections/:id" segments.
-
-module RoutingFilter
-  class SectionPath < Filter
-    extend ActiveSupport::Memoizable
-
-    cattr_accessor :default_port
-    self.default_port = '80'
-
-    cattr_accessor :exclude
-    self.exclude = %r(^/admin)
-
-    def around_recognize(path, env, &block)
-      # p "#{self.class.name}: #{path}"
-      if !excluded?(path)
-        search, replace = recognition(host(env), path)
-        path.sub!(%r(^/([\w]{2,4}/)?(#{search})(?=/|\.|\?|$)), "/#{$1}#{replace}#{$3}") if search
-      end
-      yield
-    end
-
-    def around_generate(params, &block)
-      yield.tap do |path|
-        # p "#{self.class.name}: #{path}"
-        if !excluded?(path)
-          search, replace = *generation(path)
-          path.sub!(search) { "#{replace}#{$3}" } if search
-          path.replace("/#{path}") unless path[0, 1] == '/'
-        end
-      end
-    end
-
-    protected
-
-      def excluded?(path)
-        path =~ exclude
-      end
-
-      def recognition(host, path)
-        if site = Site.by_host(host) and path =~ recognition_pattern(site)
-          section = site.sections.where(:path => $2).first
-          [$2, "#{$1}#{section.type.pluralize.downcase}/#{section.id}"]
-        end
-      end
-
-      def recognition_pattern(site)
-        paths = site.sections.map(&:path).reject(&:blank?)
-        paths = paths.sort { |a, b| b.size <=> a.size }.join('|')
-        paths.empty? ? %r(^$) : %r(^/([\w]{2,4}/)?(#{paths})(?=/|\.|\?|$))
-      end
-
-      def generation(path)
-        if path =~ generate_pattern
-          section = Section.find($2.to_i)
-          ["/#{$1}/#{$2}", "#{section.path}#{$3}"]
-        end
-      end
-
-      def generate_pattern
-        types = Section.types.map { |type| type.downcase.pluralize }.join('|')
-        %r(/(sections|#{types})/([\d]+(/?))(\.?))
-      end
-
-      def host(env)
-        host, port = env.values_at('SERVER_NAME', 'SERVER_PORT')
-        port == default_port ? host : [host, port].compact.join(':')
-      end
-  end
-end

data/lib/adva/routing_filters/section_root.rb

@@ -1,65 +0,0 @@
-require 'routing_filter'
-
-module RoutingFilter
-  class SectionRoot < Filter
-    extend ActiveSupport::Memoizable
-
-    cattr_accessor :default_port
-    self.default_port = '80'
-
-    cattr_accessor :exclude
-    self.exclude = %r(^/admin)
-
-    cattr_accessor :anchors
-    self.anchors = %w(article)
-
-    def around_recognize(path, env, &block)
-      # p "#{self.class.name}: #{path}"
-      if !excluded?(path)
-        search, replace = *recognition(host(env))
-        path.sub!(search) { "#{$1}#{replace}#{$2}" } if search
-      end
-      yield
-    end
-
-    def around_generate(params, &block)
-      yield.tap do |path|
-        # p "#{self.class.name}: #{path}"
-        remove_root_section!(path) unless excluded?(path)
-      end
-    end
-
-    protected
-
-      def excluded?(path)
-        path =~ exclude
-      end
-
-      def recognition(host)
-        if site = Site.by_host(host) and root = site.sections.root
-          [%r(^(/[\w]{2})?(?:\/?)(#{anchors.join('|')}|\.|\?|/?\Z)), "/#{root.type.tableize}/#{root.id}"]
-        end
-      end
-
-      def anchors
-        @anchors ||= self.class.anchors.map { |anchor| "/#{anchor}" }
-      end
-
-      def remove_root_section!(path)
-        path.sub!(%r(#{$2}/#{$3}/?), '') if path =~ generate_pattern && home?($3)
-      end
-
-      def generate_pattern
-        @generate_pattern ||= %r(^(?:/[\w]{2})?(/(#{Section.types.map(&:tableize).join('|')})/([\d]+)(?:/|\.|\?|$)))
-      end
-
-      def home?(id)
-        Section.find(id.to_i).try(:home?)
-      end
-
-      def host(env)
-        host, port = env.values_at('SERVER_NAME', 'SERVER_PORT')
-        port == default_port ? host : [host, port].compact.join(':')
-      end
-  end
-end