adva-core 0.0.3 → 0.0.4

data/lib/adva/testing.rb

@@ -0,0 +1,58 @@
+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 }
+        ActiveSupport::Slices.register
+
+        each_engine { |e| e.new.require_patches }
+        each_engine { |e| e.migrate }
+
+        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/helper/i18n.rb

@@ -0,0 +1,10 @@
+I18n::Backend::Simple.send(:include, I18n::Backend::Cascade)
+
+# should be a module, but i have no idea how/where to include one :/
+ActionView::Base.class_eval do
+  def translate(key, options = {})
+    super(key, options.merge(:cascade => { :offset => 2, :skip_root => false }))
+  end
+  alias t translate
+end
+

data/lib/adva/view/menu.rb

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

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

@@ -0,0 +1,100 @@
+# 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 build
+          div :id => id, :class => 'menus' do
+            ul :class => 'menu main' do
+              main
+              render_items
+            end
+            ul :class => 'menu right' do
+              right
+              render_items
+            end
+          end
+        end
+
+        def main
+        end
+
+        def right
+        end
+
+        protected
+
+          def id
+            self.class.read_inheritable_attribute(:id)
+          end
+
+          def resource_label
+            label("#{resource.name}:")
+          end
+
+          def resource_section_label
+            label("#{resource.section.name}:")
+          end
+
+          def parent_resource_label
+            label("#{parent_resource.name}:")
+          end
+
+          def index
+            item(:".#{resource.class.name.pluralize.underscore}", index_path)
+          end
+
+          def show
+            item(:".#{resource.class.name.underscore}", show_path)
+          end
+
+          def edit
+            item(:'.edit', edit_path)
+          end
+
+          def edit_parent
+            item(:".edit_#{parent_resource.class.base_class.name.underscore}", edit_parent_path)
+          end
+
+          def categories(url = nil, options = { :before => :'.edit_section' })
+            item(:'.categories', url || index_path(:categories), options)
+          end
+
+          def new
+            item(:'.new', new_path)
+          end
+
+          def reorder(options = {})
+            item(:'.reorder', index_path, options.merge(:activate => false))
+          end
+
+          def destroy
+            item(:'.destroy', resource_path, :method => :delete, :confirm => t(:'.confirm_destroy', :model_name => resource.class.model_name.human))
+          end
+
+          def persisted?
+            resource.try(:persisted?)
+          end
+
+          def collection?
+            index? || new? || create?
+          end
+
+          %w(index show new create edit update).each do |action|
+            define_method(:"#{action}?") do
+              params[:action] == action
+            end
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module Adva
+  module View
+    class Menu
+      class Items < Array
+        def insert(text, url, options, block)
+          item = [text, url, options, block]
+          if ix = options.delete(:at)
+            super(ix, item)
+          elsif ix = index(options.delete(:before))
+            super(ix, item)
+          elsif ix = index(options.delete(:after))
+            super(ix + 1, item)
+          elsif ix = index(options.delete(:replace))
+            self[ix] = item
+          else
+            push(item)
+          end
+        end
+
+        def index(text)
+          each_with_index { |item, ix| return ix if item[0] == text } and nil
+        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/adva_core/version.rb

@@ -0,0 +1,3 @@
+module AdvaCore
+  VERSION = "0.0.4"
+end