adva-core 0.0.2 → 0.0.3

data/lib/adva/controller/internal_redirect.rb

@@ -1,26 +0,0 @@
-# Internally redirects a request to another controller. This is used by the
-# abstract_actions module.
-
-module Adva
-  module Controller
-    module InternalRedirect
-      def internal_redirect_to(target, params = nil)
-        action, controller = target.split('#').reverse
-        controller ||= controller_path
-
-        params ||= self.params
-        params.merge!(:controller => controller, :action => action)
-        params = yield(params) if block_given?
-
-        rack_endpoint = "#{controller}_controller".classify.constantize.action(action)
-        env['action_dispatch.request.parameters'] = params
-        response = rack_endpoint.call(env)
-
-        self.status, self.headers, self.response_body = response
-        @_response.headers.replace(response[1])
-
-        response
-      end
-    end
-  end
-end

data/lib/adva/controller/references.rb

@@ -1,28 +0,0 @@
-require 'action_controller'
-
-begin
-  require 'reference_tracking'
-rescue LoadError
-end
-
-# Stub methods for ReferenceTracking. Will only be used if ReferenceTracking
-# (which is only required by adva-cache) is not available.
-
-module Adva
-  module Controller
-    module References
-      module Stubs
-        def self.included(base)
-          base.class_eval do
-            def self.tracks(*); end
-            def self.purges(*); end
-          end
-        end
-        def purge?(*); end
-      end
-      
-      ActionController::Base.send(:include, Stubs) unless defined?(ReferenceTracking)
-    end
-  end
-end
-

data/lib/adva/core.rb

@@ -1,85 +0,0 @@
-require 'rails'
-require 'rails/engine'
-require 'adva'
-
-require 'simple_form'
-require 'simple_slugs'
-require 'simple_nested_set'
-require 'simple_slugs'
-require 'has_many_polymorphs'
-require 'minimal'
-require 'silence_log_tailer'
-
-require 'adva/i18n'
-require 'adva/routing_filters/section_path'
-require 'adva/routing_filters/section_root'
-require 'adva/controller/abstract_actions'
-require 'adva/controller/references'
-require 'adva/active_record/has_options'
-require 'adva/view/form'
-require 'adva/view/helper/i18n'
-require 'adva/view/tabs'
-
-require 'core_ext/ruby/module/include_anonymous'
-require 'core_ext/rails/action_view/has_many_through_collection_helpers'
-require 'core_ext/rails/active_record/skip_callbacks'
-
-module Adva
-  class Core < ::Rails::Engine
-    include Adva::Engine
-
-    initializer 'adva-core.register_middlewares.static' do
-      config.app_middleware.insert_before 'Rack::Lock', Adva::Rack::Static
-    end
-
-    initializer 'adva-core.require_section_types' do
-      config.to_prepare { require_dependency 'page' }
-    end
-
-    initializer 'adva-core.setup_minimal' do
-      require 'inherited_resources/helpers'
-
-      Minimal::Template::FormBuilderProxy::PROXY_TAGS << :simple_form_for << :simple_fields_for
-      Minimal::Template.class_eval do
-        include Minimal::Template::FormBuilderProxy
-        include Minimal::Template::TranslatedTags
-        include InheritedResources::Helpers::LinkTo
-        include FormHelper
-      end
-      ActionView::Template.register_template_handler('rb', Minimal::Template::Handler)
-    end
-
-    initializer 'adva-core.register_asset_expansions' do
-      ActionView::Helpers::AssetTagHelper.register_javascript_expansion(
-        :common  => %w(),
-        :simple  => %w(),
-        :default => %w(),
-        :admin   => %w( adva-core/jquery/jquery-1.4.2.min.js
-                        adva-core/jquery/jquery.tablednd_0_5.js
-                        adva-core/jquery/jquery.table_tree.js
-                        adva-core/rails
-                        adva-core/admin )
-      )
-
-      ActionView::Helpers::AssetTagHelper.register_stylesheet_expansion(
-        :common  => %w( adva-core/common/reset
-                        adva-core/common/layout
-                        adva-core/common/styles
-                        adva-core/common/forms ),
-
-        :simple  => %w( adva-core/simple/layout ),
-
-        :default => %w( adva-core/default/layout
-                        adva-core/default/styles ),
-
-        :admin   => %w( adva-core/common/reset
-                        adva-core/admin/layout
-                        adva-core/admin/navigation
-                        adva-core/admin/sidebar
-                        adva-core/admin/styles
-                        adva-core/admin/forms
-                        adva-core/admin/lists )
-      )
-    end
-  end
-end

data/lib/adva/engine.rb

