adva-core 0.0.2 → 0.0.3

data/lib/adva/tasks/core.rake

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

@@ -1,160 +0,0 @@
-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
-          # TODO submit a patch to Cucumber: programatically find out supported Cucumber options seems
-          # close to impossible bc/ 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
-

data/lib/adva/testing.rb

@@ -1,57 +0,0 @@
-module Adva
-  module Testing
-    autoload :Engine, 'adva/testing/engine'
-
-    Rails::Engine.extend(Engine)
-
-    class << self
-      def setup(options = {})
-        Adva.out = StringIO.new('')
-        setup_logging(options)
-        setup_active_record
-
-        each_engine { |e| e.setup_load_paths }
-        each_engine { |e| e.migrate }
-        each_engine { |e| e.require_patches }
-        each_engine { |e| e.preload_sliced_models }
-
-        load_assertions
-        load_factories
-      end
-
-      def each_engine(&block)
-        Adva.engines.each(&block)
-      end
-
-      def load_assertions
-        Adva.engines.each { |e| e.load_assertions }
-      end
-
-      def load_factories
-        Adva.engines.each { |e| e.load_factories }
-      end
-
-      def load_cucumber_support
-        Adva.engines.each { |e| e.load_cucumber_support }
-      end
-
-      def load_helpers
-        Adva.engines.each { |e| e.load_helpers }
-      end
-
-      def setup_logging(options)
-        if log = options[:log]
-          FileUtils.touch(log) unless File.exists?(log)
-          ActiveRecord::Base.logger = Logger.new(log)
-          ActiveRecord::LogSubscriber.attach_to(:active_record)
-        end
-      end
-
-      def setup_active_record
-        ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => ':memory:')
-        ActiveRecord::Migration.verbose = false
-        DatabaseCleaner.strategy = :truncation
-      end
-    end
-  end
-end

data/lib/adva/testing/engine.rb

@@ -1,37 +0,0 @@
-module Adva
-  module Testing
-    module Engine
-      def setup_load_paths
-        paths.app.each { |path| $:.unshift(path) if File.directory?(path) }
-        ActiveSupport::Dependencies.autoload_paths.unshift(*paths.app)
-      end
-
-      def migrate
-        ActiveRecord::Migrator.up(root.join('db/migrate'))
-      end
-
-      def load_assertions
-        load_all('lib/testing/assertions')
-      end
-
-      def load_factories
-        load_all('lib/testing/factories')
-      end
-
-      def load_cucumber_support
-        load_all('lib/testing/step_definitions')
-        load_all('lib/testing/paths')
-      end
-
-      def load_helpers
-        load_all('lib/testing/helpers')
-      end
-
-      def load_all(search)
-        Pathname.glob(root.join("#{search}{.rb,/*.rb}")).each do |file|
-          require(file) if file.exist?
-        end
-      end
-    end
-  end
-end

data/lib/adva/view.rb

@@ -1,7 +0,0 @@
-module Adva
-  module View
-    autoload :Form, 'adva/view/form'
-    autoload :Menu, 'adva/view/menu'
-    autoload :Tabs, 'adva/view/tabs'
-  end
-end

data/lib/adva/view/form.rb

@@ -1,44 +0,0 @@
-module Adva
-  module View
-    class Form < Minimal::Template
-      autoload :Tabs, 'adva/view/form/tabs'
-      include Tabs
-
-      attr_reader :form
-
-      def to_html
-        form_tag
-      end
-
-      def form_tag
-        simple_form_for(*form_arguments) do |form|
-          @form = form
-          fields
-          button_group
-        end
-      end
-
-      def form_arguments
-        [resources]
-      end
-
-      def button_group
-        content_tag(:div, :class => 'buttons') do
-          buttons
-        end
-      end
-
-      def buttons
-        form.button :submit
-      end
-
-      def return_here
-        hidden_field_tag :return_to, request.url
-      end
-
-      def pass_return_to
-        hidden_field_tag :return_to, params[:return_to]
-      end
-    end
-  end
-end

data/lib/adva/view/form/tabs.rb

