adva-core 0.0.3 → 0.0.4

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

data/lib/adva/rack.rb

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

data/lib/adva/rack/static.rb

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

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

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

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

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

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

data/lib/adva/tasks/core.rake

@@ -0,0 +1,9 @@
+require 'rake'
+require 'adva/tasks/core'
+
+namespace :adva do
+  desc 'Install adva'
+  task :install do
+    Adva::Tasks::Install.start
+  end
+end

data/lib/adva/tasks/core.rb

@@ -0,0 +1,160 @@
+require 'thor'
+require 'thor/group'
+require 'patches/thor/core_ext/hash'
+require 'patches/thor/group/symbolized_options'
+require 'rails/engine'
+
+module Adva
+  module Tasks
+    class App < Thor::Group
+      namespace 'adva:app'
+      desc 'Create a new adva app'
+      argument :name, :required => false
+      class_option :target,   :required => false
+      class_option :engines,  :required => false, :type => :array
+      class_option :install,  :required => false, :type => :boolean
+      class_option :migrate,  :required => false, :type => :boolean, :default => true
+      class_option :template, :required => false
+      class_option :force,    :required => false, :type => :boolean, :default => true
+
+      def perform
+        Adva::Generators::App.new(name, symbolized_options).invoke
+      end
+    end
+
+    class Engine < Thor::Group
+      namespace 'adva:engine'
+      desc 'Create an adva engine'
+      argument :name
+
+      def perform
+        require 'adva/generators/engine'
+        Adva::Generators::Engine.new(name, symbolized_options).invoke_all
+      end
+    end
+
+    class Install < Thor::Group
+      namespace 'adva:install'
+      desc 'Install adva engines'
+      class_option :engines, :required => false, :type => :array
+
+      def install
+        Adva::Generators::Install.new(symbolized_options).invoke
+      end
+    end
+
+    module Test
+      module Cucumber
+        def cucumber_args
+          args = cucumber_options + cucumber_files
+          args.flatten.compact
+        end
+
+        def cucumber_files
+          paths = Adva.engines.map { |engine| engine.root.join('features/**/*.feature').to_s }
+          paths = paths.select { |path| path.include?(pattern) } if pattern
+          Dir["{#{paths.join(',')}}"].sort
+        end
+
+        def cucumber_pattern
+          self.respond_to?(:pattern) ? self.pattern : ''
+        end
+
+        def cucumber_options
+          # programatically find out supported Cucumber options seems close to impossible because it
+          # immediately calls parse! on its options as soon they are defined.
+          # see http://github.com/aslakhellesoy/cucumber/blob/master/lib/cucumber/cli/options.rb#L261
+          options = self.options.reject { |name, value| name.include?('rebuild') }
+          options.map { |name, value| ["--#{name}", value.is_a?(String) ? value : nil] }.flatten.compact
+        end
+      end
+
+      class All < Thor::Group
+        namespace 'test:all'
+        desc 'run all features and tests'
+        class_option :rebuild, :aliases => '-r', :required => false
+
+        include Cucumber
+
+
+        def all
+          require 'cucumber'
+          ENV['REGENERATE_APP'] = true if options['rebuild']
+          Rails.env = 'test'
+          passed = !::Cucumber::Cli::Main.execute(cucumber_args) # returns true on failure
+
+          Dir['**/test/**/*_test.rb'].each { |file| require file }
+          passed &= test_runner.run # returns true on pass
+
+          exit(passed ? 0 : 1)
+        end
+
+        protected
+
+          # GOSHHHH. maybe we really should switch to minitest.
+
+          def test_runner
+            require 'test/unit'
+            ::Test::Unit::AutoRunner.new(false).tap do |runner|
+              runner.collector = lambda { |r| test_collector.new.collect($0.sub(/\.rb\Z/, '')) }
+            end
+          end
+
+          def test_collector
+            require 'test/unit/collector/objectspace'
+            require 'mocha/integration/test_unit'
+            Class.new(::Test::Unit::Collector::ObjectSpace) do
+              def collect(name=NAME)
+                suite, sub_suites = ::Test::Unit::TestSuite.new(name), []
+                @source.each_object(Class) do |klass|
+                  if klass < ::Test::Unit::TestCase && klass != ::Cucumber::Rails::World
+                    add_suite(sub_suites, klass.suite)
+                  end
+                end
+                sort(sub_suites).each { |s| suite << s }
+                suite
+              end
+            end
+          end
+      end
+
+      class Features < Thor::Group
+        namespace 'test:features'
+        desc 'run cucumber features'
+        argument :pattern, :required => false, :default => '/features'
+        class_option :rebuild,   :aliases => '-r', :required => false, :default => false
+        class_option :format,    :aliases => '-f', :required => false, :default => 'pretty'
+        class_option :tags,      :aliases => '-t', :required => false, :default => '~@wip'
+        class_option :name,      :aliases => '-n', :required => false
+        class_option :exclude,   :aliases => '-e', :required => false
+        class_option :backtrace, :aliases => '-b', :required => false, :default => true
+        class_option :wip,       :aliases => '-w', :required => false
+
+        include Cucumber
+
+        def features
+          require 'cucumber'
+          ENV['REGENERATE_APP'] = 'true' if options['rebuild']
+          Rails.env = 'test'
+
+          passed = !::Cucumber::Cli::Main.execute(cucumber_args) # returns true on failure
+          exit(passed ? 0 : 1)
+        end
+      end
+
+      class Unit < Thor::Group
+        namespace 'test:unit'
+        desc 'run tests'
+        argument     :pattern, :required => false, :default => '**/test/**/*_test.rb'
+        class_option :name,    :required => false, :desc => 'Runs tests matching NAME. Patterns may be used.' # Runs tests matching NAME.
+
+        def unit
+          Rails.env = 'test'
+          Dir[pattern].each { |file| require file }
+          exit($1.exitstatus) if $1.exited? && $1.exitstatus != 0
+        end
+      end
+    end
+  end
+end
+