@@ -1,64 +0,0 @@
-# Common behaviour that we want included in all adva engines
-
-module Adva
-  module Engine
-    autoload :SlicedModels, 'adva/engine/sliced_models'
-
-    class << self
-      def included(base)
-        base.class_eval do
-          include Initializations # ugh. why does these need to be both class
-          extend Initializations  # and instance methods?
-
-          engine_name = base.name.underscore.split('/').last
-
-          config.autoload_paths << paths.app.views.to_a.first
-
-          paths.lib.tasks = Dir[root.join('lib/adva/tasks/*.*')]
-
-          initializer "adva-#{engine_name}.require_patches" do |app|
-            require_patches
-          end
-
-          initializer "adva-#{engine_name}.load_redirects" do |app|
-            load_redirects
-          end
-
-          initializer "adva-#{engine_name}.preload_sliced_models" do |app|
-            engine = self
-            config.to_prepare { engine.preload_sliced_models }
-          end
-        end
-      end
-    end
-
-    module Initializations
-      include SlicedModels
-
-      def engine_name
-        name = is_a?(Class) ? self.name : self.class.name # ughugh.
-        name.underscore.split('/').last
-      end
-
-      def require_patches
-        Dir[root.join('lib/patches/**/*.rb')].each { |patch| require patch }
-      end
-
-      def load_redirects
-        begin
-          load root.join('config/redirects.rb')
-        rescue LoadError
-        end
-      end
-
-      def copy_migrations
-        Dir[root.join('db/migrate/*')].map do |source|
-          target = File.expand_path(source.gsub(root.to_s, '.'))
-          FileUtils.mkdir_p(File.dirname(target))
-          FileUtils.cp(source, target)
-          target
-        end
-      end
-    end
-  end
-end

data/lib/adva/engine/sliced_models.rb

