adva-core 0.0.1

data/lib/adva/controller/references.rb

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

@@ -0,0 +1,84 @@
+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 'routing_filter'
+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/tabs'
+require 'adva/view/form'
+
+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

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

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

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

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

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

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