@@ -1,46 +0,0 @@
-module Adva
-  module View
-    class Form
-      module Tabs
-        def form_for(*args, &block)
-          super(*args, &with_tabs(block))
-        end
-
-        def simple_form_for(*args, &block)
-          super(*args, &with_tabs(block))
-        end
-
-        def with_tabs(block)
-          if respond_to?(:sidebar)
-            lambda do |*args|
-              block.call(*args)
-              sidebar
-
-              div :class => :tabs do
-                ul do
-                  controller.tabs.each do |tab|
-                    li(:class => tab.active? ? :active : '') do
-                      link_to(:"admin.tabs.#{tab.name}", "##{tab.name}")
-                    end
-                  end
-                end
-                controller.tabs.each do |tab|
-                  div :id => "tab_#{tab.name}", :class => "tab #{tab.active? ? :active : ''}" do
-                    tab.blocks.each { |block| block.call }
-                  end
-                end
-              end
-            end
-          else
-            block
-          end
-        end
-
-        # should store the tabs on the form builder object instead of the controller
-        def tab(*args, &block)
-          controller.tabs.tab(*args, &block)
-        end
-      end
-    end
-  end
-end

data/lib/adva/view/helper/i18n.rb

@@ -1,26 +0,0 @@
-I18n::Backend::Simple.send(:include, I18n::Backend::Cascade)
-
-# TODO no idea how to use a module here :/
-ActionView::Base.class_eval do
-  def translate(key, options = {})
-    # TODO must be fixed in I18n::Backend::Cascade
-    options.merge!(:cascade => { :step => 1, :offset => 2, :skip_root => false }) if key.to_s.include?('.')
-    super(key, options)
-  end
-  alias t translate
-end
-
-# TODO submit a Rails patch
-ActionView::Helpers::TranslationHelper.module_eval do
-  def translate(key, options = {})
-    options.merge!(:wrap_exception => true) unless options.key?(:wrap_exception)
-    translation = I18n.translate(scope_key_by_partial(key), options)
-    if html_safe_translation_key?(key) && translation.respond_to?(:html_safe)
-      translation.html_safe
-    else
-      translation
-    end
-  end
-  alias :t :translate
-end
-

data/lib/adva/view/menu.rb

@@ -1,73 +0,0 @@
-module Adva
-  module View
-    class Menu < Minimal::Template
-      autoload :Admin, 'adva/view/menu/admin'
-      autoload :Items, 'adva/view/menu/items'
-
-      def to_html
-        build
-        render_items
-      end
-
-      def item(text, url = nil, options = {}, &block)
-        items.insert(text, url, options, block)
-      end
-
-      def label(text, url = nil, options = {}, &block)
-        item(text, url, options.merge(:type => :label), &block)
-      end
-
-      protected
-        def items
-          @items ||= Items.new
-        end
-
-        def render_items
-          items, @items = self.items, Items.new
-          items.each { |args| render_item(*args) }
-        end
-
-        def render_item(text, url, options, block)
-          options.merge!(:class => text.to_s.split('.').last) if text.is_a?(Symbol)
-          url = url_for(url) unless url.is_a?(String) || options[:type] == :label
-
-          li(:class => active?(url, options) ? 'active' : nil) do
-            options[:type] == :label ? h4(text, options) : link_to(text, url, options)
-            render_block(block) if block
-          end
-        end
-
-        def render_block(block)
-          self << capture do
-            instance_eval(&block)
-            render_items
-          end
-        end
-
-        def name
-          @name ||= self.class.name.demodulize.underscore
-        end
-
-        def css_classes
-          ['menu', name].uniq
-        end
-
-        def active?(url, options)
-          activate = options.key?(:activate) ? options.delete(:activate) : true
-          delete   = options[:method] == :delete
-          activate && !delete && active_paths.include?(url)
-        end
-
-        def active_paths
-          @active_paths ||= path_and_parents(controller.request.fullpath)
-        end
-
-        def path_and_parents(path)
-          path.split('/').inject([]) do |paths, segment|
-            path = [paths.last == '/' ? '' : paths.last, segment].compact.join('/')
-            paths << (path.empty? ? '/' : path)
-          end
-        end
-    end
-  end
-end