adva-core 0.0.1

data/lib/adva/testing.rb

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

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

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

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

@@ -0,0 +1,46 @@
+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/menu.rb

@@ -0,0 +1,51 @@
+module Adva
+  module View
+    class Menu < Minimal::Template
+      autoload :Admin, 'adva/view/menu/admin'
+
+      def item(text, url = nil, options = {}, &block)
+        options.merge!(:class => text.to_s.gsub('.', '')) if text.is_a?(Symbol)
+        url = url_for(url) unless url.is_a?(String)
+        li(:class => active?(url, options) ? 'active' : nil) do
+          options[:type] == :label ? h4(text, options) : link_to(text, url, options)
+          self << capture { instance_eval(&block) } if block_given?
+        end
+      end
+
+      def label(text, url = nil, options = {}, &block)
+        item(text, url, options.merge(:type => :label), &block)
+      end
+
+      def link(text, url = '#', options = {}, &block)
+        item(text, url, options.merge(:type => :link), &block)
+      end
+
+      protected
+
+        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

data/lib/adva/view/menu/admin.rb

@@ -0,0 +1,48 @@
+# Base class for admin menus. Encapsulates assumptions made by the admin layout.
+
+module Adva
+  module View
+    class Menu
+      class Admin < Menu
+        def self.id(id)
+          write_inheritable_attribute(:id, id)
+        end
+
+        class Actions < Admin
+          id :actions
+        end
+
+        def to_html
+          div :id => id, :class => 'menus' do
+            menus
+          end
+        end
+
+        def menus
+          ul :class => 'menu main' do
+            main
+          end
+          ul :class => 'menu right' do
+            right
+          end
+        end
+
+        def main
+        end
+
+        def right
+        end
+
+        protected
+
+          def id
+            self.class.read_inheritable_attribute(:id)
+          end
+
+          def persisted?
+            resource.try(:persisted?)
+          end
+      end
+    end
+  end
+end

data/lib/adva/view/tabs.rb

@@ -0,0 +1,28 @@
+module Adva
+  module View
+    class Tabs < Array
+      class Tab
+        attr_reader :tabs, :name
+
+        def initialize(tabs, name)
+          @tabs = tabs
+          @name = name
+        end
+
+        def active?
+          self == tabs.first
+        end
+
+        def blocks
+          @blocks ||= []
+        end
+      end
+
+      def tab(name, &block)
+        tab = detect { |tab| tab.name == name }
+        self << tab = Tab.new(self, name) unless tab
+        tab.blocks << block
+      end
+    end
+  end
+end

data/lib/core_ext/rails/action_view/has_many_through_collection_helpers.rb

@@ -0,0 +1,27 @@
+require 'action_view/helpers/form_helper'
+
+ActionView::Helpers::FormBuilder.send :include do
+  def has_many_through_collection_check_boxes(attribute, collection, label_attribute)
+    through_class = object.class.reflect_on_association(attribute).class_name.constantize
+    foreign_key = through_class.reflect_on_all_associations(:belongs_to).detect { |r| r.class_name != object.class.name }.primary_key_name
+
+    html = ''
+    collection.each_with_index do |item, ix|
+      param   = "#{object_name}[#{attribute}_attributes][#{ix}]"
+      through = object.send(attribute).detect { |t| t.send(foreign_key) == item.id }
+
+      if through
+        html << @template.hidden_field_tag("#{param}[id]", through.id, :id => '')
+        html << @template.hidden_field_tag("#{param}[_destroy]", '1', :id => '')
+        html << @template.label_tag("#{param}[_destroy]", :class => 'checkbox') do
+          @template.check_box_tag("#{param}[_destroy]", '0', true) + item.send(label_attribute)
+        end
+      else
+        html << @template.label_tag("#{param}[#{foreign_key}]", :class => 'checkbox') do
+          @template.check_box_tag("#{param}[#{foreign_key}]", item.id) + item.send(label_attribute)
+        end
+      end
+    end
+    html.html_safe
+  end
+end

data/lib/core_ext/rails/active_record/skip_callbacks.rb

@@ -0,0 +1,51 @@
+require 'active_support/basic_object'
+
+ActiveRecord::Base.class_eval do
+  class WithoutCallbacks < ActiveSupport::BasicObject
+    def initialize(target, types)
+      @target = target
+      @types  = types
+    end
+
+    def respond_to?(method, include_private = false)
+      @target.respond_to?(method, include_private)
+    end
+
+    def method_missing(method, *args, &block)
+      @target.skip_callbacks(*@types) do
+        @target.send(method, *args, &block)
+      end
+    end
+  end
+
+  class << self
+    def without_callbacks(*types)
+      WithoutCallbacks.new(self, types)
+    end
+
+    def skip_callbacks(*types)
+      deactivate_callbacks(*types)
+      yield.tap do
+        activate_callbacks(*types)
+      end
+    end
+
+    def deactivate_callbacks(*types)
+      types = [:save, :create, :update, :destroy, :touch] if types.empty?
+      types.each do |type|
+        name = :"_run_#{type}_callbacks"
+        alias_method(:"_deactivated_#{name}", name)
+        define_method(name) { |&block| block.call }
+      end
+    end
+
+    def activate_callbacks(*types)
+      types = [:save, :create, :update, :destroy, :touch] if types.empty?
+      types.each do |type|
+        name = :"_run_#{type}_callbacks"
+        alias_method(name, :"_deactivated_#{name}")
+        undef_method(:"_deactivated_#{name}")
+      end
+    end
+  end
+end

data/lib/core_ext/ruby/array/flatten_once.rb

@@ -0,0 +1,9 @@
+class Array
+  def flatten_once
+    inject([]) { |result, elem| elem.is_a?(Array) ? result + elem : result << elem }
+  end
+
+  def flatten_once!
+    replace(flatten_once)
+  end
+end

data/lib/core_ext/ruby/kernel/silence_stream.rb

@@ -0,0 +1,17 @@
+# from lib/core/facets/kernel/silence.rb
+def silence_stream(*streams)
+  on_hold = streams.collect{ |stream| stream.dup }
+  streams.each do |stream|
+    stream.reopen(RUBY_PLATFORM =~ /mswin/ ? 'NUL:' : '/dev/null')
+    stream.sync = true
+  end
+  yield
+ensure
+  streams.each_with_index do |stream, i|
+    stream.reopen(on_hold[i])
+  end
+end
+
+def silence_stdout
+  silence_stream(STDOUT) { yield }
+end

data/lib/core_ext/ruby/module/include_anonymous.rb

@@ -0,0 +1,36 @@
+# Include an anonymous module
+#
+# Useful for defining a class or module with a base module. So, instead of:
+#
+#   class Foo
+#     module Base
+#       def bar
+#         # ...
+#       end
+#     end
+#     include Base
+#   end
+#
+# You can do:
+#
+#   class Foo
+#     include do
+#       def bar
+#         # ...
+#       end
+#     end
+#   end
+
+Class.class_eval do
+  def include(*args, &block)
+    block_given? ? super(Module.new(&block)) : super(*args)
+  end
+end
+
+Module.class_eval do
+  def include_with_anonymous(*args, &block)
+    block_given? ? include_without_anonymous(Module.new(&block)) : include_without_anonymous(*args)
+  end
+  alias :include_without_anonymous :include
+  alias :include :include_with_anonymous
+end