@@ -1,35 +0,0 @@
-module Adva
-  module Engine
-    module SlicedModels
-      # TODO while preloading seems to work fine, it slows the dev mode down
-      # quite a bit. should be replace with an approace which lazyloads sliced
-      # models in Dependencies maybe an after-load hook in Dependencies would
-      # work.
-      def preload_sliced_models
-        types = %w(helpers controllers models views)
-        paths = types.map { |type| self.paths.app.send(type).to_a.first }
-        pattern = %r((?:#{paths.join('|')})/((?:\w+/)*\w+_slice(?:.\w+)*).rb$)
-
-        Dir["{#{paths.join(',')}}/**/*.rb"].each do |filename|
-          if filename =~ pattern
-            begin
-              require_dependency $1.gsub(%r(_slice), '')
-              require_dependency filename
-            rescue LoadError
-            end
-          end
-        end
-      end
-    end
-  end
-end
-
-require 'rails'
-
-Rails::Application.class_eval do
-  include Adva::Engine::SlicedModels
-
-  initializer "application.preload_sliced_models" do |app|
-    config.to_prepare { app.preload_sliced_models }
-  end
-end

data/lib/adva/generators.rb

@@ -1,8 +0,0 @@
-module Adva
-  module Generators
-    autoload :App,     'adva/generators/app'
-    autoload :Engine,  'adva/generators/engine'
-    autoload :Gemfile, 'adva/generators/gemfile'
-    autoload :Install, 'adva/generators/install'
-  end
-end

data/lib/adva/generators/app.rb

@@ -1,121 +0,0 @@
-STDOUT.sync = true
-
-require 'fileutils'
-require 'active_record'
-require 'active_support/core_ext/hash/reverse_merge'
-require 'rails/generators'
-require 'rails/generators/rails/app/app_generator'
-require 'core_ext/ruby/module/option_reader'
-
-module Adva
-  module Generators
-    class App
-      DEFAULT_OPTIONS = {
-        :source    => File.expand_path('../../../../..', __FILE__),
-        :target    => File.expand_path('.'),
-        :template  => File.expand_path('../templates/app/app_template.rb', __FILE__),
-        :engines   => [:all],
-        :resources => false,
-        :migrate   => false,
-        :bundle    => false,
-        :force     => false
-      }
-
-      def initialize(name, options = {}, &block)
-        @options = options.reverse_merge!(DEFAULT_OPTIONS)
-        @name    = name || File.basename(source)
-        raise ArgumentError, "#{source.inspect} is not a directory" unless File.directory?(source)
-      end
-
-      def invoke
-        if force? || build?
-          build
-          generate_resources  if generate_resources?
-          bundle              if bundle?
-          load_environment    if block_given? || migrate?
-          exec(&block)        if block_given?
-          install
-          migrate             if migrate?
-        else
-          load_environment
-        end
-      end
-
-      protected
-
-        attr_reader :name
-        option_reader :source, :target, :template, :engines, :resources, :migrate, :bundle, :force
-
-        def root
-          "#{target}/#{name}"
-        end
-
-        def build
-          puts "Building application ..."
-          FileUtils.rm_r(root) if File.exists?(root)
-          in_root do
-            options = force? || ENV.key?('REGENERATE_APP') ? ['-f'] : []
-            generator = Rails::Generators::AppGenerator.new([root], options, :shell => shell)
-            generator.invoke_all
-            generator.apply(template, :source => Pathname.new(source))
-            FileUtils.cp("#{source}/Thorfile", "#{root}/Thorfile")
-          end
-        end
-
-        def install
-          puts "Installing adva engines ..."
-          in_root { Adva::Generators::Install.new(engines).invoke }
-        end
-
-        def migrate
-          puts "Migrating database ..."
-          in_root { ActiveRecord::Migrator.migrate('db/migrate/') }
-        end
-
-        def bundle
-          puts "Bundling gems ..."
-          in_root { run 'bundle install' }
-        end
-
-        def load_environment
-          puts "Loading environment ..."
-          in_root { require "config/environment" }
-        end
-
-        def generate_resources
-          puts "Generating resources ..."
-          FileUtils.cp(resources, "#{root}/config/resource_layout.rb")
-          run "rails generate resource_layout --generator=ingoweiss:scaffold"
-        end
-
-        def exec(&block)
-          in_root { self.instance_exec(&block) }
-        end
-
-        def build?
-          ENV.key?('REGENERATE_APP') || !exists?
-        end
-
-        def generate_resources?
-          resources && File.exists?(resources)
-        end
-
-        def exists?
-          File.exists?(root)
-        end
-
-        def in_root(&block)
-          FileUtils.mkdir_p(root) unless File.directory?(root)
-          Dir.chdir(root) { yield }
-        end
-
-        def run(command, &block)
-          in_root { system "#{command}" }
-        end
-
-        def shell
-          Thor::Shell::Color.new
-        end
-    end
-  end
-end

data/lib/adva/generators/engine.rb

@@ -1,58 +0,0 @@
-require 'rails/generators'
-
-module Adva
-  module Generators
-    class Engine < Rails::Generators::Base
-      source_root File.expand_path('../templates/engine', __FILE__)
-      
-      attr_reader :name
-      
-      def initialize(name, options = {})
-        @name = name
-        super()
-      end
-      
-      def build
-        empty_directory "adva-#{name}"
-        template        "gemspec.erb", "adva-#{name}/adva-#{name}.gemspec"
-        template        'Gemfile.erb', "adva-#{name}/Gemfile"
-
-        empty_directory "adva-#{name}/app"
-        empty_directory "adva-#{name}/app/controllers"
-        empty_directory "adva-#{name}/app/models"
-        empty_directory "adva-#{name}/app/views"
-
-        empty_directory "adva-#{name}/config"
-        empty_directory "adva-#{name}/config/locales"
-        template        'en.yml.erb',  "adva-#{name}/config/locales/en.yml"
-        template        'redirects.rb.erb', "adva-#{name}/config/redirects.rb"
-        template        'routes.rb.erb', "adva-#{name}/config/routes.rb"
-
-        empty_directory "adva-#{name}/db/migrate"
-        template        'migration.rb.erb', "adva-#{name}/db/migrate/#{migration_timestamp}_adva_#{name}_create_tables.rb"
-
-        empty_directory "adva-#{name}/lib/adva"
-        create_file     "adva-#{name}/lib/adva-#{name}.rb", "require 'adva/#{name}'"
-        template        'engine.rb.erb', "adva-#{name}/lib/adva/#{name}.rb"
-
-        empty_directory "adva-#{name}/test"
-        template        'all.rb', "adva-#{name}/test/all.rb"
-        template        'test_helper.rb.erb', "adva-#{name}/test/test_helper.rb"
-      end
-      
-      protected
-
-        def migration_timestamp
-          Time.now.strftime('%Y%m%d%H%M%S')
-        end
-
-        def table_name
-          name.tableize
-        end
-        
-        def class_name
-          name.camelize
-        end
-    end
-  end
-end

data/lib/adva/generators/gemfile.rb

@@ -1,50 +0,0 @@
-module Adva
-  module Generators
-    class Gemfile
-      attr_reader :source, :target, :engines
-
-      def initialize(target, options = {})
-        self.engines = options[:engines]
-        @target  = Pathname.new(target)
-        @source  = options[:source] || raise('no source given') # TODO should bubble up to find the current Gemfile
-        @engines = engines
-      end
-
-      def write
-        File.open(target, 'w+') { |f| f.write(with_engines) }
-      end
-
-      protected
-
-        def engines=(engines)
-          engines = engine_names if engines.blank? || Array(engines).include?(:all)
-          engines.unshift(:core) unless engines.include?(:core)
-          @engines = engines.map(&:to_sym).uniq
-        end
-
-        def with_engines
-          lines.join.sub(adva_gem_lines.join, engine_lines.join("\n"))
-        end
-
-        def engine_lines
-          engines.map { |engine| engine_line(engine) }
-        end
-
-        def engine_line(engine)
-          "gem 'adva-#{engine}', :path => '#{File.expand_path("../adva-#{engine}", source)}'"
-        end
-
-        def engine_names
-          Adva.engines.map { |engine| engine.name.demodulize.underscore.to_sym }
-        end
-
-        def adva_gem_lines
-          @adva_gem_lines ||= lines.select { |line| line =~ /gem ("|')adva-/ }
-        end
-
-        def lines
-          @lines ||= File.readlines(source)
-        end
-    end
-  end
-end